ERIS Pipeline Reference Manual 1.9.2
eris_ifu_vector.c
1
2/*********************************************************************
3 * E.S.O. - VLT project
4 *
5 * "@(#) $Id: eris_ifu_vector.c,v 1.12 2013-07-31 10:35:34 aagudo Exp $"
6 *
7 * Functions that are implemented as recipes. They are also used in KMOS
8 * data reduction pipeline.
9 *
10 * who when what
11 * -------- ---------- ----------------------------------------------
12 */
13
14#ifdef HAVE_CONFIG_H
15#include <config.h>
16#endif
17
18/*------------------------------------------------------------------------------
19 * Includes, etc
20 *----------------------------------------------------------------------------*/
21#define _ISOC99_SOURCE
22
23#include <math.h>
24
25#include <cpl.h>
26
27#include "eris_ifu_error.h"
28#include "eris_ifu_vector.h"
29#include "eris_ifu_utils.h"
30//#include "eris_ifu_math.h"
31
32/* CPL_SORT_ASCENDING is introduced only after CPL 5.3.0 */
33#ifndef CPL_SORT_ASCENDING
34 #define CPL_SORT_ASCENDING 1
35#endif
36
37/*------------------------------------------------------------------------------
38 * Definitions
39 *----------------------------------------------------------------------------*/
162/*----------------------------------------------------------------------------*/
163
184eris_ifu_vector* eris_ifu_vector_new(int n)
185{
186 eris_ifu_vector *ev = NULL;
187
188 cpl_ensure(n >= 1, CPL_ERROR_ILLEGAL_INPUT, NULL);
189
190 TRY
191 {
192 BRK_IF_NULL(
193 ev = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
194
195 BRK_IF_NULL(
196 ev->data = cpl_vector_new(n));
197
198 BRK_IF_ERROR(
199 cpl_vector_fill(ev->data, 0));
200
201 BRK_IF_NULL(
202 ev->mask = cpl_vector_new(n));
203
204 BRK_IF_ERROR(
205 cpl_vector_fill(ev->mask, 1));
206 }
207 CATCH
208 {
209 if (ev != NULL) {
210 cpl_vector_delete(ev->data); ev->data = NULL;
211 cpl_vector_delete(ev->mask); ev->mask = NULL;
212 }
213 cpl_free(ev); ev = NULL;
214 }
215
216 return ev;
217}
218
240eris_ifu_vector* eris_ifu_vector_new_wrap(int n, const double *data)
241{
242 eris_ifu_vector *ev = NULL;
243 cpl_vector *tmp = NULL;
244 double *pdata = NULL,
245 *pmask = NULL;
246
247 cpl_ensure(n >= 1, CPL_ERROR_ILLEGAL_INPUT, NULL);
248
249 TRY
250 {
251 BRK_IF_NULL(
252 ev = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
253
254 BRK_IF_NULL(
255 tmp = cpl_vector_wrap(n, (double*) data));
256 BRK_IF_NULL(
257 ev->data = cpl_vector_duplicate(tmp));
258 cpl_vector_unwrap(tmp);
259
260 BRK_IF_NULL(
261 ev->mask = cpl_vector_new(n));
262
263 BRK_IF_ERROR(
264 cpl_vector_fill(ev->mask, 1));
265
266 BRK_IF_NULL(
267 pdata = cpl_vector_get_data(ev->data));
268 BRK_IF_NULL(
269 pmask = cpl_vector_get_data(ev->mask));
270 for (int i = 0; i < n; i++) {
271 if (eris_ifu_is_nan_or_inf(pdata[i])) {
272 /*pdata[i] = NAN;*/
273 pmask[i] = 0.;
274 }
275 }
276 }
277 CATCH
278 {
279 if (ev != NULL) {
280 cpl_vector_delete(ev->data); ev->data = NULL;
281 cpl_vector_delete(ev->mask); ev->mask = NULL;
282 }
283 cpl_free(ev); ev = NULL;
284 }
285
286 return ev;
287}
288
310eris_ifu_vector* eris_ifu_vector_create(const cpl_vector *data)
311{
312 eris_ifu_vector *ev = NULL;
313 double *pdata = NULL,
314 *pmask = NULL;
315 int n = 0;
316
317 cpl_ensure(data, CPL_ERROR_NULL_INPUT, NULL);
318
319 TRY
320 {
321 BRK_IF_NULL(
322 ev = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
323
324 BRK_IF_NULL(
325 ev->data = cpl_vector_duplicate(data));
326
327 n = cpl_vector_get_size(data);
328
329 BRK_IF_NULL(
330 ev->mask = cpl_vector_new(n));
331
332 BRK_IF_ERROR(
333 cpl_vector_fill(ev->mask, 1));
334
335 BRK_IF_NULL(
336 pdata = cpl_vector_get_data(ev->data));
337 BRK_IF_NULL(
338 pmask = cpl_vector_get_data(ev->mask));
339 for (int i = 0; i < cpl_vector_get_size(data); i++)
340 {
341 if (eris_ifu_is_nan_or_inf(pdata[i])) {
342 /*pdata[i] = NAN;*/
343 pmask[i] = 0.;
344 }
345 }
346 }
347 CATCH
348 {
349 if (ev != NULL) {
350 cpl_vector_delete(ev->data); ev->data = NULL;
351 cpl_vector_delete(ev->mask); ev->mask = NULL;
352 }
353 cpl_free(ev); ev = NULL;
354 }
355
356 return ev;
357}
358
390eris_ifu_vector* eris_ifu_vector_create2(const cpl_vector *data,
391 const cpl_vector *mask)
392{
393 eris_ifu_vector *ev = NULL;
394 double *pdata = NULL,
395 *pmask = NULL;
396
397 cpl_ensure(data, CPL_ERROR_NULL_INPUT, NULL);
398 cpl_ensure(mask, CPL_ERROR_NULL_INPUT, NULL);
399 cpl_ensure(cpl_vector_get_size(data) == cpl_vector_get_size(mask),
400 CPL_ERROR_ILLEGAL_INPUT, NULL);
401
402 TRY
403 {
404 BRK_IF_NULL(
405 ev = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
406
407 BRK_IF_NULL(
408 ev->data = cpl_vector_duplicate(data));
409 BRK_IF_NULL(
410 ev->mask = cpl_vector_duplicate(mask));
411
412 BRK_IF_NULL(
413 pdata = cpl_vector_get_data(ev->data));
414 BRK_IF_NULL(
415 pmask = cpl_vector_get_data(ev->mask));
416
417 for (int i = 0; i < cpl_vector_get_size(data); i++)
418 {
419 if (eris_ifu_is_nan_or_inf(pmask[i])) {
420 /*pdata[i] = NAN;*/
421 pmask[i] = 0.;
422 } else if (pmask[i] >= 0.5) {
423 if (eris_ifu_is_nan_or_inf(pdata[i])) {
424 /*pdata[i] = NAN;*/
425 pmask[i] = 0.;
426 } else {
427 pmask[i] = 1;
428 }
429 } else {
430 /*pdata[i] = NAN;*/
431 pmask[i] = 0;
432 }
433 }
434 }
435 CATCH
436 {
437 if (ev != NULL) {
438 cpl_vector_delete(ev->data); ev->data = NULL;
439 cpl_vector_delete(ev->mask); ev->mask = NULL;
440 }
441 cpl_free(ev); ev = NULL;
442 }
443
444 return ev;
445}
446
457void eris_ifu_vector_delete(eris_ifu_vector *ev)
458{
459 TRY
460 {
461 if (ev != NULL) {
462 cpl_vector_delete(ev->data); ev->data = NULL;
463 cpl_vector_delete(ev->mask); ev->mask = NULL;
464 cpl_free(ev);
465 }
466 }
467 CATCH
468 {
469 }
470}
471
489eris_ifu_vector* eris_ifu_vector_duplicate(const eris_ifu_vector *ev)
490{
491 eris_ifu_vector *ev_dup = NULL;
492
493 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
494
495 TRY
496 {
497 BRK_IF_NULL(
498 ev_dup = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
499
500 ev_dup->data = cpl_vector_duplicate(ev->data);
501 CHECK_ERROR_STATE();
502
503 ev_dup->mask = cpl_vector_duplicate(ev->mask);
504 CHECK_ERROR_STATE();
505 }
506 CATCH
507 {
508 if (ev_dup != NULL) {
509 cpl_vector_delete(ev_dup->data); ev_dup->data = NULL;
510 cpl_vector_delete(ev_dup->mask); ev_dup->mask = NULL;
511 }
512 cpl_free(ev_dup); ev_dup = NULL;
513 }
514
515 return ev_dup;
516}
517
540cpl_error_code eris_ifu_vector_set(eris_ifu_vector *ev, int pos, double val)
541{
542 cpl_error_code err = CPL_ERROR_NONE;
543
544 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
545 cpl_ensure_code((pos >= 0) && (pos < cpl_vector_get_size(ev->data)),
546 CPL_ERROR_ACCESS_OUT_OF_RANGE);
547
548 TRY
549 {
550 cpl_vector_set(ev->data, pos, val);
551 if (eris_ifu_is_nan_or_inf(val)) {
552 cpl_vector_set(ev->mask, pos, 0.);
553 } else {
554 cpl_vector_set(ev->mask, pos, 1.);
555 }
556 }
557 CATCH
558 {
559 err = cpl_error_get_code();
560 }
561
562 return err;
563}
564
587double eris_ifu_vector_get_rej(const eris_ifu_vector *ev, int pos, int *rej)
588{
589 double ret = 0.;
590
591 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
592 cpl_ensure_code((pos >= 0) && (pos < cpl_vector_get_size(ev->data)),
593 CPL_ERROR_ACCESS_OUT_OF_RANGE);
594
595 TRY
596 {
597 ret = cpl_vector_get(ev->data, pos);
598 if (rej != NULL) {
599 if (cpl_vector_get(ev->mask, pos) > 0.5) {
600 /* value isn't rejected */
601 *rej = 0;
602 } else {
603 /* value is rejected */
604 *rej = 1;
605 }
606 }
607 }
608 CATCH
609 {
610 ret = 0.;
611 if (rej != NULL) {
612 *rej = -1;
613 }
614 }
615
616 return ret;
617}
618
639double eris_ifu_vector_get(const eris_ifu_vector *ev, int pos)
640{
641 int rej = 0;
642
643 return eris_ifu_vector_get_rej(ev, pos, &rej);
644}
645
663cpl_vector* eris_ifu_vector_get_mask(const eris_ifu_vector *ev)
664{
665 cpl_vector *mask = NULL;
666
667 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
668
669 TRY
670 {
671 BRK_IF_NULL(
672 mask = cpl_vector_duplicate(ev->mask));
673 }
674 CATCH
675 {
676 cpl_vector_delete(mask); mask = NULL;
677 }
678
679 return mask;
680}
681
700cpl_vector* eris_ifu_vector_get_data(const eris_ifu_vector *ev)
701{
702 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
703
704 cpl_vector *data = NULL;
705
706 TRY
707 {
708 BRK_IF_NULL(
709 data = cpl_vector_duplicate(ev->data));
710 for (int i = 0; i < eris_ifu_vector_get_size(ev); i++) {
711 if (eris_ifu_vector_is_rejected(ev, i)) {
712 BRK_IF_ERROR(
713 cpl_vector_set(data, i, NAN));
714 }
715 }
716 }
717 CATCH
718 {
719 cpl_vector_delete(data); data = NULL;
720 }
721 return data;
722}
723
742cpl_vector* eris_ifu_vector_get_bpm(eris_ifu_vector *ev)
743{
744 cpl_vector *mask = NULL;
745
746 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
747
748 TRY
749 {
750 BRK_IF_NULL(
751 mask = ev->mask);
752 }
753 CATCH
754 {
755 mask = NULL;
756 }
757
758 return mask;
759}
760
783cpl_error_code eris_ifu_vector_reject_from_mask(eris_ifu_vector *ev,
784 const cpl_vector *mask,
785 int keep)
786{
787 int ret = CPL_ERROR_NONE,
788 size = 0;
789 double *pkvmask = NULL;
790 const double *pmask = NULL;
791
792 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
793 cpl_ensure_code(mask, CPL_ERROR_NULL_INPUT);
794
795 size = cpl_vector_get_size(ev->data);
796
797 cpl_ensure_code(size == cpl_vector_get_size(mask), CPL_ERROR_ILLEGAL_INPUT);
798 cpl_ensure_code((keep == 0) || (keep == 1), CPL_ERROR_ILLEGAL_INPUT);
799
800 TRY
801 {
802 BRK_IF_NULL(
803 pkvmask = cpl_vector_get_data(ev->mask));
804 BRK_IF_NULL(
805 pmask = cpl_vector_get_data_const(mask));
806
807 for (int i = 0; i < size; i++) {
808 if ((!keep) ||
809 ((keep) && (pkvmask[i] > 0.5)))
810 {
811 pkvmask[i] = pmask[i];
812 }
813 }
814 CHECK_ERROR_STATE();
815 }
816 CATCH
817 {
818 ret = cpl_error_get_code();
819 }
820
821 return ret;
822}
823
838int eris_ifu_vector_count_rejected(const eris_ifu_vector *ev)
839{
840 int cnt = 0;
841 double *pmask = NULL;
842
843 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
844
845 TRY
846 {
847 BRK_IF_NULL(
848 pmask = cpl_vector_get_data(ev->mask));
849 for (int i = 0; i < cpl_vector_get_size(ev->mask); i++) {
850 if (pmask[i] == 0) {
851 cnt++;
852 }
853 }
854 }
855 CATCH
856 {
857 cnt = -1;
858 }
859
860 return cnt;
861}
862
878int eris_ifu_vector_count_non_rejected(const eris_ifu_vector *ev)
879{
880 int cnt = 0,
881 size = 0;
882 double *pmask = NULL;
883
884 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
885
886 TRY
887 {
888 size = cpl_vector_get_size(ev->data);
889
890 BRK_IF_NULL(
891 pmask = cpl_vector_get_data(ev->mask));
892 for (int i = 0; i < size; i++) {
893 if (pmask[i] == 0) {
894 cnt++;
895 }
896 }
897
898 cnt = size - cnt;
899 }
900 CATCH
901 {
902 cnt = -1;
903 }
904
905 return cnt;
906}
907
925int eris_ifu_vector_is_rejected(const eris_ifu_vector *ev, int n)
926{
927 int ret = 0;
928
929 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
930 cpl_ensure_code((n >= 0) && (n < cpl_vector_get_size(ev->data)),
931 CPL_ERROR_ACCESS_OUT_OF_RANGE);
932
933 TRY
934 {
935 if (cpl_vector_get(ev->mask, n) > 0.5) {
936 ret = FALSE;
937 } else {
938 ret = TRUE;
939 }
940 }
941 CATCH
942 {
943 ret = -1;
944 }
945
946 return ret;
947}
948
970cpl_error_code eris_ifu_vector_reject(eris_ifu_vector *ev, int n)
971{
972 int ret = CPL_ERROR_NONE;
973
974 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
975 cpl_ensure_code((n >= 0) && (n < cpl_vector_get_size(ev->data)),
976 CPL_ERROR_ILLEGAL_INPUT);
977
978 TRY
979 {
980/* cpl_vector_set(ev->data, n, NAN);*/
981 cpl_vector_set(ev->mask, n, 0);
982 CHECK_ERROR_STATE();
983 }
984 CATCH
985 {
986 ret = cpl_error_get_code();
987 }
988
989 return ret;
990}
991
1013eris_ifu_vector* eris_ifu_vector_extract(const eris_ifu_vector *ev,
1014 int istart,
1015 int istop)
1016{
1017 eris_ifu_vector *ev_out = NULL;
1018
1019 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
1020 cpl_ensure(istop > istart, CPL_ERROR_ILLEGAL_INPUT, NULL);
1021
1022 TRY
1023 {
1024 BRK_IF_NULL(
1025 ev_out = (eris_ifu_vector*)cpl_malloc(sizeof(eris_ifu_vector)));
1026
1027 BRK_IF_NULL(
1028 ev_out->data = cpl_vector_extract(ev->data, istart, istop, 1));
1029
1030 BRK_IF_NULL(
1031 ev_out->mask = cpl_vector_extract(ev->mask, istart, istop, 1));
1032 }
1033 CATCH
1034 {
1035 if (ev_out != NULL) {
1036 cpl_vector_delete(ev_out->data); ev_out->data = NULL;
1037 cpl_vector_delete(ev_out->mask); ev_out->mask = NULL;
1038 }
1039 cpl_free(ev_out); ev_out = NULL;
1040 }
1041
1042 return ev_out;
1043}
1044
1066cpl_vector* eris_ifu_vector_create_non_rejected(const eris_ifu_vector *ev)
1067{
1068 int cnt = 0,
1069 j = 0,
1070 n = 0;
1071 const double *pkvmask = NULL,
1072 *pkvdata = NULL;
1073 double *pret = NULL;
1074 cpl_vector *ret = NULL;
1075
1076 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
1077
1078 TRY
1079 {
1080 n = cpl_vector_get_size(ev->data);
1081 cnt = eris_ifu_vector_count_rejected(ev);
1082 CHECK_ERROR_STATE();
1083
1084 if (n-cnt > 0) {
1085 BRK_IF_NULL(
1086 ret = cpl_vector_new(n-cnt));
1087 BRK_IF_NULL(
1088 pret = cpl_vector_get_data(ret));
1089 BRK_IF_NULL(
1090 pkvdata = cpl_vector_get_data_const(ev->data));
1091 BRK_IF_NULL(
1092 pkvmask = cpl_vector_get_data_const(ev->mask));
1093 for (int i = 0; i < n; i++) {
1094 if (pkvmask[i] > 0.5) {
1095 pret[j++] = pkvdata[i];
1096 }
1097 }
1098 }
1099 }
1100 CATCH
1101 {
1102 cpl_vector_delete(ret); ret = NULL;
1103 }
1104
1105 return ret;
1106}
1107
1129cpl_error_code eris_ifu_vector_adapt_rejected(eris_ifu_vector *kv1,
1130 eris_ifu_vector *kv2)
1131{
1132 cpl_error_code err = CPL_ERROR_NONE;
1133 int size = 0;
1134 double *pkv1mask = NULL,
1135 *pkv2mask = NULL;
1136
1137 cpl_ensure_code(kv1, CPL_ERROR_NULL_INPUT);
1138 cpl_ensure_code(kv2, CPL_ERROR_NULL_INPUT);
1139
1140 size = cpl_vector_get_size(kv1->data);
1141
1142 cpl_ensure_code(size == cpl_vector_get_size(kv2->data),
1143 CPL_ERROR_ILLEGAL_INPUT);
1144
1145 TRY
1146 {
1147 BRK_IF_NULL(
1148 pkv1mask = cpl_vector_get_data(kv1->mask));
1149 BRK_IF_NULL(
1150 pkv2mask = cpl_vector_get_data(kv2->mask));
1151
1152 for (int i = 0; i < size; i++) {
1153 if (pkv1mask[i] < 0.5) {
1154 pkv2mask[i] = 0.;
1155 } else if (pkv2mask[i] < 0.5) {
1156 pkv1mask[i] = 0.;
1157 }
1158 }
1159 }
1160 CATCH
1161 {
1162 err = cpl_error_get_code();
1163 }
1164
1165 return err;
1166}
1167
1195cpl_error_code eris_ifu_vector_add(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
1196{
1197 int size = 0;
1198 double *pkv1data = NULL,
1199 *pkv1mask = NULL,
1200 *pkv2data = NULL,
1201 *pkv2mask = NULL;
1202 cpl_error_code err = CPL_ERROR_NONE;
1203
1204 cpl_ensure_code(kv1, CPL_ERROR_NULL_INPUT);
1205 cpl_ensure_code(kv2, CPL_ERROR_NULL_INPUT);
1206
1207 size = cpl_vector_get_size(kv1->data);
1208
1209 cpl_ensure_code(size == cpl_vector_get_size(kv2->data),
1210 CPL_ERROR_ILLEGAL_INPUT);
1211
1212 TRY
1213 {
1214 BRK_IF_NULL(
1215 pkv1data = cpl_vector_get_data(kv1->data));
1216 BRK_IF_NULL(
1217 pkv1mask = cpl_vector_get_data(kv1->mask));
1218 BRK_IF_NULL(
1219 pkv2data = cpl_vector_get_data(kv2->data));
1220 BRK_IF_NULL(
1221 pkv2mask = cpl_vector_get_data(kv2->mask));
1222
1223 for (int i = 0; i < size; i++) {
1224 if ((pkv1mask[i] > 0.5) && (pkv2mask[i] > 0.5)) {
1225 /* add elements (if element in kv1 is rejected it stays anyway
1226 rejected) */
1227 pkv1data[i] += pkv2data[i];
1228
1229 if (eris_ifu_is_nan_or_inf(pkv1data[i])) {
1230 /*pkvdata[i] = NAN;*/
1231 pkv1mask[i] = 0.;
1232 }
1233 } else {
1234 /* element of kv2 is rejected, reject also element in kv1 */
1235 pkv1mask[i] = 0.;
1236 }
1237 }
1238 }
1239 CATCH
1240 {
1241 err = cpl_error_get_code();
1242 }
1243
1244 return err;
1245}
1246
1274cpl_error_code eris_ifu_vector_subtract(eris_ifu_vector *kv1,
1275 const eris_ifu_vector *kv2)
1276{
1277 int size = 0;
1278 double *pkv1data = NULL,
1279 *pkv1mask = NULL,
1280 *pkv2data = NULL,
1281 *pkv2mask = NULL;
1282 cpl_error_code err = CPL_ERROR_NONE;
1283
1284 cpl_ensure_code(kv1, CPL_ERROR_NULL_INPUT);
1285 cpl_ensure_code(kv2, CPL_ERROR_NULL_INPUT);
1286
1287 size = cpl_vector_get_size(kv1->data);
1288
1289 cpl_ensure_code(size == cpl_vector_get_size(kv2->data),
1290 CPL_ERROR_ILLEGAL_INPUT);
1291
1292 TRY
1293 {
1294 BRK_IF_NULL(
1295 pkv1data = cpl_vector_get_data(kv1->data));
1296 BRK_IF_NULL(
1297 pkv1mask = cpl_vector_get_data(kv1->mask));
1298 BRK_IF_NULL(
1299 pkv2data = cpl_vector_get_data(kv2->data));
1300 BRK_IF_NULL(
1301 pkv2mask = cpl_vector_get_data(kv2->mask));
1302
1303 for (int i = 0; i < size; i++) {
1304 if ((pkv1mask[i] > 0.5) && (pkv2mask[i] > 0.5)) {
1305 /* subtract elements (if element in kv1 is rejected it stays anyway
1306 rejected) */
1307 pkv1data[i] -= pkv2data[i];
1308
1309 if (eris_ifu_is_nan_or_inf(pkv1data[i])) {
1310 /*pkvdata[i] = NAN;*/
1311 pkv1mask[i] = 0.;
1312 }
1313 } else {
1314 /* element of kv2 is rejected, reject also element in kv1 */
1315 pkv1mask[i] = 0.;
1316 }
1317 }
1318 }
1319 CATCH
1320 {
1321 err = cpl_error_get_code();
1322 }
1323
1324 return err;
1325}
1326
1354cpl_error_code eris_ifu_vector_multiply(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
1355{
1356 int size = 0;
1357 double *pkv1data = NULL,
1358 *pkv1mask = NULL,
1359 *pkv2data = NULL,
1360 *pkv2mask = NULL;
1361 cpl_error_code err = CPL_ERROR_NONE;
1362
1363 cpl_ensure_code(kv1, CPL_ERROR_NULL_INPUT);
1364 cpl_ensure_code(kv2, CPL_ERROR_NULL_INPUT);
1365
1366 size = cpl_vector_get_size(kv1->data);
1367
1368 cpl_ensure_code(size == cpl_vector_get_size(kv2->data),
1369 CPL_ERROR_ILLEGAL_INPUT);
1370
1371 TRY
1372 {
1373
1374 BRK_IF_NULL(
1375 pkv1data = cpl_vector_get_data(kv1->data));
1376 BRK_IF_NULL(
1377 pkv1mask = cpl_vector_get_data(kv1->mask));
1378 BRK_IF_NULL(
1379 pkv2data = cpl_vector_get_data(kv2->data));
1380 BRK_IF_NULL(
1381 pkv2mask = cpl_vector_get_data(kv2->mask));
1382
1383 for (int i = 0; i < size; i++) {
1384 if ((pkv1mask[i] > 0.5) && (pkv2mask[i] > 0.5)) {
1385 /* multiply elements (if element in kv1 is rejected it stays anyway
1386 rejected) */
1387 pkv1data[i] *= pkv2data[i];
1388
1389 if (eris_ifu_is_nan_or_inf(pkv1data[i])) {
1390 /*pkvdata[i] = NAN;*/
1391 pkv1mask[i] = 0.;
1392 }
1393 } else {
1394 /* element of kv2 is rejected, reject also element in kv1 */
1395 pkv1mask[i] = 0.;
1396 }
1397 }
1398 }
1399 CATCH
1400 {
1401 err = cpl_error_get_code();
1402 }
1403
1404 return err;
1405}
1406
1437cpl_error_code eris_ifu_vector_divide(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
1438{
1439 int size = 0;
1440 double *pkv1data = NULL,
1441 *pkv1mask = NULL,
1442 *pkv2data = NULL,
1443 *pkv2mask = NULL;
1444 cpl_error_code err = CPL_ERROR_NONE;
1445
1446 cpl_ensure_code(kv1, CPL_ERROR_NULL_INPUT);
1447 cpl_ensure_code(kv2, CPL_ERROR_NULL_INPUT);
1448
1449 size = cpl_vector_get_size(kv1->data);
1450
1451 cpl_ensure_code(size == cpl_vector_get_size(kv2->data),
1452 CPL_ERROR_ILLEGAL_INPUT);
1453
1454 TRY
1455 {
1456 BRK_IF_NULL(
1457 pkv1data = cpl_vector_get_data(kv1->data));
1458 BRK_IF_NULL(
1459 pkv1mask = cpl_vector_get_data(kv1->mask));
1460 BRK_IF_NULL(
1461 pkv2data = cpl_vector_get_data(kv2->data));
1462 BRK_IF_NULL(
1463 pkv2mask = cpl_vector_get_data(kv2->mask));
1464
1465 for (int i = 0; i < size; i++) {
1466 if ((pkv1mask[i] > 0.5) && (pkv2mask[i] > 0.5)) {
1467 /* divide elements (if element in kv1 is rejected it stays anyway
1468 rejected) */
1469 pkv1data[i] /= pkv2data[i];
1470
1471 if (eris_ifu_is_nan_or_inf(pkv1data[i])) {
1472 /*pkvdata[i] = NAN;*/
1473 pkv1mask[i] = 0.;
1474 }
1475 } else {
1476 /* element of kv2 is rejected, reject also element in kv1 */
1477 pkv1mask[i] = 0.;
1478 }
1479 }
1480 }
1481 CATCH
1482 {
1483 err = cpl_error_get_code();
1484 }
1485
1486 return err;
1487}
1488
1508cpl_error_code eris_ifu_vector_add_scalar(eris_ifu_vector *ev, double addend)
1509{
1510 int n = 0;
1511 double *pkvmask = NULL,
1512 *pkvdata = NULL;
1513 cpl_error_code err = CPL_ERROR_NONE;
1514
1515 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1516
1517 TRY
1518 {
1519 n = cpl_vector_get_size(ev->data);
1520 CHECK_ERROR_STATE();
1521
1522 BRK_IF_NULL(
1523 pkvdata = cpl_vector_get_data(ev->data));
1524 BRK_IF_NULL(
1525 pkvmask = cpl_vector_get_data(ev->mask));
1526 for (int i = 0; i < n; i++) {
1527 if (pkvmask[i] > 0.5) {
1528 pkvdata[i] += addend;
1529 }
1530 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
1531 /*pkvdata[i] = NAN;*/
1532 pkvmask[i] = 0.;
1533 }
1534 }
1535 }
1536 CATCH
1537 {
1538 err = cpl_error_get_code();
1539 }
1540
1541 return err;
1542}
1543
1563cpl_error_code eris_ifu_vector_subtract_scalar(eris_ifu_vector *ev,
1564 double subtrahend)
1565{
1566 int n = 0;
1567 double *pkvmask = NULL,
1568 *pkvdata = NULL;
1569 cpl_error_code err = CPL_ERROR_NONE;
1570
1571 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1572
1573 TRY
1574 {
1575 n = cpl_vector_get_size(ev->data);
1576 CHECK_ERROR_STATE();
1577
1578 BRK_IF_NULL(
1579 pkvdata = cpl_vector_get_data(ev->data));
1580 BRK_IF_NULL(
1581 pkvmask = cpl_vector_get_data(ev->mask));
1582 for (int i = 0; i < n; i++) {
1583 if (pkvmask[i] > 0.5) {
1584 pkvdata[i] -= subtrahend;
1585 }
1586 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
1587 /*pkvdata[i] = NAN;*/
1588 pkvmask[i] = 0.;
1589 }
1590 }
1591 }
1592 CATCH
1593 {
1594 err = cpl_error_get_code();
1595 }
1596
1597 return err;
1598}
1599
1619cpl_error_code eris_ifu_vector_multiply_scalar(eris_ifu_vector *ev, double factor)
1620{
1621 int n = 0;
1622 double *pkvmask = NULL,
1623 *pkvdata = NULL;
1624 cpl_error_code err = CPL_ERROR_NONE;
1625
1626 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1627
1628 TRY
1629 {
1630 n = cpl_vector_get_size(ev->data);
1631 CHECK_ERROR_STATE();
1632
1633 BRK_IF_NULL(
1634 pkvdata = cpl_vector_get_data(ev->data));
1635 BRK_IF_NULL(
1636 pkvmask = cpl_vector_get_data(ev->mask));
1637 for (int i = 0; i < n; i++) {
1638 if (pkvmask[i] > 0.5) {
1639 pkvdata[i] *= factor;
1640 }
1641 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
1642 /*pkvdata[i] = NAN;*/
1643 pkvmask[i] = 0.;
1644 }
1645 }
1646 }
1647 CATCH
1648 {
1649 err = cpl_error_get_code();
1650 }
1651
1652 return err;
1653}
1654
1674cpl_error_code eris_ifu_vector_divide_scalar(eris_ifu_vector *ev, double dividend)
1675{
1676 int n = 0;
1677 double *pkvmask = NULL,
1678 *pkvdata = NULL;
1679 cpl_error_code err = CPL_ERROR_NONE;
1680
1681 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1682
1683 TRY
1684 {
1685 n = cpl_vector_get_size(ev->data);
1686 CHECK_ERROR_STATE();
1687
1688 BRK_IF_NULL(
1689 pkvdata = cpl_vector_get_data(ev->data));
1690 BRK_IF_NULL(
1691 pkvmask = cpl_vector_get_data(ev->mask));
1692 for (int i = 0; i < n; i++) {
1693 if (pkvmask[i] > 0.5) {
1694 pkvdata[i] /= dividend;
1695 }
1696 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
1697 /*pkvdata[i] = NAN;*/
1698 pkvmask[i] = 0.;
1699 }
1700 }
1701 }
1702 CATCH
1703 {
1704 err = cpl_error_get_code();
1705 }
1706
1707 return err;
1708}
1709
1730cpl_error_code eris_ifu_vector_abs(eris_ifu_vector *ev)
1731{
1732 cpl_error_code ret_error = CPL_ERROR_NONE;
1733 double *pkvdata = NULL,
1734 *pkvmask = NULL;
1735
1736 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1737
1738 TRY
1739 {
1740 BRK_IF_NULL(
1741 pkvdata = cpl_vector_get_data(ev->data));
1742 BRK_IF_NULL(
1743 pkvmask = cpl_vector_get_data(ev->mask));
1744
1745 for (int i = 0; i < cpl_vector_get_size(ev->data);i++) {
1746 if ((pkvmask[i] > 0.5) && (pkvdata[i] < 0.0)) {
1747 pkvdata[i] = -pkvdata[i];
1748 }
1749 }
1750 }
1751 CATCH
1752 {
1753 ret_error = cpl_error_get_code();
1754 }
1755
1756 return ret_error;
1757}
1758
1776int eris_ifu_vector_get_size(const eris_ifu_vector *ev)
1777{
1778 int ret_val = 0;
1779
1780 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1781
1782 TRY
1783 {
1784 ret_val = cpl_vector_get_size(ev->data);
1785 CHECK_ERROR_STATE();
1786 }
1787 CATCH
1788 {
1789 ret_val = -1;
1790 }
1791
1792 return ret_val;
1793}
1794
1813double eris_ifu_vector_get_mean(const eris_ifu_vector *ev)
1814{
1815 cpl_vector *vec = NULL;
1816 double val = 0.;
1817
1818 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1819
1820 TRY
1821 {
1822 vec = eris_ifu_vector_create_non_rejected(ev);
1823 if (vec != NULL) {
1824 val = cpl_vector_get_mean(vec);
1825 CHECK_ERROR_STATE();
1826 }
1827 }
1828 CATCH
1829 {
1830 val = 0.;
1831 }
1832 cpl_vector_delete(vec); vec = NULL;
1833
1834 return val;
1835}
1836
1864double eris_ifu_vector_get_median(const eris_ifu_vector *ev,
1865 const enum medianType type)
1866{
1867 cpl_vector *vec = NULL;
1868 double val = 0.;
1869 int size = 0;
1870
1871 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1872
1873 TRY
1874 {
1875 vec = eris_ifu_vector_create_non_rejected(ev);
1876
1877 if (vec != NULL) {
1878 size = cpl_vector_get_size(vec);
1879 if ((type == ERIS_IFU_STATISTICAL) && ((size % 2) == 0)) {
1880 /* statistical method and even size */
1881 cpl_vector_sort(vec, CPL_SORT_ASCENDING);
1882
1883 val = cpl_vector_get(vec, size/2 - 1);
1884 } else {
1885 /* arithmetic method or uneven size */
1886 val = cpl_vector_get_median(vec);
1887 }
1888 }
1889 }
1890 CATCH
1891 {
1892 val = 0.;
1893 }
1894 cpl_vector_delete(vec); vec = NULL;
1895
1896 return val;
1897}
1898
1921eris_ifu_vector* eris_ifu_vector_cut_percentian(const eris_ifu_vector *ev,
1922 double percentage)
1923{
1924 eris_ifu_vector *ret_vec = NULL;
1925 cpl_vector *vec = NULL,
1926 *cut_vec = NULL;
1927 int size = 0;
1928
1929 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
1930 cpl_ensure((percentage >= 0.0) && (percentage < 1.0),
1931 CPL_ERROR_ILLEGAL_INPUT, NULL);
1932
1933 TRY
1934 {
1935 vec = eris_ifu_vector_create_non_rejected(ev);
1936
1937 if (vec != NULL) {
1938 /* sort vector */
1939 cpl_vector_sort(vec, CPL_SORT_ASCENDING);
1940 CHECK_ERROR_STATE();
1941
1942 /* cut percentage wanted */
1943 size = cpl_vector_get_size(vec);
1944 cpl_size tmp = (cpl_size)rint((1.-percentage)*(double)size-1.);
1945 BRK_IF_NULL(
1946 cut_vec = cpl_vector_extract(vec, 0, tmp, 1));
1947 BRK_IF_NULL(
1948 ret_vec = eris_ifu_vector_create(cut_vec));
1949 cpl_vector_delete(cut_vec);
1950 }
1951 }
1952 CATCH
1953 {
1954 eris_ifu_vector_delete(ret_vec); ret_vec = NULL;
1955 }
1956 cpl_vector_delete(vec); vec = NULL;
1957
1958 return ret_vec;
1959}
1960
1979double eris_ifu_vector_get_sum(const eris_ifu_vector *ev)
1980{
1981 int n = 0;
1982 double sum = 0,
1983 *pkvmask = NULL,
1984 *pkvdata = NULL;
1985
1986 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
1987
1988 TRY
1989 {
1990 n = cpl_vector_get_size(ev->data);
1991 CHECK_ERROR_STATE();
1992
1993 BRK_IF_NULL(
1994 pkvdata = cpl_vector_get_data(ev->data));
1995 BRK_IF_NULL(
1996 pkvmask = cpl_vector_get_data(ev->mask));
1997 for (int i = 0; i < n; i++) {
1998 if (pkvmask[i] > 0.5) {
1999 sum += pkvdata[i];
2000 }
2001 }
2002 }
2003 CATCH
2004 {
2005 sum = 0;
2006 }
2007
2008 return sum;
2009}
2010
2034double eris_ifu_vector_get_stdev(const eris_ifu_vector *ev)
2035{
2036 cpl_vector *vec = NULL;
2037 double val = 0.;
2038
2039 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2040
2041 TRY
2042 {
2043 vec = eris_ifu_vector_create_non_rejected(ev);
2044 if (vec != NULL) {
2045 val = cpl_vector_get_stdev(vec);
2046 CHECK_ERROR_STATE();
2047 }
2048 }
2049 CATCH
2050 {
2051 val = -1.;
2052 }
2053 cpl_vector_delete(vec); vec = NULL;
2054
2055 return val;
2056}
2057
2083double eris_ifu_vector_get_stdev_median(const eris_ifu_vector *ev)
2084{
2085 int n = 0;
2086 double stdev = 0,
2087 median = 0,
2088 *pkvmask = NULL,
2089 *pkvdata = NULL;
2090
2091 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2092
2093 TRY
2094 {
2095 n = eris_ifu_vector_count_non_rejected(ev);
2096 CHECK_ERROR_STATE();
2097
2098 if (n <= 1) {
2099 BRK_WITH_ERROR(CPL_ERROR_ILLEGAL_INPUT);
2100 }
2101
2102 median = eris_ifu_vector_get_median(ev, ERIS_IFU_ARITHMETIC);
2103 CHECK_ERROR_STATE();
2104
2105 BRK_IF_NULL(
2106 pkvdata = cpl_vector_get_data(ev->data));
2107 BRK_IF_NULL(
2108 pkvmask = cpl_vector_get_data(ev->mask));
2109 for (int i = 0; i < cpl_vector_get_size(ev->data); i++) {
2110 if (pkvmask[i] > 0.5) {
2111 stdev += pow(pkvdata[i]-median, 2);
2112 }
2113 }
2114
2115 stdev /= (n - 1);
2116 stdev = sqrt(stdev);
2117 }
2118 CATCH
2119 {
2120 stdev = -1;
2121 }
2122
2123 return stdev;
2124}
2125
2145double eris_ifu_vector_get_max(const eris_ifu_vector *ev, int *pos)
2146{
2147 double val = -DBL_MAX;
2148 const double *pkvdata = NULL,
2149 *pkvmask = NULL;
2150 int n = 0;
2151
2152 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2153
2154 TRY
2155 {
2156 BRK_IF_NULL(
2157 pkvdata = cpl_vector_get_data_const(ev->data));
2158 BRK_IF_NULL(
2159 pkvmask = cpl_vector_get_data_const(ev->mask));
2160
2161 n = cpl_vector_get_size(ev->data);
2162 if (eris_ifu_vector_count_rejected(ev) == n) {
2163 val = 0.;
2164 if (pos != NULL) {
2165 *pos = -1;
2166 }
2167 } else {
2168 for (int i = 0; i < n; i++) {
2169 if ((pkvmask[i] > 0.5) && (val < pkvdata[i])) {
2170 val = pkvdata[i];
2171 if (pos != NULL) {
2172 *pos = i;
2173 }
2174 }
2175 }
2176 }
2177 CHECK_ERROR_STATE();
2178 }
2179 CATCH
2180 {
2181 val = 0.;
2182 if (pos != NULL) {
2183 *pos = -1;
2184 }
2185 }
2186
2187 return val;
2188}
2189
2209double eris_ifu_vector_get_min(const eris_ifu_vector *ev, int *pos)
2210{
2211 double val = DBL_MAX;
2212 const double *pkvdata = NULL,
2213 *pkvmask = NULL;
2214 int n = 0;
2215
2216 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2217
2218 TRY
2219 {
2220 BRK_IF_NULL(
2221 pkvdata = cpl_vector_get_data_const(ev->data));
2222 BRK_IF_NULL(
2223 pkvmask = cpl_vector_get_data_const(ev->mask));
2224
2225 n = cpl_vector_get_size(ev->data);
2226 if (eris_ifu_vector_count_rejected(ev) == n) {
2227 val = 0.;
2228 if (pos != NULL) {
2229 *pos = -1;
2230 }
2231 } else {
2232 for (int i = 0; i < n; i++) {
2233 if ((pkvmask[i] > 0.5) && (val > pkvdata[i])) {
2234 val = pkvdata[i];
2235 if (pos != NULL) {
2236 *pos = i;
2237 }
2238 }
2239 }
2240 }
2241 CHECK_ERROR_STATE();
2242 }
2243 CATCH
2244 {
2245 val = 0.;
2246 if (pos != NULL) {
2247 *pos = -1;
2248 }
2249 }
2250
2251 return val;
2252}
2253
2279cpl_error_code eris_ifu_vector_power(eris_ifu_vector *ev, double exponent)
2280{
2281 int n = 0;
2282 double *pkvmask = NULL,
2283 *pkvdata = NULL;
2284 cpl_error_code err = CPL_ERROR_NONE;
2285
2286 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2287
2288 TRY
2289 {
2290 if (exponent == 0.0) {
2291 /* create vector filled with ones */
2292 eris_ifu_vector_multiply_scalar(ev, 0.0);
2293 CHECK_ERROR_STATE();
2294
2295 eris_ifu_vector_add_scalar(ev, 1.0);
2296 CHECK_ERROR_STATE();
2297 } else {
2298 n = cpl_vector_get_size(ev->data);
2299 CHECK_ERROR_STATE();
2300
2301 BRK_IF_NULL(
2302 pkvdata = cpl_vector_get_data(ev->data));
2303 BRK_IF_NULL(
2304 pkvmask = cpl_vector_get_data(ev->mask));
2305 for (int i = 0; i < n; i++) {
2306 if (pkvmask[i] > 0.5) {
2307 pkvdata[i] = pow(pkvdata[i], exponent);
2308 }
2309 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
2310 /*pkvdata[i] = NAN;*/
2311 pkvmask[i] = 0.;
2312 }
2313 }
2314 }
2315 }
2316 CATCH
2317 {
2318 err = cpl_error_get_code();
2319 }
2320
2321 return err;
2322}
2323
2346cpl_error_code eris_ifu_vector_fill(eris_ifu_vector *ev, double val)
2347{
2348 cpl_error_code err = CPL_ERROR_NONE;
2349
2350 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2351
2352 TRY
2353 {
2354 for (int i = 0; i < eris_ifu_vector_get_size(ev); i++) {
2355 eris_ifu_vector_set(ev, i, val);
2356 }
2357 }
2358 CATCH
2359 {
2360 err = cpl_error_get_code();
2361 }
2362
2363 return err;
2364}
2365
2386cpl_error_code eris_ifu_vector_flip(eris_ifu_vector* ev)
2387{
2388 cpl_error_code ret_error = CPL_ERROR_NONE;
2389 double *pkvdata = NULL,
2390 *pkvmask = NULL,
2391 tmp_dbl = 0;
2392 int half_size = 0,
2393 size = 0;
2394
2395 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2396
2397 TRY
2398 {
2399 BRK_IF_NULL(
2400 pkvdata = cpl_vector_get_data(ev->data));
2401 BRK_IF_NULL(
2402 pkvmask = cpl_vector_get_data(ev->mask));
2403
2404 size = cpl_vector_get_size(ev->data);
2405 half_size = floor(size / 2);
2406
2407 for (int i = 0; i < half_size;i++) {
2408 tmp_dbl = pkvdata[i];
2409 pkvdata[i] = pkvdata[size-1-i];
2410 pkvdata[size-1-i] = tmp_dbl;
2411
2412 tmp_dbl = pkvmask[i];
2413 pkvmask[i] = pkvmask[size-1-i];
2414 pkvmask[size-1-i] = tmp_dbl;
2415 }
2416 }
2417 CATCH
2418 {
2419 ret_error = cpl_error_get_code();
2420 }
2421
2422 return ret_error;
2423}
2424
2450eris_ifu_vector* eris_ifu_vector_histogram(const eris_ifu_vector *ev, int nbins)
2451{
2452 int pos = 0;
2453 const double *pkvdata = NULL,
2454 *pkvmask = NULL;
2455 double *phdata = NULL,
2456 binwidth = 0.0,
2457 hmin = 0.0,
2458 hmax = 0.0;
2459 eris_ifu_vector *h = NULL;
2460
2461 cpl_ensure(ev, CPL_ERROR_NULL_INPUT, NULL);
2462 cpl_ensure(nbins > 0, CPL_ERROR_NULL_INPUT, NULL);
2463
2464 TRY
2465 {
2466 hmin = eris_ifu_vector_get_min(ev, NULL);
2467 hmax = eris_ifu_vector_get_max(ev, NULL);
2468 CHECK_ERROR_STATE();
2469
2470 binwidth = (hmax - hmin) / (nbins - 1);
2471
2472 BRK_IF_NULL(
2473 pkvdata = cpl_vector_get_data_const(ev->data));
2474 BRK_IF_NULL(
2475 pkvmask = cpl_vector_get_data_const(ev->mask));
2476
2477 BRK_IF_NULL(
2478 h = eris_ifu_vector_new(nbins));
2479 BRK_IF_NULL(
2480 phdata = cpl_vector_get_data(h->data));
2481
2482 for (int i = 0; i < cpl_vector_get_size(ev->data); i++) {
2483 if (pkvmask[i] > 0.5) {
2484 pos = floor((pkvdata[i] - hmin) / binwidth);
2485 phdata[pos]++;
2486 }
2487 }
2488 }
2489 CATCH
2490 {
2491 eris_ifu_vector_delete(h); h = NULL;
2492 }
2493
2494 return h;
2495}
2496
2511eris_ifu_vector* eris_ifu_vector_load(const char *filename, int position)
2512{
2513 cpl_vector *vec = NULL;
2514 eris_ifu_vector *ev = NULL;
2515
2516 TRY
2517 {
2518 vec = cpl_vector_load(filename, position);
2519 if (cpl_error_get_code() != CPL_ERROR_NONE) {
2520 if (cpl_error_get_code() == CPL_ERROR_FILE_IO) {
2521 cpl_msg_error("", "File not found: %s", filename);
2522 } else {
2523 cpl_msg_error("", "Problem loading file '%s' (%s --> Code %d)",
2524 filename, cpl_error_get_message(),
2525 cpl_error_get_code());
2526 }
2527 }
2528 CHECK_ERROR_STATE();
2529
2530 BRK_IF_NULL(
2531 ev = eris_ifu_vector_create(vec));
2532 cpl_vector_delete(vec);
2533 }
2534 CATCH
2535 {
2536 eris_ifu_vector_delete(ev);
2537 }
2538
2539 return ev;
2540}
2541
2561cpl_error_code eris_ifu_vector_save(const eris_ifu_vector *ev,
2562 const char *filename,
2563 cpl_type_bpp bpp,
2564 const cpl_propertylist *pl,
2565 unsigned mode,
2566 double rej_val)
2567{
2568 cpl_error_code err = CPL_ERROR_NONE;
2569 eris_ifu_vector *ev_dup = NULL;
2570 double *pkvdata = NULL,
2571 *pkvmask = NULL;
2572 int n = 0;
2573
2574 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2575
2576 TRY
2577 {
2578 if ((rej_val != -1) || (eris_ifu_is_nan_or_inf(rej_val))) {
2579 BRK_IF_NULL(
2580 ev_dup = eris_ifu_vector_duplicate(ev));
2581 /* set rejected values to NaN */
2582 BRK_IF_NULL(
2583 pkvdata = cpl_vector_get_data(ev_dup->data));
2584 BRK_IF_NULL(
2585 pkvmask = cpl_vector_get_data(ev_dup->mask));
2586 n = cpl_vector_get_size(ev_dup->data);
2587 for (int i = 0; i < n; i++) {
2588 if (pkvmask[i] < 0.5) {
2589 pkvdata[i] = rej_val;
2590 }
2591 }
2592
2593 err = cpl_vector_save(ev_dup->data, filename, bpp, pl, mode);
2594 CHECK_ERROR_STATE();
2595 } else {
2596 err = cpl_vector_save(ev->data, filename, bpp, pl, mode);
2597 CHECK_ERROR_STATE();
2598 }
2599 eris_ifu_vector_delete(ev_dup); ev_dup = NULL;
2600 }
2601 CATCH
2602 {
2603 err = cpl_error_get_code();
2604 }
2605
2606 return err;
2607}
2608
2619cpl_error_code eris_ifu_vector_dump(const eris_ifu_vector *ev)
2620{
2621 int n = 0;
2622 cpl_error_code err = CPL_ERROR_NONE;
2623 const double *pkvdata = NULL,
2624 *pkvmask = NULL;
2625
2626 TRY
2627 {
2628 if (ev == NULL) {
2629 cpl_msg_debug("", " ====== START KMCLIPM_VECTOR ======");
2630 cpl_msg_debug("", " empty vector");
2631 cpl_msg_debug("", " ====== END KMCLIPM_VECTOR ========");
2632 } else {
2633 n = cpl_vector_get_size(ev->data);
2634
2635 if (n != cpl_vector_get_size(ev->mask)) {
2636 BRK_WITH_ERROR_MSG(CPL_ERROR_ILLEGAL_INPUT,
2637 "data and mask not of same size!");
2638 }
2639
2640 BRK_IF_NULL(
2641 pkvdata = cpl_vector_get_data_const(ev->data));
2642 BRK_IF_NULL(
2643 pkvmask = cpl_vector_get_data_const(ev->mask));
2644
2645 cpl_msg_debug("", " ====== START KMCLIPM_VECTOR ======");
2646 cpl_msg_debug("", " #\tdata:\tmask:");
2647 cpl_msg_debug("", " ---------------------");
2648 for (int i = 0; i < n; i++) {
2649 cpl_msg_debug("", " %d\t%g\t%g", i, pkvdata[i], pkvmask[i]);
2650 }
2651 cpl_msg_debug("", " ====== END KMCLIPM_VECTOR ========");
2652 CHECK_ERROR_STATE();
2653 }
2654 }
2655 CATCH
2656 {
2657 err = cpl_error_get_code();
2658 }
2659
2660 return err;
2661}
2662
2671int eris_ifu_is_nan_or_inf(double A)
2672{
2673 return (isnan(A) || (isinf(A)==1) || (isinf(A)==-1));
2674}
2675
2684cpl_error_code eris_ifu_vector_sqrt(eris_ifu_vector *ev)
2685{
2686 cpl_size n = 0;
2687 double *pkvmask = NULL,
2688 *pkvdata = NULL;
2689 cpl_error_code err = CPL_ERROR_NONE;
2690
2691 cpl_ensure_code(ev, CPL_ERROR_NULL_INPUT);
2692
2693 TRY
2694 {
2695 n = cpl_vector_get_size(ev->data);
2696 CHECK_ERROR_STATE();
2697
2698 BRK_IF_NULL(
2699 pkvdata = cpl_vector_get_data(ev->data));
2700 BRK_IF_NULL(
2701 pkvmask = cpl_vector_get_data(ev->mask));
2702
2703 /* Compute the sqrt */
2704 for (int i = 0; i < n; i++) {
2705 if (pkvmask[i] > 0.5) {
2706 /* assert that data is >= 0
2707 it can be NaN, since sqrt() handles NaN correctly:
2708 sqrt(NaN) = NaN */
2709 cpl_ensure_code(pkvdata[i] >= 0, CPL_ERROR_ILLEGAL_INPUT);
2710
2711 pkvdata[i] = sqrt(pkvdata[i]);
2712
2713 if (eris_ifu_is_nan_or_inf(pkvdata[i])) {
2714 /*pkvdata[i] = NAN;*/
2715 pkvmask[i] = 0.;
2716 }
2717 }
2718 }
2719 }
2720 CATCH
2721 {
2722 err = cpl_error_get_code();
2723 }
2724
2725 return err;
2726}
BRK_WITH_ERROR
#define BRK_WITH_ERROR(code)
Set a new CPL error, and exit the try-block.
Definition: eris_ifu_error.h:306
BRK_IF_ERROR
#define BRK_IF_ERROR(function)
If function is or returns an error != CPL_ERROR_NONE, then the try-block is exited.
Definition: eris_ifu_error.h:339
CHECK_ERROR_STATE
#define CHECK_ERROR_STATE(void)
Check the CPL error state, and exit the try-block if not CPL_ERROR_NONE.
Definition: eris_ifu_error.h:266
BRK_WITH_ERROR_MSG
#define BRK_WITH_ERROR_MSG(code,...)
Set a new CPL error, and exit the try-block.
Definition: eris_ifu_error.h:322
TRY
#define TRY
Beginning of a TRY-block.
Definition: eris_ifu_error.h:156
CATCH
#define CATCH
End of a TRY-block, beginning of a CATCH-block.
Definition: eris_ifu_error.h:173
BRK_IF_NULL
#define BRK_IF_NULL(function)
If function is or returns a NULL pointer, then the try-block is exited.
Definition: eris_ifu_error.h:360
eris_ifu_vector_reject_from_mask
cpl_error_code eris_ifu_vector_reject_from_mask(eris_ifu_vector *ev, const cpl_vector *mask, int keep)
Set the rejected elements in an eris_ifu_vector as defined in a mask.
Definition: eris_ifu_vector.c:783
eris_ifu_vector_cut_percentian
eris_ifu_vector * eris_ifu_vector_cut_percentian(const eris_ifu_vector *ev, double percentage)
Remove a certain percentage of brightest pixels.
Definition: eris_ifu_vector.c:1921
eris_ifu_vector_create2
eris_ifu_vector * eris_ifu_vector_create2(const cpl_vector *data, const cpl_vector *mask)
Create a new eris_ifu_vector out of a data and mask cpl_vector.
Definition: eris_ifu_vector.c:390
eris_ifu_vector_histogram
eris_ifu_vector * eris_ifu_vector_histogram(const eris_ifu_vector *ev, int nbins)
Calculates the histogram of a vector.
Definition: eris_ifu_vector.c:2450
eris_ifu_vector_get_stdev_median
double eris_ifu_vector_get_stdev_median(const eris_ifu_vector *ev)
Compute the bias-corrected standard deviation using median instead of mean.
Definition: eris_ifu_vector.c:2083
eris_ifu_vector_save
cpl_error_code eris_ifu_vector_save(const eris_ifu_vector *ev, const char *filename, cpl_type_bpp bpp, const cpl_propertylist *pl, unsigned mode, double rej_val)
Override for cpl_vector_save().
Definition: eris_ifu_vector.c:2561
eris_ifu_is_nan_or_inf
int eris_ifu_is_nan_or_inf(double A)
Checks if a value is nan, inf or -inf.
Definition: eris_ifu_vector.c:2671
eris_ifu_vector_new
eris_ifu_vector * eris_ifu_vector_new(int n)
Create a new eris_ifu_vector.
Definition: eris_ifu_vector.c:184
eris_ifu_vector_get_rej
double eris_ifu_vector_get_rej(const eris_ifu_vector *ev, int pos, int *rej)
Get an element of the eris_ifu_vector.
Definition: eris_ifu_vector.c:587
eris_ifu_vector_get_size
int eris_ifu_vector_get_size(const eris_ifu_vector *ev)
Get the size of the eris_ifu_vector.
Definition: eris_ifu_vector.c:1776
eris_ifu_vector_multiply_scalar
cpl_error_code eris_ifu_vector_multiply_scalar(eris_ifu_vector *ev, double factor)
Elementwise multiplication of a scalar to a eris_ifu_vector.
Definition: eris_ifu_vector.c:1619
eris_ifu_vector_count_non_rejected
int eris_ifu_vector_count_non_rejected(const eris_ifu_vector *ev)
Count the number of non-rejected elements in a eris_ifu_vector.
Definition: eris_ifu_vector.c:878
eris_ifu_vector_is_rejected
int eris_ifu_vector_is_rejected(const eris_ifu_vector *ev, int n)
Test if a value is good or bad.
Definition: eris_ifu_vector.c:925
eris_ifu_vector_flip
cpl_error_code eris_ifu_vector_flip(eris_ifu_vector *ev)
Flip the values of a vector.
Definition: eris_ifu_vector.c:2386
eris_ifu_vector_subtract
cpl_error_code eris_ifu_vector_subtract(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
Subtract two eris_ifu_vectors.
Definition: eris_ifu_vector.c:1274
eris_ifu_vector_dump
cpl_error_code eris_ifu_vector_dump(const eris_ifu_vector *ev)
All values contained in vec are printed for debugging purposes.
Definition: eris_ifu_vector.c:2619
eris_ifu_vector_multiply
cpl_error_code eris_ifu_vector_multiply(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
Multiply two eris_ifu_vectors.
Definition: eris_ifu_vector.c:1354
eris_ifu_vector_get_mask
cpl_vector * eris_ifu_vector_get_mask(const eris_ifu_vector *ev)
Get a copy of the mask of eris_ifu_vector.
Definition: eris_ifu_vector.c:663
eris_ifu_vector_set
cpl_error_code eris_ifu_vector_set(eris_ifu_vector *ev, int pos, double val)
Set an element of the eris_ifu_vector.
Definition: eris_ifu_vector.c:540
eris_ifu_vector_abs
cpl_error_code eris_ifu_vector_abs(eris_ifu_vector *ev)
Calculates the absolute value of a vector in-place.
Definition: eris_ifu_vector.c:1730
eris_ifu_vector_duplicate
eris_ifu_vector * eris_ifu_vector_duplicate(const eris_ifu_vector *ev)
This function duplicates an existing eris_ifu_vector and allocates memory.
Definition: eris_ifu_vector.c:489
eris_ifu_vector_fill
cpl_error_code eris_ifu_vector_fill(eris_ifu_vector *ev, double val)
Fill a eris_ifu_vector.
Definition: eris_ifu_vector.c:2346
eris_ifu_vector_get_min
double eris_ifu_vector_get_min(const eris_ifu_vector *ev, int *pos)
Get the minimum of the eris_ifu_vector and its position.
Definition: eris_ifu_vector.c:2209
eris_ifu_vector_new_wrap
eris_ifu_vector * eris_ifu_vector_new_wrap(int n, const double *data)
Create a new eris_ifu_vector from a C array (duplicated).
Definition: eris_ifu_vector.c:240
eris_ifu_vector_extract
eris_ifu_vector * eris_ifu_vector_extract(const eris_ifu_vector *ev, int istart, int istop)
Extract a sub-vector from a eris_ifu_vector.
Definition: eris_ifu_vector.c:1013
eris_ifu_vector_sqrt
cpl_error_code eris_ifu_vector_sqrt(eris_ifu_vector *ev)
eris_ifu_vector_sqrt
Definition: eris_ifu_vector.c:2684
eris_ifu_vector_power
cpl_error_code eris_ifu_vector_power(eris_ifu_vector *ev, double exponent)
Compute the elementwise power of the vector.
Definition: eris_ifu_vector.c:2279
eris_ifu_vector_get_max
double eris_ifu_vector_get_max(const eris_ifu_vector *ev, int *pos)
Get the maximum of the eris_ifu_vector and its position.
Definition: eris_ifu_vector.c:2145
eris_ifu_vector_get_bpm
cpl_vector * eris_ifu_vector_get_bpm(eris_ifu_vector *ev)
Get the pointer to the mask of the eris_ifu_vector.
Definition: eris_ifu_vector.c:742
eris_ifu_vector_get_stdev
double eris_ifu_vector_get_stdev(const eris_ifu_vector *ev)
Compute the bias-corrected standard deviation of a vector's elements.
Definition: eris_ifu_vector.c:2034
eris_ifu_vector_subtract_scalar
cpl_error_code eris_ifu_vector_subtract_scalar(eris_ifu_vector *ev, double subtrahend)
Elementwise subtraction of a scalar from a eris_ifu_vector.
Definition: eris_ifu_vector.c:1563
eris_ifu_vector_adapt_rejected
cpl_error_code eris_ifu_vector_adapt_rejected(eris_ifu_vector *kv1, eris_ifu_vector *kv2)
Assert that rejected values on both vectors are the same.
Definition: eris_ifu_vector.c:1129
eris_ifu_vector_get
double eris_ifu_vector_get(const eris_ifu_vector *ev, int pos)
Get an element of the eris_ifu_vector.
Definition: eris_ifu_vector.c:639
eris_ifu_vector_add_scalar
cpl_error_code eris_ifu_vector_add_scalar(eris_ifu_vector *ev, double addend)
Elementwise addition of a scalar to a eris_ifu_vector.
Definition: eris_ifu_vector.c:1508
medianType
medianType
The type of median behavior: For an odd number of samples the behaviour is the same for both methods....
Definition: eris_ifu_vector.h:58
eris_ifu_vector_count_rejected
int eris_ifu_vector_count_rejected(const eris_ifu_vector *ev)
Count the number of rejected elements in a eris_ifu_vector.
Definition: eris_ifu_vector.c:838
eris_ifu_vector_reject
cpl_error_code eris_ifu_vector_reject(eris_ifu_vector *ev, int n)
Set a value as rejected in a eris_ifu_vector.
Definition: eris_ifu_vector.c:970
eris_ifu_vector_get_data
cpl_vector * eris_ifu_vector_get_data(const eris_ifu_vector *ev)
Get a copy of the data, rejected values are set to NaN.
Definition: eris_ifu_vector.c:700
eris_ifu_vector_get_sum
double eris_ifu_vector_get_sum(const eris_ifu_vector *ev)
Compute the sum of non-rejected eris_ifu_vector elements.
Definition: eris_ifu_vector.c:1979
eris_ifu_vector_get_median
double eris_ifu_vector_get_median(const eris_ifu_vector *ev, const enum medianType type)
Compute the median of the elements of a vector.
Definition: eris_ifu_vector.c:1864
eris_ifu_vector_add
cpl_error_code eris_ifu_vector_add(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
Add a eris_ifu_vector to another.
Definition: eris_ifu_vector.c:1195
eris_ifu_vector_create_non_rejected
cpl_vector * eris_ifu_vector_create_non_rejected(const eris_ifu_vector *ev)
Creates a cpl_vector out of a eris_ifu_vector with non-rejected values.
Definition: eris_ifu_vector.c:1066
eris_ifu_vector_divide_scalar
cpl_error_code eris_ifu_vector_divide_scalar(eris_ifu_vector *ev, double dividend)
Elementwise division of a eris_ifu_vector by a scalar.
Definition: eris_ifu_vector.c:1674
eris_ifu_vector_delete
void eris_ifu_vector_delete(eris_ifu_vector *ev)
Delete a eris_ifu_vector.
Definition: eris_ifu_vector.c:457
eris_ifu_vector_load
eris_ifu_vector * eris_ifu_vector_load(const char *filename, int position)
Override for cpl_vector_load().
Definition: eris_ifu_vector.c:2511
eris_ifu_vector_create
eris_ifu_vector * eris_ifu_vector_create(const cpl_vector *data)
Create a new eris_ifu_vector out of a data cpl_vector.
Definition: eris_ifu_vector.c:310
eris_ifu_vector_divide
cpl_error_code eris_ifu_vector_divide(eris_ifu_vector *kv1, const eris_ifu_vector *kv2)
Divide two eris_ifu_vectors element-wise.
Definition: eris_ifu_vector.c:1437
eris_ifu_vector_get_mean
double eris_ifu_vector_get_mean(const eris_ifu_vector *ev)
Compute the mean value of non-rejected eris_ifu_vector elements.
Definition: eris_ifu_vector.c:1813
Generated on Tue Jan 27 2026 21:31:13 for ERIS Pipeline Reference Manual by doxygen 1.9.6