57 #include "gravi_data.h" 58 #include "gravi_dfs.h" 59 #include "gravi_pfits.h" 60 #include "gravi_cpl.h" 62 #include "gravi_utils.h" 64 #include "gravi_vis.h" 65 #include "gravi_eop.h" 74 cpl_error_code gravi_array_online_variance(cpl_array * data, cpl_array * mean, cpl_array * variance,
int n);
87 cpl_table * oi_vis2_avg,
90 const char * phase_ref,
97 cpl_error_code
gravi_vis_average_amp (cpl_table *oi_table,
const char *name,
const char *err,
int nbase);
98 cpl_error_code
gravi_vis_average_phi (cpl_table *oi_table,
const char *name,
const char *err,
int nbase);
101 cpl_size nsamp, cpl_size nwave_new);
103 cpl_size nsamp, cpl_size nwave_new);
110 const char * err, cpl_size maxdeg);
113 cpl_table * in_table,
114 const char * name,
int ntel);
116 cpl_error_code
gravi_vis_flag_median (cpl_table * oi_table,
const char * data,
const char *flag,
double value);
131 double samp[] = {0.97446388, 0.78404357, 2.24226141, 1.85507201, 1.10792943,
132 1.34028771, -0.15399594, 0.07316682, 1.60898976, 0.33111245,
133 0.76767625, -2.1252529 , 0.3898138 , 2.1218198 , 0.51703696,
134 0.38451722, 1.07581416, -0.61435275, 1.91926679, 1.10020069,
135 1.82407999, 1.07367663, 0.46105875, 0.45497282, 1.65549611,
136 1.21647974, -0.32725523, -0.36477508, 0.43947414, 1.0242778 ,
137 2.05617949, 1.06163165, 1.24564147, 2.36249995, 0.20676319,
138 1.30886256, 0.7122533 , 2.28503709, 0.7134141 , -0.19104819,
139 2.9925884 , 0.95761567, 2.11770457, 0.34763896, 0.30040327,
140 2.3535165 , 1.65839907, 1.89819461, 1.67480833, 1.11174145};
143 return samp[rand()%nsamp];
149 cpl_error_code gravi_array_online_variance(cpl_array * data, cpl_array * mean, cpl_array * variance,
int n)
151 cpl_ensure_code (data, CPL_ERROR_NULL_INPUT);
152 cpl_ensure_code (mean, CPL_ERROR_NULL_INPUT);
153 cpl_ensure_code (variance, CPL_ERROR_NULL_INPUT);
154 cpl_ensure_code (n>=0, CPL_ERROR_ILLEGAL_INPUT);
159 double n1 = 1. / ( (double)n + 1.0 );
160 double n2 = (double)n / ( (
double)n + 1.0 );
162 cpl_size size = cpl_array_get_size (data);
170 for (w = 0; w < size; w ++) {
172 rdata = cpl_array_get (data, w, &nv);
173 rmean = cpl_array_get (mean, w, &nv);
174 delta = ( rdata - rmean ) * n1;
176 rmean = rmean + delta;
177 cpl_array_set (mean, w, rmean);
179 cpl_array_set (variance, w,
180 cpl_array_get (variance, w, &nv) * n2 + delta * ( rdata - rmean ));
184 if ( (code=cpl_error_get_code()) ) {
185 return cpl_error_set_message(cpl_func, code,
"Cannot do online variance");
188 return CPL_ERROR_NONE;
212 gravi_msg_function_start(0);
213 cpl_ensure_code (data, CPL_ERROR_NULL_INPUT);
214 cpl_ensure_code (n>=0, CPL_ERROR_ILLEGAL_INPUT);
216 cpl_size size = cpl_array_get_size (data[0]);
217 cpl_msg_debug(cpl_func,
"Start function");
222 cpl_array_add (data[2], data[0]);
227 for (
int w=0; w<size; w++ ) {
228 cpl_array_set (data[0], w,
229 carg( cexp (1*I* (cpl_array_get(data[0], w, NULL) -
230 cpl_array_get(data[2], w, NULL))) ) );
235 gravi_array_online_variance(data[0], data[1], data[3], n);
238 cpl_array_fill_window (data[0], 0, size, 0.0);
240 CPLCHECK_MSG (
"Error in online variance");
242 gravi_msg_function_exit(0);
243 return CPL_ERROR_NONE;
266 gravi_msg_function_start(0);
267 cpl_ensure_code (oi_flux_avg, CPL_ERROR_ILLEGAL_OUTPUT);
268 cpl_ensure_code (oi_flux, CPL_ERROR_NULL_INPUT);
269 cpl_ensure_code (nboot>0, CPL_ERROR_ILLEGAL_INPUT);
272 int nv = 0, ntel = 4;
273 cpl_size nrow = cpl_table_get_nrow (oi_flux) / ntel;
274 cpl_size nwave = cpl_table_get_column_depth (oi_flux,
"FLUX");
277 cpl_array ** pFLUX = cpl_table_get_data_array (oi_flux,
"FLUX");
278 cpl_array ** pFLUXERR = cpl_table_get_data_array (oi_flux,
"FLUXERR");
279 double * pINTTIME = cpl_table_get_data_double (oi_flux,
"INT_TIME");
280 double * pMJD = cpl_table_get_data_double (oi_flux,
"MJD");
281 CPLCHECK_MSG (
"Cannot get the data");
284 for (cpl_size tel = 0; tel < ntel; tel++) {
292 double total_exptime = 0.0, mjd_avg = 0.0;
299 int * flag = cpl_malloc(
sizeof(
int) * nrow );
300 for (
int row=0 ; row<nrow; row++ ) {
301 flag[row] = 0; nvalid++;
305 cpl_size nrow_per_seg = CPL_MAX(nvalid / CPL_MIN (nrow, 100), 1);
306 cpl_size nseg = nvalid / nrow_per_seg;
310 cpl_size nsamp = 5, nmontecarlo = CPL_MAX (nsamp - nseg, 0);
312 cpl_msg_info (
"Stat",
"%6lld valid frames over %6lld (%5.1f%%), make %4lld seg. of %5lld (miss %lld), add %lld MonteCarlo",
313 nvalid, nrow, (
double)nvalid/(
double)nrow*100.0,
314 nseg, nrow_per_seg, nvalid - nseg*nrow_per_seg, nmontecarlo);
327 for (
int seg = 0 ; seg < nseg + nmontecarlo; seg ++ ) {
328 cpl_msg_debug(cpl_func,
"pre integration of seg %d start with row %lld", seg, row);
332 while ( r < nrow_per_seg ) {
333 row = (row + 1) % nrow;
334 if ( flag[row] ) {
continue;}
else {r++;}
337 cpl_size rtel = row * ntel + tel;
342 total_exptime += pINTTIME[rtel];
343 mjd_avg += pMJD[rtel] * pINTTIME[rtel];
347 double * tflux = cpl_array_get_data_double (flux[seg]);
350 for (
int w=0; w<nwave; w++ ) {
351 double FLUX = cpl_array_get (pFLUX[rtel], w, NULL);
352 double FLUXERR = cpl_array_get (pFLUXERR[rtel], w, NULL);
355 if ( seg > nseg-1 ) {
374 for (
int boot = 0 ; boot < nboot ; boot ++ ) {
375 cpl_msg_debug(cpl_func,
"Bootstrap %d over %d", boot+1, nboot);
379 for (
int rowb = 0; rowb < nseg; rowb ++){
385 if (boot == 0 ) rows = rowb;
386 else rows = rand()%(nseg+nmontecarlo);
389 cpl_array_add (flux_res[0], flux[rows]);
397 CPLCHECK_MSG(
"while computing the variances over the bootstrap");
402 FREELOOP (cpl_array_delete, flux, nseg + nmontecarlo);
405 cpl_msg_debug(cpl_func,
"Put the RMS over bootstrap");
406 cpl_array_power (flux_res[3], 0.5);
407 CPLCHECK_MSG(
"while converting variance -> rms");
410 mjd_avg /= total_exptime;
418 cpl_msg_debug (cpl_func,
"Not valid frames, force zero and infinit RMS");
419 cpl_array_fill_window (flux_res[3], 0, nwave, 1e10);
420 mjd_avg = cpl_table_get_column_mean (oi_flux,
"MJD");
428 cpl_table_set_array (oi_flux_avg,
"FLUX", tel, flux_res[2]);
429 cpl_table_set_array (oi_flux_avg,
"FLUXERR", tel, flux_res[3]);
430 CPLCHECK_MSG(
"filling FLUX and FLUXERR");
434 CPLCHECK_MSG(
"cannot flag baddata data");
437 cpl_msg_debug(cpl_func,
"Total integration time = %.3f s", total_exptime);
438 cpl_table_set_double (oi_flux_avg,
"INT_TIME", tel, total_exptime);
439 cpl_table_set_double (oi_flux_avg,
"MJD", tel, mjd_avg);
440 cpl_table_set (oi_flux_avg,
"NVALID", tel, nvalid);
441 cpl_table_set (oi_flux_avg,
"NDIT", tel, nrow);
444 cpl_table_set_int (oi_flux_avg,
"TARGET_ID", tel, cpl_table_get_int (oi_flux,
"TARGET_ID", tel, &nv));
445 cpl_table_set_int (oi_flux_avg,
"STA_INDEX", tel, cpl_table_get_int (oi_flux,
"STA_INDEX", tel, &nv));
447 FREELOOP (cpl_array_delete, flux_res, 4);
452 gravi_msg_function_exit(0);
453 return CPL_ERROR_NONE;
480 gravi_msg_function_start(0);
481 cpl_ensure_code (oi_t3_avg, CPL_ERROR_ILLEGAL_OUTPUT);
482 cpl_ensure_code (oi_vis, CPL_ERROR_NULL_INPUT);
483 cpl_ensure_code (oi_flux, CPL_ERROR_NULL_INPUT);
484 cpl_ensure_code (nboot>0, CPL_ERROR_ILLEGAL_INPUT);
492 int nv = 0, nbase = 6, ntel = 4, nclo = 4;
494 cpl_size nrow = cpl_table_get_nrow (oi_vis) / nbase;
495 cpl_size nwave = cpl_table_get_column_depth (oi_vis,
"VISDATA");
498 cpl_array ** pVISDATA = cpl_table_get_data_array (oi_vis,
"VISDATA");
499 cpl_array ** pVISERR = cpl_table_get_data_array (oi_vis,
"VISERR");
500 cpl_array ** pFLUX = cpl_table_get_data_array (oi_flux,
"FLUX");
501 double * pINTTIME = cpl_table_get_data_double (oi_vis,
"INT_TIME");
502 double * pMJD = cpl_table_get_data_double (oi_vis,
"MJD");
503 double * pUCOORD = cpl_table_get_data_double (oi_vis,
"UCOORD");
504 double * pVCOORD = cpl_table_get_data_double (oi_vis,
"VCOORD");
505 cpl_array ** pVFACTOR = use_vFactor?cpl_table_get_data_array (oi_vis,
"V_FACTOR"):NULL;
506 double * pPFACTOR = use_pFactor?cpl_table_get_data_double (oi_vis,
"P_FACTOR"):NULL;
507 CPLCHECK_MSG (
"Cannot get the data");
510 for (cpl_size closure = 0; closure < nclo; closure++) {
513 int base0 = GRAVI_CLO_BASE[closure][0];
514 int base1 = GRAVI_CLO_BASE[closure][1];
515 int base2 = GRAVI_CLO_BASE[closure][2];
516 int ctel0 = GRAVI_CLO_TEL[closure][0];
517 int ctel1 = GRAVI_CLO_TEL[closure][1];
518 int ctel2 = GRAVI_CLO_TEL[closure][2];
524 double total_exptime = 0.0, mjd_avg = 0.0;
525 double u1Coord = 0.0, v1Coord = 0.0, u2Coord = 0.0, v2Coord = 0.0;
532 int * flag = cpl_table_get_data_int (oi_vis,
"REJECTION_FLAG");
533 cpl_ensure_code (flag, CPL_ERROR_ILLEGAL_INPUT);
534 int * flagclo = cpl_malloc(
sizeof(
int) * nrow );
535 for (
int row=0 ; row<nrow; row++ ) {
536 flagclo[row] = flag[row * nbase + base0] + flag[row * nbase + base1] + flag[row * nbase + base2];
537 if ( flagclo[row] == 0 ) nvalid++;
541 cpl_size nrow_per_seg = CPL_MAX (nvalid / CPL_MIN (nrow, 100), 1);
542 cpl_size nseg = nvalid / nrow_per_seg;
546 cpl_size nsamp = 5, nmontecarlo = CPL_MAX (nsamp - nseg, 0);
548 cpl_msg_info (
"Stat",
"%6lld valid frames over %6lld (%5.1f%%), make %4lld seg. of %5lld (miss %lld), add %lld MonteCarlo",
549 nvalid, nrow, (
double)nvalid/(
double)nrow*100.0,
550 nseg, nrow_per_seg, nvalid - nseg*nrow_per_seg, nmontecarlo);
564 for (
int seg = 0 ; seg < nseg + nmontecarlo ; seg ++ ) {
565 cpl_msg_debug(cpl_func,
"pre integration of seg %d start with row %lld", seg, row);
569 while ( r < nrow_per_seg ) {
570 row = (row + 1) % nrow;
571 if ( flagclo[row] ) {
continue;}
else {r++;}
574 cpl_size rbase0 = row * nbase + base0;
575 cpl_size rbase1 = row * nbase + base1;
576 cpl_size rbase2 = row * nbase + base2;
581 total_exptime += pINTTIME[rbase0];
582 mjd_avg += pMJD[rbase0] * pINTTIME[rbase0];
583 u1Coord += pUCOORD[rbase0] * pINTTIME[rbase0];
584 v1Coord += pVCOORD[rbase0] * pINTTIME[rbase0];
585 u2Coord += pUCOORD[rbase1] * pINTTIME[rbase0];
586 v2Coord += pVCOORD[rbase1] * pINTTIME[rbase0];
590 double complex * tbisp = cpl_array_get_data_double_complex (bisp[seg]);
591 double *tF012 = cpl_array_get_data_double (F012[seg]);
592 CPLCHECK_MSG (
"Cannot get data");
594 double PFACTOR0 = (use_pFactor?pPFACTOR[rbase0]:1.0);
595 double PFACTOR1 = (use_pFactor?pPFACTOR[rbase1]:1.0);
596 double PFACTOR2 = (use_pFactor?pPFACTOR[rbase2]:1.0);
597 CPLCHECK_MSG (
"Cannot get FACTOR data");
600 for (
int w=0; w<nwave; w++ ) {
601 double complex Vis0 = cpl_array_get_complex (pVISDATA[rbase0], w, NULL);
602 double complex Vis1 = cpl_array_get_complex (pVISDATA[rbase1], w, NULL);
603 double complex Vis2 = cpl_array_get_complex (pVISDATA[rbase2], w, NULL);
604 double complex VisErr0 = cpl_array_get_complex (pVISERR[rbase0], w, NULL);
605 double complex VisErr1 = cpl_array_get_complex (pVISERR[rbase1], w, NULL);
606 double complex VisErr2 = cpl_array_get_complex (pVISERR[rbase2], w, NULL);
607 double F0 = cpl_array_get (pFLUX[row * ntel + ctel0], w, NULL);
608 double F1 = cpl_array_get (pFLUX[row * ntel + ctel1], w, NULL);
609 double F2 = cpl_array_get (pFLUX[row * ntel + ctel2], w, NULL);
610 double VFACTOR0 = (use_vFactor?cpl_array_get (pVFACTOR[row * nbase + base0], w, NULL):1.0);
611 double VFACTOR1 = (use_vFactor?cpl_array_get (pVFACTOR[row * nbase + base1], w, NULL):1.0);
612 double VFACTOR2 = (use_vFactor?cpl_array_get (pVFACTOR[row * nbase + base2], w, NULL):1.0);
616 if ( seg > nseg-1 ) {
626 tbisp[w] += Vis0 * Vis1 * conj (Vis2);
630 tF012[w] += F0 * F1 * F2 *
631 sqrt (CPL_MAX (VFACTOR0 * VFACTOR1 * VFACTOR2 *
632 PFACTOR0 * PFACTOR1 * PFACTOR2, 0.0));
646 for (
int boot = 0 ; boot < nboot ; boot ++ ) {
647 cpl_msg_debug(cpl_func,
"Bootstrap %d over %d", boot+1, nboot);
650 cpl_array * bisp_boot = gravi_array_init_double_complex (nwave, 0.0 + I*0.0);
651 cpl_array * f012_boot = gravi_array_init_double (nwave, 0.0);
655 for (
int rowb = 0; rowb < nseg; rowb ++){
661 if (boot == 0 ) rows = rowb;
662 else rows = rand()%(nseg+nmontecarlo);
665 cpl_array_add (bisp_boot, bisp[rows]);
666 cpl_array_add (f012_boot, F012[rows]);
671 gravi_array_threshold_min (f012_boot, 0.0, 1e-15);
674 FREE (cpl_array_delete, t3Amp_res[0]);
675 t3Amp_res[0] = cpl_array_duplicate(bisp_boot);
676 cpl_array_abs (t3Amp_res[0]);
677 cpl_array_divide (t3Amp_res[0], f012_boot);
679 FREE (cpl_array_delete, t3Phi_res[0]);
680 t3Phi_res[0] = cpl_array_duplicate(bisp_boot);
681 cpl_array_arg (t3Phi_res[0]);
688 FREE (cpl_array_delete, bisp_boot);
689 FREE (cpl_array_delete, f012_boot);
690 CPLCHECK_MSG(
"while computing the variances over the bootstrap");
695 FREELOOP (cpl_array_delete, bisp, nseg + nmontecarlo);
696 FREELOOP (cpl_array_delete, F012, nseg + nmontecarlo);
699 cpl_msg_debug(cpl_func,
"Put the RMS over bootstrap");
700 cpl_array_power (t3Phi_res[3], 0.5);
701 cpl_array_power (t3Amp_res[3], 0.5);
702 CPLCHECK_MSG(
"while converting variance -> rms");
705 mjd_avg /= total_exptime;
706 u1Coord /= total_exptime;
707 v1Coord /= total_exptime;
708 u2Coord /= total_exptime;
709 v2Coord /= total_exptime;
717 cpl_msg_debug (cpl_func,
"Not valid frames, force zero and infinit RMS");
718 cpl_array_fill_window (t3Amp_res[3], 0, nwave, 1e10);
719 cpl_array_fill_window (t3Phi_res[3], 0, nwave, 1e10);
720 mjd_avg = cpl_table_get_column_mean (oi_vis,
"MJD");
728 cpl_table_set_array (oi_t3_avg,
"T3AMP", closure, t3Amp_res[2]);
729 cpl_table_set_array (oi_t3_avg,
"T3AMPERR", closure, t3Amp_res[3]);
730 CPLCHECK_MSG(
"filling T3AMP");
733 gravi_table_set_array_phase (oi_t3_avg,
"T3PHI", closure, t3Phi_res[2]);
734 gravi_table_set_array_phase (oi_t3_avg,
"T3PHIERR", closure, t3Phi_res[3]);
735 CPLCHECK_MSG(
"filling T3PHI");
741 CPLCHECK_MSG(
"cannot flag baddata data");
744 cpl_msg_debug(cpl_func,
"Total integration time = %.3f s", total_exptime);
745 cpl_table_set_double (oi_t3_avg,
"INT_TIME", closure, total_exptime);
746 cpl_table_set_double (oi_t3_avg,
"MJD", closure, mjd_avg);
747 cpl_table_set_double (oi_t3_avg,
"U1COORD", closure, u1Coord);
748 cpl_table_set_double (oi_t3_avg,
"V1COORD", closure, v1Coord);
749 cpl_table_set_double (oi_t3_avg,
"U2COORD", closure, u2Coord);
750 cpl_table_set_double (oi_t3_avg,
"V2COORD", closure, v2Coord);
751 cpl_table_set (oi_t3_avg,
"NVALID", closure, nvalid);
752 cpl_table_set (oi_t3_avg,
"NDIT", closure, nrow);
755 cpl_table_set_int (oi_t3_avg,
"TARGET_ID", closure, cpl_table_get_int (oi_vis,
"TARGET_ID", base0, &nv));
758 cpl_array * sta_index = cpl_array_new (3, CPL_TYPE_INT);
759 cpl_array_set_int (sta_index, 0, cpl_table_get_int (oi_flux,
"STA_INDEX", ctel0, &nv));
760 cpl_array_set_int (sta_index, 1, cpl_table_get_int (oi_flux,
"STA_INDEX", ctel1, &nv));
761 cpl_array_set_int (sta_index, 2, cpl_table_get_int (oi_flux,
"STA_INDEX", ctel2, &nv));
762 cpl_table_set_array (oi_t3_avg,
"STA_INDEX", closure, sta_index);
763 FREE (cpl_array_delete, sta_index);
766 FREELOOP (cpl_array_delete, t3Phi_res, 4);
767 FREELOOP (cpl_array_delete, t3Amp_res, 4);
768 FREE (cpl_free, flagclo);
772 gravi_msg_function_exit(0);
773 return CPL_ERROR_NONE;
798 cpl_table * oi_vis2_avg,
801 const char * phase_ref,
806 gravi_msg_function_start(0);
807 cpl_ensure_code (oi_vis_avg, CPL_ERROR_ILLEGAL_OUTPUT);
808 cpl_ensure_code (oi_vis2_avg, CPL_ERROR_ILLEGAL_OUTPUT);
809 cpl_ensure_code (oi_vis, CPL_ERROR_NULL_INPUT);
810 cpl_ensure_code (nboot>0, CPL_ERROR_ILLEGAL_INPUT);
813 int nv = 0, nbase = 6;
814 cpl_size nrow = cpl_table_get_nrow (oi_vis) / nbase;
815 cpl_size nwave = cpl_table_get_column_depth (oi_vis,
"VISDATA");
818 cpl_array ** pVISDATA = cpl_table_get_data_array (oi_vis,
"VISDATA");
819 cpl_array ** pVISERR = cpl_table_get_data_array (oi_vis,
"VISERR");
820 cpl_array ** pFNORM = cpl_table_get_data_array (oi_vis,
"F1F2");
821 double * pINTTIME = cpl_table_get_data_double (oi_vis,
"INT_TIME");
822 double * pMJD = cpl_table_get_data_double (oi_vis,
"MJD");
823 double * pUCOORD = cpl_table_get_data_double (oi_vis,
"UCOORD");
824 double * pVCOORD = cpl_table_get_data_double (oi_vis,
"VCOORD");
825 cpl_array ** pVFACTOR = use_vFactor?cpl_table_get_data_array (oi_vis,
"V_FACTOR"):NULL;
826 double * pPFACTOR = use_pFactor?cpl_table_get_data_double (oi_vis,
"P_FACTOR"):NULL;
827 CPLCHECK_MSG (
"Cannot get the data");
830 cpl_array ** pPHASEREF = NULL;
831 if (phase_ref && strcmp (phase_ref,
"NONE"))
832 pPHASEREF = cpl_table_get_data_array (oi_vis, phase_ref);
833 CPLCHECK_MSG (
"Cannot get the reference phase data (column missing?)");
836 for (cpl_size base = 0; base < nbase; base ++) {
848 double total_exptime = 0.0, mjd_avg = 0.0;
849 double uCoord = 0.0, vCoord = 0.0;
856 int * flag = cpl_table_get_data_int (oi_vis,
"REJECTION_FLAG");
857 cpl_ensure_code (flag, CPL_ERROR_ILLEGAL_INPUT);
858 for (
int row=0 ; row<nrow; row++ )
if ( flag[row * nbase + base] == 0 ) nvalid++;
861 cpl_size nrow_per_seg = CPL_MAX (nvalid / CPL_MIN (nrow, 100), 1);
862 cpl_size nseg = nvalid / nrow_per_seg;
866 cpl_size nsamp = 5, nmontecarlo = CPL_MAX (nsamp - nseg, 0);
868 cpl_msg_info (
"Stat",
"%6lld valid frames over %6lld (%5.1f%%), make %4lld seg. of %5lld (miss %lld), add %lld MonteCarlo",
869 nvalid, nrow, (
double)nvalid/(
double)nrow*100.0,
870 nseg, nrow_per_seg, nvalid - nseg*nrow_per_seg, nmontecarlo);
886 for (
int seg = 0 ; seg < nseg + nmontecarlo ; seg ++ ) {
887 cpl_msg_debug(cpl_func,
"pre integration of seg %d start with row %lld", seg, row);
891 while ( r < nrow_per_seg ) {
892 row = (row + 1) % nrow;
893 if ( flag[row * nbase + base] ) {
continue;}
else {r++;}
896 cpl_size rbase = row * nbase + base;
901 total_exptime += pINTTIME[rbase];
902 mjd_avg += pMJD[rbase] * pINTTIME[rbase];
903 uCoord += pUCOORD[rbase] * pINTTIME[rbase];
904 vCoord += pVCOORD[rbase] * pINTTIME[rbase];
908 double *tR = cpl_array_get_data_double (visR[seg]);
909 double *tI = cpl_array_get_data_double (visI[seg]);
910 double *tP = cpl_array_get_data_double (POWER[seg]);
911 double *tF1F2 = cpl_array_get_data_double (F1F2[seg]);
912 double *tF12 = cpl_array_get_data_double (F12[seg]);
913 CPLCHECK_MSG (
"Cannot get data");
915 double PFACTOR = (use_pFactor?pPFACTOR[rbase]:1.0);
916 CPLCHECK_MSG (
"Cannot get FACTOR data");
919 for (
int w = 0; w < nwave; w++) {
920 double VFACTOR = use_vFactor?cpl_array_get (pVFACTOR[rbase], w, NULL):1.0;
921 double PHASEREF = pPHASEREF?cpl_array_get (pPHASEREF[rbase], w, NULL):0.0;
922 double FNORM = cpl_array_get (pFNORM[rbase], w, NULL);
923 double complex Vis = cpl_array_get_complex (pVISDATA[rbase], w, NULL);
924 double complex VErr = cpl_array_get_complex (pVISERR[rbase], w, NULL);
925 double mR = creal (Vis);
926 double mI = cimag (Vis);
927 double eR = creal (VErr);
928 double eI = cimag (VErr);
929 CPLCHECK_MSG (
"Cannot get data");
933 if ( seg > nseg-1 ) {
940 tR[w] += cos(PHASEREF) * mR - sin(PHASEREF) * mI;
941 tI[w] += cos(PHASEREF) * mI + sin(PHASEREF) * mR;
950 tF1F2[w] += FNORM * VFACTOR * PFACTOR;
951 tF12[w] += sqrt( CPL_MAX (FNORM * VFACTOR * PFACTOR, 0.0) );
955 tP[w] += mR*mR + mI*mI - eR*eR - eI*eI;
957 tP[w] += mR*mR + mI*mI;
972 for (
int boot = 0 ; boot < nboot ; boot ++ ) {
973 cpl_msg_debug (cpl_func,
"Bootstrap %d over %d", boot+1, nboot);
976 cpl_array * F12_boot = gravi_array_init_double (nwave, 0.0);
977 cpl_array * F1F2_boot = gravi_array_init_double (nwave, 0.0);
981 for (
int rowb = 0; rowb < nseg; rowb ++) {
987 if (boot == 0 ) rows = rowb;
988 else rows = rand()%(nseg+nmontecarlo);
991 cpl_array_add (visR_res[0], visR[rows]);
992 cpl_array_add (visI_res[0], visI[rows]);
993 cpl_array_add (vis2_res[0], POWER[rows]);
994 cpl_array_add (F12_boot, F12[rows]);
995 cpl_array_add (F1F2_boot, F1F2[rows]);
1002 gravi_array_threshold_min (F1F2_boot, 0.0, 1e-15);
1006 cpl_array_divide (vis2_res[0], F1F2_boot);
1007 CPLCHECK_MSG(
"while computing the energie integration");
1011 FREE (cpl_array_delete, visAmp_res[0]);
1012 visAmp_res[0] = gravi_array_compute_norm2 (visR_res[0], visI_res[0]);
1013 cpl_array_power (visAmp_res[0], 0.5);
1014 cpl_array_divide (visAmp_res[0], F12_boot);
1015 CPLCHECK_MSG(
"while computing the norm of the coherent integration");
1019 FREE (cpl_array_delete, visPhi_res[0]);
1020 visPhi_res[0] = gravi_array_wrap_complex (visR_res[0], visI_res[0]);
1021 cpl_array_arg (visPhi_res[0]);
1030 CPLCHECK_MSG(
"while computing the variances over the bootstrap");
1033 FREE (cpl_array_delete, F12_boot);
1034 FREE (cpl_array_delete, F1F2_boot);
1035 CPLCHECK_MSG(
"while freeing during bootstrap");
1040 FREELOOP (cpl_array_delete, visR, nseg + nmontecarlo);
1041 FREELOOP (cpl_array_delete, visI, nseg + nmontecarlo);
1042 FREELOOP (cpl_array_delete, POWER, nseg + nmontecarlo);
1043 FREELOOP (cpl_array_delete, F12, nseg + nmontecarlo);
1044 FREELOOP (cpl_array_delete, F1F2, nseg + nmontecarlo);
1047 cpl_msg_debug (cpl_func,
"Put the RMS over bootstrap");
1048 cpl_array_power (vis2_res[3], 0.5);
1049 cpl_array_power (visAmp_res[3], 0.5);
1050 cpl_array_power (visPhi_res[3], 0.5);
1051 cpl_array_power (visR_res[3], 0.5);
1052 cpl_array_power (visI_res[3], 0.5);
1053 CPLCHECK_MSG (
"while converting variance -> rms");
1056 mjd_avg /= total_exptime;
1057 uCoord /= total_exptime;
1058 vCoord /= total_exptime;
1066 cpl_msg_debug (cpl_func,
"Not valid frames, force zero and infinit RMS");
1067 cpl_array_fill_window (vis2_res[3], 0, nwave, 1e10);
1068 cpl_array_fill_window (visR_res[3], 0, nwave, 1e10);
1069 cpl_array_fill_window (visI_res[3], 0, nwave, 1e10);
1070 cpl_array_fill_window (visAmp_res[3], 0, nwave, 1e10);
1071 cpl_array_fill_window (visPhi_res[3], 0, nwave, 1e10);
1072 mjd_avg = cpl_table_get_column_mean (oi_vis,
"MJD");
1079 cpl_table_set_array (oi_vis2_avg,
"VIS2DATA", base, vis2_res[2]);
1080 cpl_table_set_array (oi_vis2_avg,
"VIS2ERR", base, vis2_res[3]);
1081 CPLCHECK_MSG(
"filling VIS2");
1083 gravi_table_set_array_double_complex (oi_vis_avg,
"VISDATA", base, visR_res[2], visI_res[2]);
1084 gravi_table_set_array_double_complex (oi_vis_avg,
"VISERR", base, visR_res[3], visI_res[3]);
1085 CPLCHECK_MSG(
"filling VISDATA");
1087 cpl_table_set_array (oi_vis_avg,
"RVIS", base, visR_res[2]);
1088 cpl_table_set_array (oi_vis_avg,
"RVISERR", base, visR_res[3]);
1089 CPLCHECK_MSG(
"filling RVIS");
1091 cpl_table_set_array (oi_vis_avg,
"IVIS", base, visI_res[2]);
1092 cpl_table_set_array (oi_vis_avg,
"IVISERR", base, visI_res[3]);
1093 CPLCHECK_MSG(
"filling IVIS");
1095 cpl_table_set_array (oi_vis_avg,
"VISAMP", base, visAmp_res[2]);
1096 cpl_table_set_array (oi_vis_avg,
"VISAMPERR", base, visAmp_res[3]);
1097 CPLCHECK_MSG(
"filling VISAMP");
1099 gravi_table_set_array_phase (oi_vis_avg,
"VISPHI", base, visPhi_res[2]);
1100 gravi_table_set_array_phase (oi_vis_avg,
"VISPHIERR", base, visPhi_res[3]);
1101 CPLCHECK_MSG(
"filling VISPHI");
1108 CPLCHECK_MSG(
"cannot flag baddata data");
1111 cpl_table_set (oi_vis_avg,
"INT_TIME", base, total_exptime);
1112 cpl_table_set (oi_vis2_avg,
"INT_TIME", base, total_exptime);
1113 cpl_table_set (oi_vis_avg,
"MJD", base, mjd_avg);
1114 cpl_table_set (oi_vis2_avg,
"MJD", base, mjd_avg);
1115 cpl_table_set (oi_vis_avg,
"UCOORD", base, uCoord);
1116 cpl_table_set (oi_vis_avg,
"VCOORD", base, vCoord);
1117 cpl_table_set (oi_vis2_avg,
"UCOORD", base, uCoord);
1118 cpl_table_set (oi_vis2_avg,
"VCOORD", base, vCoord);
1119 CPLCHECK_MSG(
"cannot fill time");
1122 cpl_table_set (oi_vis2_avg,
"NVALID", base, nvalid);
1123 cpl_table_set (oi_vis2_avg,
"NDIT", base, nrow);
1124 cpl_table_set (oi_vis_avg,
"NVALID", base, nvalid);
1125 cpl_table_set (oi_vis_avg,
"NDIT", base, nrow);
1126 CPLCHECK_MSG(
"cannot fill nvalid");
1129 cpl_table_set_int (oi_vis_avg,
"TARGET_ID", base, cpl_table_get_int (oi_vis,
"TARGET_ID", base, &nv));
1130 cpl_table_set_int (oi_vis2_avg,
"TARGET_ID", base, cpl_table_get_int (oi_vis,
"TARGET_ID", base, &nv));
1131 cpl_table_set_array (oi_vis_avg,
"STA_INDEX", base, cpl_table_get_array (oi_vis,
"STA_INDEX", base));
1132 cpl_table_set_array (oi_vis2_avg,
"STA_INDEX", base, cpl_table_get_array (oi_vis,
"STA_INDEX", base));
1135 FREELOOP (cpl_array_delete, vis2_res, 4);
1136 FREELOOP (cpl_array_delete, visAmp_res, 4);
1137 FREELOOP (cpl_array_delete, visPhi_res, 4);
1138 FREELOOP (cpl_array_delete, visR_res, 4);
1139 FREELOOP (cpl_array_delete, visI_res, 4);
1144 gravi_msg_function_exit(0);
1145 return CPL_ERROR_NONE;
1174 const double Asymptot = CPL_MATH_PI / sqrt(3.0);
1175 double c[8] = {2.7191808010909,
1184 double x2, x3, x4, x5, x6, x7, z;
1189 return (0.691 / (Asymptot - x));
1200 z = c[0] * x7 + c[1] * x6 + c[2] * x5 + c[3] * x4 + c[4] * x3 + c[5] * x2 + c[6] * x + c[7];
1219 cpl_array * wavenumber,
1220 const char * phase_ref,
int* cmin,
int* cmax,
int nrange)
1222 gravi_msg_function_start(0);
1223 cpl_ensure_code(oi_vis_avg, CPL_ERROR_ILLEGAL_OUTPUT);
1224 cpl_ensure_code(oi_vis, CPL_ERROR_NULL_INPUT);
1228 cpl_size nrow = cpl_table_get_nrow(oi_vis) / nbase;
1229 cpl_size nwave = cpl_table_get_column_depth(oi_vis,
"VISDATA");
1231 int use_crange = (nrange > 0);
1233 for (
int i = 0; i < nrange; ++i) {
1234 if (cmax[i] - cmin[i] < 1) {
1238 if (cmax[i] > nwave - 1) {
1248 for (
int i = 0; i < nrange; ++i) cpl_msg_info(
"Reference Channel",
"Part %02d [%3d:%3d]", i + 1, cmin[i], cmax[i]);
1250 cpl_msg_info(
"Warning (SELF_VISPHI)",
"Invalid Ranges Found, continuing with default Method.");
1255 cpl_array ** pVISDATA = cpl_table_get_data_array(oi_vis,
"VISDATA");
1256 cpl_array ** pVISERR = cpl_table_get_data_array(oi_vis,
"VISERR");
1257 CPLCHECK_MSG(
"Cannot get the data");
1260 cpl_array ** pPHASEREF = NULL;
1261 if (phase_ref && strcmp(phase_ref,
"NONE"))
1262 pPHASEREF = cpl_table_get_data_array(oi_vis, phase_ref);
1263 CPLCHECK_MSG(
"Cannot get the reference phase data (column missing?)");
1266 for (cpl_size base = 0; base < nbase; base++) {
1269 cpl_size nvalid = 0;
1276 int * flag = cpl_table_get_data_int(oi_vis,
"REJECTION_FLAG");
1277 cpl_ensure_code(flag, CPL_ERROR_ILLEGAL_INPUT);
1278 for (
int row = 0; row < nrow; row++)
if (flag[row * nbase + base] == 0) nvalid++;
1280 cpl_msg_info(
"Stat (SELF_VISPHI)",
"%6lld valid frames over %6lld (%5.1f%%)",
1281 nvalid, nrow, (
double) nvalid / (
double) nrow * 100.0);
1287 cpl_msg_debug(cpl_func,
"No valid frames, force zero and infinite RMS");
1288 cpl_array_fill_window(visPhi_res[1], 0, nwave, 1e10);
1289 gravi_table_set_array_phase(oi_vis_avg,
"VISPHI", base, visPhi_res[0]);
1290 gravi_table_set_array_phase(oi_vis_avg,
"VISPHIERR", base, visPhi_res[1]);
1291 CPLCHECK_MSG(
"filling VISPHI");
1293 FREELOOP(cpl_array_delete, visPhi_res, 2);
1304 for (cpl_size currentRow = 0, validRowIndex = -1; currentRow < nrow; currentRow++) {
1305 if (flag[currentRow * nbase + base]) {
1309 cpl_size rbase = currentRow * nbase + base;
1313 double complex *ptrC = cpl_array_get_data_double_complex(Vis[validRowIndex]);
1314 double complex *ptrEC = cpl_array_get_data_double_complex(EVis[validRowIndex]);
1315 CPLCHECK_MSG(
"Cannot get data");
1318 for (
int w = 0; w < nwave; w++) {
1319 double PHASEREF = pPHASEREF ? cpl_array_get(pPHASEREF[rbase], w, NULL) : 0.0;
1320 double complex vis = cpl_array_get_double_complex(pVISDATA[rbase], w, NULL);
1321 double complex viserr = cpl_array_get_double_complex(pVISERR[rbase], w, NULL);
1322 CPLCHECK_MSG(
"Cannot get data");
1325 ptrC[w] = (cos(PHASEREF) * creal(vis) - sin(PHASEREF) * cimag(vis)) +
1326 I * (cos(PHASEREF) * cimag(vis) + sin(PHASEREF) * creal(vis));
1336 for (
int irow = 0; irow < nvalid; irow++) {
1346 double mean_delay = 0.0;
1351 double mean_phase = carg(cpl_array_get_mean_complex(Vis[irow]));
1352 cpl_array_multiply_scalar_complex(Vis[irow], cexp(-I * mean_phase));
1355 cpl_array *CRef = cpl_array_new(nwave, CPL_TYPE_DOUBLE_COMPLEX);
1356 cpl_array *ECRef = cpl_array_new(nwave, CPL_TYPE_DOUBLE_COMPLEX);
1357 double complex *pCRef = cpl_array_get_data_double_complex(CRef);
1358 double complex *pECRef = cpl_array_get_data_double_complex(ECRef);
1362 for (
int irow = 0; irow < nvalid; irow++) {
1364 double complex totalVis = 0.0 + I * 0.0;
1365 double complex totalEVis = 0.0 + I * 0.0;
1367 double complex *pVis = cpl_array_get_data_double_complex(Vis[irow]);
1368 double complex *pEVis = cpl_array_get_data_double_complex(EVis[irow]);
1370 double complex *pW1 = cpl_array_get_data_double_complex(W1[irow]);
1371 double complex *pEW1 = cpl_array_get_data_double_complex(EW1[irow]);
1373 CPLCHECK_MSG(
"Cannot get data");
1377 for (
int i = 0; i < nrange; ++i) {
1378 for (
int w = cmin[i]; w < cmax[i]; ++w) {
1379 totalVis += pVis[w];
1380 totalEVis += pEVis[w];
1384 for (
int w = 0; w < nwave; w++) {
1385 cpl_array_set_double_complex(CRef, w, totalVis / nchans);
1386 cpl_array_set_double_complex(ECRef, w, totalEVis / nchans);
1390 for (
int w = 0; w < nwave; w++) {
1391 totalVis += pVis[w];
1392 totalEVis += pEVis[w];
1400 int divider = nwave - (2 * radius) - 1;
1401 for (; iw < radius; iw++) {
1402 cpl_array_set_double_complex(CRef, iw, totalVis / nwave);
1403 cpl_array_set_double_complex(ECRef, iw, totalEVis / nwave);
1405 for (; iw < nwave - radius; iw++) {
1406 double complex tmp = 0.0 + I * 0.0;
1407 double complex Etmp = 0.0 + I * 0.0;
1408 for (
int j = iw; j < iw + 2 * radius + 1; ++j) tmp += pVis[iw];
1409 cpl_array_set_double_complex(CRef, iw, (totalVis - tmp) / divider);
1410 for (
int j = iw; j < iw + 2 * radius + 1; ++j) Etmp += pEVis[iw];
1411 cpl_array_set_double_complex(ECRef, iw, (totalEVis - Etmp) / divider);
1413 for (; iw < radius; iw++) {
1414 cpl_array_set_double_complex(CRef, iw, totalVis / nwave);
1415 cpl_array_set_double_complex(ECRef, iw, totalEVis / nwave);
1419 for (
int w = 0; w < nwave; w++) {
1420 pW1[w] = pVis[w] * conj(pCRef[w]);
1425 pEW1[w] = (creal(pEVis[w]) * pow(creal(pCRef[w]), 2) +
1426 creal(pECRef[w]) * pow(creal(pVis[w]), 2) +
1427 cimag(pVis[w]) * pow(cimag(pCRef[w]), 2) +
1428 cimag(pECRef[w]) + pow(cimag(pVis[w]), 2)) +
1431 cimag(pVis[w]) * pow(creal(pCRef[w]), 2) +
1432 cimag(pECRef[w]) * pow(creal(pVis[w]), 2) +
1433 creal(pVis[w]) * pow(cimag(pCRef[w]), 2) +
1434 creal(pECRef[w]) + pow(cimag(pVis[w]), 2)
1439 FREE(cpl_array_delete, CRef);
1440 FREE(cpl_array_delete, ECRef);
1441 FREELOOP(cpl_array_delete, Vis, nvalid);
1442 FREELOOP(cpl_array_delete, EVis, nvalid);
1444 double *pPhi = cpl_array_get_data_double(visPhi_res[0]);
1445 double *pPhiErr = cpl_array_get_data_double(visPhi_res[1]);
1448 for (
int w = 0; w < nwave; w++) {
1449 cpl_array *cpxVisVect = cpl_array_new(nvalid, CPL_TYPE_DOUBLE_COMPLEX);
1452 for (
int irow = 0; irow < nvalid; irow++) {
1453 const double complex *pW1 = cpl_array_get_data_double_complex_const(W1[irow]);
1454 cpl_array_set_double_complex(cpxVisVect, irow, pW1[w]);
1458 double complex w1Avg;
1459 w1Avg = cpl_array_get_mean_complex(cpxVisVect);
1462 pPhi[w] = atan2(cimag(w1Avg), creal(w1Avg));
1464 w1Avg = conj(w1Avg);
1465 cpl_array *Vect = cpl_array_new(nvalid, CPL_TYPE_DOUBLE);
1466 for (
int irow = 0; irow < nvalid; irow++) {
1467 const double complex *tW1 = cpl_array_get_data_double_complex_const(W1[irow]);
1469 cpl_array_set_double(Vect, irow, atan2(cimag(tW1[w] * w1Avg), creal(tW1[w] * w1Avg)));
1471 double x = cpl_array_get_stdev(Vect);
1475 FREE(cpl_array_delete, cpxVisVect);
1476 FREE(cpl_array_delete, Vect);
1480 gravi_table_set_array_phase(oi_vis_avg,
"VISPHI", base, visPhi_res[0]);
1481 gravi_table_set_array_phase(oi_vis_avg,
"VISPHIERR", base, visPhi_res[1]);
1482 CPLCHECK_MSG(
"filling VISPHI");
1484 FREELOOP(cpl_array_delete, visPhi_res, 2);
1486 FREELOOP(cpl_array_delete, EW1 , nvalid);
1487 FREELOOP(cpl_array_delete, W1 , nvalid);
1494 gravi_msg_function_exit(0);
1495 return CPL_ERROR_NONE;
1510 const cpl_parameterlist * parlist,
1511 cpl_size * current_frame)
1513 gravi_msg_function_start(1);
1514 cpl_ensure (p2vmred_data, CPL_ERROR_NULL_INPUT, NULL);
1515 cpl_ensure (parlist, CPL_ERROR_NULL_INPUT, NULL);
1517 int nv, nbase = 6, ntel = 4;
1524 cpl_size max_frame = gravi_param_get_int (parlist,
"gravity.vis.max-frame");
1525 cpl_msg_info (cpl_func,
"Average %lli frames starting from %lli",
1526 max_frame, *current_frame);
1531 cpl_propertylist * p2vmred_header = gravi_data_get_header (p2vmred_data);
1532 double dit_sc = gravi_pfits_get_dit_sc (p2vmred_header) * 1e6;
1535 int npol_sc = gravi_pfits_get_pola_num (p2vmred_header, GRAVI_SC);
1536 cpl_table * vis_SC = gravi_data_get_oi_vis (p2vmred_data, GRAVI_SC, 0, npol_sc);
1537 cpl_size nrow = cpl_table_get_nrow (vis_SC) / nbase;
1540 cpl_size sframe = *current_frame;
1541 cpl_size eframe = CPL_MIN (*current_frame + max_frame - 1, nrow-1);
1544 if (eframe >= nrow-1) *current_frame = -1;
1545 else *current_frame += max_frame;
1548 double start_time, end_time;
1549 start_time = cpl_table_get (vis_SC,
"TIME", sframe*nbase, &nv) - dit_sc/2;
1550 end_time = cpl_table_get (vis_SC,
"TIME", eframe*nbase, &nv) + dit_sc/2;
1553 cpl_msg_info (cpl_func,
"Integrate frames: first = %lli last = %lli", sframe, eframe);
1554 cpl_msg_info (cpl_func,
"start = %f end = %f [s]", start_time*1e-6, end_time*1e-6);
1561 cpl_msg_info(cpl_func,
"Construction of the averaged output data");
1564 cpl_propertylist * vis_header = gravi_data_get_header (vis_data);
1565 cpl_propertylist_append (vis_header, p2vmred_header);
1573 CPLCHECK_NUL (
"Cannot get tables for output data");
1580 cpl_msg_info (cpl_func,
"P2VMRED data has no FT extensions");
1584 int v_factor_flag_ft = 0;
1585 int p_factor_flag_ft = 0;
1586 int debiasing_flag_ft = gravi_param_get_bool (parlist,
"gravity.vis.debias-ft");
1587 int nboot_ft = gravi_param_get_int (parlist,
"gravity.vis.nboot");
1588 const char * phase_ref_ft =
"SELF_REF";
1589 CPLCHECK_NUL(
"Cannot get parameters");
1591 cpl_msg_info (cpl_func,
"Bias subtraction of V2 for FT is %s",debiasing_flag_ft?
"ENABLE":
"DISABLE");
1592 cpl_msg_info (cpl_func,
"Reference phase for FT is %s",phase_ref_ft);
1598 int npol_ft = gravi_pfits_get_pola_num (p2vmred_header, GRAVI_FT);
1599 for (
int pol = 0; pol < npol_ft; pol++) {
1600 cpl_msg_info (cpl_func,
"Start FT polarisation %d over %d",pol+1, npol_ft);
1603 cpl_table * vis_FT = gravi_data_get_oi_vis (p2vmred_data, GRAVI_FT, pol, npol_ft);
1604 cpl_table * flux_FT = gravi_data_get_oi_flux (p2vmred_data, GRAVI_FT, pol, npol_ft);
1605 int nwave_ft = cpl_table_get_column_depth (vis_FT,
"VISDATA");
1606 CPLCHECK_NUL (
"Cannot get data");
1610 gravi_table_new_column (oi_vis2_FT,
"NDIT", NULL, CPL_TYPE_INT);
1611 gravi_table_new_column (oi_vis2_FT,
"NVALID", NULL, CPL_TYPE_INT);
1614 gravi_table_new_column (oi_vis_FT,
"NDIT", NULL, CPL_TYPE_INT);
1615 gravi_table_new_column (oi_vis_FT,
"NVALID", NULL, CPL_TYPE_INT);
1618 gravi_table_new_column (oi_T3_FT,
"NDIT", NULL, CPL_TYPE_INT);
1619 gravi_table_new_column (oi_T3_FT,
"NVALID", NULL, CPL_TYPE_INT);
1622 gravi_table_new_column (oi_flux_FT,
"NDIT", NULL, CPL_TYPE_INT);
1623 gravi_table_new_column (oi_flux_FT,
"NVALID", NULL, CPL_TYPE_INT);
1624 CPLCHECK_NUL (
"Cannot create product");
1633 cpl_msg_info (cpl_func,
"Compute OIVIS2 and OIVIS for FT");
1641 CPLCHECK_NUL(
"Cannot average the FT frames");
1646 cpl_msg_info (cpl_func,
"Compute OIT3 for FT");
1652 CPLCHECK_NUL(
"Cannot average t3 of FT");
1657 cpl_msg_info (cpl_func,
"Compute OI_FLUX for FT");
1661 CPLCHECK_NUL(
"Cannot average flux of FT");
1666 cpl_propertylist * vis_plist = gravi_data_get_oi_vis_plist (p2vmred_data, GRAVI_FT, pol, npol_ft);
1667 cpl_propertylist * oivis_plist = cpl_propertylist_new();
1668 cpl_propertylist_copy_property (oivis_plist, vis_plist,
"DATE-OBS");
1669 cpl_propertylist_copy_property (oivis_plist, vis_plist,
"EXTVER");
1670 cpl_propertylist_copy_property (oivis_plist, vis_plist,
"ARRNAME");
1671 cpl_propertylist_copy_property (oivis_plist, vis_plist,
"INSNAME");
1672 cpl_propertylist_update_string (oivis_plist,
"AMPTYP",
"absolute");
1673 cpl_propertylist_update_string (oivis_plist,
"PHITYP",
"differential");
1674 cpl_propertylist_update_int (oivis_plist,
"PHIORDER",1);
1677 cpl_propertylist * oivis2_plist = cpl_propertylist_new();
1678 cpl_propertylist_copy_property (oivis2_plist, vis_plist,
"DATE-OBS");
1679 cpl_propertylist_copy_property (oivis2_plist, vis_plist,
"EXTVER");
1680 cpl_propertylist_copy_property (oivis2_plist, vis_plist,
"ARRNAME");
1681 cpl_propertylist_copy_property (oivis2_plist, vis_plist,
"INSNAME");
1684 cpl_propertylist * oit3_plist = cpl_propertylist_new();
1685 cpl_propertylist_copy_property (oit3_plist, vis_plist,
"DATE-OBS");
1686 cpl_propertylist_copy_property (oit3_plist, vis_plist,
"EXTVER");
1687 cpl_propertylist_copy_property (oit3_plist, vis_plist,
"ARRNAME");
1688 cpl_propertylist_copy_property (oit3_plist, vis_plist,
"INSNAME");
1691 cpl_propertylist * oiflux_plist = cpl_propertylist_new();
1692 cpl_propertylist_copy_property (oiflux_plist, vis_plist,
"DATE-OBS");
1693 cpl_propertylist_copy_property (oiflux_plist, vis_plist,
"EXTVER");
1694 cpl_propertylist_copy_property (oiflux_plist, vis_plist,
"ARRNAME");
1695 cpl_propertylist_copy_property (oiflux_plist, vis_plist,
"INSNAME");
1696 cpl_propertylist_update_string (oiflux_plist,
"CALSTAT",
"U");
1697 cpl_propertylist_set_comment (oiflux_plist,
"CALSTAT",
"Uncalibrated flux per telescope");
1700 CPLCHECK_NUL (
"Cannot add tables");
1702 FREE (cpl_table_delete, vis_FT);
1703 FREE (cpl_table_delete, flux_FT);
1713 cpl_msg_info (cpl_func,
"P2VMRED data has no SC extensions");
1719 double SOBJ_X = gravi_pfits_get_sobj_x (p2vmred_header);
1720 double SOBJ_Y = gravi_pfits_get_sobj_y (p2vmred_header);
1721 double SOBJ_R = sqrt(SOBJ_X*SOBJ_X + SOBJ_Y*SOBJ_Y);
1724 const char * phase_ref_sc = gravi_param_get_string (parlist,
"gravity.vis.phase-ref-sc");
1726 if ( !strcmp (phase_ref_sc,
"AUTO") && SOBJ_R > 0.001)
1728 phase_ref_sc =
"IMAGING_REF";
1729 if (cpl_table_has_column (vis_SC, phase_ref_sc) == 0) {
1730 phase_ref_sc =
"PHASE_REF";
1731 cpl_msg_warning (cpl_func,
"No table 'IMAGING_REF', changing mode to phase_ref_sc='PHASE_REF'");
1732 CPLCHECK_NUL(
"tototo....");
1735 else if ( !strcmp (phase_ref_sc,
"AUTO") && SOBJ_R < 0.001)
1736 phase_ref_sc =
"PHASE_REF";
1738 cpl_msg_info (cpl_func,
"Reference phase for SC is %s",phase_ref_sc);
1741 const char * output_phase_sc = gravi_param_get_string (parlist,
"gravity.vis.output-phase-sc");
1743 if ( !strcmp (output_phase_sc,
"AUTO") && SOBJ_R > 0.001)
1744 output_phase_sc =
"ABSOLUTE";
1745 else if ( !strcmp (output_phase_sc,
"AUTO") && SOBJ_R < 0.001)
1746 output_phase_sc =
"DIFFERENTIAL";
1751 if (!strcmp(output_phase_sc,
"SELF_VISPHI")) {
1752 if (strcmp(phase_ref_sc,
"NONE")) {
1753 phase_ref_sc =
"SELF_REF";
1754 cpl_msg_info(cpl_func,
"Reference phase for SC forced to %s due to option SELF_VISPHI", phase_ref_sc);
1755 }
else cpl_msg_info(cpl_func,
"Reference phase for SC is %s", phase_ref_sc);
1756 }
else cpl_msg_info(cpl_func,
"Reference phase for SC is %s", phase_ref_sc);
1758 cpl_msg_info (cpl_func,
"Output phase for SC is %s",output_phase_sc);
1761 int v_factor_flag_sc = strstr (gravi_param_get_string (parlist,
"gravity.vis.vis-correction-sc"),
"VFACTOR") ? 1 : 0;
1762 int p_factor_flag_sc = strstr (gravi_param_get_string (parlist,
"gravity.vis.vis-correction-sc"),
"PFACTOR") ? 1 : 0;
1763 int debiasing_flag_sc = gravi_param_get_bool (parlist,
"gravity.vis.debias-sc");
1764 int nboot_sc = gravi_param_get_int (parlist,
"gravity.vis.nboot");
1765 const char* rangeString = gravi_param_get_string (parlist,
"gravity.vis.output-phase-channels");
1767 cpl_msg_info (cpl_func,
"Bias subtraction of V2 for SC is %s",debiasing_flag_sc?
"ENABLE":
"DISABLE");
1771 if (!strcmp(output_phase_sc,
"SELF_VISPHI")) {
1772 v_factor_flag_sc= 0;
1773 p_factor_flag_sc= 0;
1774 cpl_msg_info(cpl_func,
"vFactor correction for SC is %s due to option SELF_VISPHI", v_factor_flag_sc ?
"ENABLE" :
"DISABLE");
1775 cpl_msg_info(cpl_func,
"pFactor correction for SC is %s due to option SELF_VISPHI", p_factor_flag_sc ?
"ENABLE" :
"DISABLE");
1777 cpl_msg_info (cpl_func,
"vFactor correction for SC is %s",v_factor_flag_sc?
"ENABLE":
"DISABLE");
1778 cpl_msg_info (cpl_func,
"pFactor correction for SC is %s",p_factor_flag_sc?
"ENABLE":
"DISABLE");
1781 CPLCHECK_NUL(
"Cannot get parameters");
1786 int npol_sc = gravi_pfits_get_pola_num (p2vmred_header, GRAVI_SC);
1787 for (
int pol = 0; pol < npol_sc; pol++) {
1788 cpl_msg_info (cpl_func,
"Start SC polarisation %d over %d",pol+1, npol_sc);
1791 cpl_table * vis_SC = gravi_data_get_oi_vis (p2vmred_data, GRAVI_SC, pol, npol_sc);
1792 cpl_table * flux_SC = gravi_data_get_oi_flux (p2vmred_data, GRAVI_SC, pol, npol_sc);
1793 cpl_table * oi_wavelengthsc = gravi_data_get_oi_wave (p2vmred_data, GRAVI_SC, pol, npol_sc);
1794 CPLCHECK_NUL (
"Cannot get data");
1797 cpl_array * wavenumber_sc;
1798 int nwave_sc = cpl_table_get_column_depth (vis_SC,
"VISDATA");
1799 wavenumber_sc = cpl_array_new (nwave_sc, CPL_TYPE_DOUBLE);
1800 for (cpl_size wave = 0; wave < nwave_sc; wave ++){
1801 cpl_array_set (wavenumber_sc, wave, 1./cpl_table_get (oi_wavelengthsc,
"EFF_WAVE", wave, &nv));
1804 CPLCHECK_NUL (
"Cannot build the wave and wavenumber");
1808 gravi_table_new_column (oi_vis2_SC,
"NDIT", NULL, CPL_TYPE_INT);
1809 gravi_table_new_column (oi_vis2_SC,
"NVALID", NULL, CPL_TYPE_INT);
1812 gravi_table_new_column (oi_vis_SC,
"NDIT", NULL, CPL_TYPE_INT);
1813 gravi_table_new_column (oi_vis_SC,
"NVALID", NULL, CPL_TYPE_INT);
1814 gravi_table_new_column (oi_vis_SC,
"GDELAY",
"m", CPL_TYPE_DOUBLE);
1815 gravi_table_new_column (oi_vis_SC,
"PHASE",
"rad", CPL_TYPE_DOUBLE);
1818 gravi_table_new_column (oi_T3_SC,
"NDIT", NULL, CPL_TYPE_INT);
1819 gravi_table_new_column (oi_T3_SC,
"NVALID", NULL, CPL_TYPE_INT);
1822 gravi_table_new_column (oi_flux_SC,
"NDIT", NULL, CPL_TYPE_INT);
1823 gravi_table_new_column (oi_flux_SC,
"NVALID", NULL, CPL_TYPE_INT);
1824 gravi_table_new_column (oi_flux_SC,
"LKDT_MET_FC",
"mjd", CPL_TYPE_DOUBLE);
1826 CPLCHECK_NUL(
"Cannot create columns in averaged OIFITS...");
1835 cpl_msg_info (cpl_func,
"Compute OIVIS2 and OIVIS for SC");
1843 CPLCHECK_NUL(
"Cannot average the SC frames");
1853 CPLCHECK_NUL(
"Cannot compute means.");
1858 if ( !strcmp (output_phase_sc,
"DIFFERENTIAL") ) {
1859 for (
int base = 0; base < nbase; base++) {
1862 cpl_array * visData_sc, * visErr_sc;
1863 visData_sc = cpl_array_cast (cpl_table_get_array (oi_vis_SC,
"VISDATA", base),
1864 CPL_TYPE_DOUBLE_COMPLEX);
1867 visErr_sc = cpl_array_duplicate (visData_sc);
1868 cpl_array_abs (visErr_sc);
1869 cpl_array_divide (visData_sc, visErr_sc);
1872 double mean_delay = 0.0;
1877 cpl_table_set (oi_vis_SC,
"GDELAY", base, mean_delay);
1880 double mean_phase = carg (cpl_array_get_mean_complex (visData_sc));
1881 cpl_array_multiply_scalar_complex (visData_sc, cexp(- I * mean_phase));
1884 cpl_table_set (oi_vis_SC,
"PHASE", base, mean_phase);
1887 cpl_array_arg (visData_sc);
1888 gravi_table_set_array_phase (oi_vis_SC,
"VISPHI", base, visData_sc);
1889 cpl_array_delete (visData_sc);
1890 cpl_array_delete (visErr_sc);
1892 CPLCHECK_NUL(
"when computing the astrometric phase");
1896 if (!strcmp(output_phase_sc,
"SELF_VISPHI")) {
1901 if (strcmp(rangeString,
"UNKNOWN")) {
1904 int l=strlen(rangeString)+1;
1907 str=(
char*)malloc(l);
1908 strncpy(str,rangeString,l);
1909 for (i = 0; i<l; ++i)
if (str[i]!=
' ' && str[i]!=
'\t') str[j++]=str[i];
1912 str1=(
char*)malloc(l);
1913 strncpy(str1,str,l);
1916 token = strtok(str,
"[,]");
1919 token = strtok(NULL,
"[,]");
1922 cmin=(
int*) calloc(nrange,
sizeof(
int));
1923 cmax=(
int*) calloc(nrange,
sizeof(
int));
1925 char *str2, *subtoken;
1926 char *saveptr1, *saveptr2;
1927 for (j = 0; ; j++, str1 = NULL) {
1928 token = strtok_r(str1,
"[,]" , &saveptr1);
1931 for (str2 = token, i=0; i<2 ; str2 = NULL, ++i) {
1932 subtoken = strtok_r(str2,
":", &saveptr2);
1933 if (subtoken == NULL)
1946 cpl_msg_info (cpl_func,
"Compute OIT3 for SC");
1952 CPLCHECK_NUL(
"Cannot average t3 of SC");
1957 cpl_msg_info (cpl_func,
"Compute OI_FLUX for SC");
1961 CPLCHECK_NUL(
"Cannot average flux of SC");
1968 CPLCHECK_NUL (
"Cannot compute mean columns");
1971 for (
int tel = 0; tel < ntel; tel++){
1972 double lockdate = gravi_pfits_get_metfc_lockmjd (p2vmred_header, tel);
1973 cpl_table_set (oi_flux_SC,
"LKDT_MET_FC", tel, lockdate);
1979 cpl_propertylist * vis_plist = gravi_data_get_oi_vis_plist (p2vmred_data, GRAVI_SC, pol, npol_sc);
1980 cpl_propertylist * oivis_plist = cpl_propertylist_new();
1981 cpl_propertylist_copy_property (oivis_plist, vis_plist,
"DATE-OBS");
1982 cpl_propertylist_copy_property (oivis_plist, vis_plist,
"EXTVER");
1983 cpl_propertylist_copy_property (oivis_plist, vis_plist,
"ARRNAME");
1984 cpl_propertylist_copy_property (oivis_plist, vis_plist,
"INSNAME");
1985 cpl_propertylist_update_string (oivis_plist,
"AMPTYP",
"absolute");
1986 if ( !strcmp (output_phase_sc,
"DIFFERENTIAL") )
1987 cpl_propertylist_update_string (oivis_plist,
"PHITYP",
"differential");
1988 if ( !strcmp (output_phase_sc,
"ABSOLUTE") )
1989 cpl_propertylist_update_string (oivis_plist,
"PHITYP",
"absolute");
1990 cpl_propertylist_update_int (oivis_plist,
"PHIORDER",1);
1993 cpl_propertylist * oivis2_plist = cpl_propertylist_new();
1994 cpl_propertylist_copy_property (oivis2_plist, vis_plist,
"DATE-OBS");
1995 cpl_propertylist_copy_property (oivis2_plist, vis_plist,
"EXTVER");
1996 cpl_propertylist_copy_property (oivis2_plist, vis_plist,
"ARRNAME");
1997 cpl_propertylist_copy_property (oivis2_plist, vis_plist,
"INSNAME");
2000 cpl_propertylist * oit3_plist = cpl_propertylist_new();
2001 cpl_propertylist_copy_property (oit3_plist, vis_plist,
"DATE-OBS");
2002 cpl_propertylist_copy_property (oit3_plist, vis_plist,
"EXTVER");
2003 cpl_propertylist_copy_property (oit3_plist, vis_plist,
"ARRNAME");
2004 cpl_propertylist_copy_property (oit3_plist, vis_plist,
"INSNAME");
2007 cpl_propertylist * oiflux_plist = cpl_propertylist_new();
2008 cpl_propertylist_copy_property (oiflux_plist, vis_plist,
"DATE-OBS");
2009 cpl_propertylist_copy_property (oiflux_plist, vis_plist,
"EXTVER");
2010 cpl_propertylist_copy_property (oiflux_plist, vis_plist,
"ARRNAME");
2011 cpl_propertylist_copy_property (oiflux_plist, vis_plist,
"INSNAME");
2012 cpl_propertylist_update_string (oiflux_plist,
"CALSTAT",
"U");
2013 cpl_propertylist_set_comment (oiflux_plist,
"CALSTAT",
"Uncalibrated flux per telescope");
2016 CPLCHECK_NUL (
"Cannot add tables");
2019 FREE (cpl_array_delete, wavenumber_sc);
2020 CPLCHECK_NUL (
"Cannot delete wavenumber");
2022 FREE (cpl_table_delete, vis_SC);
2023 FREE (cpl_table_delete, flux_SC);
2031 double mjd_obs = cpl_table_get_column_mean (
gravi_data_get_table (vis_data, GRAVI_OI_VIS_EXT),
"MJD");
2032 cpl_propertylist_update_int (vis_header, GRAVI_NIGHT_OBS, (
int)floor(mjd_obs-0.625));
2034 gravi_msg_function_exit(1);
2050 gravi_msg_function_start(1);
2051 cpl_ensure_code (vis_data, CPL_ERROR_NULL_INPUT);
2053 int nv, nbase = 6, ntel=4, nclo=4;
2060 cpl_propertylist * vis_header = gravi_data_get_header (vis_data);
2061 cpl_propertylist * plist = gravi_data_get_header (vis_data);
2068 cpl_msg_info (cpl_func,
"VIS data has no FT extensions");
2073 int npol_ft = gravi_pfits_get_pola_num (vis_header, GRAVI_FT);
2074 for (
int pol = 0; pol < npol_ft; pol++) {
2075 cpl_msg_info (cpl_func,
"Start FT polarisation %d over %d",pol+1, npol_ft);
2079 cpl_msg_info (cpl_func,
"Compute QC OIVIS2 and OIVIS for FT");
2081 cpl_table * oi_vis2_FT = gravi_data_get_oi_vis2 (vis_data, GRAVI_FT, pol, npol_ft);
2082 cpl_table * oi_vis_FT = gravi_data_get_oi_vis (vis_data, GRAVI_FT, pol, npol_ft);
2084 for (
int base = 0; base < nbase; base++) {
2087 sprintf (qc_name,
"ESO QC ACCEPTED_RATIO_FT%s_P%d", GRAVI_BASE_NAME[base], pol+1);
2088 double ratio = gravi_table_get_column_mean (oi_vis_FT,
"NVALID", base, nbase) /
2089 gravi_table_get_column_mean (oi_vis_FT,
"NDIT", base, nbase);
2090 cpl_propertylist_update_double (plist, qc_name, round(100 * ratio * 1e2) / 1e2);
2091 cpl_propertylist_set_comment (plist, qc_name,
"[%] of accepted frames");
2093 sprintf (qc_name,
"ESO QC VISPHIERR_FT%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2094 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis_FT,
"VISPHIERR", base, nbase));
2095 cpl_propertylist_set_comment (plist, qc_name,
"[deg] mean over lbd");
2097 sprintf (qc_name,
"ESO QC VIS2_FT%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2098 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis2_FT,
"VIS2DATA", base, nbase));
2099 cpl_propertylist_set_comment (plist, qc_name,
"mean over lbd");
2101 sprintf (qc_name,
"ESO QC VIS2ERR_FT%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2102 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis2_FT,
"VIS2ERR", base, nbase));
2103 cpl_propertylist_set_comment (plist, qc_name,
"mean over lbd");
2105 sprintf (qc_name,
"ESO QC VISAMP_FT%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2106 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis_FT,
"VISAMP", base, nbase));
2107 cpl_propertylist_set_comment (plist, qc_name,
"mean over lbd");
2109 sprintf (qc_name,
"ESO QC VISAMPERR_FT%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2110 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis_FT,
"VISAMPERR", base, nbase));
2111 cpl_propertylist_set_comment (plist, qc_name,
"mean over lbd");
2113 CPLCHECK_MSG(
"Cannot compute QC parameter for OI_VIS for FT");
2119 cpl_msg_info (cpl_func,
"Compute QC OIT3 for FT");
2121 cpl_table * oi_T3_FT = gravi_data_get_oi_t3 (vis_data, GRAVI_FT, pol, npol_ft);
2123 for (
int clo = 0; clo < nclo; clo++){
2125 sprintf (qc_name,
"ESO QC T3PHI_FT%s_P%d AVG", GRAVI_CLO_NAME[clo], pol+1);
2126 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_T3_FT,
"T3PHI", clo, nclo));
2127 cpl_propertylist_set_comment (plist, qc_name,
"[deg] mean over lbd");
2129 sprintf (qc_name,
"ESO QC T3PHIERR_FT%s_P%d AVG", GRAVI_CLO_NAME[clo], pol+1);
2130 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_T3_FT,
"T3PHIERR", clo, nclo));
2131 cpl_propertylist_set_comment (plist, qc_name,
"[deg] mean over lbd");
2133 CPLCHECK_MSG(
"Cannot compute QC parameter for OI_T3 for FT");
2139 cpl_msg_info (cpl_func,
"Compute QC OI_FLUX for FT");
2141 cpl_table * oi_flux_FT = gravi_data_get_oi_flux (vis_data, GRAVI_FT, pol, npol_ft);
2143 for (
int tel = 0; tel < ntel; tel++){
2145 sprintf (qc_name,
"ESO QC FLUX_FT%d_P%d AVG", tel+1, pol+1);
2146 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_flux_FT,
"FLUX", tel, ntel));
2147 cpl_propertylist_set_comment (plist, qc_name,
"[e/total_int_time] mean over lbd");
2149 sprintf (qc_name,
"ESO QC FLUXERR_FT%d_P%d AVG", tel+1, pol+1);
2150 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_flux_FT,
"FLUXERR", tel, ntel));
2151 cpl_propertylist_set_comment (plist, qc_name,
"[e/total_int_time] mean over lbd");
2153 sprintf (qc_name,
"ESO QC FLUXRATE_FT%d_P%d SUM", tel+1, pol+1);
2154 double flux_rate = cpl_array_get_mean (cpl_table_get_array (oi_flux_FT,
"FLUX", tel)) *
2155 cpl_array_get_size (cpl_table_get_array (oi_flux_FT,
"FLUX", tel)) / cpl_table_get_double (oi_flux_FT,
"INT_TIME", tel, &nv);
2156 cpl_propertylist_update_double (plist, qc_name, flux_rate);
2157 cpl_propertylist_set_comment (plist, qc_name,
"[e/s] sum over lbd");
2159 CPLCHECK_MSG(
"Cannot compute QC parameter for OI_FLUX for FT");
2171 cpl_msg_info (cpl_func,
"VIS data has no SC extensions");
2176 int npol_sc = gravi_pfits_get_pola_num (vis_header, GRAVI_SC);
2177 for (
int pol = 0; pol < npol_sc; pol++) {
2182 cpl_msg_info (cpl_func,
"Compute QC OIVIS2 and OIVIS for SC");
2184 cpl_table * oi_vis2_SC = gravi_data_get_oi_vis2 (vis_data, GRAVI_SC, pol, npol_sc);
2185 cpl_table * oi_vis_SC = gravi_data_get_oi_vis (vis_data, GRAVI_SC, pol, npol_sc);
2187 for (
int base = 0; base < nbase; base++) {
2200 sprintf (qc_name,
"ESO QC ACCEPTED_RATIO_SC%s_P%d", GRAVI_BASE_NAME[base], pol+1);
2201 double ratio = gravi_table_get_column_mean (oi_vis_SC,
"NVALID", base, nbase) /
2202 gravi_table_get_column_mean (oi_vis_SC,
"NDIT", base, nbase);
2203 cpl_propertylist_update_double (plist, qc_name, round(100 * ratio * 1e2) / 1e2);
2204 cpl_propertylist_set_comment (plist, qc_name,
"[%] of accepted frames");
2206 sprintf (qc_name,
"ESO QC GD_SC%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2207 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis_SC,
"GDELAY", base, nbase));
2208 cpl_propertylist_set_comment (plist, qc_name,
"[m] mean Group-Delay");
2210 sprintf (qc_name,
"ESO QC VIS2_SC%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2211 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis2_SC,
"VIS2DATA", base, nbase));
2212 cpl_propertylist_set_comment (plist, qc_name,
"mean over lbd");
2214 sprintf (qc_name,
"ESO QC VIS2ERR_SC%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2215 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis2_SC,
"VIS2ERR", base, nbase));
2216 cpl_propertylist_set_comment (plist, qc_name,
"mean over lbd");
2218 sprintf (qc_name,
"ESO QC VISPHI_SC%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2219 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis_SC,
"VISPHI", base, nbase));
2220 cpl_propertylist_set_comment (plist, qc_name,
"[deg] mean over lbd");
2222 sprintf (qc_name,
"ESO QC VISPHIERR_SC%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2223 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis_SC,
"VISPHIERR", base, nbase));
2224 cpl_propertylist_set_comment (plist, qc_name,
"[deg] mean over lbd");
2226 sprintf (qc_name,
"ESO QC VISAMP_SC%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2227 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis_SC,
"VISAMP", base, nbase));
2228 cpl_propertylist_set_comment (plist, qc_name,
"mean over lbd");
2230 sprintf (qc_name,
"ESO QC VISAMPERR_SC%s_P%d AVG", GRAVI_BASE_NAME[base], pol+1);
2231 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_vis_SC,
"VISAMPERR", base, nbase));
2232 cpl_propertylist_set_comment (plist, qc_name,
"mean over lbd");
2234 double coeff2 = gravi_table_get_value (oi_vis_SC,
"PHASE_REF_COEFF", base, 2);
2235 sprintf (qc_name,
"ESO QC PHASE_REF_COEFF2 SC%s_P%d", GRAVI_BASE_NAME[base], pol+1);
2236 cpl_propertylist_update_double (plist, qc_name, coeff2);
2237 cpl_propertylist_set_comment (plist, qc_name,
"[rad] 2sd order of FT phase");
2239 CPLCHECK_MSG(
"Cannot set QC parameter for OI_VIS for SC");
2245 cpl_msg_info (cpl_func,
"Compute QC OIT3 for SC");
2247 cpl_table * oi_T3_SC = gravi_data_get_oi_t3 (vis_data, GRAVI_SC, pol, npol_sc);
2249 for (
int clo = 0; clo < nclo; clo++){
2251 sprintf (qc_name,
"ESO QC T3PHI_SC%s_P%d AVG", GRAVI_CLO_NAME[clo], pol+1);
2252 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_T3_SC,
"T3PHI", clo, nclo));
2253 cpl_propertylist_set_comment (plist, qc_name,
"[deg] mean over lbd");
2255 sprintf (qc_name,
"ESO QC T3PHIERR_SC%s_P%d AVG", GRAVI_CLO_NAME[clo], pol+1);
2256 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_T3_SC,
"T3PHIERR", clo, nclo));
2257 cpl_propertylist_set_comment (plist, qc_name,
"[deg] mean over lbd");
2259 CPLCHECK_MSG(
"Cannot set QC parameter for OI_T3 for SC");
2265 cpl_msg_info (cpl_func,
"Compute QC OI_FLUX for SC");
2267 cpl_table * oi_flux_SC = gravi_data_get_oi_flux (vis_data, GRAVI_SC, pol, npol_sc);
2269 for (
int tel = 0; tel < ntel; tel++){
2271 sprintf (qc_name,
"ESO QC FLUX_SC%d_P%d AVG", tel+1, pol+1);
2272 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_flux_SC,
"FLUX", tel, ntel));
2273 cpl_propertylist_set_comment (plist, qc_name,
"[e/total_int_time] mean over lbd");
2275 sprintf (qc_name,
"ESO QC FLUXERR_SC%d_P%d AVG", tel+1, pol+1);
2276 cpl_propertylist_update_double (plist, qc_name, gravi_table_get_column_mean (oi_flux_SC,
"FLUXERR", tel, ntel));
2277 cpl_propertylist_set_comment (plist, qc_name,
"[e/total_int_time] mean over lbd");
2279 sprintf (qc_name,
"ESO QC FLUXRATE_SC%d_P%d SUM", tel+1, pol+1);
2280 double flux_rate = cpl_array_get_mean (cpl_table_get_array (oi_flux_SC,
"FLUX", tel)) *
2281 cpl_array_get_size(cpl_table_get_array (oi_flux_SC,
"FLUX", tel)) / cpl_table_get_double (oi_flux_SC,
"INT_TIME", tel, &nv);
2282 cpl_propertylist_update_double (plist, qc_name, flux_rate);
2283 cpl_propertylist_set_comment (plist, qc_name,
"[e/s] sum over lbd");
2285 double ftpos_mean = cpl_table_get (oi_flux_SC,
"FT_POS", tel, NULL);
2286 sprintf (qc_name,
"ESO QC FT_POS SC%d_P%d", tel+1, pol+1);
2287 cpl_propertylist_update_double (plist, qc_name, ftpos_mean);
2288 cpl_propertylist_set_comment (plist, qc_name,
"[V]");
2290 double oplair_mean = cpl_table_get (oi_flux_SC,
"OPL_AIR", tel, NULL);
2291 sprintf (qc_name,
"ESO QC OPL_AIR SC%d_P%d", tel+1, pol+1);
2292 cpl_propertylist_update_double (plist, qc_name, oplair_mean);
2293 cpl_propertylist_set_comment (plist, qc_name,
"[m]");
2295 CPLCHECK_MSG(
"Cannot set QC parameter for OI_FLUX for SC");
2302 gravi_msg_function_exit(1);
2303 return CPL_ERROR_NONE;
2319 gravi_msg_function_start(1);
2320 cpl_ensure_code (vis_data, CPL_ERROR_NULL_INPUT);
2322 cpl_propertylist * hdr_data = gravi_data_get_header (vis_data);
2323 int pol, npol = gravi_pfits_get_pola_num (hdr_data, GRAVI_SC);
2326 if ( npol != gravi_pfits_get_pola_num (hdr_data, GRAVI_FT)) {
2327 return cpl_error_set_message(cpl_func,CPL_ERROR_ILLEGAL_INPUT,
"polarisation of SC and FT shall be compatible");
2332 for ( pol= 0 ; pol < npol ; pol++ ) {
2334 cpl_table * oi_wave_sc = gravi_data_get_oi_wave (vis_data, GRAVI_SC, pol, npol);
2335 cpl_table * oi_wave_ft = gravi_data_get_oi_wave (vis_data, GRAVI_FT, pol, npol);
2340 cpl_table * oi_vis2_sc = gravi_data_get_oi_vis2 (vis_data, GRAVI_SC, pol, npol);
2341 cpl_table * oi_vis2_ft = gravi_data_get_oi_vis2 (vis_data, GRAVI_FT, pol, npol);
2342 cpl_table * oi_vis_sc = gravi_data_get_oi_vis (vis_data, GRAVI_SC, pol, npol);
2343 cpl_table * oi_vis_ft = gravi_data_get_oi_vis (vis_data, GRAVI_FT, pol, npol);
2345 CPLCHECK_MSG(
"Cannot get data");
2348 for (cpl_size base = 0; base < cpl_table_get_nrow (oi_vis2_ft); base ++) {
2351 const cpl_array * vis2_ft = cpl_table_get_array (oi_vis2_ft,
"VIS2DATA", base);
2354 cpl_array * vis2_lr = gravi_array_rebin (cpl_table_get_array (oi_vis2_sc,
"VIS2DATA", base),
2355 cpl_table_get_array (oi_vis2_sc,
"VIS2ERR", base),
2356 oi_wave_sc, oi_wave_ft);
2360 qFactor = cpl_array_get_mean (vis2_lr) / cpl_array_get_mean (vis2_ft);
2361 cpl_msg_info (cpl_func,
"vis2 %lli: qFactor = %f", base, qFactor);
2364 cpl_array_divide_scalar (cpl_table_get_data_array (oi_vis2_sc,
"VIS2DATA")[base], qFactor);
2365 cpl_array_divide_scalar (cpl_table_get_data_array (oi_vis2_sc,
"VIS2ERR")[base], qFactor);
2368 const cpl_array * vis_ft = cpl_table_get_array (oi_vis_ft,
"VISAMP", base);
2371 cpl_array * vis_lr = gravi_array_rebin (cpl_table_get_array (oi_vis_sc,
"VISAMP", base),
2372 cpl_table_get_array (oi_vis_sc,
"VISAMPERR", base),
2373 oi_wave_sc, oi_wave_ft);
2376 qFactor = cpl_array_get_mean (vis_lr) / cpl_array_get_mean (vis_ft);
2377 cpl_msg_info (cpl_func,
"visAmp %lli: qFactor = %f", base, qFactor);
2380 cpl_array_divide_scalar (cpl_table_get_data_array (oi_vis_sc,
"VISAMP")[base], qFactor);
2381 cpl_array_divide_scalar (cpl_table_get_data_array (oi_vis_sc,
"VISAMPERR")[base], qFactor);
2383 FREE (cpl_array_delete, vis2_lr);
2384 FREE (cpl_array_delete, vis_lr);
2389 gravi_msg_function_exit(1);
2390 return CPL_ERROR_NONE;
2405 gravi_msg_function_start(1);
2406 cpl_ensure_code (vis_data, CPL_ERROR_NULL_INPUT);
2411 for (
int ext = 0; ext < next; ext ++) {
2413 const char * extname = gravi_data_get_extname (vis_data,ext);
2414 if (!strcmp (extname,
"OI_VIS") ||
2415 !strcmp (extname,
"OI_VIS2") ||
2416 !strcmp (extname,
"OI_T3") ||
2417 !strcmp (extname,
"OI_FLUX")) {
2421 sprintf (date,
"%.10sT00:00:00.000", cpl_propertylist_get_string (plist,
"DATE-OBS"));
2424 double mjd0 = gravi_convert_to_mjd (date);
2425 cpl_msg_debug (cpl_func,
"DATE-OBS = %s -> mjd = %.3f", date, mjd0);
2429 cpl_size nrow = cpl_table_get_nrow (oi_table);
2430 for (cpl_size row = 0; row < nrow; row++) {
2431 double mjd = cpl_table_get (oi_table,
"MJD", row, NULL);
2432 cpl_table_set (oi_table,
"TIME", row, (mjd-mjd0) * 24 * 3600);
2436 cpl_table_set_column_unit (oi_table,
"TIME",
"s");
2440 gravi_msg_function_exit(1);
2441 return CPL_ERROR_NONE;
2459 gravi_msg_function_start(1);
2460 cpl_ensure_code (vis_data, CPL_ERROR_NULL_INPUT);
2461 cpl_ensure_code (p2vm_map, CPL_ERROR_NULL_INPUT);
2463 int num_used_tf = 1;
2464 gravi_data **used_tf_data = &p2vm_map;
2467 cpl_propertylist * hdr_data = gravi_data_get_header (vis_data);
2471 for (
int type_data = 0; type_data < ntype_data ; type_data ++) {
2474 int npol = gravi_pfits_get_pola_num (hdr_data, type_data);
2475 for (
int pol= 0 ; pol < npol ; pol++ ) {
2478 double delta_t = 10000.0;
2481 GRAVI_INSNAME(type_data, pol, npol),
2482 "FLUX",
"FLUXERR", 4, delta_t);
2484 CPLCHECK_MSG(
"Cannot apply normalize flux");
2491 gravi_msg_function_exit(1);
2492 return CPL_ERROR_NONE;
2509 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
2510 cpl_ensure_code (name, CPL_ERROR_NULL_INPUT);
2511 cpl_ensure_code (err, CPL_ERROR_NULL_INPUT);
2513 cpl_size nwave = cpl_table_get_column_depth (oi_table, name);
2514 cpl_array * weight = gravi_array_init_double (nwave, 0.0);
2515 cpl_array * value = gravi_array_init_double (nwave, 0.0);
2518 int nrow = cpl_table_get_nrow (oi_table) / nbase;
2519 for (cpl_size base = 0; base < nbase ; base++) {
2520 cpl_array_fill_window (weight, 0, nwave, 0.0);
2521 cpl_array_fill_window (value, 0, nwave, 0.0);
2524 for (cpl_size row = 0; row < nrow ; row++) {
2525 const cpl_array * rval = cpl_table_get_array (oi_table, name, base + row*nbase);
2526 const cpl_array * rerr = cpl_table_get_array (oi_table, err, base + row*nbase);
2527 const cpl_array * flag = cpl_table_get_array (oi_table,
"FLAG", base + row*nbase);
2528 for (cpl_size wave = 0; wave < nwave; wave++) {
2529 double w = pow (cpl_array_get (rerr, wave, NULL), -2);
2530 if (cpl_array_get (flag, wave, NULL)) w = 10e-20;
2531 double v = cpl_array_get (rval, wave, NULL);
2532 cpl_array_set (weight, wave, cpl_array_get (weight, wave, NULL) + w);
2533 cpl_array_set (value, wave, cpl_array_get (value, wave, NULL) + v * w);
2536 CPLCHECK_MSG(
"Cannot average amp");
2539 cpl_array_divide (value, weight);
2540 cpl_table_set_array (oi_table, name, base, value);
2542 cpl_array_power (weight, -0.5);
2543 cpl_table_set_array (oi_table, err, base, weight);
2549 FREE (cpl_array_delete, weight);
2550 FREE (cpl_array_delete, value);
2551 return CPL_ERROR_NONE;
2569 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
2570 cpl_ensure_code (name, CPL_ERROR_NULL_INPUT);
2571 cpl_ensure_code (err, CPL_ERROR_NULL_INPUT);
2573 cpl_size nwave = cpl_table_get_column_depth (oi_table, name);
2574 cpl_array * weight = gravi_array_init_double (nwave, 0.0);
2575 cpl_array * value = gravi_array_init_double_complex (nwave, 0.0 + I*0.0);
2578 int nrow = cpl_table_get_nrow (oi_table) / nbase;
2579 for (cpl_size base = 0; base < nbase ; base++) {
2580 cpl_array_fill_window (weight, 0, nwave, 0.0);
2581 cpl_array_fill_window_complex (value, 0, nwave, 0.0);
2584 for (cpl_size row = 0; row < nrow ; row++) {
2585 const cpl_array * rval = cpl_table_get_array (oi_table, name, base + row*nbase);
2586 const cpl_array * rerr = cpl_table_get_array (oi_table, err, base + row*nbase);
2587 const cpl_array * flag = cpl_table_get_array (oi_table,
"FLAG", base + row*nbase);
2588 for (cpl_size wave = 0; wave < nwave; wave++) {
2589 double w = pow (cpl_array_get (rerr, wave, NULL), -2);
2590 if (cpl_array_get (flag, wave, NULL)) w = 10e-20;
2591 double complex v = cexp (1.*I * cpl_array_get (rval, wave, NULL) * CPL_MATH_RAD_DEG);
2592 cpl_array_set (weight, wave, cpl_array_get (weight, wave, NULL) + w);
2593 cpl_array_set_complex (value, wave, cpl_array_get_complex (value, wave, NULL) + v * w);
2596 CPLCHECK_MSG(
"Cannot average phi");
2599 gravi_table_set_array_phase (oi_table, name, base, value);
2601 cpl_array_power (weight, -0.5);
2602 cpl_table_set_array (oi_table, err, base, weight);
2606 FREE (cpl_array_delete, weight);
2607 FREE (cpl_array_delete, value);
2608 return CPL_ERROR_NONE;
2625 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
2626 cpl_ensure_code (name, CPL_ERROR_NULL_INPUT);
2630 int nrow = cpl_table_get_nrow (oi_table) / nbase;
2631 for (cpl_size base = 0; base < nbase ; base++) {
2632 double weight = 0.0;
2636 for (cpl_size row = 0; row < nrow ; row++) {
2637 double w = (err!=NULL ? pow (cpl_table_get (oi_table, err, base + row*nbase, &nv), -2.0) : 1.0);
2638 value += cpl_table_get (oi_table, name, base + row*nbase, &nv) * w;
2641 CPLCHECK_MSG(
"Cannot average value");
2644 cpl_table_set (oi_table, name, base, value / weight);
2647 return CPL_ERROR_NONE;
2661 const cpl_parameterlist * parlist)
2663 gravi_msg_function_start(1);
2664 cpl_ensure_code (oi_data, CPL_ERROR_NULL_INPUT);
2665 cpl_ensure_code (parlist, CPL_ERROR_NULL_INPUT);
2670 cpl_propertylist * header = gravi_data_get_header (oi_data);
2675 cpl_msg_info (cpl_func,
"Force VISAMPERR to %.e for all observations", err);
2677 int npol = gravi_pfits_get_pola_num (header, GRAVI_SC);
2678 for (
int pol = 0; pol < npol; pol++) {
2679 cpl_table * oi_table = gravi_data_get_oi_vis (oi_data, GRAVI_SC, pol, npol);
2680 cpl_array ** array = cpl_table_get_data_array (oi_table,
"VISAMPERR");
2681 for (cpl_size row = 0; row<cpl_table_get_nrow (oi_table); row++) {
2682 cpl_array_fill_window (array[row], 0, CPL_SIZE_MAX, err);
2690 cpl_msg_info (cpl_func,
"Force VISPHIERR to %.e for all observations", err);
2692 int npol = gravi_pfits_get_pola_num (header, GRAVI_SC);
2693 for (
int pol = 0; pol < npol; pol++) {
2694 cpl_table * oi_table = gravi_data_get_oi_vis (oi_data, GRAVI_SC, pol, npol);
2695 cpl_array ** array = cpl_table_get_data_array (oi_table,
"VISPHIERR");
2696 for (cpl_size row = 0; row<cpl_table_get_nrow (oi_table); row++) {
2697 cpl_array_fill_window (array[row], 0, CPL_SIZE_MAX, err);
2705 cpl_msg_info (cpl_func,
"Force FLUXERR to %.e for all observations", err);
2707 int npol = gravi_pfits_get_pola_num (header, GRAVI_SC);
2708 for (
int pol = 0; pol < npol; pol++) {
2709 cpl_table * oi_table = gravi_data_get_oi_flux (oi_data, GRAVI_SC, pol, npol);
2710 cpl_array ** array = cpl_table_get_data_array (oi_table,
"FLUXERR");
2711 for (cpl_size row = 0; row<cpl_table_get_nrow (oi_table); row++) {
2712 cpl_array_fill_window (array[row], 0, CPL_SIZE_MAX, err);
2720 cpl_msg_info (cpl_func,
"Force VIS2ERR to %.e for all observations", err);
2722 int npol = gravi_pfits_get_pola_num (header, GRAVI_SC);
2723 for (
int pol = 0; pol < npol; pol++) {
2724 cpl_table * oi_table = gravi_data_get_oi_vis2 (oi_data, GRAVI_SC, pol, npol);
2725 cpl_array ** array = cpl_table_get_data_array (oi_table,
"VIS2ERR");
2726 for (cpl_size row = 0; row<cpl_table_get_nrow (oi_table); row++) {
2727 cpl_array_fill_window (array[row], 0, CPL_SIZE_MAX, err);
2732 gravi_msg_function_exit(1);
2733 return CPL_ERROR_NONE;
2752 gravi_msg_function_start(1);
2753 cpl_ensure_code (oi_data, CPL_ERROR_NULL_INPUT);
2755 gravi_msg_warning (
"FIXME",
"Average the different observation is EXPERIMENTAL");
2757 cpl_msg_warning (cpl_func,
"FIXME: Weightening of UVCOORD and MJD is not done properly yet !");
2758 cpl_msg_warning (cpl_func,
"FIXME: Integration of INT_TIME is not done properly yet !");
2761 cpl_table * oi_table;
2764 cpl_propertylist * header = gravi_data_get_header (oi_data);
2767 for (
int type_data = 0; type_data < 2 ; type_data ++) {
2770 cpl_msg_info (cpl_func,
"OI_VIS has no %s, skip", GRAVI_TYPE(type_data));
2774 int npol = gravi_pfits_get_pola_num (header, type_data);
2775 for (
int pol = 0 ; pol < npol ; pol++ ) {
2777 cpl_size nrow = cpl_table_get_nrow (gravi_data_get_oi_vis (oi_data, type_data, pol, npol))/nbase;
2779 cpl_msg_info (cpl_func,
"OI_VIS %s has only one observation, skip", GRAVI_TYPE(type_data));
2784 oi_table = gravi_data_get_oi_vis (oi_data, type_data, pol, npol);
2795 gravi_msg_warning (
"FIXME",
"VISDATA are not averaged !!!!");
2796 cpl_table_erase_window (oi_table, 6, CPL_SIZE_MAX);
2798 CPLCHECK_MSG (
"Cannot co-add OI_VIS");
2801 oi_table = gravi_data_get_oi_vis2 (oi_data, type_data, pol, npol);
2808 cpl_table_erase_window (oi_table, 6, CPL_SIZE_MAX);
2810 CPLCHECK_MSG (
"Cannot co-add OI_VIS2");
2813 oi_table = gravi_data_get_oi_flux (oi_data, type_data, pol, npol);
2818 cpl_table_erase_window (oi_table, 4, CPL_SIZE_MAX);
2820 CPLCHECK_MSG (
"Cannot co-add OI_FLUX");
2823 oi_table = gravi_data_get_oi_t3 (oi_data, type_data, pol, npol);
2833 cpl_table_erase_window (oi_table, 4, CPL_SIZE_MAX);
2835 CPLCHECK_MSG (
"Cannot co-add OI_T3");
2840 gravi_msg_function_exit(1);
2841 return CPL_ERROR_NONE;
2858 gravi_msg_function_start(1);
2859 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
2860 if (nsamp < 1)
return CPL_ERROR_NONE;
2864 cpl_size nwave = cpl_table_get_column_depth (oi_table, name);
2865 cpl_size nrow = cpl_table_get_nrow (oi_table);
2866 cpl_ensure_code (nrow > 0, CPL_ERROR_ILLEGAL_INPUT);
2869 cpl_array ** v_array = cpl_table_get_data_array (oi_table, name);
2870 cpl_array ** e_array = cpl_table_get_data_array (oi_table, err);
2871 cpl_array ** f_array = cpl_table_get_data_array (oi_table,
"FLAG");
2872 CPLCHECK_MSG (
"Cannot get data");
2875 cpl_array * smo_array = cpl_array_duplicate (v_array[0]);
2876 cpl_array * err_array = cpl_array_duplicate (e_array[0]);
2879 for (cpl_size row = 0 ; row < nrow ; row ++) {
2883 cpl_vector * i_vector = cpl_vector_new (nwave);
2884 for (cpl_size wave = 0; wave < nwave; wave++)
2885 cpl_vector_set (i_vector, wave, cpl_array_get (e_array[row],wave,&nv));
2886 cpl_vector * o_vector;
2887 o_vector = cpl_vector_filter_median_create (i_vector, nsamp);
2890 for (cpl_size wave = 0 ; wave < nwave ; wave ++) {
2891 double sum = 0.0, weight = 0.0;
2894 for (cpl_size samp = CPL_MAX(0,wave-nsamp) ; samp < CPL_MIN(nwave,wave+nsamp) ; samp ++) {
2895 if (cpl_array_get (f_array[row],samp,&nv)) {
2899 double w = pow (cpl_vector_get (o_vector,samp), -2);
2900 sum += cpl_array_get (v_array[row],samp,&nv) * w;
2905 cpl_array_set_double (smo_array, wave, sum / weight);
2906 cpl_array_set_double (err_array, wave, pow (weight, -0.5));
2910 cpl_table_set_array (oi_table, name, row, smo_array);
2911 cpl_table_set_array (oi_table, err, row, err_array);
2912 CPLCHECK_MSG (
"Cannot smooth amp");
2914 FREE (cpl_vector_delete, i_vector);
2915 FREE (cpl_vector_delete, o_vector);
2918 FREE (cpl_array_delete, smo_array);
2919 FREE (cpl_array_delete, err_array);
2921 gravi_msg_function_exit(1);
2922 return CPL_ERROR_NONE;
2939 gravi_msg_function_start(1);
2940 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
2941 if (nsamp < 1)
return CPL_ERROR_NONE;
2944 cpl_size nwave = cpl_table_get_column_depth (oi_table, name);
2945 cpl_size nrow = cpl_table_get_nrow (oi_table);
2946 cpl_ensure_code (nrow > 0, CPL_ERROR_ILLEGAL_INPUT);
2950 cpl_array ** v_array = cpl_table_get_data_array (oi_table, name);
2951 cpl_array ** e_array = cpl_table_get_data_array (oi_table, err);
2952 cpl_array ** f_array = cpl_table_get_data_array (oi_table,
"FLAG");
2953 CPLCHECK_MSG (
"Cannot get data");
2956 cpl_array * smo_array = cpl_array_duplicate (v_array[0]);
2957 cpl_array * err_array = cpl_array_duplicate (e_array[0]);
2960 for (cpl_size row = 0 ; row < nrow ; row ++) {
2964 cpl_vector * i_vector = cpl_vector_new (nwave);
2965 for (cpl_size wave = 0; wave < nwave; wave++)
2966 cpl_vector_set (i_vector, wave, cpl_array_get (e_array[row],wave,&nv));
2967 cpl_vector * o_vector;
2968 o_vector = cpl_vector_filter_median_create (i_vector, nsamp);
2971 for (cpl_size wave = 0 ; wave < nwave ; wave ++) {
2972 double complex sum = 0.0 + I*0.0;
2973 double weight = 0.0;
2976 for (cpl_size samp = CPL_MAX(0,wave-nsamp) ; samp < CPL_MIN(nwave,wave+nsamp) ; samp ++) {
2977 if (cpl_array_get (f_array[row],samp,&nv)) {
2981 double w = pow (cpl_vector_get (o_vector,samp), -2);
2982 sum += cexp (1.*I* cpl_array_get (v_array[row],samp,&nv) * CPL_MATH_RAD_DEG) * w;
2987 cpl_array_set_double (smo_array, wave, carg (sum) * CPL_MATH_DEG_RAD);
2988 cpl_array_set_double (err_array, wave, pow (weight, -0.5));
2992 cpl_table_set_array (oi_table, name, row, smo_array);
2993 cpl_table_set_array (oi_table, err, row, err_array);
2994 CPLCHECK_MSG (
"Cannot smooth phi");
2996 FREE (cpl_vector_delete, i_vector);
2997 FREE (cpl_vector_delete, o_vector);
3000 FREE (cpl_array_delete, smo_array);
3001 FREE (cpl_array_delete, err_array);
3003 gravi_msg_function_exit(1);
3004 return CPL_ERROR_NONE;
3019 const char * err, cpl_size maxdeg)
3021 gravi_msg_function_start(1);
3022 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
3023 if (maxdeg < 0)
return CPL_ERROR_NONE;
3026 cpl_size nwave = cpl_table_get_column_depth (oi_table, name);
3027 cpl_size nrow = cpl_table_get_nrow (oi_table);
3028 cpl_ensure_code (nrow > 0, CPL_ERROR_ILLEGAL_INPUT);
3032 cpl_array ** v_array = cpl_table_get_data_array (oi_table, name);
3033 cpl_array ** e_array = cpl_table_get_data_array (oi_table, err);
3034 cpl_array ** f_array = cpl_table_get_data_array (oi_table,
"FLAG");
3035 CPLCHECK_MSG (
"Cannot get data");
3038 for (cpl_size row = 0 ; row < nrow ; row ++) {
3041 cpl_matrix * coeff = cpl_matrix_new (nwave,maxdeg+1);
3042 cpl_matrix * rhs = cpl_matrix_new (nwave,1);
3045 for (cpl_size wave = 0 ; wave < nwave ; wave ++) {
3046 double weight = cpl_array_get (f_array[row],wave,&nv) ? 10e-20 :
3047 pow (cpl_array_get (e_array[row],wave,&nv), -2);
3048 double value = cpl_array_get (f_array[row],wave,&nv) ? 0.0 :
3049 cpl_array_get (v_array[row],wave,&nv);
3050 cpl_matrix_set (rhs, wave, 0, value * weight);
3051 for (cpl_size deg = 0; deg <= maxdeg; deg++)
3052 cpl_matrix_set (coeff, wave, deg, pow ((
double)wave,(
double)deg) * weight);
3053 CPLCHECK_MSG (
"Cannot fill");
3057 cpl_errorstate prev_state = cpl_errorstate_get();
3058 cpl_matrix * solve = cpl_matrix_solve_normal (coeff, rhs);
3061 if ( !cpl_errorstate_is_equal (prev_state))
3063 cpl_errorstate_dump (prev_state, 0, NULL);
3064 cpl_msg_error (cpl_func,
"%s row=%lld",name,row);
3066 CPLCHECK_MSG (
"Cannot solve matrix");
3069 for (cpl_size wave = 0 ; wave < nwave ; wave ++) {
3071 for (cpl_size deg = 0; deg <= maxdeg; deg++)
3072 value += cpl_matrix_get (solve, deg, 0) * pow (wave, deg);
3073 cpl_array_set (v_array[row],wave,value);
3074 CPLCHECK_MSG (
"Cannot evaluate");
3077 FREE (cpl_matrix_delete, coeff);
3078 FREE (cpl_matrix_delete, rhs);
3079 FREE (cpl_matrix_delete, solve);
3082 gravi_msg_function_exit(1);
3083 return CPL_ERROR_NONE;
3107 gravi_msg_function_start(1);
3108 cpl_ensure_code (oi_data, CPL_ERROR_NULL_INPUT);
3110 cpl_table * oi_table;
3113 cpl_propertylist * header = gravi_data_get_header (oi_data);
3115 int type_data = GRAVI_SC;
3116 int npol = gravi_pfits_get_pola_num (header, type_data);
3118 for (
int pol = 0 ; pol < npol ; pol++ ) {
3121 oi_table = gravi_data_get_oi_flux (oi_data, type_data, pol, npol);
3125 CPLCHECK_MSG (
"Cannot resamp OI_FLUX");
3128 oi_table = gravi_data_get_oi_vis2 (oi_data, type_data, pol, npol);
3134 CPLCHECK_MSG (
"Cannot resamp OI_VIS2");
3137 oi_table = gravi_data_get_oi_vis (oi_data, type_data, pol, npol);
3148 gravi_msg_warning (
"FIXME",
"VISDATA is not properly smooth !!");
3149 CPLCHECK_MSG (
"Cannot resamp OI_VIS");
3152 oi_table = gravi_data_get_oi_t3 (oi_data, type_data, pol, npol);
3160 CPLCHECK_MSG (
"Cannot resamp OI_T3");
3164 gravi_msg_function_exit(1);
3165 return CPL_ERROR_NONE;
3181 cpl_size nsamp, cpl_size nwave_new)
3183 gravi_msg_function_start(1);
3184 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
3187 cpl_size nrow = cpl_table_get_nrow (oi_table);
3188 cpl_ensure_code (nrow > 0, CPL_ERROR_ILLEGAL_INPUT);
3189 for (cpl_size row = 0 ; row < nrow ; row ++) {
3192 for (cpl_size wave = 0 ; wave < nwave_new ; wave ++) {
3194 double weight = 0.0;
3195 for (cpl_size samp = 0 ; samp < nsamp ; samp ++) {
3196 double w = pow (gravi_table_get_value (oi_table,err,row,wave*nsamp+samp), -2.0);
3197 if (gravi_table_get_value (oi_table,
"FLAG",row,wave*nsamp+samp)) w = 10e-20;
3198 sum += gravi_table_get_value (oi_table,name,row,wave*nsamp+samp) * w;
3201 gravi_table_set_value (oi_table,name,row,wave, sum / weight);
3202 gravi_table_set_value (oi_table,err,row,wave, pow (weight, -0.5));
3207 cpl_table_set_column_depth (oi_table, name, nwave_new);
3208 cpl_table_set_column_depth (oi_table, err, nwave_new);
3210 gravi_msg_function_exit(1);
3211 return CPL_ERROR_NONE;
3227 cpl_size nsamp, cpl_size nwave_new)
3229 gravi_msg_function_start(1);
3230 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
3233 cpl_size nrow = cpl_table_get_nrow (oi_table);
3234 cpl_ensure_code (nrow > 0, CPL_ERROR_ILLEGAL_INPUT);
3235 for (cpl_size row = 0 ; row < nrow ; row ++) {
3238 for (cpl_size wave = 0 ; wave < nwave_new ; wave ++) {
3239 double complex sum = 0.0;
3240 double weight = 0.0;
3241 for (cpl_size samp = 0 ; samp < nsamp ; samp ++) {
3242 double w = pow (gravi_table_get_value (oi_table,err,row,wave*nsamp+samp), -2.0);
3243 if (gravi_table_get_value (oi_table,
"FLAG",row,wave*nsamp+samp)) w = 10e-20;
3244 sum += cexp (1.*I* gravi_table_get_value (oi_table,name,row,wave*nsamp+samp) * CPL_MATH_RAD_DEG) * w;
3247 gravi_table_set_value (oi_table,name,row,wave, carg (sum) * CPL_MATH_DEG_RAD);
3248 gravi_table_set_value (oi_table,err,row,wave, pow (weight, -0.5));
3253 cpl_table_set_column_depth (oi_table, name, nwave_new);
3254 cpl_table_set_column_depth (oi_table, err, nwave_new);
3256 gravi_msg_function_exit(1);
3257 return CPL_ERROR_NONE;
3275 gravi_msg_function_start(1);
3276 cpl_ensure_code (oi_data, CPL_ERROR_NULL_INPUT);
3277 cpl_ensure_code (nsamp>1, CPL_ERROR_ILLEGAL_INPUT);
3279 cpl_table * oi_table;
3280 cpl_size nwave, nwave_new;
3284 cpl_propertylist * header = gravi_data_get_header (oi_data);
3286 int type_data = GRAVI_SC;
3287 int npol = gravi_pfits_get_pola_num (header, type_data);
3288 for (
int pol = 0 ; pol < npol ; pol++ ) {
3291 oi_table = gravi_data_get_oi_wave (oi_data, type_data, pol, npol);
3292 nwave = cpl_table_get_nrow (oi_table);
3295 nwave_new = nwave / nsamp;
3296 cpl_msg_info (cpl_func,
"Resamp the SC data by %lld bins: %lld -> %lld",
3297 nsamp, nwave, nwave_new);
3298 cpl_ensure_code (nwave_new > 1, CPL_ERROR_ILLEGAL_INPUT);
3301 for (cpl_size wave = 0 ; wave < nwave_new ; wave ++) {
3303 cpl_table_set (oi_table,
"EFF_BAND", wave,
3304 cpl_table_get (oi_table,
"EFF_WAVE", wave*nsamp+nsamp-1, &nv) -
3305 cpl_table_get (oi_table,
"EFF_WAVE", wave*nsamp, &nv));
3309 for (cpl_size samp = 0 ; samp < nsamp ; samp++)
3310 mean += cpl_table_get (oi_table,
"EFF_WAVE", wave*nsamp+samp, &nv);
3311 cpl_table_set (oi_table,
"EFF_WAVE", wave, mean / nsamp);
3315 cpl_table_erase_window (oi_table, nwave_new, CPL_SIZE_MAX);
3316 CPLCHECK_MSG (
"Cannot resamp OI_WAVELENGTH");
3319 oi_table = gravi_data_get_oi_flux (oi_data, type_data, pol, npol);
3321 cpl_table_set_column_depth (oi_table,
"FLAG", nwave_new);
3323 CPLCHECK_MSG (
"Cannot resamp OI_FLUX");
3326 oi_table = gravi_data_get_oi_vis2 (oi_data, type_data, pol, npol);
3328 cpl_table_set_column_depth (oi_table,
"FLAG", nwave_new);
3330 CPLCHECK_MSG (
"Cannot resamp OI_VIS2");
3333 oi_table = gravi_data_get_oi_vis (oi_data, type_data, pol, npol);
3338 cpl_table_set_column_depth (oi_table,
"FLAG", nwave_new);
3341 gravi_msg_warning (
"FIXME",
"VISDATA is not properly resampled !!");
3342 cpl_table_set_column_depth (oi_table,
"VISDATA", nwave_new);
3343 cpl_table_set_column_depth (oi_table,
"VISERR", nwave_new);
3344 CPLCHECK_MSG (
"Cannot resamp OI_VIS");
3347 oi_table = gravi_data_get_oi_t3 (oi_data, type_data, pol, npol);
3350 cpl_table_set_column_depth (oi_table,
"FLAG", nwave_new);
3352 CPLCHECK_MSG (
"Cannot resamp OI_T3");
3356 gravi_msg_function_exit(1);
3357 return CPL_ERROR_NONE;
3370 gravi_msg_function_start(1);
3371 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
3373 cpl_size nrow = cpl_table_get_nrow (oi_table);
3374 cpl_ensure_code (nrow > 0, CPL_ERROR_ILLEGAL_INPUT);
3377 const char * names[] = {
"VIS2DATA",
"VIS2ERR",
"VISAMP",
"VISAMPERR",
3378 "VISPHI",
"VISPHIERR",
"T3PHI",
"T3PHIERR",
3379 "T3AMP",
"T3AMPERR"};
3382 for (
int c = 0; c < ncols; c++) {
3384 if (!cpl_table_has_column (oi_table,names[c]))
continue;
3385 cpl_msg_info (cpl_func,
"Check column %s",names[c]);
3388 cpl_size nwave = cpl_table_get_column_depth (oi_table, names[c]);
3389 cpl_array ** v_array = cpl_table_get_data_array (oi_table, names[c]);
3390 cpl_array ** f_array = cpl_table_get_data_array (oi_table,
"FLAG");
3391 CPLCHECK_MSG (
"Cannot get data");
3394 cpl_size ninvalid = 0;
3395 for (cpl_size row = 0; row < nrow ; row ++) {
3396 for (cpl_size wave = 0 ; wave < nwave ; wave ++) {
3400 double value = cpl_array_get (v_array[row], wave, &nv);
3403 if (nv || isnan (value)) {
3404 cpl_array_set (f_array[row], wave, 1.0);
3405 cpl_array_set (v_array[row], wave, 0.0);
3408 CPLCHECK_MSG (
"Cannot check data");
3414 cpl_msg_warning (cpl_func,
"Flag %lld invalid data (NAN or NULL) in %s", ninvalid, names[c]);
3419 gravi_msg_function_exit(1);
3420 return CPL_ERROR_NONE;
3439 gravi_msg_function_start(0);
3440 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
3441 cpl_ensure_code (data, CPL_ERROR_NULL_INPUT);
3442 cpl_ensure_code (flag, CPL_ERROR_ILLEGAL_OUTPUT);
3446 cpl_size nrow = cpl_table_get_nrow (oi_table);
3447 cpl_array ** pdata = cpl_table_get_data_array (oi_table, data);
3448 cpl_array ** pflag = cpl_table_get_data_array (oi_table, flag);
3450 CPLCHECK_MSG (
"Cannot get data");
3452 cpl_size size = cpl_array_get_size (pdata[0]);
3455 for ( cpl_size row = 0 ; row < nrow ; row ++ ) {
3456 if (pdata[row]==NULL)
continue;
3458 for ( cpl_size indx = 0 ; indx < size ; indx ++ ) {
3459 if ( cpl_array_get (pdata[row], indx, &nv) > value ) {
3460 cpl_array_set (pflag[row], indx, cpl_array_get (pflag[row], indx, &nv) + 1 );
3465 gravi_msg_function_exit(0);
3466 return CPL_ERROR_NONE;
3485 gravi_msg_function_start(0);
3486 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
3487 cpl_ensure_code (data, CPL_ERROR_NULL_INPUT);
3488 cpl_ensure_code (flag, CPL_ERROR_ILLEGAL_OUTPUT);
3492 cpl_size nrow = cpl_table_get_nrow (oi_table);
3493 cpl_array ** pdata = cpl_table_get_data_array (oi_table, data);
3494 cpl_array ** pflag = cpl_table_get_data_array (oi_table, flag);
3496 CPLCHECK_MSG (
"Cannot get data");
3498 cpl_size size = cpl_array_get_size (pdata[0]);
3499 cpl_vector * i_vector = cpl_vector_new (size);
3502 for ( cpl_size row = 0 ; row < nrow ; row ++ ) {
3503 if (pdata[row]==NULL || size<100)
continue;
3506 for (cpl_size indx = 0; indx < size; indx++)
3507 cpl_vector_set (i_vector, indx, cpl_array_get (pdata[0],indx,&nv));
3510 cpl_vector * o_vector = cpl_vector_filter_median_create (i_vector, 4);
3513 for ( cpl_size indx = 0 ; indx < size ; indx ++ ) {
3514 if ( cpl_array_get (pdata[row], indx, &nv) > value * cpl_vector_get (o_vector, indx)) {
3515 cpl_array_set (pflag[row], indx, cpl_array_get (pflag[row], indx, &nv) + 1 );
3519 FREE (cpl_vector_delete, o_vector);
3522 FREE (cpl_vector_delete, i_vector);
3523 gravi_msg_function_exit(0);
3524 return CPL_ERROR_NONE;
3544 const char * data,
const char *flag,
double value)
3546 gravi_msg_function_start(0);
3547 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
3548 cpl_ensure_code (data, CPL_ERROR_NULL_INPUT);
3549 cpl_ensure_code (err, CPL_ERROR_NULL_INPUT);
3550 cpl_ensure_code (flag, CPL_ERROR_ILLEGAL_OUTPUT);
3554 cpl_size row, nrow = cpl_table_get_nrow (oi_table);
3555 cpl_array ** perr = cpl_table_get_data_array (oi_table, err);
3556 cpl_array ** pdata = cpl_table_get_data_array (oi_table, data);
3557 cpl_array ** pflag = cpl_table_get_data_array (oi_table, flag);
3559 CPLCHECK_MSG (
"Cannot get data");
3561 cpl_size indx, size = cpl_array_get_size (pdata[0]);
3564 for ( row = 0 ; row < nrow ; row ++ ) {
3565 if (perr[row]==NULL)
continue;
3566 cpl_array * tmp = cpl_array_duplicate (perr[row]);
3567 cpl_array_divide (tmp, pdata[row]);
3568 for ( indx = 0 ; indx < size ; indx ++ ) {
3569 if ( cpl_array_get (tmp, indx, &nv) > value) {
3570 cpl_array_set (pflag[row], indx, cpl_array_get (pflag[row], indx, &nv) + 1 );
3573 cpl_array_delete (tmp);
3576 gravi_msg_function_exit(0);
3577 return CPL_ERROR_NONE;
3595 gravi_msg_function_start(0);
3596 cpl_ensure_code (oi_table, CPL_ERROR_NULL_INPUT);
3597 cpl_ensure_code (flag_array, CPL_ERROR_NULL_INPUT);
3600 cpl_size nrow = cpl_table_get_nrow (oi_table) / ntel;
3601 cpl_ensure_code (nrow == cpl_array_get_size (flag_array),
3602 CPL_ERROR_ILLEGAL_INPUT);
3605 cpl_table_unselect_all (oi_table);
3606 for (cpl_size row = 0; row < nrow; row++) {
3607 if (cpl_array_get (flag_array, row, NULL) == 0)
continue;
3608 cpl_table_or_selected_window (oi_table, row * ntel, ntel);
3612 cpl_table_erase_selected (oi_table);
3613 CPLCHECK_MSG (
"Cannot erase");
3615 gravi_msg_function_exit(0);
3616 return CPL_ERROR_NONE;
3642 cpl_table * in_table,
3643 const char * name,
int ntel)
3645 gravi_msg_function_start(0);
3646 cpl_ensure_code (out_table, CPL_ERROR_NULL_INPUT);
3647 cpl_ensure_code (in_table, CPL_ERROR_NULL_INPUT);
3648 cpl_ensure_code (name, CPL_ERROR_NULL_INPUT);
3649 cpl_ensure_code (ntel == cpl_table_get_nrow (out_table),
3650 CPL_ERROR_ILLEGAL_OUTPUT);
3653 if ( !cpl_table_has_column (in_table, name)) {
3654 cpl_msg_info (cpl_func,
"Cannot average column %s (not existing)", name);
3655 return CPL_ERROR_NONE;
3659 int type = cpl_table_get_column_type (in_table, name);
3660 cpl_size depth = cpl_table_get_column_depth (in_table, name);
3663 cpl_size nrow = cpl_table_get_nrow (in_table) / ntel;
3664 cpl_ensure_code (nrow, CPL_ERROR_ILLEGAL_INPUT);
3668 if (cpl_table_has_column (in_table,
"REJECTION_FLAG"))
3669 flag = cpl_table_get_data_int (in_table,
"REJECTION_FLAG");
3671 cpl_msg_info (cpl_func,
"Average column: %s (%s REJECTION_FLAG)",
3672 name, flag ?
"with" :
"without");
3675 case CPL_TYPE_DOUBLE:
3676 case CPL_TYPE_FLOAT:
3679 if (!cpl_table_has_column (out_table, name))
3680 cpl_table_new_column (out_table, name, CPL_TYPE_DOUBLE);
3681 for (
int tel = 0; tel < ntel; tel++) {
3682 cpl_size nvalid = 0;
3684 for (cpl_size row = 0; row < nrow; row++) {
3685 if (flag && flag[row*ntel+tel] != 0)
continue;
3687 mean += cpl_table_get (in_table, name, row*ntel+tel, NULL);
3689 if (nvalid > 0) mean /= nvalid;
3690 cpl_table_set (out_table, name, tel, mean);
3694 case CPL_TYPE_POINTER|CPL_TYPE_DOUBLE:
3695 case CPL_TYPE_POINTER|CPL_TYPE_FLOAT:
3696 case CPL_TYPE_POINTER|CPL_TYPE_INT:
3698 if (!cpl_table_has_column (out_table, name))
3699 cpl_table_new_column_array (out_table, name, CPL_TYPE_DOUBLE, depth);
3700 for (
int tel = 0; tel < ntel; tel++) {
3701 cpl_size nvalid = 0;
3702 cpl_array * mean = gravi_array_init_double (depth, 0.0);
3703 for (cpl_size row = 0; row < nrow; row++) {
3704 if (flag && flag[row*ntel+tel] != 0)
continue;
3706 cpl_array_add (mean, cpl_table_get_array (in_table, name, row*ntel+tel));
3707 CPLCHECK_MSG (
"Cannot add arrays...");
3709 if (nvalid > 0) cpl_array_divide_scalar (mean, nvalid);
3710 cpl_table_set_array (out_table, name, tel, mean);
3711 FREE (cpl_array_delete, mean);
3715 case CPL_TYPE_POINTER|CPL_TYPE_DOUBLE_COMPLEX:
3716 case CPL_TYPE_POINTER|CPL_TYPE_FLOAT_COMPLEX:
3718 if (!cpl_table_has_column (out_table, name))
3719 cpl_table_new_column_array (out_table, name, CPL_TYPE_DOUBLE_COMPLEX, depth);
3720 for (
int tel = 0; tel < ntel; tel++) {
3721 cpl_size nvalid = 0;
3722 cpl_array * mean = gravi_array_init_double_complex (depth, 0.0*I+0.0);
3723 for (cpl_size row = 0; row < nrow; row++) {
3724 if (flag && flag[row*ntel+tel] != 0)
continue;
3726 cpl_array_add (mean, cpl_table_get_array (in_table, name, row*ntel+tel));
3728 if (nvalid > 0) cpl_array_divide_scalar (mean, nvalid);
3729 cpl_table_set_array (out_table, name, tel, mean);
3731 FREE (cpl_array_delete, mean);
3735 cpl_msg_error (cpl_func,
"Type column not yet supported...");
3736 cpl_error_set_message (cpl_func, CPL_ERROR_ILLEGAL_INPUT,
"This type is not supported.");
3737 return CPL_ERROR_ILLEGAL_INPUT;
3741 cpl_table_set_column_unit (out_table, name, cpl_table_get_column_unit (in_table, name));
3743 gravi_msg_function_exit(0);
3744 return CPL_ERROR_NONE;
3763 gravi_msg_function_start(1);
3764 cpl_ensure_code (oi_data, CPL_ERROR_NULL_INPUT);
3768 cpl_ensure_code (nb_ext>0, CPL_ERROR_ILLEGAL_INPUT);
3771 double mean_mjd = 0.0;
3772 double mean_time = 0.0;
3776 for (
int ext = 0; ext < nb_ext; ext++) {
3779 const char * extname = gravi_data_get_extname (oi_data, ext);
3780 if (!strcmp (extname,
"OI_VIS") || !strcmp (extname,
"OI_VIS2") ||
3781 !strcmp (extname,
"OI_T3") || !strcmp (extname,
"OI_FLUX")) {
3785 mean_mjd += cpl_table_get_column_mean (oi_table,
"MJD");
3786 mean_time += cpl_table_get_column_mean (oi_table,
"TIME");
3789 CPLCHECK_MSG (
"Cannot get TIME or MJD...");
3794 cpl_ensure_code (count>0, CPL_ERROR_ILLEGAL_INPUT);
3799 cpl_msg_info (cpl_func,
"Mean MDJ = %g [mdj]", mean_mjd);
3800 cpl_msg_info (cpl_func,
"Mean TIME = %g [s]", mean_time);
3803 for (
int ext = 0; ext < nb_ext; ext++) {
3806 const char * extname = gravi_data_get_extname (oi_data, ext);
3807 if (!strcmp (extname,
"OI_VIS") || !strcmp (extname,
"OI_VIS2") ||
3808 !strcmp (extname,
"OI_T3") || !strcmp (extname,
"OI_FLUX")) {
3812 cpl_table_fill_column_window (oi_table,
"MJD", 0, CPL_SIZE_MAX, mean_mjd);
3813 cpl_table_fill_column_window (oi_table,
"TIME", 0, CPL_SIZE_MAX, mean_time);
3815 CPLCHECK_MSG (
"Cannot set average TIME or MJD...");
3819 gravi_msg_function_exit(1);
3820 return CPL_ERROR_NONE;
gravi_data * gravi_data_new(int nb_ext)
Create an empty gravi_data.
cpl_error_code gravi_vis_resamp(gravi_data *oi_data, cpl_size nsamp)
Re-bin the SC table by nsamp consecutive spectral bins.
cpl_error_code gravi_data_copy_ext(gravi_data *output, gravi_data *input, const char *name)
Copy extensions from one data to another.
cpl_error_code gravi_vis_average_phi(cpl_table *oi_table, const char *name, const char *err, int nbase)
Average phases column of a multi-observation OIFITS table Phases are averaged with arg{<exp(i...
cpl_propertylist * gravi_data_get_plist_x(gravi_data *self, int i)
Get the propertylist of an extension by position.
cpl_error_code gravi_vis_flag_nan(cpl_table *oi_table)
Flag samples of OIFITS table which are NAN or NULL.
cpl_error_code gravi_array_online_variance_res(cpl_array **data, int n, int rephase)
On-line variance of arrays.
cpl_error_code gravi_vis_resamp_phi(cpl_table *oi_table, const char *name, const char *err, cpl_size nsamp, cpl_size nwave_new)
Rebin phase column of OIFITS table (arg{<exp(i.phi)>})
cpl_error_code gravi_vis_average_bootstrap(cpl_table *oi_vis_avg, cpl_table *oi_vis2_avg, cpl_table *oi_vis, int nboot, const char *phase_ref, int use_vFactor, int use_pFactor, int use_debiasing)
Average the visibility of all DITs into a final, averaged value.
cpl_error_code gravi_compute_vis_qc(gravi_data *vis_data)
The function compute the QC parameters for a VIS (averaged) data.
double gravi_randn(void)
Normal distribution pseudo-random generator.
cpl_error_code gravi_vis_compute_column_mean(cpl_table *out_table, cpl_table *in_table, const char *name, int ntel)
Compute the mean of a column in OIFITS table, and save the result in the specified output table...
cpl_error_code gravi_vis_average_value(cpl_table *oi_table, const char *name, const char *err, int nbase)
Average scalar column of a multi-observation OIFITS table. The averaged quantities are stored in the ...
gravi_data * gravi_compute_vis(gravi_data *p2vmred_data, const cpl_parameterlist *parlist, cpl_size *current_frame)
The function average the individual frames of a P2VMREDUCED file into a final, single observation per...
cpl_error_code gravi_vis_average_amp(cpl_table *oi_table, const char *name, const char *err, int nbase)
Average amplitudes column of a multi-observation OIFITS table The averaged quantities are stored in t...
cpl_table * gravi_table_extract_time_interval(cpl_table *table, double start, double end)
Extract rows from table based on the TIME column.
cpl_error_code gravi_vis_fit_amp(cpl_table *oi_table, const char *name, const char *err, cpl_size maxdeg)
Smooth amp column of OIFITS table.
cpl_array ** gravi_array_new_list(int n, cpl_type type, int size)
Allocate a list of arrays, pre-filled with 0.0.
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_table * gravi_data_get_table(gravi_data *self, const char *extname)
Return a pointer on a table extension by its EXTNAME.
cpl_error_code gravi_array_get_group_delay_loop(cpl_array **input, cpl_array *sigma, double *gd, cpl_size nrow, double max_width, int verbose)
Optimized computation of GDELAY for a list of arrays.
cpl_error_code gravi_vis_erase_obs(cpl_table *oi_table, cpl_array *flag_array, cpl_size ntel)
Erase observation from an OIFITS table.
cpl_error_code gravi_vis_mjd_to_time(gravi_data *vis_data)
Recompute the TIME column of all OIFITS extension from the MJD column, following the OIFITS standard ...
cpl_error_code gravi_vis_smooth_phi(cpl_table *oi_table, const char *name, const char *err, cpl_size nsamp)
Smooth phase column of OIFITS table.
cpl_error_code gravi_vis_flag_threshold(cpl_table *oi_table, const char *data, const char *flag, double value)
Flag samples of OIFITS table based on absolute threshold.
double gravi_param_get_double_default(const cpl_parameterlist *parlist, const char *name, double def)
Get the parameter from the parameter list.
cpl_error_code gravi_vis_smooth(gravi_data *oi_data, cpl_size nsamp_vis, cpl_size nsamp_flx, cpl_size maxdeg)
Smooth the SC table by nsamp consecutive spectral bins.
cpl_error_code gravi_average_self_visphi(cpl_table *oi_vis_avg, cpl_table *oi_vis, cpl_array *wavenumber, const char *phase_ref, int *cmin, int *cmax, int nrange)
Compute Averaged VISPHI in the manner described, e.g., in F. Millour's thesis.
cpl_error_code gravi_vis_smooth_amp(cpl_table *oi_table, const char *name, const char *err, cpl_size nsamp)
Smooth amplitude column of OIFITS table.
cpl_error_code gravi_vis_resamp_amp(cpl_table *oi_table, const char *name, const char *err, cpl_size nsamp, cpl_size nwave_new)
Rebin amplitude column of OIFITS table.
cpl_error_code gravi_average_vis(gravi_data *oi_data)
Coadd the observations together.
int gravi_data_has_type(gravi_data *self, const char *type)
Return the number of ext whose EXTNAME and INSNAME match 'type'.
cpl_table * gravi_data_get_table_x(gravi_data *self, int i)
Get the table of an extension by position.
double gdAbacusErrPhi(double x)
cpl_error_code gravi_vis_flag_median(cpl_table *oi_table, const char *data, const char *flag, double value)
Flag samples of OIFITS table based on runnning median.
cpl_error_code gravi_flux_average_bootstrap(cpl_table *oi_flux_avg, cpl_table *oi_flux, int nboot)
Average the flux of all DITs into a final, averaged value.
cpl_error_code gravi_vis_force_time(gravi_data *oi_data)
Force all data in OI_TABLE to have the same TIME and MJD.
cpl_error_code gravi_normalize_sc_to_ft(gravi_data *vis_data)
Align the SC visibilities on the FT visibilities.
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_error_code gravi_flat_flux(gravi_data *vis_data, gravi_data *p2vm_map)
Divide the OI_FLUX by OI_FLUX from the P2VM (no checks, no time distance...)
cpl_error_code gravi_force_uncertainties(gravi_data *oi_data, const cpl_parameterlist *parlist)
Force uncertainties.
cpl_error_code gravi_vis_flag_relative_threshold(cpl_table *oi_table, const char *err, const char *data, const char *flag, double value)
Flag samples of OIFITS table based on relative threshold.
cpl_error_code gravi_apply_tf_amp(gravi_data *science, gravi_data *science_tf, gravi_data **used_tf_data, int num_tf_data, const char *extName, const char *insName, const char *ampName, const char *ampErrName, int nbase, double delta_t)
Interpolate the TF at the time of the science observation for an amplitude quantity.
cpl_error_code gravi_t3_average_bootstrap(cpl_table *oi_t3_avg, cpl_table *oi_vis, cpl_table *oi_flux, int nboot, int use_vFactor, int use_pFactor)
Average the closure-phase of all DITs into a final, averaged value.
cpl_table * gravi_table_oi_create(int nwave, int nrow, const char *oi_name)
Create the oi table (oi_vis, oi_vis2, oi_t3)
int gravi_data_get_size(const gravi_data *self)
Get the number of extension in a gravi_data.