53 #include "gravi_data.h" 54 #include "gravi_dfs.h" 55 #include "gravi_pfits.h" 56 #include "gravi_cpl.h" 58 #include "gravi_utils.h" 60 #include "gravi_p2vmred.h" 61 #include "gravi_vis.h" 94 gravi_msg_function_start(1);
95 cpl_ensure (header, CPL_ERROR_NULL_INPUT, NULL);
96 cpl_ensure (mode, CPL_ERROR_NULL_INPUT, NULL);
100 if (!(strcmp (mode,
"gravi_dual"))) n_target = 2;
101 else if (!(strcmp (mode,
"gravi_single"))) n_target = 1;
102 else {cpl_error_set_message(cpl_func, CPL_ERROR_NULL_INPUT,
"Invalid mode (bug)");
return NULL;}
105 cpl_table * oi_target = cpl_table_new (n_target);
108 cpl_table_new_column (oi_target,
"TARGET_ID", CPL_TYPE_INT);
109 cpl_table_set_column_savetype (oi_target,
"TARGET_ID", CPL_TYPE_SHORT);
111 cpl_table_new_column (oi_target,
"TARGET", CPL_TYPE_STRING);
113 cpl_table_new_column (oi_target,
"EQUINOX", CPL_TYPE_FLOAT);
114 cpl_table_set_column_unit (oi_target,
"EQUINOX",
"yr");
116 cpl_table_new_column (oi_target,
"RAEP0", CPL_TYPE_DOUBLE);
117 cpl_table_set_column_unit (oi_target,
"RAEP0",
"deg");
118 cpl_table_new_column (oi_target,
"DECEP0", CPL_TYPE_DOUBLE);
119 cpl_table_set_column_unit (oi_target,
"DECEP0",
"deg");
121 cpl_table_new_column (oi_target,
"RA_ERR", CPL_TYPE_DOUBLE);
122 cpl_table_set_column_unit (oi_target,
"RA_ERR",
"deg");
123 cpl_table_new_column (oi_target,
"DEC_ERR", CPL_TYPE_DOUBLE);
124 cpl_table_set_column_unit (oi_target,
"DEC_ERR",
"deg");
126 cpl_table_new_column (oi_target,
"SYSVEL", CPL_TYPE_DOUBLE);
127 cpl_table_set_column_unit (oi_target,
"SYSVEL",
"m/s");
128 cpl_table_new_column (oi_target,
"VELTYP", CPL_TYPE_STRING);
129 cpl_table_new_column (oi_target,
"VELDEF", CPL_TYPE_STRING);
131 cpl_table_new_column (oi_target,
"PMRA", CPL_TYPE_DOUBLE);
132 cpl_table_set_column_unit (oi_target,
"PMRA",
"deg/yr");
133 cpl_table_new_column (oi_target,
"PMDEC", CPL_TYPE_DOUBLE);
134 cpl_table_set_column_unit (oi_target,
"PMDEC",
"deg/yr");
135 cpl_table_new_column (oi_target,
"PMRA_ERR", CPL_TYPE_DOUBLE);
136 cpl_table_set_column_unit (oi_target,
"PMRA_ERR",
"deg/yr");
137 cpl_table_new_column (oi_target,
"PMDEC_ERR", CPL_TYPE_DOUBLE);
138 cpl_table_set_column_unit (oi_target,
"PMDEC_ERR",
"deg/yr");
140 cpl_table_new_column (oi_target,
"PARALLAX", CPL_TYPE_FLOAT);
141 cpl_table_set_column_unit (oi_target,
"PARALLAX",
"deg");
142 cpl_table_new_column (oi_target,
"PARA_ERR", CPL_TYPE_FLOAT);
143 cpl_table_set_column_unit (oi_target,
"PARA_ERR",
"deg");
145 cpl_table_new_column (oi_target,
"SPECTYP", CPL_TYPE_STRING);
146 CPLCHECK_NUL(
"Cannot create columns in OI_TARGET");
149 for (
int ti=0; ti<n_target; ti++) {
152 cpl_table_set_int (oi_target,
"TARGET_ID", ti, ti+1);
155 const char *name = (ti?gravi_pfits_get_sobj(header):gravi_pfits_get_robj(header));
158 CPLCHECK_NUL(
"Cannot set Target");
165 float equinox = (float)gravi_pfits_get_double_silentdefault (header,
"EQUINOX", 0.);
166 double raep = (ti?gravi_pfits_get_sobj_raep (header):gravi_pfits_get_robj_raep (header));
167 double decp = (ti?gravi_pfits_get_sobj_decep (header):gravi_pfits_get_robj_decep (header));
168 if (ti==0) gravi_dump_the_boss (raep, decp);
171 double dec_err = 0.0;
172 raep *= CPL_MATH_DEG_RAD;
173 decp *= CPL_MATH_DEG_RAD;
174 CPLCHECK_NUL(
"Cannot get EQUINOX, RA and DEC");
177 cpl_msg_info (cpl_func,
"Found target '%s' with ra=%fd and dec=%fd at equinox %.2f", name, raep, decp, equinox);
180 double sysvel = gravi_pfits_get_double_silentdefault (header,
"ESO FT ROBJ RADVEL", 0.);
181 const char * veltyp =
"UNKNOWN ";
182 const char * veldef =
"OPTICAL ";
183 CPLCHECK_NUL(
"Cannot get SYSVEL, VELTYPE...");
187 double pmra = gravi_pfits_get_pmra (header) / 3600.0;
188 double pmdec = gravi_pfits_get_pmdec (header) / 3600.0;
189 double pmra_err = 0.0;
190 double pmdec_err = 0.0;
191 CPLCHECK_NUL(
"Cannot get PMRA...");
194 float parallax = gravi_pfits_get_plx (header);
195 float para_err = 0.0;
196 CPLCHECK_NUL(
"Cannot get PARRALAX...");
199 const char * spectyp =
"UNKNOWN ";
202 cpl_table_set_float (oi_target,
"EQUINOX", ti, equinox);
203 cpl_table_set_double (oi_target,
"RAEP0", ti, raep);
204 cpl_table_set_double (oi_target,
"DECEP0", ti, decp);
205 cpl_table_set_double (oi_target,
"RA_ERR", ti, ra_err);
206 cpl_table_set_double (oi_target,
"DEC_ERR", ti, dec_err);
207 cpl_table_set_double (oi_target,
"SYSVEL", ti, sysvel);
208 cpl_table_set_string (oi_target,
"VELTYP", ti, veltyp);
209 cpl_table_set_string (oi_target,
"VELDEF", ti, veldef);
210 cpl_table_set_double (oi_target,
"PMRA", ti, pmra);
211 cpl_table_set_double (oi_target,
"PMDEC", ti, pmdec);
212 cpl_table_set_double (oi_target,
"PMRA_ERR", ti, pmra_err);
213 cpl_table_set_double (oi_target,
"PMDEC_ERR",ti, pmdec_err);
214 cpl_table_set_float (oi_target,
"PARALLAX", ti, parallax);
215 cpl_table_set_float (oi_target,
"PARA_ERR", ti, para_err);
216 cpl_table_set_string (oi_target,
"SPECTYP", ti, spectyp);
220 gravi_msg_function_exit(1);
241 gravi_msg_function_start(1);
242 cpl_ensure (array_geometry, CPL_ERROR_NULL_INPUT, NULL);
244 cpl_table * oi_array = cpl_table_duplicate (array_geometry);
247 if (cpl_table_has_column (oi_array,
"STA") ) {
248 cpl_table_name_column (oi_array,
"STA",
"STAXYZ");
250 CPLCHECK_NUL (
"Cannot rename STA into STAXYZ");
253 cpl_size n_row = cpl_table_get_nrow (oi_array);
256 if (is_cal) cpl_msg_info (cpl_func,
"ARRAY_GEOMETRY has %lld rows instead of 4", n_row);
257 else cpl_msg_warning (cpl_func,
"ARRAY_GEOMETRY has %lld rows instead of 4", n_row);
258 cpl_table_set_size (oi_array, 4);
260 cpl_array * zero_array = gravi_array_init_double (3,0.0);
263 for (
int row=n_row; row<4; row++ ) {
265 cpl_table_set_int (oi_array,
"STA_INDEX", row, 100+row);
266 sprintf (name16,
"S%i", row);
267 cpl_table_set_string (oi_array,
"STA_NAME", row, name16);
268 sprintf (name16,
"T%i", row);
269 cpl_table_set_string (oi_array,
"TEL_NAME", row, name16);
270 cpl_table_set_array (oi_array,
"STAXYZ", row, zero_array);
271 cpl_table_set_float (oi_array,
"DIAMETER", row, 0.0);
272 cpl_table_set_int (oi_array,
"MNTSTA", row, 0);
273 if (is_cal) cpl_msg_info (cpl_func,
"Add STA_INDEX %i with TEL_NAME=%s in OI_ARRAY",100+row,name16);
274 else cpl_msg_warning (cpl_func,
"Add STA_INDEX %i with TEL_NAME=%s in OI_ARRAY",100+row,name16);
275 CPLCHECK_NUL (
"Cannot insert rows");
278 FREE (cpl_array_delete, zero_array);
283 for (
int row=0; row<cpl_table_get_nrow (oi_array); row++ ) {
284 const char * tel_name = cpl_table_get_string (oi_array,
"TEL_NAME", row);
286 const char * sta_name = cpl_table_get_string (oi_array,
"STA_NAME", row);
289 CPLCHECK_NUL (
"Cannot force 16 chars in OI_ARRAY");
291 gravi_msg_function_exit(1);
331 const char * mode,
const cpl_parameterlist * parlist,
332 enum gravi_detector_type det_type)
335 gravi_msg_function_start(1);
336 cpl_ensure (preproc_data, CPL_ERROR_NULL_INPUT, NULL);
337 cpl_ensure (p2vm_map, CPL_ERROR_NULL_INPUT, NULL);
338 cpl_ensure (mode, CPL_ERROR_NULL_INPUT, NULL);
339 cpl_ensure (parlist, CPL_ERROR_NULL_INPUT, NULL);
342 int ntel = 4, nbase = 6;
346 clock_t timer_ft = 0, timer_sc = 0, timer_other = 0, timer_start = 0;
347 timer_start = clock();
350 cpl_propertylist * preproc_header = gravi_data_get_header (preproc_data);
354 if ( (cpl_parameterlist_find_const (parlist,
"gravity.dfs.p2vmred-file") != NULL &&
355 gravi_param_get_bool (parlist,
"gravity.dfs.p2vmred-file")) ||
356 (cpl_parameterlist_find_const (parlist,
"gravity.dfs.astro-file") != NULL &&
357 gravi_param_get_bool (parlist,
"gravity.dfs.astro-file")) ) {
358 cpl_msg_info (cpl_func,
"p2vmreduced-file is requested, will add computation time.");
361 cpl_msg_info (cpl_func,
"p2vmreduced-file is not requested.");
364 CPLCHECK_NUL(
"Cannot check the parameter");
367 int is_cal = gravi_pfits_is_calib (preproc_header);
371 cpl_propertylist * p2vmred_header = gravi_data_get_header (p2vmred_data);
374 cpl_propertylist_append (p2vmred_header, preproc_header);
382 CPLCHECK_NUL(
"Cannot create OI_TARGET");
386 CPLCHECK_NUL(
"Cannot get ARRAY_GEOMETRY");
388 CPLCHECK_NUL(
"Cannot convert ARRAY_GEOMETRY into OI_ARRAY");
391 cpl_propertylist * oiarray_plist =
gravi_data_get_plist (preproc_data, GRAVI_ARRAY_GEOMETRY_EXT);
392 oiarray_plist = cpl_propertylist_duplicate (oiarray_plist);
396 GRAVI_OI_ARRAY_EXT, oi_array);
397 CPLCHECK_NUL (
"Cannot add OI_ARRAY");
400 cpl_msg_info (cpl_func,
"Update the ARRAYX/Y/Z keywords as double precision");
401 gravi_pfits_ensure_double (oiarray_plist,
"ARRAYX");
402 gravi_pfits_ensure_double (oiarray_plist,
"ARRAYY");
403 gravi_pfits_ensure_double (oiarray_plist,
"ARRAYZ");
410 int labInput[4] = {GRAVI_LABINPUT_1,GRAVI_LABINPUT_2,GRAVI_LABINPUT_3,GRAVI_LABINPUT_4};
411 for (
int lab = 0 ; lab < 4 ; lab++) {
414 cpl_table_unselect_all (optical_train_table);
415 if ( cpl_table_or_selected_int (optical_train_table,
"VALUE2", CPL_EQUAL_TO, labInput[lab]) == 1 ) {
421 int nrow = cpl_table_get_nrow (optical_train_table);
422 cpl_table_set_size (optical_train_table, nrow + 1);
423 cpl_table_set_int (optical_train_table,
"VALUE2", nrow, labInput[lab]);
424 sprintf (name16,
"T%i", nrow);
425 cpl_table_set_string (optical_train_table,
"TEL_NAME", nrow, name16);
426 if (is_cal) cpl_msg_info (cpl_func,
"Add LABINPUT %i with TEL_NAME=%s in OPTICAL_TRAIN",labInput[lab],name16);
427 else cpl_msg_warning (cpl_func,
"Add LABINPUT %i with TEL_NAME=%s in OPTICAL_TRAIN",labInput[lab],name16);
428 CPLCHECK_NUL(
"Cannot insert rows");
442 for (
int type_data = 0; type_data < 2; type_data ++){
446 cpl_msg_info (cpl_func,
"No data for %s, skip it", GRAVI_TYPE(type_data));
451 cpl_table * p2vm_table = gravi_data_get_p2vm_data (p2vm_map, type_data);
452 cpl_table * spectrum_table = gravi_data_get_spectrum_data (preproc_data, type_data);
453 cpl_table * detector_table = gravi_data_get_imaging_detector (preproc_data, type_data);
454 cpl_table * detector_p2vm = gravi_data_get_imaging_detector (p2vm_map, type_data);
455 CPLCHECK_NUL (
"Cannot get data");
458 cpl_ensure (cpl_table_get_nrow (detector_table) ==
459 cpl_table_get_nrow (detector_p2vm),
460 CPL_ERROR_ILLEGAL_INPUT, NULL);
463 cpl_size nrow = cpl_table_get_nrow (spectrum_table);
464 int n_detregion = cpl_table_get_nrow (detector_table);
468 int npol = (n_detregion>24 ? 2 : 1);
474 cpl_size nwave = gravi_spectrum_get_nwave (spectrum_table);
479 for (
int p = 0; p < npol; p ++) {
481 cpl_msg_info(cpl_func,
"Visibility extraction: polarisation %d over %d for %s",
482 p+1, npol, type_data==GRAVI_FT?
"FT":
"SC");
484 timer_other += (clock() - timer_start);
485 timer_start = clock();
492 cpl_msg_info(cpl_func,
"Create and set output tables...");
499 cpl_table_erase_column (oi_vis,
"VISAMP");
500 cpl_table_erase_column (oi_vis,
"VISPHI");
501 cpl_table_erase_column (oi_vis,
"VISAMPERR");
502 cpl_table_erase_column (oi_vis,
"VISPHIERR");
503 cpl_table_erase_column (oi_vis,
"RVIS");
504 cpl_table_erase_column (oi_vis,
"RVISERR");
505 cpl_table_erase_column (oi_vis,
"IVIS");
506 cpl_table_erase_column (oi_vis,
"IVISERR");
509 cpl_propertylist * oi_plist = cpl_propertylist_new ();
510 cpl_propertylist_copy_property (oi_plist, oiarray_plist,
"ARRNAME");
511 cpl_propertylist_copy_property (oi_plist, preproc_header,
"DATE-OBS");
512 cpl_propertylist_update_int (oi_plist,
"OI_REVN", 1);
513 cpl_propertylist_update_int (oi_plist,
"NWAVE", nwave);
514 cpl_propertylist_update_string (oi_plist,
"INSNAME", GRAVI_INSNAME(type_data,p,npol));
515 cpl_propertylist_update_int (oi_plist,
"EXTVER", GRAVI_EXTVER(type_data,p,npol));
518 GRAVI_OI_VIS_EXT, oi_vis);
520 oi_plist = cpl_propertylist_duplicate (oi_plist);
523 GRAVI_OI_FLUX_EXT, oi_flux);
525 cpl_msg_info(cpl_func,
"Total time to create tables: %.4f s", (
double)(clock()-timer_start)/(
double)CLOCKS_PER_SEC );
532 timer_other += (clock() - timer_start);
533 timer_start = clock();
535 cpl_msg_info (cpl_func,
"Compute the invers V2P2M -> P2VM matrix...");
538 cpl_matrix ** p2vm = cpl_calloc (nwave,
sizeof (cpl_matrix*));
543 for (
int detreg = 0; detreg < n_detregion; detreg++) {
545 all_region[n_region] = detreg;
550 const cpl_array ** trans, ** coh, ** phase;
551 trans = cpl_table_get_data_array_const (p2vm_table, TRANSMISSION);
552 coh = cpl_table_get_data_array_const (p2vm_table, COHERENCE);
553 phase = cpl_table_get_data_array_const (p2vm_table, PHASE);
554 CPLCHECK_NUL (
"Cannot load the p2vm data");
557 double ** pP2VM = cpl_malloc (
sizeof(
double*) * nwave);
560 for (cpl_size wave = 0; wave < nwave; wave ++) {
563 cpl_matrix * v2pm = cpl_matrix_new (n_region, 16);
566 for (cpl_size region = 0; region < n_region; region++) {
567 int detregion = all_region[region];
571 for (
int i = 0; i < 4; i++){
572 cpl_matrix_set (v2pm, region, i,
573 cpl_array_get (trans[detregion], wave + i * nwave, &nv));
579 for (
int i = 0; i < 6; i++) {
580 cpl_matrix_set (v2pm, region, i + 4,
581 cpl_array_get (coh[detregion], wave + i * nwave, &nv) *
582 cos(cpl_array_get (phase[detregion], wave + i * nwave, &nv)));
583 cpl_matrix_set (v2pm, region, i + 10,
584 cpl_array_get (coh[detregion], wave + i * nwave, &nv) *
585 sin(cpl_array_get (phase[detregion], wave + i * nwave, &nv)));
588 CPLCHECK_NUL(
"Cannot fill the V2PM");
591 cpl_matrix_multiply_scalar (v2pm, 1./n_region);
596 cpl_matrix_delete (v2pm);
599 pP2VM[wave] = cpl_matrix_get_data (p2vm[wave]);
601 CPLCHECK_NUL (
"Cannot invers V2PM");
605 cpl_msg_info (cpl_func,
"Total time to invers matrix: %.4f s", (
double)(clock()-timer_start)/(
double)CLOCKS_PER_SEC );
610 cpl_msg_info (cpl_func,
"Fill the STA_INDEX and TIME.");
611 timer_other += (clock() - timer_start);
612 timer_start = clock();
616 cpl_array * times = cpl_array_wrap_int (cpl_table_get_data_int (spectrum_table,
"TIME"),
617 cpl_table_get_nrow (spectrum_table));
618 cpl_ensure (times, CPL_ERROR_ILLEGAL_INPUT, NULL);
622 cpl_array * mjds = cpl_array_cast (times, CPL_TYPE_DOUBLE);
623 cpl_array_divide_scalar (mjds, 86400.E6);
624 double mjd0 = gravi_convert_to_mjd (gravi_pfits_get_start_prcacq (preproc_header));
625 cpl_array_add_scalar (mjds, mjd0);
630 cpl_table_set_column_unit (oi_vis,
"TIME",
"usec");
631 cpl_table_set_column_unit (oi_flux,
"TIME",
"usec");
634 cpl_array * sta_index = cpl_array_new (2, CPL_TYPE_INT);
636 for (
int base=0; base < nbase; ++base) {
639 int sta0 =
gravi_sta_index(GRAVI_BASE_TEL[base][0]+1, optical_train_table, oi_array);
640 int sta1 =
gravi_sta_index(GRAVI_BASE_TEL[base][1]+1, optical_train_table, oi_array);
641 cpl_array_set_int (sta_index, 0, sta0);
642 cpl_array_set_int (sta_index, 1, sta1);
643 CPLCHECK_NUL (
"Cannot find the sta_index");
646 for (
int row=0; row < nrow; ++row) {
647 int idx = row * nbase + base;
648 cpl_table_set_array (oi_vis,
"STA_INDEX", idx, sta_index);
649 cpl_table_set (oi_vis,
"TIME", idx, cpl_array_get (times, row, &nv));
650 cpl_table_set (oi_vis,
"MJD", idx, cpl_array_get (mjds, row, &nv));
654 cpl_array_delete (sta_index);
655 CPLCHECK_NUL (
"Cannot fill sta_index or time in OI_VIS");
658 for (
int tel = 0; tel < ntel; tel++){
660 for (
int row=0; row < nrow; ++row) {
661 int idx = row * ntel + tel;
662 cpl_table_set_int (oi_flux,
"STA_INDEX", idx, sta0);
663 cpl_table_set (oi_flux,
"TIME", idx, cpl_array_get (times, row, &nv));
664 cpl_table_set (oi_flux,
"MJD", idx, cpl_array_get (mjds, row, &nv));
668 cpl_array_delete (mjds);
669 cpl_array_unwrap (times);
670 CPLCHECK_NUL (
"Cannot fill sta_index or time in OI_FLUX");
673 double exptime = gravi_pfits_get_dit (gravi_data_get_header (preproc_data), type_data);
674 cpl_table_fill_column_window (oi_vis,
"INT_TIME", 0, nrow * nbase, exptime);
675 cpl_table_fill_column_window (oi_flux,
"INT_TIME", 0, nrow * ntel, exptime);
676 CPLCHECK_NUL (
"Cannot fill exptime");
680 int target_id = (!strcmp(mode,
"gravi_dual") && (type_data==GRAVI_SC) )?2:1;
681 cpl_table_fill_column_window_int (oi_vis,
"TARGET_ID", 0, nrow * nbase, target_id);
682 cpl_table_fill_column_window_int (oi_flux,
"TARGET_ID", 0, nrow * ntel, target_id);
683 CPLCHECK_NUL (
"Cannot fill target_id");
685 cpl_msg_info (cpl_func,
"Total time to fill STA_INDEX and TIME: %.4f s",
686 (
double)(clock()-timer_start)/(
double)CLOCKS_PER_SEC );
694 cpl_msg_info (cpl_func,
"Apply p2vm to the data...");
695 timer_other += (clock() - timer_start);
696 timer_start = clock();
699 double ** pReg = cpl_malloc (n_region *
sizeof(
double*));
700 double ** pErr = cpl_malloc (n_region *
sizeof(
double*));
701 cpl_array *** pRegArr = cpl_malloc (n_region *
sizeof(cpl_array**));
702 cpl_array *** pErrArr = cpl_malloc (n_region *
sizeof(cpl_array**));
703 for (
int reg = 0; reg < n_region; reg++) {
704 pRegArr[reg] = cpl_table_get_data_array (spectrum_table, GRAVI_DATA[all_region[reg]]);
705 pErrArr[reg] = cpl_table_get_data_array (spectrum_table, GRAVI_DATAERR[all_region[reg]]);
707 CPLCHECK_NUL (
"Cannot get data");
710 cpl_array** tFlux = cpl_table_get_data_array (oi_flux,
"FLUX");
711 cpl_array** tFluxErr = cpl_table_get_data_array (oi_flux,
"FLUXERR");
712 cpl_array** tVis = cpl_table_get_data_array (oi_vis,
"VISDATA");
713 cpl_array** tVisErr = cpl_table_get_data_array (oi_vis,
"VISERR");
714 CPLCHECK_NUL (
"Cannot get data");
717 double* pOut = cpl_malloc (16 * nwave *
sizeof(
double));
718 double* pOutVar = cpl_malloc (16 * nwave *
sizeof(
double));
721 double full_flux_reg = 0.0, full_flux_tel = 0.0;
723 cpl_msg_debug (cpl_func,
"Matrix multiplication");
726 for (cpl_size row = 0; row < nrow; row ++) {
729 for (
int reg = 0; reg < n_region; reg++) {
730 pReg[reg] = cpl_array_get_data_double (pRegArr[reg][row]);
731 pErr[reg] = cpl_array_get_data_double (pErrArr[reg][row]);
735 for (cpl_size wave = 0 ; wave < nwave ; wave++ ) {
738 for (
int reg = 0; reg < n_region; reg++) full_flux_reg += pReg[reg][wave];
744 for (
int out=0; out<16; out++) {
745 pOut[out*nwave+wave] = 0.0;
746 pOutVar[out*nwave+wave] = 0.0;
747 for (cpl_size reg = 0; reg < n_region; reg++) {
748 pOut[out*nwave+wave] += pReg[reg][wave] * pP2VM[wave][out*n_region+reg];
749 pOutVar[out*nwave+wave] += gravi_pow2 (pErr[reg][wave] * pP2VM[wave][out*n_region+reg]);
754 for (
int tel = 0; tel < 4; tel++) full_flux_tel += pOut[tel*nwave+wave];
759 for (
int tel = 0; tel < ntel; tel++){
760 double * data = cpl_malloc (nwave *
sizeof(
double));
761 for (cpl_size wave = 0 ; wave < nwave ; wave++ )
762 data[wave] = pOut[tel*nwave+wave];
763 tFlux[row*ntel+tel] = cpl_array_wrap_double (data, nwave);
767 for (
int tel = 0; tel < ntel; tel++){
768 double * data = cpl_malloc (nwave *
sizeof(
double));
769 for (cpl_size wave = 0 ; wave < nwave ; wave++ )
770 data[wave] = sqrt (pOutVar[tel*nwave+wave]);
771 tFluxErr[row*ntel+tel] = cpl_array_wrap_double (data, nwave);
775 for (
int base = 0; base < nbase; base++){
776 double complex * data = cpl_malloc (nwave *
sizeof(
double complex));
777 for (cpl_size wave = 0 ; wave < nwave ; wave++ )
778 data[wave] = (
double complex)( pOut[(base+4)*nwave+wave] + 1.*I * pOut[(base+10)*nwave+wave] );
779 tVis[row*nbase+base] = cpl_array_wrap_double_complex (data, nwave);
783 for (
int base = 0; base < nbase; base++){
784 double complex * data = cpl_malloc (nwave *
sizeof(
double complex));
785 for (cpl_size wave = 0 ; wave < nwave ; wave++ )
786 data[wave] = (
double complex)( sqrt(pOutVar[(base+4)*nwave+wave]) + 1.*I * sqrt(pOutVar[(base+10)*nwave+wave]) );
787 tVisErr[row*nbase+base] = cpl_array_wrap_double_complex (data, nwave);
792 for (cpl_size reg = 0; reg < n_region; reg++) {
793 FREE (cpl_array_delete, pRegArr[reg][row]);
794 FREE (cpl_array_delete, pErrArr[reg][row]);
801 cpl_msg_debug (cpl_func,
"Free pointers to data");
802 FREE (cpl_free, pReg);
803 FREE (cpl_free, pErr);
804 FREE (cpl_free, pRegArr);
805 FREE (cpl_free, pErrArr);
806 FREE (cpl_free, pOut);
807 FREE (cpl_free, pOutVar);
808 FREE (cpl_free, pP2VM);
809 FREELOOP (cpl_matrix_delete, p2vm, nwave);
812 cpl_msg_info (cpl_func,
"Total flux in TELs: %.2f [e], in REGIONs:%.2f [e] (ratio=%.5f)",
813 full_flux_tel,full_flux_reg,full_flux_tel/full_flux_reg);
815 sprintf (qc_name,
"ESO QC TRANS P2VM %s",GRAVI_TYPE(type_data));
816 cpl_propertylist_update_double (p2vmred_header, qc_name, full_flux_tel/full_flux_reg);
817 cpl_propertylist_set_comment (p2vmred_header, qc_name,
"[e/e] at P2VM extraction");
820 cpl_msg_info (cpl_func,
"Total time to apply matrix: %.4f s", (
double)(clock()-timer_start)/(
double)CLOCKS_PER_SEC );
822 if( type_data==GRAVI_FT )
823 timer_ft += (clock() - timer_start);
825 timer_sc += (clock() - timer_start);
826 timer_start = clock();
836 double lambda_met = gravi_pfits_get_met_wavelength_mean(preproc_header,
gravi_data_get_table(preproc_data, GRAVI_METROLOGY_EXT));
837 sprintf (qc_name,
"ESO QC MET LAMBDA MEAN");
838 cpl_propertylist_update_double (p2vmred_header, qc_name, lambda_met);
839 cpl_propertylist_set_comment (p2vmred_header, qc_name,
"[m] Effective mean metrology wavelength");
846 timer_other += (clock() - timer_start);
847 cpl_msg_info (cpl_func,
"Total time for FT: %10.4f s", (
double)(timer_ft)/(
double)CLOCKS_PER_SEC);
848 cpl_msg_info (cpl_func,
"Total time for SC: %10.4f s", (
double)(timer_sc)/(
double)CLOCKS_PER_SEC);
849 cpl_msg_info (cpl_func,
"Total time for OTHER: %7.4f s", (
double)(timer_other)/(
double)CLOCKS_PER_SEC);
852 gravi_msg_function_exit(1);
873 gravi_msg_function_start(1);
874 cpl_ensure_code (p2vmred_data, CPL_ERROR_NULL_INPUT);
876 int nbase = 6, ntel = 4;
880 cpl_propertylist * header = gravi_data_get_header (p2vmred_data);
881 int npol_ft = gravi_pfits_get_pola_num (header, GRAVI_FT);
882 cpl_table * oi_vis = gravi_data_get_oi_vis (p2vmred_data, GRAVI_FT, 0, npol_ft);
883 cpl_table * oi_flux = gravi_data_get_oi_flux (p2vmred_data, GRAVI_FT, 0, npol_ft);
885 cpl_size nrow_ft = cpl_table_get_nrow (oi_vis) / nbase;
886 cpl_size nrow_opdc = cpl_table_get_nrow (opdc);
887 CPLCHECK_MSG (
"Cannot get data");
890 gravi_table_new_column (oi_vis,
"TARGET_PHASE",
"rad", CPL_TYPE_DOUBLE);
893 cpl_table_new_column (oi_flux,
"STATE", CPL_TYPE_INT);
894 cpl_table_fill_column_window (oi_flux,
"STATE", 0, nrow_ft * ntel, -1);
897 cpl_table_new_column (oi_vis,
"STATE", CPL_TYPE_INT);
898 cpl_table_fill_column_window (oi_vis,
"STATE", 0, nrow_ft * nbase, -1);
901 cpl_table_new_column (oi_vis,
"OPDC_STATE", CPL_TYPE_INT);
902 cpl_table_fill_column_window (oi_vis,
"OPDC_STATE", 0, nrow_ft * nbase, -1);
904 if (nrow_opdc < nrow_ft)
905 cpl_msg_warning (cpl_func,
"Missing FT or OPDC data: nrow_ft - nrow_opdc = %lli", nrow_ft-nrow_opdc);
909 int * time_opdc = cpl_table_get_data_int (opdc,
"TIME");
910 double * time_ft = cpl_table_get_data_double (oi_vis,
"TIME");
911 int * global_state_opdc = cpl_table_get_data_int (opdc,
"STATE");
912 int * global_state = cpl_table_get_data_int (oi_vis,
"OPDC_STATE");
913 CPLCHECK_MSG (
"Cannot get data");
916 for (cpl_size row_opdc=0, row_ft=0 ; row_ft<nrow_ft ; row_ft++) {
920 if ( (time_ft[row_ft*nbase] < time_opdc[0]) || (time_ft[row_ft*nbase] > time_opdc[nrow_opdc-1]) )
continue;
921 while ( time_ft[row_ft*nbase] > time_opdc[row_opdc] ) row_opdc ++;
924 for (
int base = 0; base < nbase; base++)
925 global_state[row_ft*nbase+base] = global_state_opdc[row_opdc];
929 if ( cpl_table_has_column (opdc,
"BASELINE_STATE") ) {
931 int * steps_opdc = cpl_table_get_data_int (opdc,
"STEPS");
932 int * state_opdc = cpl_table_get_data_int (opdc,
"BASELINE_STATE");
933 int * base_state = cpl_table_get_data_int (oi_vis,
"STATE");
934 int * tel_state = cpl_table_get_data_int (oi_flux,
"STATE");
935 double * base_steps = cpl_table_get_data_double (oi_vis,
"TARGET_PHASE");
936 CPLCHECK_MSG (
"Cannot get data");
939 for (cpl_size row_opdc=0, row_ft=0 ; row_ft<nrow_ft ; row_ft++) {
943 if ( (time_ft[row_ft*nbase] < time_opdc[0]) || (time_ft[row_ft*nbase] > time_opdc[nrow_opdc-1]) )
continue;
944 while ( time_ft[row_ft*nbase] > time_opdc[row_opdc] ) row_opdc ++;
947 int state_flag = state_opdc[row_opdc];
951 for (
int tel = 0; tel < ntel; tel++)
952 tel_state[row_ft*ntel+tel] = gravi_bit_get (state_flag, tel);
956 for (
int base = 0; base < nbase; base++)
957 base_state[row_ft*nbase+base] = gravi_bit_get (state_flag, ntel+base);
966 for (cpl_size base = 0; base < nbase; base++) {
967 base_state[row_ft*nbase+base] = CPL_MAX( base_state[row_ft*nbase+base],
968 base_state[row_ft*nbase+GRAVI_TRI_BASE[base][0][0]] *
969 base_state[row_ft*nbase+GRAVI_TRI_BASE[base][0][1]] );
970 base_state[row_ft*nbase+base] = CPL_MAX( base_state[row_ft*nbase+base],
971 base_state[row_ft*nbase+GRAVI_TRI_BASE[base][1][0]] *
972 base_state[row_ft*nbase+GRAVI_TRI_BASE[base][1][1]] );
980 for (
int tel = 0; tel < ntel; tel++) {
981 int pos = (tel<3) ? 4*tel : 4*(tel+1);
982 tmp_arr[tel] = 15 & ((steps_opdc[row_opdc]) >> pos);
986 for (
int base=0; base<nbase; base++) {
987 base_steps[row_ft*nbase+base] = (tmp_arr[GRAVI_BASE_TEL[base][1]] - tmp_arr[GRAVI_BASE_TEL[base][0]]) * CPL_MATH_PI / 8.0;
993 cpl_msg_warning (cpl_func,
"No column BASELINE_STATE in OPDC... old data ?");
994 cpl_msg_warning (cpl_func,
"The STATE flags are set to 1 (valid) although the information is unavailable");
995 cpl_table_fill_column_window (oi_flux,
"STATE", 0, nrow_ft * ntel, 1);
996 cpl_table_fill_column_window (oi_vis,
"STATE", 0, nrow_ft * nbase, 1);
1002 cpl_msg_debug (cpl_func,
"Duplicate the FT tracking state for 2sd polarisation");
1004 tmp = gravi_data_get_oi_vis (p2vmred_data, GRAVI_FT, 1, npol_ft);
1005 cpl_table_duplicate_column (tmp,
"TARGET_PHASE", oi_vis,
"TARGET_PHASE");
1006 cpl_table_duplicate_column (tmp,
"STATE", oi_vis,
"STATE");
1007 cpl_table_duplicate_column (tmp,
"OPDC_STATE", oi_vis,
"OPDC_STATE");
1009 tmp = gravi_data_get_oi_flux (p2vmred_data, GRAVI_FT, 1, npol_ft);
1010 cpl_table_duplicate_column (tmp,
"STATE", oi_flux,
"STATE");
1018 cpl_array **visdata = cpl_table_get_data_array (oi_vis,
"VISDATA");
1019 int * state = cpl_table_get_data_int (oi_vis,
"STATE");
1020 double * target_phase = cpl_table_get_data_double (oi_vis,
"TARGET_PHASE");
1021 CPLCHECK_MSG (
"Cannot get data");
1023 double complex * tmp_cpx = cpl_malloc (
sizeof(
double complex)*nrow_ft);
1026 for (
int base = 0; base < nbase; base ++) {
1029 double complex mean_cpx = 0.0 + I * 0.0;
1030 for (cpl_size row_ft=0 ; row_ft<nrow_ft ; row_ft++) {
1031 if (state[row_ft*nbase+base] < 1)
continue;
1032 tmp_cpx[row_ft] = cpl_array_get_mean_complex (visdata[row_ft*nbase+base]) * cexp (-I*target_phase[row_ft*nbase+base]);
1033 mean_cpx += tmp_cpx[row_ft];
1037 double sum = 0.0000001, sum2 = 0.0;
1038 for (cpl_size row_ft=0 ; row_ft<nrow_ft ; row_ft++) {
1039 if (state[row_ft*nbase+base] < 1)
continue;
1040 sum2 += pow (carg (tmp_cpx[row_ft] * conj(mean_cpx)), 2);
1045 sprintf (qc_name,
"ESO QC PHASE_FT%d%d RMS",GRAVI_BASE_TEL[base][0]+1, GRAVI_BASE_TEL[base][1]+1);
1046 cpl_propertylist_update_double (header, qc_name, sqrt (sum2 / sum));
1047 cpl_propertylist_set_comment (header, qc_name,
"[rad] residuals when tracking");
1050 sprintf (qc_name,
"ESO QC TRACKING_RATIO_FT%d%d",GRAVI_BASE_TEL[base][0]+1, GRAVI_BASE_TEL[base][1]+1);
1051 cpl_propertylist_update_double (header, qc_name, sum*100.0/nrow_ft);
1052 cpl_propertylist_set_comment (header, qc_name,
"[%] ratio of time with tracking");
1056 FREE (cpl_free,tmp_cpx);
1062 int* tab_state = cpl_table_get_data_int (
gravi_data_get_table (p2vmred_data, GRAVI_OPDC_EXT),
"STATE");
1063 CPLCHECK_MSG (
"Cannot get data");
1066 for (cpl_size row_opdc=0; row_opdc < nrow_opdc; row_opdc++) {
1067 if (tab_state[row_opdc] == 3 || tab_state[row_opdc] == 2) tracking ++;
1070 sprintf (qc_name,
"ESO QC TRACKING_RATIO");
1071 cpl_propertylist_update_int (header, qc_name, tracking*100/nrow_ft);
1072 cpl_propertylist_set_comment (header, qc_name,
"[%] ratio of time with full FT tracking");
1074 CPLCHECK_MSG (
"Cannot put QC parameters");
1077 gravi_msg_function_exit(1);
1078 return CPL_ERROR_NONE;
1097 gravi_msg_function_start(1);
1098 cpl_ensure_code (data, CPL_ERROR_NULL_INPUT);
1105 cpl_propertylist * header = gravi_data_get_header (data);
1107 cpl_size nrow = cpl_table_get_nrow (opdc);
1109 CPLCHECK_MSG(
"Cannot load the OPDC table");
1112 cpl_size max_delay = 200;
1115 int *time = cpl_table_get_data_int (opdc,
"TIME");
1116 CPLCHECK_MSG(
"Cannot load the TIME column");
1118 float ** piezo = gravi_table_get_data_array_float (opdc,
"PIEZO_DL_OFFSET");
1119 CPLCHECK_MSG(
"Cannot load the PIEZO_OFFSET columns");
1122 for (
int base=0; base<nbase; base++) {
1123 int t1 = GRAVI_BASE_TEL[base][0];
1124 int t2 = GRAVI_BASE_TEL[base][1];
1127 sprintf (qc_name,
"ESO QC TAU0 OPDC%d%d", t1+1,t2+1);
1128 cpl_propertylist_update_double (header, qc_name, GRAVI_NAN_DOUBLE);
1129 cpl_propertylist_set_comment (header, qc_name,
"[s] tau0 for variance of 1 rad2");
1133 for (cpl_size delay=0; delay < max_delay; delay++) {
1137 for (cpl_size row=0; row < nrow - max_delay - 1 ; row++) {
1138 float diff = (piezo[row][t1]-piezo[row][t2]) - (piezo[row+delay][t1]-piezo[row+delay][t2]);
1139 strf += (double)(diff * diff);
1141 strf = strf * gain * gain / (nrow - max_delay - 1);
1146 double tau0 = (time[delay+1] - time[1]) * 1e-6;
1147 cpl_msg_info (cpl_func,
"Compute %s = %.2f [ms]", qc_name, 1e3 * tau0);
1148 cpl_propertylist_update_double (header, qc_name, tau0);
1157 FREE (cpl_free, piezo);
1159 gravi_msg_function_exit(1);
1160 return CPL_ERROR_NONE;
1177 gravi_msg_function_start(1);
1178 cpl_ensure_code (data, CPL_ERROR_NULL_INPUT);
1181 double p05 = 0.0, p95 = 0.0;
1183 cpl_propertylist * header = gravi_data_get_header (data);
1184 int npol = gravi_pfits_get_pola_num (header, GRAVI_FT);
1185 int ntel = 4, hw = 2;
1188 cpl_msg_info (cpl_func,
"Smooth flux sery over %i samples", hw);
1191 cpl_table * table = gravi_data_get_oi_flux (data, GRAVI_FT, 0, npol);
1192 cpl_size nrow = cpl_table_get_nrow (table) / ntel;
1196 for (
int tel = 0; tel<ntel; tel++) {
1199 cpl_vector * raw_flux = cpl_vector_new (nrow);
1200 cpl_vector_fill (raw_flux, 0.0);
1202 for (
int pol = 0; pol<npol; pol++) {
1205 cpl_table * table = gravi_data_get_oi_flux (data, GRAVI_FT, pol, npol);
1206 const cpl_array ** flux_array = cpl_table_get_data_array_const (table,
"FLUX");
1208 for (
int row = 0; row<nrow; row++)
1209 cpl_vector_set (raw_flux, row, cpl_vector_get (raw_flux, row) +
1210 cpl_array_get_mean (flux_array[tel+row*ntel]));
1215 flux = cpl_vector_filter_lowpass_create (raw_flux, CPL_LOWPASS_GAUSSIAN, hw);
1216 cpl_vector_delete (raw_flux);
1219 for (
int row = 0; row<nrow; row++)
1220 cpl_vector_set (flux, row, CPL_MAX (0.0, cpl_vector_get (flux, row)));
1223 cpl_vector_sort (flux, CPL_SORT_ASCENDING);
1224 cpl_vector_divide_scalar (flux, cpl_vector_get_max (flux) / 100);
1228 sprintf (qc_value,
"%.0f,%.0f,%.0f,%.0f,%.0f,%.0f,%.0f,%.0f,%.0f",
1229 cpl_vector_get (flux, (cpl_size)(0.1*(nrow-1))),
1230 cpl_vector_get (flux, (cpl_size)(0.2*(nrow-1))),
1231 cpl_vector_get (flux, (cpl_size)(0.3*(nrow-1))),
1232 cpl_vector_get (flux, (cpl_size)(0.4*(nrow-1))),
1233 cpl_vector_get (flux, (cpl_size)(0.5*(nrow-1))),
1234 cpl_vector_get (flux, (cpl_size)(0.6*(nrow-1))),
1235 cpl_vector_get (flux, (cpl_size)(0.7*(nrow-1))),
1236 cpl_vector_get (flux, (cpl_size)(0.8*(nrow-1))),
1237 cpl_vector_get (flux, (cpl_size)(0.9*(nrow-1))));
1240 cpl_msg_info (cpl_func,
"Flux Histo: %s", qc_value);
1241 sprintf (qc_name,
"ESO QC FLUX_FT%d HISTO", tel+1);
1242 cpl_propertylist_update_string (header, qc_name, qc_value);
1243 cpl_propertylist_set_comment (header, qc_name,
"decile in percent");
1246 p05 = cpl_vector_get (flux, (cpl_size)(0.05*(nrow-1)));
1247 p95 = cpl_vector_get (flux, (cpl_size)(0.95*(nrow-1)));
1250 sprintf (qc_name,
"ESO QC FLUX_FT%d P05P95", tel+1);
1251 cpl_propertylist_update_double (header, qc_name, p05/p95);
1252 cpl_propertylist_set_comment (header, qc_name,
"injected flux 5 percentile over 95 percentile");
1255 cpl_vector_delete (flux);
1258 gravi_msg_function_exit(1);
1259 return CPL_ERROR_NONE;
1277 gravi_msg_function_start(1);
1278 cpl_ensure_code (p2vmred_data, CPL_ERROR_NULL_INPUT);
1285 cpl_propertylist * header = gravi_data_get_header (p2vmred_data);
1286 int npol = gravi_pfits_get_pola_num (header, GRAVI_FT);
1288 int * time_opdc = cpl_table_get_data_int (opdc,
"TIME");
1289 if (cpl_table_has_column(opdc,
"OPD") == 1){
1290 cpl_array **opd_data_opdc = cpl_table_get_data_array (opdc,
"OPD");
1291 cpl_size nrow = cpl_table_get_nrow (opdc);
1292 CPLCHECK_MSG (
"Cannot get data");
1295 cpl_array * opd_res_array = cpl_array_new(nrow, CPL_TYPE_DOUBLE_COMPLEX);
1296 cpl_array * opd_array = cpl_array_new(nrow, CPL_TYPE_DOUBLE);
1297 cpl_array * snr_array = cpl_array_new(nrow, CPL_TYPE_DOUBLE);
1300 for (
int pol = 0; pol<npol; pol++) {
1301 cpl_table * oi_vis = gravi_data_get_oi_vis (p2vmred_data, GRAVI_FT, pol, npol);
1302 double * time_oivis = cpl_table_get_data_double (oi_vis,
"TIME");
1303 cpl_array **visdata = cpl_table_get_data_array (oi_vis,
"VISDATA");
1304 cpl_array **visdata_err = cpl_table_get_data_array (oi_vis,
"VISERR");
1306 cpl_size nrow_oivis = cpl_table_get_nrow (oi_vis);
1307 cpl_size nwave= cpl_array_get_size (visdata[0]);
1311 for (
int base = 0; base<nbase; base++) {
1312 cpl_size row_oivis = base;
1314 for (cpl_size row = 0; row<nrow; row++)
1318 while (( fabs (time_oivis[row_oivis+nbase]-time_opdc[row]+0.0011/2*1e6 )< fabs (time_oivis[row_oivis]-time_opdc[row]+0.0011/2*1e6 ) ) && (row_oivis<nrow_oivis-2*nbase))
1323 double complex visdata_mean=cpl_array_get_mean_complex (visdata[row_oivis]);
1324 cpl_array_set_double_complex(opd_res_array,row, visdata_mean*cexp ( I * cpl_array_get_float (opd_data_opdc[row], base, &nv) ));
1325 cpl_array_set_double(opd_array, row, carg(visdata_mean));
1331 for (cpl_size wave = 0 ; wave < nwave ; wave ++)
1333 signal+=cabs(cpl_array_get_double_complex (visdata[row_oivis],wave, &nv));
1334 double err=cabs(cpl_array_get_double_complex (visdata_err[row_oivis],wave, &nv));
1337 noise=sqrt(noise+1);
1339 cpl_array_set_double(snr_array,row, signal /noise -1 );
1341 cpl_array_set_double(snr_array,row, 0 );
1344 CPLCHECK_MSG (
"Cannot compute new array for cross-referencing OPD and FT OPD");
1346 double complex opd_mean = cpl_array_get_mean_complex (opd_res_array);
1347 cpl_array_multiply_scalar_complex(opd_res_array,conj(opd_mean));
1350 double a_num=0,b_num=0,c_num=0,d_num=0,a_den=1,b_den=1,c_den=1,d_den=1;
1351 double opd_std_num=0,opd_std_den=1;
1352 double opd, opd_ref, snr_ref;
1354 for (cpl_size row = 0; row<nrow; row++)
1356 opd=cpl_array_get_double(opd_array,row,&nv);
1357 opd_ref=carg(cpl_array_get_double_complex(opd_res_array,row,&nv));
1358 snr_ref=cpl_array_get_double(snr_array,row,&nv);
1360 a_num+=snr_ref*opd_ref*c_o;
1361 a_den+=snr_ref*c_o*c_o;
1363 b_num+=snr_ref*opd_ref*s_o;
1364 b_den+=snr_ref*s_o*s_o;
1366 c_num+=snr_ref*opd_ref*c_o;
1367 c_den+=snr_ref*c_o*c_o;
1369 d_num+=snr_ref*opd_ref*s_o;
1370 d_den+=snr_ref*s_o*s_o;
1373 opd_std_num+=snr_ref*opd_ref*snr_ref*opd_ref;
1374 opd_std_den+=snr_ref;
1378 CPLCHECK_MSG (
"Cannot calculate variance of linearity");
1380 double a=a_num/a_den;
1381 double b=b_num/b_den;
1382 double c=c_num/c_den;
1383 double d=d_num/d_den;
1385 double opd_std=sqrt(0.1+opd_std_num)/opd_std_den;
1388 double res_car=a*a+b*b+c*c+d*d-16*opd_std*opd_std;
1389 if (res_car > 0) res_car=sqrt(res_car);
1393 if (npol == 2) sprintf (qc_name,
"ESO QC LIN_FT P%d_B%d", pol,base+1);
1394 if (npol == 1) sprintf (qc_name,
"ESO QC LIN_FT P%d_B%d", 3,base+1);
1395 cpl_propertylist_update_double (header, qc_name, res_car);
1396 cpl_propertylist_set_comment (header, qc_name,
"FT nonlinearity biases [rad]");
1398 CPLCHECK_MSG (
"Cannot store QCs");
1403 cpl_array_delete (opd_array);
1404 cpl_array_delete (opd_res_array);
1405 cpl_array_delete (snr_array);
1406 CPLCHECK_MSG (
"Cannot close arrays");
1409 cpl_msg_info(cpl_func,
"Cannot found the OPD column (probably old data). Skip computation of QC LIN_FT");
1412 gravi_msg_function_exit(1);
1413 return CPL_ERROR_NONE;
cpl_error_code gravi_compute_opdc_state(gravi_data *p2vmred_data)
Compute the real-time tracking state from OPDC.
gravi_data * gravi_data_new(int nb_ext)
Create an empty gravi_data.
short gravi_sta_index(int gravi_input, cpl_table *optical_train_table, cpl_table *array_geometry_table)
Retrieve STA_INDEX corresponding to a given input.
int gravi_region_get_pol(cpl_table *imaging_detector, int region)
Return the polarisation id of a region.
cpl_error_code gravi_data_copy_ext(gravi_data *output, gravi_data *input, const char *name)
Copy extensions from one data to another.
int gravi_data_has_extension(gravi_data *raw_calib, const char *ext_name)
Check if data has extension with given EXTNAME.
cpl_table * gravi_create_oiarray_table(const cpl_table *array_geometry, int is_cal)
Create the OI_ARRAY table from the ARRAY_GEOMETRY.
cpl_table * gravi_data_get_table(gravi_data *self, const char *extname)
Return a pointer on a table extension by its EXTNAME.
cpl_matrix * gravi_matrix_invertSV_create(cpl_matrix *a_in)
Invers a matrix with singular value decomposition.
gravi_data * gravi_compute_p2vmred(gravi_data *preproc_data, gravi_data *p2vm_map, const char *mode, const cpl_parameterlist *parlist, enum gravi_detector_type det_type)
Converts preprocessed data into coherent fluxes using the P2VM.
cpl_error_code gravi_table_set_string_fixlen(cpl_table *table, const char *name, int row, const char *value, int len)
Set string in table, ensuring fixed length (right space padding). see cpl_table_set_string.
cpl_error_code gravi_compute_tau0(gravi_data *data)
Compute the QC TAU0 parameter.
cpl_error_code gravi_compute_qc_injection(gravi_data *data)
Compute the QC for the injection stability.
cpl_error_code gravi_compute_qc_ft_opd_estimator(gravi_data *p2vmred_data)
Compute the QC for the FT linearity.
cpl_table * gravi_create_oitarget_table(const cpl_propertylist *header, const char *mode)
Create the OI_TARGET table from the main header.
cpl_propertylist * gravi_data_get_plist(gravi_data *self, const char *extname)
Get the propertylist from EXTNAME.
cpl_error_code gravi_data_add_table(gravi_data *self, cpl_propertylist *plist, const char *extname, cpl_table *table)
Add a BINTABLE extension in gravi_data.
cpl_table * gravi_table_oi_create(int nwave, int nrow, const char *oi_name)
Create the oi table (oi_vis, oi_vis2, oi_t3)