X-shooter Pipeline Reference Manual 3.8.15
xsh_pfits.c
Go to the documentation of this file.
1/* *
2 * This file is part of the ESO X-shooter Pipeline *
3 * Copyright (C) 2006 European Southern Observatory *
4 * *
5 * This library is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the Free Software *
17 * Foundation, 51 Franklin St, Fifth Floor, Boston, MA 02111-1307 USA *
18 * */
19
20/*
21 * $Author: amodigli $
22 * $Date: 2013-04-01 18:15:21 $
23 * $Revision: 1.113 $
24 * $Name: not supported by cvs2svn $
25 */
26
27#ifdef HAVE_CONFIG_H
28#include <config.h>
29#endif
30
31/*----------------------------------------------------------------------------
32 Includes
33 ----------------------------------------------------------------------------*/
34#include <math.h>
35
36#include <xsh_dump.h>
37#include <xsh_utils.h>
38#include <xsh_error.h>
39#include <xsh_msg.h>
40#include <xsh_qc_handling.h>
41#include <xsh_data_instrument.h>
42#include <xsh_pfits.h>
43#include <string.h>
44#include <cpl.h>
45#include <stdbool.h>
46/*---------------------------------------------------------------------------*/
54/*---------------------------------------------------------------------------*/
55
58/*----------------------------------------------------------------------------
59 Function prototypes
60 ----------------------------------------------------------------------------*/
61
62/*----------------------------------------------------------------------------
63 Function implementation
64 ----------------------------------------------------------------------------*/
65/*----------------------------------------------------------------------------*/
71/*----------------------------------------------------------------------------*/
72int xsh_pfits_get_tpl_expno(const cpl_propertylist * plist)
73{
74 int returnvalue = 0;
75 returnvalue=cpl_propertylist_get_int(plist,XSH_TPL_EXPNO);
76 return returnvalue;
77}
78
79/*----------------------------------------------------------------------------*/
85/*----------------------------------------------------------------------------*/
86double xsh_pfits_get_tpl_start(const cpl_propertylist * plist)
87{
88 double returnvalue = 0;
89 returnvalue=cpl_propertylist_get_double(plist,XSH_TPL_START);
90 return returnvalue;
91}
92
93/*----------------------------------------------------------------------------*/
99/*----------------------------------------------------------------------------*/
100double xsh_pfits_get_tpl_end(const cpl_propertylist * plist)
101{
102 double returnvalue = 0;
103 returnvalue=cpl_propertylist_get_double(plist,XSH_TPL_END);
104 return returnvalue;
105}
106
107/*----------------------------------------------------------------------------*/
113/*----------------------------------------------------------------------------*/
114double xsh_pfits_get_geolat(const cpl_propertylist * plist)
115{
116 double returnvalue = 0;
117 returnvalue=cpl_propertylist_get_double(plist,XSH_GEOLAT);
118 return returnvalue;
119}
120
121/*----------------------------------------------------------------------------*/
127/*----------------------------------------------------------------------------*/
128double xsh_pfits_get_geolon(const cpl_propertylist * plist)
129{
130 double returnvalue = 0;
131 returnvalue=cpl_propertylist_get_double(plist,XSH_GEOLON);
132 return returnvalue;
133}
134
135/*----------------------------------------------------------------------------*/
141/*----------------------------------------------------------------------------*/
142double xsh_pfits_get_utc(const cpl_propertylist * plist)
143{
144 double returnvalue = 0;
145 returnvalue=cpl_propertylist_get_double(plist,XSH_UTC);
146 return returnvalue;
147}
148
149
150
151/*---------------------------------------------------------------------------*/
157/*---------------------------------------------------------------------------*/
158double xsh_pfits_get_pixscale(const cpl_propertylist * plist)
159{
160 const char* val=NULL;
161 val=cpl_propertylist_get_string(plist,"ESO INS OPTI1 NAME");
162 return atof(val);
163}
164
165/*---------------------------------------------------------------------------*/
171/*---------------------------------------------------------------------------*/
172double xsh_pfits_get_posangle(const cpl_propertylist * plist)
173{
174 return cpl_propertylist_get_double(plist,"ESO ADA POSANG");
175}
176
177
178
179/*----------------------------------------------------------------------------*/
185/*----------------------------------------------------------------------------*/
186double xsh_pfits_get_mjdobs(const cpl_propertylist * plist)
187{
188 double returnvalue = 0;
189
190 check_msg(xsh_get_property_value(plist, XSH_MJDOBS,
191 CPL_TYPE_DOUBLE, &returnvalue),
192 "Error reading keyword '%s'", XSH_MJDOBS);
193
194 cleanup:
195 return returnvalue;
196}
197
198
199
200
201/*---------------------------------------------------------------------------*/
207/*---------------------------------------------------------------------------*/
208
209int xsh_pfits_get_naxis (const cpl_propertylist * plist)
210{
211 int ret = 0;
212
213 XSH_PFITS_GET( ret, plist, XSH_NAXIS, CPL_TYPE_INT);
214
215 cleanup:
216 return ret;
217}
218
219/*---------------------------------------------------------------------------*/
225/*---------------------------------------------------------------------------*/
226int
227xsh_pfits_get_naxis1 (const cpl_propertylist * plist)
228{
229 int ret = 0;
230
231 XSH_PFITS_GET( ret, plist, XSH_NAXIS1, CPL_TYPE_INT);
232
233 cleanup:
234 return ret;
235}
236
237/*---------------------------------------------------------------------------*/
243/*---------------------------------------------------------------------------*/
244int xsh_pfits_get_naxis2 (const cpl_propertylist * plist)
245{
246 int ret = 0;
247
248 XSH_PFITS_GET( ret, plist, XSH_NAXIS2, CPL_TYPE_INT);
249
250 cleanup:
251 return ret;
252}
253/*---------------------------------------------------------------------------*/
259/*---------------------------------------------------------------------------*/
260int xsh_pfits_get_naxis3(const cpl_propertylist * plist)
261{
262 int ret = 0;
263
264 XSH_PFITS_GET( ret, plist, XSH_NAXIS3, CPL_TYPE_INT);
265
266 cleanup:
267 return ret;
268}
269
270XSH_ARM xsh_pfits_get_arm( const cpl_propertylist * plist)
271{
272 XSH_ARM ret = XSH_ARM_UNDEFINED;
273 const char *arm = "";
274
275 XSH_PFITS_GET( arm, plist, XSH_SEQ_ARM, CPL_TYPE_STRING ) ;
276 ret = xsh_arm_get( arm ) ;
277
278 cleanup:
279 return ret ;
280}
281
282/*---------------------------------------------------------------------------*/
288/*---------------------------------------------------------------------------*/
289int xsh_pfits_get_binx(const cpl_propertylist * plist)
290{
291 int ret = 0;
292
293 XSH_PFITS_GET( ret, plist, XSH_WIN_BINX, CPL_TYPE_INT);
294
295 cleanup:
296 return ret;
297}
298
299/*---------------------------------------------------------------------------*/
305/*---------------------------------------------------------------------------*/
306int xsh_pfits_get_biny(const cpl_propertylist * plist)
307{
308 int ret = 0;
309
310 XSH_PFITS_GET( ret, plist, XSH_WIN_BINY, CPL_TYPE_INT);
311
312 cleanup:
313 return ret;
314}
315
316/*--------------------------------------------------------------------------- */
322/*--------------------------------------------------------------------------- */
323int xsh_pfits_get_chip_nx (const cpl_propertylist * plist)
324{
325 int ret = 0;
326
327 XSH_PFITS_GET( ret, plist, XSH_CHIP_NX, CPL_TYPE_INT);
328
329 cleanup:
330 return ret;
331}
332
333/*--------------------------------------------------------------------------- */
339/*--------------------------------------------------------------------------- */
340int xsh_pfits_get_chip_ny (const cpl_propertylist * plist)
341{
342 int ret = 0;
343
344 XSH_PFITS_GET( ret, plist, XSH_CHIP_NY, CPL_TYPE_INT);
345
346 cleanup:
347 return ret;
348}
349
350/*--------------------------------------------------------------------------- */
356/*--------------------------------------------------------------------------- */
357int xsh_pfits_get_out_nx (const cpl_propertylist * plist)
358{
359 int ret = 0;
360
361 XSH_PFITS_GET( ret, plist, XSH_OUT_NX, CPL_TYPE_INT);
362
363 cleanup:
364 return ret;
365}
366
367/*--------------------------------------------------------------------------- */
373/*--------------------------------------------------------------------------- */
374int xsh_pfits_get_out_ny (const cpl_propertylist * plist)
375{
376 int ret = 0;
377
378 XSH_PFITS_GET( ret, plist, XSH_OUT_NY, CPL_TYPE_INT);
379
380 cleanup:
381 return ret;
382}
383
384/*--------------------------------------------------------------------------- */
390/*--------------------------------------------------------------------------- */
391int xsh_pfits_get_ovscx (const cpl_propertylist * plist)
392{
393 int ret = 0;
394
395 XSH_PFITS_GET( ret, plist, XSH_OVSCX, CPL_TYPE_INT);
396
397 cleanup:
398 return ret;
399}
400
401/*--------------------------------------------------------------------------- */
407/*--------------------------------------------------------------------------- */
408int xsh_pfits_get_ovscy (const cpl_propertylist * plist)
409{
410 int ret = 0;
411
412 XSH_PFITS_GET( ret, plist, XSH_OVSCY, CPL_TYPE_INT);
413
414 cleanup:
415 return ret;
416}
417
418/*--------------------------------------------------------------------------- */
424/*--------------------------------------------------------------------------- */
425int xsh_pfits_get_prscx (const cpl_propertylist * plist)
426{
427 int ret = 0;
428
429 XSH_PFITS_GET( ret, plist, XSH_PRSCX, CPL_TYPE_INT);
430
431 cleanup:
432 return ret;
433}
434
435/*--------------------------------------------------------------------------- */
441/*--------------------------------------------------------------------------- */
442int xsh_pfits_get_prscy (const cpl_propertylist * plist)
443{
444 int ret = 0;
445
446 XSH_PFITS_GET( ret, plist, XSH_PRSCY, CPL_TYPE_INT);
447
448 cleanup:
449 return ret;
450}
451
452/*--------------------------------------------------------------------------- */
458/*--------------------------------------------------------------------------- */
459double xsh_pfits_get_ron (const cpl_propertylist * plist)
460{
461 double ret = 0;
462
463 XSH_PFITS_GET( ret, plist, XSH_RON, CPL_TYPE_DOUBLE);
464
465 cleanup:
466 return ret;
467}
468
469
470
471/*--------------------------------------------------------------------------- */
477/*--------------------------------------------------------------------------- */
478double xsh_pfits_get_lst (const cpl_propertylist * plist)
479{
480 double ret = 0;
481
482 XSH_PFITS_GET( ret, plist, XSH_LST, CPL_TYPE_DOUBLE);
483
484 cleanup:
485 return ret;
486}
487
488
489/*--------------------------------------------------------------------------- */
495/*--------------------------------------------------------------------------- */
496double xsh_pfits_get_airm_start (const cpl_propertylist * plist)
497{
498 double ret = 1. ;
499
500 xsh_get_property_value( plist, XSH_AIRM_START, CPL_TYPE_DOUBLE, &ret ) ;
501
502 return ret;
503}
504/*--------------------------------------------------------------------------- */
510/*--------------------------------------------------------------------------- */
511double xsh_pfits_get_airm_mean (const cpl_propertylist * plist)
512{
513 double airmass_start=0;
514 double airmass_end=0;
515 airmass_start = xsh_pfits_get_airm_start(plist);
516 airmass_end = xsh_pfits_get_airm_end(plist);
517
518 return 0.5*(airmass_start+airmass_end);
519}
520/*--------------------------------------------------------------------------- */
526/*--------------------------------------------------------------------------- */
527double xsh_pfits_get_airm_end (const cpl_propertylist * plist)
528{
529 double ret = 1. ;
530
531 xsh_get_property_value( plist, XSH_AIRM_END, CPL_TYPE_DOUBLE, &ret ) ;
532
533 return ret;
534}
535
536
537/*--------------------------------------------------------------------------- */
543/*--------------------------------------------------------------------------- */
544double xsh_pfits_get_seeing_start (const cpl_propertylist * plist)
545{
546 double ret = 0;
547
548 XSH_PFITS_GET( ret, plist, XSH_SEEING_START, CPL_TYPE_DOUBLE);
549
550 cleanup:
551 return ret;
552}
553
554/*--------------------------------------------------------------------------- */
560/*--------------------------------------------------------------------------- */
561double xsh_pfits_get_seeing_end (const cpl_propertylist * plist)
562{
563 double ret = 0;
564
565 XSH_PFITS_GET( ret, plist, XSH_SEEING_END, CPL_TYPE_DOUBLE);
566
567 cleanup:
568 return ret;
569}
570
571/*--------------------------------------------------------------------------- */
579/*--------------------------------------------------------------------------- */
580double xsh_pfits_get_slit_width (const cpl_propertylist * plist,
581 xsh_instrument * instrument )
582{
583 char * str =NULL;
584 double ret = 0;
585 XSH_ARM arm ;
586
587 arm = xsh_instrument_get_arm( instrument ) ;
588
589 switch ( arm ) {
590 case XSH_ARM_UVB:
591 case XSH_ARM_AGC:
592 XSH_PFITS_GET( str, plist, XSH_SLIT_UVB, CPL_TYPE_STRING);
593 break ;
594 case XSH_ARM_VIS:
595 XSH_PFITS_GET( str, plist, XSH_SLIT_VIS, CPL_TYPE_STRING);
596 break ;
597 case XSH_ARM_NIR:
598 XSH_PFITS_GET( str, plist, XSH_SLIT_NIR, CPL_TYPE_STRING);
599 break ;
600 case XSH_ARM_UNDEFINED:
601 xsh_msg("arm undefined");
602 break;
603 }
604 sscanf( str, "%64lf", &ret ) ;
605 cleanup:
606 return ret;
607}
608
609
610/*--------------------------------------------------------------------------- */
618/*--------------------------------------------------------------------------- */
619char* xsh_pfits_get_slit_value (const cpl_propertylist * plist,
620 xsh_instrument * instrument )
621{
622 char * str =NULL;
623 XSH_ARM arm ;
624
625 arm = xsh_instrument_get_arm( instrument ) ;
626
627 switch ( arm ) {
628 case XSH_ARM_UVB:
629 case XSH_ARM_AGC:
630 XSH_PFITS_GET( str, plist, XSH_SLIT_UVB, CPL_TYPE_STRING);
631 break ;
632 case XSH_ARM_VIS:
633 XSH_PFITS_GET( str, plist, XSH_SLIT_VIS, CPL_TYPE_STRING);
634 break ;
635 case XSH_ARM_NIR:
636 XSH_PFITS_GET( str, plist, XSH_SLIT_NIR, CPL_TYPE_STRING);
637 break ;
638 case XSH_ARM_UNDEFINED:
639 xsh_msg("arm undefined");
640 break;
641 }
642
643 cleanup:
644 return str;
645}
646
647
648
649/*--------------------------------------------------------------------------- */
656/*--------------------------------------------------------------------------- */
657const char* xsh_pfits_get_telescop (const cpl_propertylist * plist)
658{
659 const char * tel =NULL;
660 check_msg (xsh_get_property_value(plist, XSH_TELESCOP, CPL_TYPE_STRING, &tel),
661 "Error reading keyword '%s'", XSH_TELESCOP);
662
663 cleanup:
664 return tel;
665}
666
667
668/*--------------------------------------------------------------------------- */
674/*--------------------------------------------------------------------------- */
675double xsh_pfits_get_gain (const cpl_propertylist * plist)
676{
677 double ret = 0;
678
679 XSH_PFITS_GET( ret, plist, XSH_DET_GAIN, CPL_TYPE_DOUBLE);
680
681 cleanup:
682 return ret;
683}
684
685/*--------------------------------------------------------------------------- */
691/*--------------------------------------------------------------------------- */
692double xsh_pfits_get_conad (const cpl_propertylist * plist)
693{
694 double ret = 0;
695
696 XSH_PFITS_GET( ret, plist, XSH_CONAD, CPL_TYPE_DOUBLE);
697
698 cleanup:
699 return ret;
700}
701
702/*--------------------------------------------------------------------------- */
711/*--------------------------------------------------------------------------- */
712int xsh_pfits_get_datancom( const cpl_propertylist *plist)
713{
714 int ret = 0;
715
716 XSH_PFITS_GET( ret, plist, XSH_DATANCOM, CPL_TYPE_INT);
717
718 cleanup:
719 return ret;
720}
721
722/*--------------------------------------------------------------------------- */
728/*--------------------------------------------------------------------------- */
729double
730xsh_pfits_get_det_gain (const cpl_propertylist * plist)
731{
732 double returnvalue = 0;
733
734 check_msg (xsh_get_property_value (plist, XSH_DET_GAIN, CPL_TYPE_DOUBLE,
735 &returnvalue),
736 "Error reading keyword '%s'", XSH_DET_GAIN);
737
738cleanup:
739 return returnvalue;
740}
741
742/*--------------------------------------------------------------------------- */
748/*--------------------------------------------------------------------------- */
749double xsh_pfits_get_bias_left_median(cpl_propertylist * plist)
750{
751 double returnvalue = 0;
752
753 check_msg (xsh_get_property_value (plist, XSH_BIAS_LEFT_MEDIAN,
754 CPL_TYPE_DOUBLE,&returnvalue),
755 "Error reading keyword '%s'", XSH_BIAS_LEFT_MEDIAN);
756
757cleanup:
758 return returnvalue;
759}
760
761
762/*--------------------------------------------------------------------------- */
768/*--------------------------------------------------------------------------- */
769double xsh_pfits_get_bias_right_median(cpl_propertylist * plist)
770{
771 double returnvalue = 0;
772
773 check_msg (xsh_get_property_value (plist, XSH_BIAS_RIGHT_MEDIAN,
774 CPL_TYPE_DOUBLE,&returnvalue),
775 "Error reading keyword '%s'", XSH_BIAS_RIGHT_MEDIAN);
776
777cleanup:
778 return returnvalue;
779}
780
781/*--------------------------------------------------------------------------- */
787/*--------------------------------------------------------------------------- */
788double xsh_pfits_get_bias_up_median(cpl_propertylist * plist)
789{
790 double returnvalue = 0;
791
792 check_msg (xsh_get_property_value (plist, XSH_BIAS_UP_MEDIAN,
793 CPL_TYPE_DOUBLE,&returnvalue),
794 "Error reading keyword '%s'", XSH_BIAS_UP_MEDIAN);
795
796cleanup:
797 return returnvalue;
798}
799
800
801/*--------------------------------------------------------------------------- */
807/*--------------------------------------------------------------------------- */
808double xsh_pfits_get_bias_down_median(cpl_propertylist * plist)
809{
810 double returnvalue = 0;
811
812 check_msg (xsh_get_property_value (plist, XSH_BIAS_DOWN_MEDIAN,
813 CPL_TYPE_DOUBLE,&returnvalue),
814 "Error reading keyword '%s'", XSH_BIAS_DOWN_MEDIAN);
815
816cleanup:
817 return returnvalue;
818}
819
820/*--------------------------------------------------------------------------- */
826/*--------------------------------------------------------------------------- */
827
828double xsh_pfits_get_bias_left_stdev(cpl_propertylist * plist)
829{
830 double returnvalue = 0;
831
832 check_msg (xsh_get_property_value (plist, XSH_BIAS_LEFT_STDEV,
833 CPL_TYPE_DOUBLE,&returnvalue),
834 "Error reading keyword '%s'", XSH_BIAS_LEFT_STDEV);
835
836cleanup:
837 return returnvalue;
838}
839
840/*--------------------------------------------------------------------------- */
846/*--------------------------------------------------------------------------- */
847double xsh_pfits_get_bias_right_stdev(cpl_propertylist * plist)
848{
849 double returnvalue = 0;
850
851 check_msg (xsh_get_property_value (plist, XSH_BIAS_RIGHT_STDEV,
852 CPL_TYPE_DOUBLE,&returnvalue),
853 "Error reading keyword '%s'", XSH_BIAS_RIGHT_STDEV);
854
855cleanup:
856 return returnvalue;
857}
858
859/*--------------------------------------------------------------------------- */
865/*--------------------------------------------------------------------------- */
866
867double xsh_pfits_get_bias_up_stdev(cpl_propertylist * plist)
868{
869 double returnvalue = 0;
870
871 check_msg (xsh_get_property_value (plist, XSH_BIAS_UP_STDEV,
872 CPL_TYPE_DOUBLE,&returnvalue),
873 "Error reading keyword '%s'", XSH_BIAS_UP_STDEV);
874
875cleanup:
876 return returnvalue;
877}
878
879/*--------------------------------------------------------------------------- */
885/*--------------------------------------------------------------------------- */
886double xsh_pfits_get_bias_down_stdev(cpl_propertylist * plist)
887{
888 double returnvalue = 0;
889
890 check_msg (xsh_get_property_value (plist, XSH_BIAS_DOWN_STDEV,
891 CPL_TYPE_DOUBLE,&returnvalue),
892 "Error reading keyword '%s'", XSH_BIAS_DOWN_STDEV);
893
894cleanup:
895 return returnvalue;
896}
897
905cpl_error_code
906xsh_frame_force_pro_catg(const char* fname,
907 const char* tag) {
908
909
910 cpl_propertylist* plist=NULL;
911 int naxis=0;
912 int update=0;
913 const char* current_tag=NULL;
914 cpl_table* tab=NULL;
915 cpl_image* ima=NULL;
916 cpl_imagelist* iml=NULL;
917
918
919
920 check(plist=cpl_propertylist_load(fname,0));
921 check(naxis=xsh_pfits_get_naxis(plist));
922 if(cpl_propertylist_has(plist,XSH_PCATG)) {
923
924 check(current_tag=cpl_propertylist_get_string(plist,XSH_PCATG));
925 if(strcmp(current_tag,tag)!= 0) {
926 check(cpl_propertylist_set_string(plist,XSH_PCATG,tag)) ;
927 update=1;
928 }
929
930 } else {
931 check(cpl_propertylist_append_string(plist,XSH_PCATG,tag)) ;
932 update=1;
933 }
934
935 if(update) {
936 check(naxis=xsh_pfits_get_naxis(plist));
937 switch (naxis) {
938 case 0:
939 check(tab=cpl_table_load(fname,1,0));
940 check(cpl_table_save(tab,plist,NULL,fname,CPL_IO_DEFAULT));
941 xsh_free_table(&tab);
942 break;
943 case 1:
944 case 2:
945 check(ima=cpl_image_load(fname,CPL_TYPE_FLOAT,0,0));
946 check(cpl_image_save(ima,fname,CPL_BPP_IEEE_FLOAT,plist,CPL_IO_DEFAULT));
947 xsh_free_image(&ima);
948 break;
949 case 3:
950 check(iml=cpl_imagelist_load(fname,CPL_TYPE_FLOAT,0));
951 check(cpl_image_save(ima,fname,CPL_BPP_IEEE_FLOAT,plist,CPL_IO_DEFAULT));
952 xsh_free_imagelist(&iml);
953 break;
954 default:
955 xsh_msg_error("naxis=%d not supported",naxis);
956 }
957
958 }
959
960 cleanup:
961 xsh_free_propertylist(&plist);
962 xsh_free_table(&tab);
963 xsh_free_image(&ima);
964 xsh_free_imagelist(&iml);
965
966 return cpl_error_get_code();
967
968}
969
970
971/*--------------------------------------------------------------------------- */
977/*--------------------------------------------------------------------------- */
978void
979xsh_pfits_set_extname (cpl_propertylist * plist, const char *value)
980{
981 check_msg (cpl_propertylist_update_string (plist, XSH_EXTNAME, value),
982 "Error writing keyword '%s'", XSH_EXTNAME);
983cleanup:
984 return;
985}
986/*--------------------------------------------------------------------------- */
987
988void xsh_pfits_set_arm( cpl_propertylist * plist, xsh_instrument* instr)
989{
990
991 const char* value = NULL;
992
993 check( value = xsh_instrument_arm_tostring( instr));
994 check_msg (cpl_propertylist_update_string (plist, XSH_SEQ_ARM, value),
995 "Error writing keyword '%s'", XSH_SEQ_ARM);
996
997 cleanup:
998 return;
999}
1000/*--------------------------------------------------------------------------- */
1006/*--------------------------------------------------------------------------- */
1007void
1008xsh_pfits_set_pcatg (cpl_propertylist * plist, const char *value)
1009{
1010 check_msg (cpl_propertylist_update_string (plist, XSH_PCATG, value),
1011 "Error writing keyword '%s'", XSH_PCATG);
1012cleanup:
1013 return;
1014}
1015
1016
1017/*--------------------------------------------------------------------------- */
1023/*--------------------------------------------------------------------------- */
1024void
1025xsh_pfits_set_dpr_type (cpl_propertylist * plist, const char *value)
1026{
1027 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_TYPE, value),
1028 "Error writing keyword '%s'", XSH_DPR_TYPE);
1029cleanup:
1030 return;
1031}
1032
1033
1034/*--------------------------------------------------------------------------- */
1040/*--------------------------------------------------------------------------- */
1041void
1042xsh_pfits_set_dpr_catg (cpl_propertylist * plist, const char *value)
1043{
1044 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_CATG, value),
1045 "Error writing keyword '%s'", XSH_DPR_CATG);
1046cleanup:
1047 return;
1048}
1049
1050
1051/*--------------------------------------------------------------------------- */
1057/*--------------------------------------------------------------------------- */
1058void
1059xsh_pfits_set_dpr_tech (cpl_propertylist * plist, const char *value)
1060{
1061 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_TECH, value),
1062 "Error writing keyword '%s'", XSH_DPR_TECH);
1063cleanup:
1064 return;
1065}
1066
1067
1068/*--------------------------------------------------------------------------- */
1074/*--------------------------------------------------------------------------- */
1075void
1076xsh_pfits_set_nsat(cpl_propertylist * plist, int value)
1077{
1078 check_msg (cpl_propertylist_update_double
1079 (plist, XSH_QC_NPIXSAT, value),
1080 "Error writing keyword '%s'", XSH_QC_NPIXSAT);
1081 cpl_propertylist_set_comment(plist, XSH_QC_NPIXSAT, XSH_QC_NPIXSAT_C);
1082
1083cleanup:
1084 return;
1085}
1086
1087
1088
1089/*--------------------------------------------------------------------------- */
1095/*--------------------------------------------------------------------------- */
1096void
1097xsh_pfits_set_frac_sat(cpl_propertylist * plist, double value)
1098{
1099 check_msg (cpl_propertylist_update_double
1100 (plist, XSH_QC_FPIXSAT, value),
1101 "Error writing keyword '%s'", XSH_QC_FPIXSAT);
1102 cpl_propertylist_set_comment(plist, XSH_QC_FPIXSAT, XSH_QC_FPIXSAT_C);
1103cleanup:
1104 return;
1105}
1106
1107
1108
1109/*--------------------------------------------------------------------------- */
1115/*--------------------------------------------------------------------------- */
1116void
1117xsh_pfits_set_total_nsat(cpl_propertylist * plist, int value)
1118{
1119 check_msg (cpl_propertylist_update_double
1120 (plist, XSH_QC_NPIXSAT_TOT, value),
1121 "Error writing keyword '%s'", XSH_QC_NPIXSAT_TOT);
1122 cpl_propertylist_set_comment(plist, XSH_QC_NPIXSAT_TOT, XSH_QC_NPIXSAT_TOT_C);
1123
1124cleanup:
1125 return;
1126}
1127
1128
1129
1130/*--------------------------------------------------------------------------- */
1136/*--------------------------------------------------------------------------- */
1137void
1138xsh_pfits_set_total_frac_sat(cpl_propertylist * plist, double value)
1139{
1140 check_msg (cpl_propertylist_update_double
1141 (plist, XSH_QC_FPIXSAT_TOT, value),
1142 "Error writing keyword '%s'", XSH_QC_FPIXSAT_TOT);
1143 cpl_propertylist_set_comment(plist, XSH_QC_FPIXSAT_TOT, XSH_QC_FPIXSAT_TOT_C);
1144cleanup:
1145 return;
1146}
1147
1148/*--------------------------------------------------------------------------- */
1154/*--------------------------------------------------------------------------- */
1155void
1156xsh_pfits_set_n_range_pix(cpl_propertylist * plist, int value)
1157{
1158 check_msg (cpl_propertylist_update_double
1159 (plist, XSH_QC_NPIXRANGE, value),
1160 "Error writing keyword '%s'", XSH_QC_NPIXRANGE);
1161 cpl_propertylist_set_comment(plist, XSH_QC_NPIXRANGE, XSH_QC_NPIXRANGE_C);
1162
1163cleanup:
1164 return;
1165}
1166
1167
1168/*--------------------------------------------------------------------------- */
1174/*--------------------------------------------------------------------------- */
1175void
1176xsh_pfits_set_frac_range_pix(cpl_propertylist * plist, double value)
1177{
1178 check_msg (cpl_propertylist_update_double
1179 (plist, XSH_QC_FPIXRANGE, value),
1180 "Error writing keyword '%s'", XSH_QC_FPIXRANGE);
1181 cpl_propertylist_set_comment(plist, XSH_QC_FPIXRANGE, XSH_QC_FPIXRANGE_C);
1182cleanup:
1183 return;
1184}
1185
1186
1187/*--------------------------------------------------------------------------- */
1193/*--------------------------------------------------------------------------- */
1194void
1195xsh_pfits_set_bias_left_median (cpl_propertylist * plist, double value)
1196{
1197 check_msg (cpl_propertylist_update_double
1198 (plist, XSH_BIAS_LEFT_MEDIAN, value),
1199 "Error writing keyword '%s'", XSH_BIAS_LEFT_MEDIAN);
1200cleanup:
1201 return;
1202}
1203
1204/*--------------------------------------------------------------------------- */
1210/*--------------------------------------------------------------------------- */
1211void
1212xsh_pfits_set_bias_right_median (cpl_propertylist * plist, double value)
1213{
1214 check_msg (cpl_propertylist_update_double
1215 (plist, XSH_BIAS_RIGHT_MEDIAN, value),
1216 "Error writing keyword '%s'", XSH_BIAS_RIGHT_MEDIAN);
1217cleanup:
1218 return;
1219}
1220
1221/*--------------------------------------------------------------------------- */
1227/*--------------------------------------------------------------------------- */
1228void
1229xsh_pfits_set_bias_up_median (cpl_propertylist * plist, double value)
1230{
1231 check_msg (cpl_propertylist_update_double
1232 (plist, XSH_BIAS_UP_MEDIAN, value),
1233 "Error writing keyword '%s'", XSH_BIAS_UP_MEDIAN);
1234cleanup:
1235 return;
1236}
1237
1238/*--------------------------------------------------------------------------- */
1239/*
1240 @brief
1241 Write the DATANCOM value
1242 @param plist
1243 The Property list to write to
1244 @param value
1245 The value to write
1246*/
1247/*--------------------------------------------------------------------------- */
1248void
1249xsh_pfits_set_datancom (cpl_propertylist * plist, int value)
1250{
1251 check_msg (cpl_propertylist_update_int
1252 (plist, XSH_DATANCOM, value),
1253 "Error writing keyword '%s'", XSH_DATANCOM);
1254cleanup:
1255 return;
1256}
1257
1258
1259
1260/*--------------------------------------------------------------------------- */
1266/*--------------------------------------------------------------------------- */
1267void
1268xsh_pfits_set_bias_down_median (cpl_propertylist * plist, double value)
1269{
1270 check_msg (cpl_propertylist_update_double
1271 (plist, XSH_BIAS_DOWN_MEDIAN, value),
1272 "Error writing keyword '%s'", XSH_BIAS_DOWN_MEDIAN);
1273cleanup:
1274 return;
1275}
1276
1277/*--------------------------------------------------------------------------- */
1283/*--------------------------------------------------------------------------- */
1284void
1285xsh_pfits_set_bias_left_stdev (cpl_propertylist * plist, double value)
1286{
1287 check_msg (cpl_propertylist_update_double
1288 (plist, XSH_BIAS_LEFT_STDEV, value), "Error writing keyword '%s'",
1289 XSH_BIAS_LEFT_STDEV);
1290cleanup:
1291 return;
1292}
1293
1294/*--------------------------------------------------------------------------- */
1300/*--------------------------------------------------------------------------- */
1301void
1302xsh_pfits_set_bias_right_stdev (cpl_propertylist * plist, double value)
1303{
1304 check_msg (cpl_propertylist_update_double
1305 (plist, XSH_BIAS_RIGHT_STDEV, value), "Error writing keyword '%s'",
1306 XSH_BIAS_RIGHT_STDEV);
1307cleanup:
1308 return;
1309}
1310
1311/*--------------------------------------------------------------------------- */
1317/*--------------------------------------------------------------------------- */
1318void
1319xsh_pfits_set_bias_up_stdev (cpl_propertylist * plist, double value)
1320{
1321 check_msg (cpl_propertylist_update_double
1322 (plist, XSH_BIAS_UP_STDEV, value), "Error writing keyword '%s'",
1323 XSH_BIAS_UP_STDEV);
1324cleanup:
1325 return;
1326}
1327
1328/*--------------------------------------------------------------------------- */
1334/*--------------------------------------------------------------------------- */
1335void
1336xsh_pfits_set_bias_down_stdev (cpl_propertylist * plist, double value)
1337{
1338 check_msg (cpl_propertylist_update_double
1339 (plist, XSH_BIAS_DOWN_STDEV, value), "Error writing keyword '%s'",
1340 XSH_BIAS_DOWN_STDEV);
1341cleanup:
1342 return;
1343}
1344/*--------------------------------------------------------------------------- */
1350/*--------------------------------------------------------------------------- */
1351void
1352xsh_pfits_set_dit (cpl_propertylist * plist, double dit)
1353{
1354 check_msg (cpl_propertylist_update_double (plist, XSH_DET_DIT, dit),
1355 "Error writing keyword '%s'", XSH_DET_DIT);
1356
1357cleanup:
1358 return;
1359}
1360
1361/*--------------------------------------------------------------------------- */
1367/*--------------------------------------------------------------------------- */
1368void
1369xsh_pfits_set_ndit (cpl_propertylist * plist, int ndit)
1370{
1371 check_msg (cpl_propertylist_update_int (plist, XSH_DET_NDIT, ndit),
1372 "Error writing keyword '%s'", XSH_DET_NDIT);
1373
1374cleanup:
1375 return;
1376}
1377/*--------------------------------------------------------------------------- */
1383/*--------------------------------------------------------------------------- */
1384double
1385xsh_pfits_get_win1_dit1 (const cpl_propertylist * plist)
1386{
1387 double returnvalue = 0;
1388
1389 check_msg (xsh_get_property_value
1390 (plist, XSH_DET_WIN1_DIT1, CPL_TYPE_DOUBLE, &returnvalue),
1391 "Error reading keyword '%s'", XSH_DET_WIN1_DIT1);
1392
1393cleanup:
1394 return returnvalue;
1395}
1396
1397/*--------------------------------------------------------------------------- */
1403/*--------------------------------------------------------------------------- */
1404double
1405xsh_pfits_get_dit (const cpl_propertylist * plist)
1406{
1407 double returnvalue = 0;
1408
1409 check_msg (xsh_get_property_value
1410 (plist, XSH_DET_DIT, CPL_TYPE_DOUBLE, &returnvalue),
1411 "Error reading keyword '%s'", XSH_DET_DIT);
1412
1413cleanup:
1414 return returnvalue;
1415}
1416
1417
1418/*--------------------------------------------------------------------------- */
1424/*--------------------------------------------------------------------------- */
1425int
1426xsh_pfits_get_ndit (const cpl_propertylist * plist)
1427{
1428 int returnvalue = 0;
1429
1430 check_msg (xsh_get_property_value
1431 (plist, XSH_DET_NDIT, CPL_TYPE_INT, &returnvalue),
1432 "Error reading keyword '%s'", XSH_DET_NDIT);
1433
1434cleanup:
1435 return returnvalue;
1436}
1437
1438/*--------------------------------------------------------------------------- */
1444/*--------------------------------------------------------------------------- */
1445const char *
1446xsh_pfits_get_raw1name (const cpl_propertylist * plist)
1447{
1448 const char *returnvalue = "";
1449
1450 check_msg (xsh_get_property_value
1451 (plist, XSH_RAW1_NAME, CPL_TYPE_STRING, &returnvalue),
1452 "Error reading keyword '%s'", XSH_RAW1_NAME);
1453
1454cleanup:
1455 return returnvalue;
1456}
1457
1458
1459/*--------------------------------------------------------------------------- */
1465/*--------------------------------------------------------------------------- */
1466const char *
1467xsh_pfits_get_bunit (const cpl_propertylist * plist)
1468{
1469 const char *returnvalue = "";
1470
1471 check_msg (xsh_get_property_value
1472 (plist, XSH_BUNIT, CPL_TYPE_STRING, &returnvalue),
1473 "Error reading keyword '%s'", XSH_BUNIT);
1474
1475cleanup:
1476 return returnvalue;
1477}
1478
1479/*--------------------------------------------------------------------------- */
1485/*--------------------------------------------------------------------------- */
1486const char *
1487xsh_pfits_get_cunit1 (const cpl_propertylist * plist)
1488{
1489 const char *returnvalue = "";
1490
1491 check_msg (xsh_get_property_value
1492 (plist, XSH_CUNIT1, CPL_TYPE_STRING, &returnvalue),
1493 "Error reading keyword '%s'", XSH_CUNIT1);
1494
1495cleanup:
1496 return returnvalue;
1497}
1498
1499/*--------------------------------------------------------------------------- */
1505/*--------------------------------------------------------------------------- */
1506const char *
1507xsh_pfits_get_cunit2 (const cpl_propertylist * plist)
1508{
1509 const char *returnvalue = "";
1510
1511 check_msg (xsh_get_property_value
1512 (plist, XSH_CUNIT2, CPL_TYPE_STRING, &returnvalue),
1513 "Error reading keyword '%s'", XSH_CUNIT2);
1514
1515cleanup:
1516 return returnvalue;
1517}
1518
1519/*--------------------------------------------------------------------------- */
1525/*--------------------------------------------------------------------------- */
1526const char *
1527xsh_pfits_get_cunit3 (const cpl_propertylist * plist)
1528{
1529 const char *returnvalue = "";
1530
1531 check_msg (xsh_get_property_value
1532 (plist, XSH_CUNIT3, CPL_TYPE_STRING, &returnvalue),
1533 "Error reading keyword '%s'", XSH_CUNIT3);
1534
1535cleanup:
1536 return returnvalue;
1537}
1538
1539
1540/*--------------------------------------------------------------------------- */
1546/*--------------------------------------------------------------------------- */
1547const char *
1548xsh_pfits_get_raw1catg (const cpl_propertylist * plist)
1549{
1550 const char *returnvalue = "";
1551
1552 check_msg (xsh_get_property_value
1553 (plist, XSH_RAW1_CATG, CPL_TYPE_STRING, &returnvalue),
1554 "Error reading keyword '%s'", XSH_RAW1_CATG);
1555
1556cleanup:
1557 return returnvalue;
1558}
1559
1560
1561/*--------------------------------------------------------------------------- */
1567/*--------------------------------------------------------------------------- */
1568const char *
1569xsh_pfits_get_obs_targ_name (const cpl_propertylist * plist)
1570{
1571 const char *returnvalue = "";
1572
1573 check_msg (xsh_get_property_value
1574 (plist, XSH_OBS_TARG_NAME, CPL_TYPE_STRING, &returnvalue),
1575 "Error reading keyword '%s'", XSH_OBS_TARG_NAME);
1576
1577cleanup:
1578 return returnvalue;
1579}
1580
1581/*--------------------------------------------------------------------------- */
1587/*--------------------------------------------------------------------------- */
1588const char *
1589xsh_pfits_get_arcfile (const cpl_propertylist * plist)
1590{
1591 const char *returnvalue = "";
1592
1593 check_msg (xsh_get_property_value
1594 (plist, XSH_ARCFILE, CPL_TYPE_STRING, &returnvalue),
1595 "Error reading keyword '%s'", XSH_ARCFILE);
1596
1597cleanup:
1598 return returnvalue;
1599}
1605/*--------------------------------------------------------------------------- */
1606bool
1607xsh_pfits_get_lamp_on_off (const cpl_propertylist * plist)
1608{
1609 const char *returnvalue = "";
1610
1611 check_msg (xsh_get_property_value
1612 (plist, XSH_LAMP_ON_OFF, CPL_TYPE_BOOL, &returnvalue),
1613 "Error reading keyword '%s'", XSH_LAMP_ON_OFF);
1614
1615cleanup:
1616 return returnvalue;
1617}
1618
1619/*--------------------------------------------------------------------------- */
1625/*--------------------------------------------------------------------------- */
1626const char *
1627xsh_pfits_get_pcatg (const cpl_propertylist * plist)
1628{
1629 const char *returnvalue = "";
1630
1631 check_msg (xsh_get_property_value
1632 (plist, XSH_PCATG, CPL_TYPE_STRING, &returnvalue),
1633 "Error reading keyword '%s'", XSH_PCATG);
1634cleanup:
1635 return returnvalue;
1636}
1637
1638
1639/*--------------------------------------------------------------------------- */
1645/*--------------------------------------------------------------------------- */
1646const char *
1647xsh_pfits_get_dpr_tech (const cpl_propertylist * plist)
1648{
1649 const char *returnvalue = "";
1650
1651 check_msg (xsh_get_property_value
1652 (plist, XSH_DPR_TECH, CPL_TYPE_STRING, &returnvalue),
1653 "Error reading keyword '%s'", XSH_DPR_TECH);
1654cleanup:
1655 return returnvalue;
1656}
1657
1658
1659/*--------------------------------------------------------------------------- */
1665/*--------------------------------------------------------------------------- */
1666const char *
1667xsh_pfits_get_dpr_type (const cpl_propertylist * plist)
1668{
1669 const char *returnvalue = "";
1670
1671 check_msg (xsh_get_property_value
1672 (plist, XSH_DPR_TYPE, CPL_TYPE_STRING, &returnvalue),
1673 "Error reading keyword '%s'", XSH_DPR_TYPE);
1674cleanup:
1675 return returnvalue;
1676}
1677
1678
1679
1680/*--------------------------------------------------------------------------- */
1686/*--------------------------------------------------------------------------- */
1687const char *
1688xsh_pfits_get_dpr_catg (const cpl_propertylist * plist)
1689{
1690 const char *returnvalue = "";
1691
1692 check_msg (xsh_get_property_value
1693 (plist, XSH_DPR_CATG, CPL_TYPE_STRING, &returnvalue),
1694 "Error reading keyword '%s'", XSH_DPR_CATG);
1695cleanup:
1696 return returnvalue;
1697}
1698
1699/*--------------------------------------------------------------------------- */
1705/*--------------------------------------------------------------------------- */
1706const char *
1707xsh_pfits_get_extname (const cpl_propertylist * plist)
1708{
1709 const char *returnvalue = "";
1710
1711 check_msg (xsh_get_property_value
1712 (plist, XSH_EXTNAME, CPL_TYPE_STRING, &returnvalue),
1713 "Error reading keyword '%s'", XSH_EXTNAME);
1714cleanup:
1715 return returnvalue;
1716}
1717
1718/*--------------------------------------------------------------------------- */
1724/*--------------------------------------------------------------------------- */
1725const char *
1726xsh_pfits_get_date (const cpl_propertylist * plist)
1727{
1728 const char *returnvalue = "";
1729
1730 check_msg (xsh_get_property_value
1731 (plist, XSH_DATE, CPL_TYPE_STRING, &returnvalue),
1732 "Error reading keyword '%s'", XSH_DATE);
1733
1734cleanup:
1735 return returnvalue;
1736}
1737
1738/*--------------------------------------------------------------------------- */
1744/*--------------------------------------------------------------------------- */
1745const char *
1746xsh_pfits_get_date_obs (const cpl_propertylist * plist)
1747{
1748 const char *returnvalue = "";
1749
1750 check_msg (xsh_get_property_value
1751 (plist, XSH_DATE_OBS, CPL_TYPE_STRING, &returnvalue),
1752 "Error reading keyword '%s'", XSH_DATE_OBS);
1753
1754cleanup:
1755 return returnvalue;
1756}
1757
1763/*--------------------------------------------------------------------------- */
1764double
1765xsh_pfits_get_pszx (const cpl_propertylist * plist)
1766{
1767 double returnvalue = 0.0;
1768
1769 check_msg (xsh_get_property_value (plist, XSH_PSZX, CPL_TYPE_DOUBLE,
1770 &returnvalue),
1771 "Error reading keyword '%s'", XSH_PSZX);
1772
1773cleanup:
1774 return returnvalue;
1775}
1776
1782/*--------------------------------------------------------------------------- */
1783double
1784xsh_pfits_get_pszy (const cpl_propertylist * plist)
1785{
1786 double returnvalue = 0.0;
1787
1788 check_msg (xsh_get_property_value (plist, XSH_PSZY, CPL_TYPE_DOUBLE,
1789 &returnvalue),
1790 "Error reading keyword '%s'", XSH_PSZY);
1791
1792cleanup:
1793 return returnvalue;
1794}
1795
1801/*--------------------------------------------------------------------------- */
1802double
1803xsh_pfits_get_det_pxspace(const cpl_propertylist * plist)
1804{
1805 double returnvalue = 0.0;
1806
1807 check_msg (xsh_get_property_value (plist, XSH_DET_PXSPACE, CPL_TYPE_DOUBLE,
1808 &returnvalue),
1809 "Error reading keyword '%s'", XSH_DET_PXSPACE);
1810
1811cleanup:
1812 return returnvalue;
1813}
1814
1815
1816
1817/*--------------------------------------------------------------------------- */
1823/*--------------------------------------------------------------------------- */
1824int xsh_pfits_get_FOCU1ENC (const cpl_propertylist * plist)
1825{
1826 int returnvalue = 0;
1827
1828 check_msg (xsh_get_property_value (plist, XSH_FOCU1ENC_VAL, CPL_TYPE_INT,
1829 &returnvalue),
1830 "Error reading keyword '%s'", XSH_FOCU1ENC_VAL);
1831
1832cleanup:
1833 return returnvalue;
1834}
1835
1836
1837/*--------------------------------------------------------------------------- */
1838/*--------------------------------------------------------------------------- */
1844/*--------------------------------------------------------------------------- */
1845double xsh_pfits_get_temp5 (const cpl_propertylist * plist)
1846{
1847 double returnvalue = 0.0;
1848
1849 check_msg (xsh_get_property_value (plist, XSH_TEMP5_VAL, CPL_TYPE_DOUBLE,
1850 &returnvalue),
1851 "Error reading keyword '%s'", XSH_TEMP5_VAL);
1852
1853cleanup:
1854 return returnvalue;
1855}
1856
1857
1858/*--------------------------------------------------------------------------- */
1859/*--------------------------------------------------------------------------- */
1865/*--------------------------------------------------------------------------- */
1866double xsh_pfits_get_temp2 (const cpl_propertylist * plist)
1867{
1868 double returnvalue = 0.0;
1869
1870 check_msg (xsh_get_property_value (plist, XSH_TEMP2_VAL, CPL_TYPE_DOUBLE,
1871 &returnvalue),
1872 "Error reading keyword '%s'", XSH_TEMP2_VAL);
1873
1874cleanup:
1875 return returnvalue;
1876}
1877
1878
1879/*--------------------------------------------------------------------------- */
1880/*--------------------------------------------------------------------------- */
1886/*--------------------------------------------------------------------------- */
1887double xsh_pfits_get_temp82 (const cpl_propertylist * plist)
1888{
1889 double returnvalue = 0.0;
1890
1891 check_msg (xsh_get_property_value (plist, XSH_TEMP82_VAL, CPL_TYPE_DOUBLE,
1892 &returnvalue),
1893 "Error reading keyword '%s'", XSH_TEMP82_VAL);
1894
1895cleanup:
1896 return returnvalue;
1897}
1898
1899
1900/*--------------------------------------------------------------------------- */
1906/*--------------------------------------------------------------------------- */
1907double xsh_pfits_get_crval1 (const cpl_propertylist * plist)
1908{
1909 double returnvalue = 0.0;
1910
1911 check_msg (xsh_get_property_value (plist, XSH_CRVAL1, CPL_TYPE_DOUBLE,
1912 &returnvalue),
1913 "Error reading keyword '%s'", XSH_CRVAL1);
1914
1915cleanup:
1916 return returnvalue;
1917}
1918
1919/*--------------------------------------------------------------------------- */
1925/*--------------------------------------------------------------------------- */
1926double xsh_pfits_get_crval2 (const cpl_propertylist * plist)
1927{
1928 double returnvalue = 0.0;
1929
1930 check_msg (xsh_get_property_value (plist, XSH_CRVAL2, CPL_TYPE_DOUBLE,
1931 &returnvalue),
1932 "Error reading keyword '%s'", XSH_CRVAL2);
1933
1934cleanup:
1935 return returnvalue;
1936}
1937
1938
1939/*--------------------------------------------------------------------------- */
1945/*--------------------------------------------------------------------------- */
1946double xsh_pfits_get_crval3 (const cpl_propertylist * plist)
1947{
1948 double returnvalue = 0.0;
1949
1950 check_msg (xsh_get_property_value (plist, XSH_CRVAL3, CPL_TYPE_DOUBLE,
1951 &returnvalue),
1952 "Error reading keyword '%s'", XSH_CRVAL3);
1953
1954cleanup:
1955 return returnvalue;
1956}
1957
1958
1959/*-------------------------------------------------------------------------- */
1964/*-------------------------------------------------------------------------- */
1965double xsh_pfits_get_crpix1(const cpl_propertylist * plist)
1966{
1967 double returnvalue = 0.0;
1968 check_msg (xsh_get_property_value (plist, XSH_CRPIX1, CPL_TYPE_DOUBLE,
1969 &returnvalue),
1970 "Error reading keyword '%s'", XSH_CRPIX1);
1971
1972 cleanup:
1973 return returnvalue;
1974}
1975
1976/*-------------------------------------------------------------------------- */
1981/*-------------------------------------------------------------------------- */
1982double xsh_pfits_get_crpix2(const cpl_propertylist * plist)
1983{
1984 double returnvalue = 0.0;
1985 check_msg (xsh_get_property_value (plist, XSH_CRPIX2, CPL_TYPE_DOUBLE,
1986 &returnvalue),
1987 "Error reading keyword '%s'", XSH_CRPIX2);
1988
1989 cleanup:
1990 return returnvalue;
1991}
1992
1993/*-------------------------------------------------------------------------- */
1998/*-------------------------------------------------------------------------- */
1999double xsh_pfits_get_crpix3(const cpl_propertylist * plist)
2000{
2001 double returnvalue = 0.0;
2002 check_msg (xsh_get_property_value (plist, XSH_CRPIX3, CPL_TYPE_DOUBLE,
2003 &returnvalue),
2004 "Error reading keyword '%s'", XSH_CRPIX3);
2005
2006 cleanup:
2007 return returnvalue;
2008}
2009
2010/*--------------------------------------------------------------------------- */
2016/*--------------------------------------------------------------------------- */
2017double xsh_pfits_get_cd11 (const cpl_propertylist * plist)
2018{
2019 double returnvalue = 0.0;
2020
2021 check_msg (xsh_get_property_value (plist, XSH_CD11, CPL_TYPE_DOUBLE,
2022 &returnvalue),
2023 "Error reading keyword '%s'", XSH_CD11);
2024
2025cleanup:
2026 return returnvalue;
2027}
2028
2029
2030
2031/*--------------------------------------------------------------------------- */
2037/*--------------------------------------------------------------------------- */
2038double xsh_pfits_get_cd12 (const cpl_propertylist * plist)
2039{
2040 double returnvalue = 0.0;
2041
2042 check_msg (xsh_get_property_value (plist, XSH_CD12, CPL_TYPE_DOUBLE,
2043 &returnvalue),
2044 "Error reading keyword '%s'", XSH_CD12);
2045
2046cleanup:
2047 return returnvalue;
2048}
2049
2050/*--------------------------------------------------------------------------- */
2056/*--------------------------------------------------------------------------- */
2057double xsh_pfits_get_cd21 (const cpl_propertylist * plist)
2058{
2059 double returnvalue = 0.0;
2060
2061 check_msg (xsh_get_property_value (plist, XSH_CD21, CPL_TYPE_DOUBLE,
2062 &returnvalue),
2063 "Error reading keyword '%s'", XSH_CD21);
2064
2065cleanup:
2066 return returnvalue;
2067}
2068
2069
2070/*--------------------------------------------------------------------------- */
2076/*--------------------------------------------------------------------------- */
2077double xsh_pfits_get_cd22 (const cpl_propertylist * plist)
2078{
2079 double returnvalue = 0.0;
2080
2081 check_msg (xsh_get_property_value (plist, XSH_CD22, CPL_TYPE_DOUBLE,
2082 &returnvalue),
2083 "Error reading keyword '%s'", XSH_CD22);
2084
2085cleanup:
2086 return returnvalue;
2087}
2088
2089/*--------------------------------------------------------------------------- */
2095/*--------------------------------------------------------------------------- */
2096double xsh_pfits_get_cd13 (const cpl_propertylist * plist)
2097{
2098 double returnvalue = 0.0;
2099
2100 check_msg (xsh_get_property_value (plist, XSH_CD13, CPL_TYPE_DOUBLE,
2101 &returnvalue),
2102 "Error reading keyword '%s'", XSH_CD13);
2103
2104cleanup:
2105 return returnvalue;
2106}
2107
2108
2109/*--------------------------------------------------------------------------- */
2115/*--------------------------------------------------------------------------- */
2116double xsh_pfits_get_cd23 (const cpl_propertylist * plist)
2117{
2118 double returnvalue = 0.0;
2119
2120 check_msg (xsh_get_property_value (plist, XSH_CD23, CPL_TYPE_DOUBLE,
2121 &returnvalue),
2122 "Error reading keyword '%s'", XSH_CD23);
2123
2124cleanup:
2125 return returnvalue;
2126}
2127
2128
2129/*--------------------------------------------------------------------------- */
2135/*--------------------------------------------------------------------------- */
2136double xsh_pfits_get_cd33 (const cpl_propertylist * plist)
2137{
2138 double returnvalue = 0.0;
2139
2140 check_msg (xsh_get_property_value (plist, XSH_CD33, CPL_TYPE_DOUBLE,
2141 &returnvalue),
2142 "Error reading keyword '%s'", XSH_CD33);
2143
2144cleanup:
2145 return returnvalue;
2146}
2147
2148/*--------------------------------------------------------------------------- */
2154/*--------------------------------------------------------------------------- */
2155double xsh_pfits_get_cd31 (const cpl_propertylist * plist)
2156{
2157 double returnvalue = 0.0;
2158
2159 check_msg (xsh_get_property_value (plist, XSH_CD31, CPL_TYPE_DOUBLE,
2160 &returnvalue),
2161 "Error reading keyword '%s'", XSH_CD31);
2162
2163cleanup:
2164 return returnvalue;
2165}
2166
2167
2168/*--------------------------------------------------------------------------- */
2174/*--------------------------------------------------------------------------- */
2175double xsh_pfits_get_cd32 (const cpl_propertylist * plist)
2176{
2177 double returnvalue = 0.0;
2178
2179 check_msg (xsh_get_property_value (plist, XSH_CD32, CPL_TYPE_DOUBLE,
2180 &returnvalue),
2181 "Error reading keyword '%s'", XSH_CD32);
2182
2183cleanup:
2184 return returnvalue;
2185}
2186
2187
2188
2189/*--------------------------------------------------------------------------- */
2195/*--------------------------------------------------------------------------- */
2196double xsh_pfits_get_cdelt1 (const cpl_propertylist * plist)
2197{
2198 double returnvalue = 0.0;
2199
2200 check_msg (xsh_get_property_value (plist, XSH_CDELT1, CPL_TYPE_DOUBLE,
2201 &returnvalue),
2202 "Error reading keyword '%s'", XSH_CDELT1);
2203
2204cleanup:
2205 return returnvalue;
2206}
2207
2208
2209/*--------------------------------------------------------------------------- */
2215/*--------------------------------------------------------------------------- */
2216double xsh_pfits_get_cdelt2 (const cpl_propertylist * plist)
2217{
2218 double returnvalue = 0.0;
2219
2220 check_msg (xsh_get_property_value (plist, XSH_CDELT2, CPL_TYPE_DOUBLE,
2221 &returnvalue),
2222 "Error reading keyword '%s'", XSH_CDELT2);
2223
2224cleanup:
2225 return returnvalue;
2226}
2227
2228/*--------------------------------------------------------------------------- */
2234/*--------------------------------------------------------------------------- */
2235double xsh_pfits_get_cdelt3 (const cpl_propertylist * plist)
2236{
2237 double returnvalue = 0.0;
2238
2239 check_msg (xsh_get_property_value (plist, XSH_CDELT3, CPL_TYPE_DOUBLE,
2240 &returnvalue),
2241 "Error reading keyword '%s'", XSH_CDELT3);
2242
2243cleanup:
2244 return returnvalue;
2245}
2246
2247/*--------------------------------------------------------------------------- */
2253/*--------------------------------------------------------------------------- */
2254double xsh_pfits_get_exptime (const cpl_propertylist * plist)
2255{
2256 double returnvalue = 0.0;
2257
2258 check_msg (xsh_get_property_value (plist, XSH_EXPTIME,CPL_TYPE_DOUBLE,
2259 &returnvalue),
2260 "Error reading keyword '%s'", XSH_EXPTIME);
2261
2262cleanup:
2263 return returnvalue;
2264}
2265
2266
2267/*--------------------------------------------------------------------------- */
2273/*--------------------------------------------------------------------------- */
2274double xsh_pfits_get_det_win1_uit1 (const cpl_propertylist * plist)
2275{
2276 double returnvalue = 0.0;
2277
2278 check_msg (xsh_get_property_value (plist, XSH_DET_WIN1_UIT1,CPL_TYPE_DOUBLE,
2279 &returnvalue),
2280 "Error reading keyword '%s'", XSH_DET_WIN1_UIT1);
2281
2282cleanup:
2283 return returnvalue;
2284}
2290/*--------------------------------------------------------------------------- */
2291void
2292xsh_pfits_set_exptime (cpl_propertylist * plist, double value)
2293{
2294 check_msg (cpl_propertylist_update_double (plist, XSH_EXPTIME, value),
2295 "Error writing keyword '%s'", XSH_EXPTIME);
2296
2297cleanup:
2298 return;
2299}
2300
2301/*--------------------------------------------------------------------------- */
2307/*--------------------------------------------------------------------------- */
2308void xsh_pfits_set_cd1(cpl_propertylist * plist, double value)
2309{
2310 check_msg (cpl_propertylist_update_double (plist, XSH_CD1, value),
2311 "Error writing keyword '%s'", XSH_CD1);
2312 cleanup:
2313 return;
2314}
2315
2316
2317/*--------------------------------------------------------------------------- */
2323/*--------------------------------------------------------------------------- */
2324void xsh_pfits_set_cd11(cpl_propertylist * plist, double value)
2325{
2326 check_msg (cpl_propertylist_update_double (plist, XSH_CD11, value),
2327 "Error writing keyword '%s'", XSH_CD11);
2328 cleanup:
2329 return;
2330}
2331
2332/*--------------------------------------------------------------------------- */
2338/*--------------------------------------------------------------------------- */
2339void xsh_pfits_set_cd12(cpl_propertylist * plist, double value)
2340{
2341 check_msg (cpl_propertylist_update_double (plist, XSH_CD12, value),
2342 "Error writing keyword '%s'", XSH_CD12);
2343 cleanup:
2344 return;
2345}
2346
2347/*--------------------------------------------------------------------------- */
2353/*--------------------------------------------------------------------------- */
2354void xsh_pfits_set_cd21(cpl_propertylist * plist, double value)
2355{
2356 check_msg (cpl_propertylist_update_double (plist, XSH_CD21, value),
2357 "Error writing keyword '%s'", XSH_CD21);
2358 cleanup:
2359 return;
2360}
2361
2362/*--------------------------------------------------------------------------- */
2368/*--------------------------------------------------------------------------- */
2369void xsh_pfits_set_cd22(cpl_propertylist * plist, double value)
2370{
2371 check_msg (cpl_propertylist_update_double (plist, XSH_CD22, value),
2372 "Error writing keyword '%s'", XSH_CD22);
2373 cleanup:
2374 return;
2375}
2376
2377/*--------------------------------------------------------------------------- */
2383/*--------------------------------------------------------------------------- */
2384void xsh_pfits_set_cd13(cpl_propertylist * plist, double value)
2385{
2386 check_msg (cpl_propertylist_update_double (plist, XSH_CD13, value),
2387 "Error writing keyword '%s'", XSH_CD13);
2388 cleanup:
2389 return;
2390}
2391
2392/*--------------------------------------------------------------------------- */
2398/*--------------------------------------------------------------------------- */
2399void xsh_pfits_set_cd23(cpl_propertylist * plist, double value)
2400{
2401 check_msg (cpl_propertylist_update_double (plist, XSH_CD23, value),
2402 "Error writing keyword '%s'", XSH_CD23);
2403 cleanup:
2404 return;
2405}
2406
2407
2408/*--------------------------------------------------------------------------- */
2414/*--------------------------------------------------------------------------- */
2415void xsh_pfits_set_cd33(cpl_propertylist * plist, double value)
2416{
2417 check_msg (cpl_propertylist_update_double (plist, XSH_CD33, value),
2418 "Error writing keyword '%s'", XSH_CD33);
2419 cleanup:
2420 return;
2421}
2422
2423/*--------------------------------------------------------------------------- */
2429/*--------------------------------------------------------------------------- */
2430void xsh_pfits_set_cd32(cpl_propertylist * plist, double value)
2431{
2432 check_msg (cpl_propertylist_update_double (plist, XSH_CD32, value),
2433 "Error writing keyword '%s'", XSH_CD32);
2434 cleanup:
2435 return;
2436}
2437
2438
2439/*--------------------------------------------------------------------------- */
2445/*--------------------------------------------------------------------------- */
2446void xsh_pfits_set_cd31(cpl_propertylist * plist, double value)
2447{
2448 check_msg (cpl_propertylist_update_double (plist, XSH_CD31, value),
2449 "Error writing keyword '%s'", XSH_CD31);
2450 cleanup:
2451 return;
2452}
2453
2454
2455
2456/*--------------------------------------------------------------------------- */
2462/*--------------------------------------------------------------------------- */
2463void xsh_pfits_set_crpix1(cpl_propertylist * plist, double value)
2464{
2465 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX1, value),
2466 "Error writing keyword '%s'", XSH_CRPIX1);
2467 cleanup:
2468 return;
2469}
2470
2471
2472
2473/*--------------------------------------------------------------------------- */
2479/*--------------------------------------------------------------------------- */
2480void xsh_pfits_set_crval1(cpl_propertylist * plist, double value)
2481{
2482 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL1, value),
2483 "Error writing keyword '%s'", XSH_CRVAL1);
2484 cleanup:
2485 return;
2486}
2487
2488
2489/*--------------------------------------------------------------------------- */
2495/*--------------------------------------------------------------------------- */
2496void xsh_pfits_set_cdelt1(cpl_propertylist * plist, double value)
2497{
2498 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT1, value),
2499 "Error writing keyword '%s'", XSH_CDELT1);
2500 cleanup:
2501 return;
2502}
2503
2504
2505
2506/*--------------------------------------------------------------------------- */
2512/*--------------------------------------------------------------------------- */
2513void xsh_pfits_set_crpix2(cpl_propertylist * plist, double value)
2514{
2515 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX2, value),
2516 "Error writing keyword '%s'", XSH_CRPIX2);
2517 cleanup:
2518 return;
2519}
2520
2521/*--------------------------------------------------------------------------- */
2527/*--------------------------------------------------------------------------- */
2528void xsh_pfits_set_crpix3(cpl_propertylist * plist, double value)
2529{
2530 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX3, value),
2531 "Error writing keyword '%s'", XSH_CRPIX3);
2532 cleanup:
2533 return;
2534}
2535
2536
2537/*--------------------------------------------------------------------------- */
2543/*--------------------------------------------------------------------------- */
2544void xsh_pfits_set_crval2(cpl_propertylist * plist, double value)
2545{
2546 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL2, value),
2547 "Error writing keyword '%s'", XSH_CRVAL2);
2548 cleanup:
2549 return;
2550}
2551
2552/*--------------------------------------------------------------------------- */
2558/*--------------------------------------------------------------------------- */
2559void xsh_pfits_set_crval3(cpl_propertylist * plist, double value)
2560{
2561 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL3, value),
2562 "Error writing keyword '%s'", XSH_CRVAL3);
2563 cleanup:
2564 return;
2565}
2566
2567
2568/*--------------------------------------------------------------------------- */
2574/*--------------------------------------------------------------------------- */
2575void xsh_pfits_set_cdelt2(cpl_propertylist * plist, double value)
2576{
2577 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT2, value),
2578 "Error writing keyword '%s'", XSH_CDELT2);
2579 cleanup:
2580 return;
2581}
2582
2583
2584/*--------------------------------------------------------------------------- */
2590/*--------------------------------------------------------------------------- */
2591void xsh_pfits_set_cdelt3(cpl_propertylist * plist, double value)
2592{
2593 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT3, value),
2594 "Error writing keyword '%s'", XSH_CDELT3);
2595 cleanup:
2596 return;
2597}
2598
2599/*--------------------------------------------------------------------------- */
2605/*--------------------------------------------------------------------------- */
2606void xsh_pfits_set_bunit(cpl_propertylist * plist, const char* value)
2607{
2608 check_msg (cpl_propertylist_update_string (plist, XSH_BUNIT, value),
2609 "Error writing keyword '%s'", XSH_BUNIT);
2610 cleanup:
2611 return;
2612}
2613
2614
2615/*--------------------------------------------------------------------------- */
2621/*--------------------------------------------------------------------------- */
2622void xsh_pfits_set_cunit1(cpl_propertylist * plist, const char* value)
2623{
2624 check_msg (cpl_propertylist_update_string (plist, XSH_CUNIT1, value),
2625 "Error writing keyword '%s'", XSH_CUNIT1);
2626 cleanup:
2627 return;
2628}
2629
2630/*--------------------------------------------------------------------------- */
2636/*--------------------------------------------------------------------------- */
2637void xsh_pfits_set_cunit2(cpl_propertylist * plist, const char* value)
2638{
2639 check_msg (cpl_propertylist_update_string (plist, XSH_CUNIT2, value),
2640 "Error writing keyword '%s'", XSH_CUNIT2);
2641 cleanup:
2642 return;
2643}
2644
2645/*--------------------------------------------------------------------------- */
2651/*--------------------------------------------------------------------------- */
2652void xsh_pfits_set_cunit3(cpl_propertylist * plist, const char* value)
2653{
2654 check_msg (cpl_propertylist_update_string (plist, XSH_CUNIT3, value),
2655 "Error writing keyword '%s'", XSH_CUNIT3);
2656 cleanup:
2657 return;
2658}
2659
2660/*--------------------------------------------------------------------------- */
2666/*--------------------------------------------------------------------------- */
2667void xsh_pfits_set_ctype1(cpl_propertylist * plist, const char* value)
2668{
2669 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE1, value),
2670 "Error writing keyword '%s'", XSH_CTYPE1);
2671 cleanup:
2672 return;
2673}
2674
2675/*--------------------------------------------------------------------------- */
2681/*--------------------------------------------------------------------------- */
2682void xsh_pfits_set_ctype2(cpl_propertylist * plist, const char* value)
2683{
2684 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE2, value),
2685 "Error writing keyword '%s'", XSH_CTYPE2);
2686 cleanup:
2687 return;
2688}
2689
2690
2691/*--------------------------------------------------------------------------- */
2697/*--------------------------------------------------------------------------- */
2698void xsh_pfits_set_ctype3(cpl_propertylist * plist, const char* value)
2699{
2700 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE3, value),
2701 "Error writing keyword '%s'", XSH_CTYPE3);
2702 cleanup:
2703 return;
2704}
2705
2706/*--------------------------------------------------------------------------- */
2712/*--------------------------------------------------------------------------- */
2713void xsh_pfits_set_wavesol_lambda_min(cpl_propertylist * plist, double value)
2714{
2715 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_LAMBDA_MIN,
2716 value),
2717 "Error writing keyword '%s'", XSH_WAVESOL_LAMBDA_MIN);
2718
2719 cleanup:
2720 return;
2721}
2722
2723/*--------------------------------------------------------------------------- */
2729/*--------------------------------------------------------------------------- */
2730void xsh_pfits_set_wavesol_lambda_max(cpl_propertylist * plist, double value)
2731{
2732 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_LAMBDA_MAX,
2733 value),
2734 "Error writing keyword '%s'", XSH_WAVESOL_LAMBDA_MAX);
2735
2736 cleanup:
2737 return;
2738}
2739
2740/*--------------------------------------------------------------------------- */
2746/*--------------------------------------------------------------------------- */
2747void xsh_pfits_set_wavesol_order_min(cpl_propertylist * plist, double value)
2748{
2749 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_ORDER_MIN,
2750 value),
2751 "Error writing keyword '%s'", XSH_WAVESOL_ORDER_MIN);
2752
2753 cleanup:
2754 return;
2755}
2756
2757/*--------------------------------------------------------------------------- */
2763/*--------------------------------------------------------------------------- */
2764void xsh_pfits_set_wavesol_order_max(cpl_propertylist * plist, double value)
2765{
2766 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_ORDER_MAX,
2767 value),
2768 "Error writing keyword '%s'", XSH_WAVESOL_ORDER_MAX);
2769
2770 cleanup:
2771 return;
2772}
2773
2774/*--------------------------------------------------------------------------- */
2780/*--------------------------------------------------------------------------- */
2781void xsh_pfits_set_wavesol_slit_min(cpl_propertylist * plist, double value)
2782{
2783 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_SLIT_MIN,
2784 value),
2785 "Error writing keyword '%s'", XSH_WAVESOL_SLIT_MIN);
2786
2787 cleanup:
2788 return;
2789}
2790
2791/*--------------------------------------------------------------------------- */
2797/*--------------------------------------------------------------------------- */
2798void xsh_pfits_set_wavesol_slit_max(cpl_propertylist * plist, double value)
2799{
2800 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_SLIT_MAX,
2801 value),
2802 "Error writing keyword '%s'", XSH_WAVESOL_SLIT_MAX);
2803
2804 cleanup:
2805 return;
2806}
2807
2808/*--------------------------------------------------------------------------- */
2814/*--------------------------------------------------------------------------- */
2815void xsh_pfits_set_extract_slit_min(cpl_propertylist * plist, double value)
2816{
2817 check_msg (cpl_propertylist_update_double (plist, XSH_EXTRACT_SLIT_MIN,
2818 value),
2819 "Error writing keyword '%s'", XSH_EXTRACT_SLIT_MIN);
2820
2821 cleanup:
2822 return;
2823}
2824
2825
2826
2827/*--------------------------------------------------------------------------- */
2833/*--------------------------------------------------------------------------- */
2834void xsh_pfits_set_extract_slit_max(cpl_propertylist * plist, double value)
2835{
2836 check_msg (cpl_propertylist_update_double (plist, XSH_EXTRACT_SLIT_MAX,
2837 value),
2838 "Error writing keyword '%s'", XSH_EXTRACT_SLIT_MAX);
2839
2840 cleanup:
2841 return;
2842}
2843/*--------------------------------------------------------------------------- */
2849/*--------------------------------------------------------------------------- */
2850void xsh_pfits_set_wavesol_x_min(cpl_propertylist * plist, double value)
2851{
2852 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_X_MIN,
2853 value),
2854 "Error writing keyword '%s'", XSH_WAVESOL_X_MIN);
2855
2856 cleanup:
2857 return;
2858}
2859
2860/*--------------------------------------------------------------------------- */
2866/*--------------------------------------------------------------------------- */
2867void xsh_pfits_set_wavesol_x_max(cpl_propertylist * plist, double value)
2868{
2869 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_X_MAX,
2870 value),
2871 "Error writing keyword '%s'", XSH_WAVESOL_X_MAX);
2872
2873 cleanup:
2874 return;
2875}
2876
2877
2878/*--------------------------------------------------------------------------- */
2884/*--------------------------------------------------------------------------- */
2885void xsh_pfits_set_wavesol_y_min(cpl_propertylist * plist, double value)
2886{
2887 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_Y_MIN,
2888 value),
2889 "Error writing keyword '%s'", XSH_WAVESOL_Y_MIN);
2890
2891 cleanup:
2892 return;
2893}
2894
2895/*--------------------------------------------------------------------------- */
2901/*--------------------------------------------------------------------------- */
2902void xsh_pfits_set_wavesol_y_max(cpl_propertylist * plist, double value)
2903{
2904 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_Y_MAX,
2905 value),
2906 "Error writing keyword '%s'", XSH_WAVESOL_Y_MAX);
2907
2908 cleanup:
2909 return;
2910}
2911
2912/*--------------------------------------------------------------------------- */
2918/*--------------------------------------------------------------------------- */
2919double xsh_pfits_get_wavesol_lambda_min(cpl_propertylist * plist)
2920{
2921 double returnvalue = 0.0;
2922
2923 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_LAMBDA_MIN,
2924 CPL_TYPE_DOUBLE, &returnvalue),
2925 "Error reading keyword '%s'", XSH_WAVESOL_LAMBDA_MIN);
2926
2927cleanup:
2928 return returnvalue;
2929}
2930
2931/*--------------------------------------------------------------------------- */
2937/*--------------------------------------------------------------------------- */
2938double xsh_pfits_get_wavesol_lambda_max(cpl_propertylist * plist)
2939{
2940 double returnvalue = 0.0;
2941
2942 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_LAMBDA_MAX,
2943 CPL_TYPE_DOUBLE, &returnvalue),
2944 "Error reading keyword '%s'", XSH_WAVESOL_LAMBDA_MAX);
2945
2946cleanup:
2947 return returnvalue;
2948}
2949
2950/*--------------------------------------------------------------------------- */
2956/*--------------------------------------------------------------------------- */
2957double xsh_pfits_get_wavesol_order_min(cpl_propertylist * plist)
2958{
2959 double returnvalue = 0.0;
2960
2961 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_ORDER_MIN,
2962 CPL_TYPE_DOUBLE, &returnvalue),
2963 "Error reading keyword '%s'", XSH_WAVESOL_ORDER_MIN);
2964
2965cleanup:
2966 return returnvalue;
2967}
2968
2969/*--------------------------------------------------------------------------- */
2975/*--------------------------------------------------------------------------- */
2976double xsh_pfits_get_wavesol_order_max(cpl_propertylist * plist)
2977{
2978 double returnvalue = 0.0;
2979
2980 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_ORDER_MAX,
2981 CPL_TYPE_DOUBLE, &returnvalue),
2982 "Error reading keyword '%s'", XSH_WAVESOL_ORDER_MAX);
2983
2984cleanup:
2985 return returnvalue;
2986}
2987
2988/*--------------------------------------------------------------------------- */
2994/*--------------------------------------------------------------------------- */
2995double xsh_pfits_get_wavesol_slit_min(cpl_propertylist * plist)
2996{
2997 double returnvalue = 0.0;
2998
2999 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_SLIT_MIN,
3000 CPL_TYPE_DOUBLE, &returnvalue),
3001 "Error reading keyword '%s'", XSH_WAVESOL_SLIT_MIN);
3002
3003cleanup:
3004 return returnvalue;
3005}
3006
3007/*--------------------------------------------------------------------------- */
3013/*--------------------------------------------------------------------------- */
3014double xsh_pfits_get_wavesol_slit_max(cpl_propertylist * plist)
3015{
3016 double returnvalue = 0.0;
3017
3018 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_SLIT_MAX,
3019 CPL_TYPE_DOUBLE, &returnvalue),
3020 "Error reading keyword '%s'", XSH_WAVESOL_SLIT_MAX);
3021
3022cleanup:
3023 return returnvalue;
3024}
3025
3026/*--------------------------------------------------------------------------- */
3032/*--------------------------------------------------------------------------- */
3033double xsh_pfits_get_extract_slit_min(cpl_propertylist * plist)
3034{
3035 double returnvalue = 0.0;
3036
3037 check_msg (xsh_get_property_value (plist, XSH_EXTRACT_SLIT_MIN,
3038 CPL_TYPE_DOUBLE, &returnvalue),
3039 "Error reading keyword '%s'", XSH_EXTRACT_SLIT_MIN);
3040
3041cleanup:
3042 return returnvalue;
3043}
3044
3045/*--------------------------------------------------------------------------- */
3051/*--------------------------------------------------------------------------- */
3052double xsh_pfits_get_extract_slit_max(cpl_propertylist * plist)
3053{
3054 double returnvalue = 0.0;
3055
3056 check_msg (xsh_get_property_value (plist, XSH_EXTRACT_SLIT_MAX,
3057 CPL_TYPE_DOUBLE, &returnvalue),
3058 "Error reading keyword '%s'", XSH_EXTRACT_SLIT_MAX);
3059
3060cleanup:
3061 return returnvalue;
3062}
3063
3064/*--------------------------------------------------------------------------- */
3070/*--------------------------------------------------------------------------- */
3071double xsh_pfits_get_wavesol_x_min(cpl_propertylist * plist)
3072{
3073 double returnvalue = 0.0;
3074
3075 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_X_MIN,
3076 CPL_TYPE_DOUBLE, &returnvalue),
3077 "Error reading keyword '%s'", XSH_WAVESOL_X_MIN);
3078
3079cleanup:
3080 return returnvalue;
3081}
3082
3083/*--------------------------------------------------------------------------- */
3089/*--------------------------------------------------------------------------- */
3090double xsh_pfits_get_wavesol_x_max(cpl_propertylist * plist)
3091{
3092 double returnvalue = 0.0;
3093
3094 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_X_MAX,
3095 CPL_TYPE_DOUBLE, &returnvalue),
3096 "Error reading keyword '%s'", XSH_WAVESOL_X_MAX);
3097
3098cleanup:
3099 return returnvalue;
3100}
3101
3102/*--------------------------------------------------------------------------- */
3108/*--------------------------------------------------------------------------- */
3109double xsh_pfits_get_wavesol_y_min(cpl_propertylist * plist)
3110{
3111 double returnvalue = 0.0;
3112
3113 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_Y_MIN,
3114 CPL_TYPE_DOUBLE, &returnvalue),
3115 "Error reading keyword '%s'", XSH_WAVESOL_Y_MIN);
3116
3117cleanup:
3118 return returnvalue;
3119}
3120
3121/*--------------------------------------------------------------------------- */
3127/*--------------------------------------------------------------------------- */
3128double xsh_pfits_get_wavesol_y_max(cpl_propertylist * plist)
3129{
3130 double returnvalue = 0.0;
3131
3132 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_Y_MAX,
3133 CPL_TYPE_DOUBLE, &returnvalue),
3134 "Error reading keyword '%s'", XSH_WAVESOL_Y_MAX);
3135
3136cleanup:
3137 return returnvalue;
3138}
3139
3140/*--------------------------------------------------------------------------- */
3149/*--------------------------------------------------------------------------- */
3150const char *
3151xsh_pfits_get_wavesoltype( const cpl_propertylist * plist)
3152{
3153 const char *returnvalue = "";
3154
3155 check_msg (xsh_get_property_value
3156 (plist, XSH_WAVESOLTYPE, CPL_TYPE_STRING, &returnvalue),
3157 "Error reading keyword '%s'", XSH_WAVESOLTYPE);
3158cleanup:
3159 return returnvalue;
3160}
3161
3162/*--------------------------------------------------------------------------- */
3171/*--------------------------------------------------------------------------- */
3172void xsh_pfits_set_wavesoltype( cpl_propertylist * plist, const char* value)
3173{
3174 XSH_REGDEBUG("writing keyword %s = %s", XSH_WAVESOLTYPE, value);
3175 check_msg (cpl_propertylist_update_string (plist, XSH_WAVESOLTYPE, value),
3176 "Error writing keyword '%s'", XSH_WAVESOLTYPE);
3177 cleanup:
3178 return;
3179}
3180
3181/*----------- RECTIFY Specific KEYWORDS ----------------*/
3187/*--------------------------------------------------------------------------- */
3188void xsh_pfits_set_rectify_bin_lambda(cpl_propertylist * plist, double value)
3189{
3190 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_BIN_LAMBDA,
3191 value),
3192 "Error writing keyword '%s'", XSH_RECTIFY_BIN_LAMBDA);
3193
3194 cleanup:
3195 return;
3196}
3197
3203/*--------------------------------------------------------------------------- */
3204void xsh_pfits_set_rectify_bin_space(cpl_propertylist * plist, double value)
3205{
3206 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_BIN_SPACE,
3207 value),
3208 "Error writing keyword '%s'", XSH_RECTIFY_BIN_SPACE);
3209
3210 cleanup:
3211 return;
3212}
3213
3219/*--------------------------------------------------------------------------- */
3220void xsh_pfits_set_rectify_lambda_min(cpl_propertylist * plist, double value)
3221{
3222 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_LAMBDA_MIN,
3223 value),
3224 "Error writing keyword '%s'", XSH_RECTIFY_LAMBDA_MIN);
3225
3226 cleanup:
3227 return;
3228}
3229
3235/*--------------------------------------------------------------------------- */
3236void xsh_pfits_set_rectify_lambda_max(cpl_propertylist * plist, double value)
3237{
3238 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_LAMBDA_MAX,
3239 value),
3240 "Error writing keyword '%s'", XSH_RECTIFY_LAMBDA_MAX);
3241
3242 cleanup:
3243 return;
3244}
3245
3251/*--------------------------------------------------------------------------- */
3252void xsh_pfits_set_rectify_space_min(cpl_propertylist * plist, double value)
3253{
3254 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_SPACE_MIN,
3255 value),
3256 "Error writing keyword '%s'", XSH_RECTIFY_SPACE_MIN);
3257
3258 cleanup:
3259 return;
3260}
3261
3267/*--------------------------------------------------------------------------- */
3268void xsh_pfits_set_rectify_space_max(cpl_propertylist * plist, double value)
3269{
3270 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_SPACE_MAX,
3271 value),
3272 "Error writing keyword '%s'", XSH_RECTIFY_SPACE_MAX);
3273
3274 cleanup:
3275 return;
3276}
3277
3283/*--------------------------------------------------------------------------- */
3284double xsh_pfits_get_rectify_bin_lambda(cpl_propertylist * plist)
3285{
3286 double returnvalue = 0.0;
3287
3288 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_BIN_LAMBDA,
3289 CPL_TYPE_DOUBLE, &returnvalue),
3290 "Error reading keyword '%s'", XSH_RECTIFY_BIN_LAMBDA);
3291
3292cleanup:
3293 return returnvalue;
3294}
3295
3301/*--------------------------------------------------------------------------- */
3302double xsh_pfits_get_rectify_bin_space(cpl_propertylist * plist)
3303{
3304 double returnvalue = 0.0;
3305
3306 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_BIN_SPACE,
3307 CPL_TYPE_DOUBLE, &returnvalue),
3308 "Error reading keyword '%s'", XSH_RECTIFY_BIN_SPACE);
3309
3310cleanup:
3311 return returnvalue;
3312}
3313
3319double xsh_pfits_get_rectify_lambda_min(cpl_propertylist * plist)
3320{
3321 double returnvalue = 0.0;
3322
3323 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_LAMBDA_MIN,
3324 CPL_TYPE_DOUBLE, &returnvalue),
3325 "Error reading keyword '%s'", XSH_RECTIFY_LAMBDA_MIN);
3326
3327cleanup:
3328 return returnvalue;
3329}
3330
3336double xsh_pfits_get_rectify_lambda_max(cpl_propertylist * plist)
3337{
3338 double returnvalue = 0.0;
3339
3340 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_LAMBDA_MAX,
3341 CPL_TYPE_DOUBLE, &returnvalue),
3342 "Error reading keyword '%s'", XSH_RECTIFY_LAMBDA_MAX);
3343
3344cleanup:
3345 return returnvalue;
3346}
3347
3353double xsh_pfits_get_rectify_space_min(cpl_propertylist * plist)
3354{
3355 double returnvalue = 0.0;
3356
3357 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_SPACE_MIN,
3358 CPL_TYPE_DOUBLE, &returnvalue),
3359 "Error reading keyword '%s'", XSH_RECTIFY_SPACE_MIN);
3360
3361cleanup:
3362 return returnvalue;
3363}
3364
3370double xsh_pfits_get_rectify_space_max(cpl_propertylist * plist)
3371{
3372 double returnvalue = 0.0;
3373
3374 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_SPACE_MAX,
3375 CPL_TYPE_DOUBLE, &returnvalue),
3376 "Error reading keyword '%s'", XSH_RECTIFY_SPACE_MAX);
3377
3378cleanup:
3379 return returnvalue;
3380}
3381
3382
3388int xsh_pfits_get_obs_id(cpl_propertylist * plist)
3389{
3390 int returnvalue = 0;
3391
3392 check_msg (xsh_get_property_value (plist, XSH_OBS_ID,
3393 CPL_TYPE_INT, &returnvalue),
3394 "Error reading keyword '%s'", XSH_OBS_ID);
3395
3396cleanup:
3397 return returnvalue;
3398}
3399
3400
3409int xsh_pfits_get_nb_pinhole( const cpl_propertylist * plist){
3410 int nb_pinhole=1;
3411 const char* pinhole = NULL;
3412
3413 XSH_ASSURE_NOT_NULL( plist);
3414 check( pinhole = xsh_pfits_get_dpr_tech( plist));
3415
3416 if ( strcmp( pinhole, XSH_DPR_TECH_MULTI_PINHOLE) == 0 ){
3417 nb_pinhole = XSH_NB_PINHOLE;
3418 }
3419 else if (strcmp( pinhole, XSH_DPR_TECH_SINGLE_PINHOLE) == 0){
3420 nb_pinhole = 1;
3421 }
3422 else{
3423 xsh_error_msg( "Undefined pinhole : can't identify DPR keyword %s\n\
3424 Authorized keyword are ( single %s multi %s )", pinhole,
3425 XSH_DPR_TECH_SINGLE_PINHOLE, XSH_DPR_TECH_MULTI_PINHOLE);
3426 }
3427 cleanup:
3428 return nb_pinhole;
3429}
3430
3439double xsh_pfits_get_tel_targ_alpha( const cpl_propertylist * plist)
3440{
3441 double returnvalue = 0. ;
3442
3443 check_msg (xsh_get_property_value (plist, XSH_TEL_TARG_ALPHA,
3444 CPL_TYPE_DOUBLE, &returnvalue),
3445 "Error reading keyword '%s'", XSH_TEL_TARG_ALPHA ) ;
3446
3447 cleanup:
3448 return returnvalue;
3449}
3450
3459double xsh_pfits_get_tel_targ_delta( const cpl_propertylist * plist)
3460{
3461 double returnvalue = 0. ;
3462
3463 check_msg (xsh_get_property_value (plist, XSH_TEL_TARG_DELTA,
3464 CPL_TYPE_DOUBLE, &returnvalue),
3465 "Error reading keyword '%s'", XSH_TEL_TARG_DELTA ) ;
3466
3467 cleanup:
3468 return returnvalue;
3469}
3470
3479double xsh_pfits_get_ra( const cpl_propertylist * plist)
3480{
3481 double returnvalue = 0. ;
3482
3483 check_msg (xsh_get_property_value (plist, XSH_RA,
3484 CPL_TYPE_DOUBLE, &returnvalue),
3485 "Error reading keyword '%s'", XSH_RA ) ;
3486
3487 cleanup:
3488 return returnvalue;
3489}
3490
3491
3500double xsh_pfits_get_dec( const cpl_propertylist * plist)
3501{
3502 double returnvalue = 0. ;
3503
3504 check_msg (xsh_get_property_value (plist, XSH_DEC,
3505 CPL_TYPE_DOUBLE, &returnvalue),
3506 "Error reading keyword '%s'", XSH_DEC ) ;
3507
3508 cleanup:
3509 return returnvalue;
3510}
3511/*--------------------------------------------------------------------------- */
3512/*--------------------------------------------------------------------------- */
3513double xsh_pfits_get_posang( const cpl_propertylist *plist)
3514{
3515 double returnvalue = 0. ;
3516
3517 check_msg (xsh_get_property_value (plist, XSH_POSANG,
3518 CPL_TYPE_DOUBLE, &returnvalue),
3519 "Error reading keyword '%s'", XSH_POSANG) ;
3520
3521 cleanup:
3522 return returnvalue;
3523}
3524/*--------------------------------------------------------------------------- */
3525
3526/*--------------------------------------------------------------------------- */
3527/*--------------------------------------------------------------------------- */
3528double xsh_pfits_get_ra_reloffset( const cpl_propertylist *plist)
3529{
3530 double returnvalue = 0. ;
3531
3532 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_RA,
3533 CPL_TYPE_DOUBLE, &returnvalue),
3534 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_RA) ;
3535
3536 cleanup:
3537 return returnvalue;
3538}
3539/*--------------------------------------------------------------------------- */
3540
3541/*--------------------------------------------------------------------------- */
3542/*--------------------------------------------------------------------------- */
3543double xsh_pfits_get_dec_reloffset( const cpl_propertylist *plist)
3544{
3545 double returnvalue = 0. ;
3546
3547 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_DEC,
3548 CPL_TYPE_DOUBLE, &returnvalue),
3549 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_DEC) ;
3550
3551 cleanup:
3552 return returnvalue;
3553}
3554/*--------------------------------------------------------------------------- */
3555
3556/*--------------------------------------------------------------------------- */
3557
3558double xsh_pfits_get_cumoffsetx( const cpl_propertylist *plist)
3559{
3560 double returnvalue = 0. ;
3561
3562 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSETX,
3563 CPL_TYPE_DOUBLE, &returnvalue),
3564 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSETX) ;
3565
3566 cleanup:
3567 return returnvalue;
3568}
3569/*--------------------------------------------------------------------------- */
3570/*--------------------------------------------------------------------------- */
3571double xsh_pfits_get_cumoffsety( const cpl_propertylist *plist)
3572{
3573 double returnvalue = 0. ;
3574
3575 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSETY,
3576 CPL_TYPE_DOUBLE, &returnvalue),
3577 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSETY) ;
3578
3579 cleanup:
3580 return returnvalue;
3581}
3582
3583/*--------------------------------------------------------------------------- */
3584/*--------------------------------------------------------------------------- */
3585double xsh_pfits_get_ra_cumoffset( const cpl_propertylist *plist)
3586{
3587 double returnvalue = 0. ;
3588
3589 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_RA,
3590 CPL_TYPE_DOUBLE, &returnvalue),
3591 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_RA) ;
3592
3593 cleanup:
3594 return returnvalue;
3595}
3596/*--------------------------------------------------------------------------- */
3597
3598/*--------------------------------------------------------------------------- */
3599/*--------------------------------------------------------------------------- */
3600double xsh_pfits_get_dec_cumoffset( const cpl_propertylist *plist)
3601{
3602 double returnvalue = 0. ;
3603
3604 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_DEC,
3605 CPL_TYPE_DOUBLE, &returnvalue),
3606 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_DEC) ;
3607
3608 cleanup:
3609 return returnvalue;
3610}
3611/*--------------------------------------------------------------------------- */
3612
3613/*--------------------------------------------------------------------------- */
3614/*--------------------------------------------------------------------------- */
3615double xsh_pfits_get_b_ra_reloffset( const cpl_propertylist *plist)
3616{
3617 double returnvalue = 0. ;
3618
3619 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_B_OFFSET_RA,
3620 CPL_TYPE_DOUBLE, &returnvalue),
3621 "Error reading keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_RA) ;
3622
3623 cleanup:
3624 return returnvalue;
3625}
3626/*--------------------------------------------------------------------------- */
3627
3628/*--------------------------------------------------------------------------- */
3629/*--------------------------------------------------------------------------- */
3630double xsh_pfits_get_b_dec_reloffset( const cpl_propertylist *plist)
3631{
3632 double returnvalue = 0. ;
3633
3634 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_B_OFFSET_DEC,
3635 CPL_TYPE_DOUBLE, &returnvalue),
3636 "Error reading keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_DEC) ;
3637
3638 cleanup:
3639 return returnvalue;
3640}
3641/*--------------------------------------------------------------------------- */
3642
3643/*--------------------------------------------------------------------------- */
3644/*--------------------------------------------------------------------------- */
3645double xsh_pfits_get_b_ra_cumoffset( const cpl_propertylist *plist)
3646{
3647 double returnvalue = 0. ;
3648
3649 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_B_OFFSET_RA,
3650 CPL_TYPE_DOUBLE, &returnvalue),
3651 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_RA) ;
3652
3653 cleanup:
3654 return returnvalue;
3655}
3656/*--------------------------------------------------------------------------- */
3657
3658/*--------------------------------------------------------------------------- */
3659/*--------------------------------------------------------------------------- */
3660double xsh_pfits_get_b_dec_cumoffset( const cpl_propertylist *plist)
3661{
3662 double returnvalue = 0. ;
3663
3664 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_B_OFFSET_DEC,
3665 CPL_TYPE_DOUBLE, &returnvalue),
3666 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_DEC);
3667
3668 cleanup:
3669 return returnvalue;
3670}
3671/*--------------------------------------------------------------------------- */
3672
3673/*--------------------------------------------------------------------------- */
3674/*--------------------------------------------------------------------------- */
3675void xsh_pfits_set_b_ra_reloffset(cpl_propertylist * plist, double value)
3676{
3677 check_msg( cpl_propertylist_update_double
3678 (plist, XSH_NOD_RELATIVE_B_OFFSET_RA, value),
3679 "Error writing keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_RA);
3680 cleanup:
3681 return;
3682}
3683/*--------------------------------------------------------------------------- */
3684
3685/*--------------------------------------------------------------------------- */
3686/*--------------------------------------------------------------------------- */
3687void xsh_pfits_set_b_dec_reloffset(cpl_propertylist * plist, double value)
3688{
3689 check_msg( cpl_propertylist_update_double
3690 (plist, XSH_NOD_RELATIVE_B_OFFSET_DEC, value),
3691 "Error writing keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_DEC);
3692 cleanup:
3693 return;
3694}
3695/*--------------------------------------------------------------------------- */
3696
3697
3698/*--------------------------------------------------------------------------- */
3699/*--------------------------------------------------------------------------- */
3700void xsh_pfits_set_b_ra_cumoffset(cpl_propertylist * plist, double value)
3701{
3702 check_msg( cpl_propertylist_update_double
3703 (plist, XSH_NOD_CUMULATIVE_B_OFFSET_RA, value),
3704 "Error writing keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_RA);
3705 cleanup:
3706 return;
3707}
3708/*--------------------------------------------------------------------------- */
3709
3710/*--------------------------------------------------------------------------- */
3711/*--------------------------------------------------------------------------- */
3712void xsh_pfits_set_b_dec_cumoffset(cpl_propertylist * plist, double value)
3713{
3714 check_msg( cpl_propertylist_update_double
3715 (plist, XSH_NOD_CUMULATIVE_B_OFFSET_DEC, value),
3716 "Error writing keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_DEC);
3717 cleanup:
3718 return;
3719}
3720/*--------------------------------------------------------------------------- */
3721
3722/*--------------------------------------------------------------------------- */
3723/*--------------------------------------------------------------------------- */
3724void xsh_pfits_set_slitmap_order_edgup( cpl_propertylist * plist, int absorder,
3725 double value)
3726{
3727 char name[256];
3728
3729 sprintf( name, XSH_SLITMAP_ORDER_EDGUP, absorder);
3730
3731 check_msg( cpl_propertylist_update_double
3732 (plist, name, value),
3733 "Error writing keyword '%s'", name);
3734
3735 cleanup:
3736 return;
3737}
3738/*--------------------------------------------------------------------------- */
3739
3740/*--------------------------------------------------------------------------- */
3741/*--------------------------------------------------------------------------- */
3742void xsh_pfits_set_slitmap_order_edglo( cpl_propertylist * plist, int absorder,
3743 double value)
3744{
3745 char name[256];
3746
3747 sprintf( name, XSH_SLITMAP_ORDER_EDGLO, absorder);
3748
3749 check_msg( cpl_propertylist_update_double
3750 (plist, name, value),
3751 "Error writing keyword '%s'", name);
3752
3753 cleanup:
3754 return;
3755}
3756/*--------------------------------------------------------------------------- */
3757
3758/*--------------------------------------------------------------------------- */
3759void xsh_pfits_set_slitmap_order_slicup( cpl_propertylist * plist, int absorder,
3760 double value)
3761{
3762 char name[256];
3763
3764 sprintf( name, XSH_SLITMAP_ORDER_SLICUP, absorder);
3765
3766 check_msg( cpl_propertylist_update_double
3767 (plist, name, value),
3768 "Error writing keyword '%s'", name);
3769
3770 cleanup:
3771 return;
3772}
3773/*--------------------------------------------------------------------------- */
3774
3775/*--------------------------------------------------------------------------- */
3776void xsh_pfits_set_slitmap_order_sliclo( cpl_propertylist * plist, int absorder,
3777 double value)
3778{
3779 char name[256];
3780
3781 sprintf( name, XSH_SLITMAP_ORDER_SLICLO, absorder);
3782
3783 check_msg( cpl_propertylist_update_double
3784 (plist, name, value),
3785 "Error writing keyword '%s'", name);
3786
3787 cleanup:
3788 return;
3789}
3790/*--------------------------------------------------------------------------- */
3791
3792/*--------------------------------------------------------------------------- */
3793/*--------------------------------------------------------------------------- */
3794void xsh_pfits_set_slitmap_order_cen( cpl_propertylist * plist, int absorder,
3795 double value)
3796{
3797 char name[256];
3798
3799 sprintf( name, XSH_SLITMAP_ORDER_CEN, absorder);
3800
3801 check_msg( cpl_propertylist_update_double
3802 (plist, name, value),
3803 "Error writing keyword '%s'", name);
3804
3805 cleanup:
3806 return;
3807}
3808/*--------------------------------------------------------------------------- */
3809
3810
3811/*--------------------------------------------------------------------------- */
3812/*--------------------------------------------------------------------------- */
3813void xsh_pfits_set_slitmap_median_edgup( cpl_propertylist * plist,
3814 double value)
3815{
3816 const char* name = XSH_SLITMAP_MEDIAN_EDGUP;
3817
3818
3819 check_msg( cpl_propertylist_update_double
3820 (plist, name, value),
3821 "Error writing keyword '%s'", name);
3822
3823 cleanup:
3824 return;
3825}
3826/*--------------------------------------------------------------------------- */
3827
3828/*--------------------------------------------------------------------------- */
3829/*--------------------------------------------------------------------------- */
3830void xsh_pfits_set_slitmap_median_edglo( cpl_propertylist * plist,
3831 double value)
3832{
3833 const char* name = XSH_SLITMAP_MEDIAN_EDGLO;
3834
3835
3836 check_msg( cpl_propertylist_update_double
3837 (plist, name, value),
3838 "Error writing keyword '%s'", name);
3839
3840 cleanup:
3841 return;
3842}
3843/*--------------------------------------------------------------------------- */
3844
3845/*--------------------------------------------------------------------------- */
3846/*--------------------------------------------------------------------------- */
3847void xsh_pfits_set_slitmap_median_sliclo( cpl_propertylist * plist,
3848 double value)
3849{
3850 const char* name = XSH_SLITMAP_MEDIAN_SLICLO;
3851
3852
3853 check_msg( cpl_propertylist_update_double
3854 (plist, name, value),
3855 "Error writing keyword '%s'", name);
3856
3857 cleanup:
3858 return;
3859}
3860/*--------------------------------------------------------------------------- */
3861
3862/*--------------------------------------------------------------------------- */
3863/*--------------------------------------------------------------------------- */
3864void xsh_pfits_set_slitmap_median_slicup( cpl_propertylist * plist,
3865 double value)
3866{
3867 const char* name = XSH_SLITMAP_MEDIAN_SLICUP;
3868
3869
3870 check_msg( cpl_propertylist_update_double
3871 (plist, name, value),
3872 "Error writing keyword '%s'", name);
3873
3874 cleanup:
3875 return;
3876}
3877/*--------------------------------------------------------------------------- */
3878
3879/*--------------------------------------------------------------------------- */
3880/*--------------------------------------------------------------------------- */
3881void xsh_pfits_set_slitmap_median_cen( cpl_propertylist * plist,
3882 double value)
3883{
3884 const char* name = XSH_SLITMAP_MEDIAN_CEN;
3885
3886
3887 check_msg( cpl_propertylist_update_double
3888 (plist, name, value),
3889 "Error writing keyword '%s'", name);
3890
3891 cleanup:
3892 return;
3893}
3894/*--------------------------------------------------------------------------- */
3895
3896/*--------------------------------------------------------------------------- */
3897/*--------------------------------------------------------------------------- */
3898double xsh_pfits_get_slitmap_median_edgup(const cpl_propertylist * plist)
3899{
3900 double returnvalue = 0.;
3901 const char *name = XSH_SLITMAP_MEDIAN_EDGUP;
3902
3903 check_msg( xsh_get_property_value (plist, name,
3904 CPL_TYPE_DOUBLE, &returnvalue),
3905 "Error reading keyword '%s'", name);
3906
3907 cleanup:
3908 return returnvalue;
3909}
3910/*--------------------------------------------------------------------------- */
3911
3912/*--------------------------------------------------------------------------- */
3913/*--------------------------------------------------------------------------- */
3914double xsh_pfits_get_slitmap_median_edglo(const cpl_propertylist * plist)
3915{
3916 double returnvalue = 0.;
3917 const char *name = XSH_SLITMAP_MEDIAN_EDGLO;
3918
3919 check_msg( xsh_get_property_value (plist, name,
3920 CPL_TYPE_DOUBLE, &returnvalue),
3921 "Error reading keyword '%s'", name);
3922
3923 cleanup:
3924 return returnvalue;
3925}
3926/*--------------------------------------------------------------------------- */
3927
3928/*--------------------------------------------------------------------------- */
3929/*--------------------------------------------------------------------------- */
3930double xsh_pfits_get_slitmap_median_cen(const cpl_propertylist * plist)
3931{
3932 double returnvalue = 0.;
3933 const char *name = XSH_SLITMAP_MEDIAN_CEN;
3934
3935 check_msg( xsh_get_property_value (plist, name,
3936 CPL_TYPE_DOUBLE, &returnvalue),
3937 "Error reading keyword '%s'", name);
3938
3939 cleanup:
3940 return returnvalue;
3941}
3942/*--------------------------------------------------------------------------- */
3943
3944/*--------------------------------------------------------------------------- */
3945/*--------------------------------------------------------------------------- */
3946double xsh_pfits_get_slitmap_median_slicup(const cpl_propertylist * plist)
3947{
3948 double returnvalue = 0.;
3949 const char *name = XSH_SLITMAP_MEDIAN_SLICUP;
3950
3951 check_msg( xsh_get_property_value (plist, name,
3952 CPL_TYPE_DOUBLE, &returnvalue),
3953 "Error reading keyword '%s'", name);
3954
3955 cleanup:
3956 return returnvalue;
3957}
3958/*--------------------------------------------------------------------------- */
3959
3960/*--------------------------------------------------------------------------- */
3961/*--------------------------------------------------------------------------- */
3962double xsh_pfits_get_slitmap_median_sliclo(const cpl_propertylist * plist)
3963{
3964 double returnvalue = 0.;
3965 const char *name = XSH_SLITMAP_MEDIAN_SLICLO;
3966
3967 check_msg( xsh_get_property_value (plist, name,
3968 CPL_TYPE_DOUBLE, &returnvalue),
3969 "Error reading keyword '%s'", name);
3970
3971 cleanup:
3972 return returnvalue;
3973}
3974/*--------------------------------------------------------------------------- */
3975
3976
3977/*--------------------------------------------------------------------------- */
3978/*--------------------------------------------------------------------------- */
3979void xsh_pfits_set_wavemap_order_lambda_min( cpl_propertylist * plist, int absorder,
3980 double value)
3981{
3982 char name[256];
3983
3984 sprintf( name, XSH_WAVEMAP_ORDER_LAMBDA_MIN, absorder);
3985
3986 check_msg( cpl_propertylist_update_double
3987 (plist, name, value),
3988 "Error writing keyword '%s'", name);
3989
3990 cleanup:
3991 return;
3992}
3993/*--------------------------------------------------------------------------- */
3994
3995/*--------------------------------------------------------------------------- */
3996/*--------------------------------------------------------------------------- */
3997void xsh_pfits_set_wavemap_order_lambda_max( cpl_propertylist * plist, int absorder,
3998 double value)
3999{
4000 char name[256];
4001
4002 sprintf( name, XSH_WAVEMAP_ORDER_LAMBDA_MAX, absorder);
4003
4004 check_msg( cpl_propertylist_update_double
4005 (plist, name, value),
4006 "Error writing keyword '%s'", name);
4007
4008 cleanup:
4009 return;
4010}
4011/*--------------------------------------------------------------------------- */
4012
4013/*--------------------------------------------------------------------------- */
4014/*--------------------------------------------------------------------------- */
4015void xsh_pfits_set_shiftifu_lambdaref( cpl_propertylist * plist,
4016 double value)
4017{
4018
4019 check_msg( cpl_propertylist_update_double
4020 (plist, XSH_SHIFTIFU_WAVEREF, value),
4021 "Error writing keyword '%s'", XSH_SHIFTIFU_WAVEREF);
4022
4023 cleanup:
4024 return;
4025}
4026/*--------------------------------------------------------------------------- */
4027
4028/*--------------------------------------------------------------------------- */
4029/*--------------------------------------------------------------------------- */
4030double xsh_pfits_get_shiftifu_lambdaref( cpl_propertylist * plist)
4031{
4032 double returnvalue = 0;
4033
4034 check_msg (xsh_get_property_value (plist, XSH_SHIFTIFU_WAVEREF,
4035 CPL_TYPE_DOUBLE, &returnvalue),
4036 "Error reading keyword '%s'", XSH_SHIFTIFU_WAVEREF);
4037 cleanup:
4038 return returnvalue;
4039}
4040/*--------------------------------------------------------------------------- */
4041
4042/*--------------------------------------------------------------------------- */
4043/*--------------------------------------------------------------------------- */
4044void xsh_pfits_set_shiftifu_slitref( cpl_propertylist * plist,
4045 double value)
4046{
4047
4048 check_msg( cpl_propertylist_update_double
4049 (plist, XSH_SHIFTIFU_SLITREF, value),
4050 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITREF);
4051
4052 cleanup:
4053 return;
4054}
4055/*--------------------------------------------------------------------------- */
4056
4057/*--------------------------------------------------------------------------- */
4058/*--------------------------------------------------------------------------- */
4059void xsh_pfits_set_shiftifu_slitdownref( cpl_propertylist * plist,
4060 double value)
4061{
4062
4063 check_msg( cpl_propertylist_update_double
4064 (plist, XSH_SHIFTIFU_SLITDOWNREF, value),
4065 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITDOWNREF);
4066
4067 cleanup:
4068 return;
4069}
4070/*--------------------------------------------------------------------------- */
4071
4072/*--------------------------------------------------------------------------- */
4073/*--------------------------------------------------------------------------- */
4074void xsh_pfits_set_shiftifu_slitcenref( cpl_propertylist * plist,
4075 double value)
4076{
4077
4078 check_msg( cpl_propertylist_update_double
4079 (plist, XSH_SHIFTIFU_SLITCENREF, value),
4080 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITCENREF);
4081
4082 cleanup:
4083 return;
4084}
4085/*--------------------------------------------------------------------------- */
4086
4087/*--------------------------------------------------------------------------- */
4088/*--------------------------------------------------------------------------- */
4089void xsh_pfits_set_shiftifu_slitupref( cpl_propertylist * plist,
4090 double value)
4091{
4092
4093 check_msg( cpl_propertylist_update_double
4094 (plist, XSH_SHIFTIFU_SLITUPREF, value),
4095 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITUPREF);
4096
4097 cleanup:
4098 return;
4099}
4100/*--------------------------------------------------------------------------- */
4101
4102/*--------------------------------------------------------------------------- */
4103/*--------------------------------------------------------------------------- */
4104double xsh_pfits_get_shiftifu_slitref( cpl_propertylist * plist)
4105{
4106 double returnvalue = 0;
4107
4108 check_msg (xsh_get_property_value (plist, XSH_SHIFTIFU_SLITREF,
4109 CPL_TYPE_DOUBLE, &returnvalue),
4110 "Error reading keyword '%s'", XSH_SHIFTIFU_SLITREF);
4111 cleanup:
4112 return returnvalue;
4113}
4114/*--------------------------------------------------------------------------- */
4115
4116/*--------------------------------------------------------------------------- */
4125double xsh_pfits_get_nod_reloffset( const cpl_propertylist * plist)
4126{
4127 double returnvalue = 0. ;
4128 double dec = 0., ra = 0. ;
4129
4130 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_DEC,
4131 CPL_TYPE_DOUBLE, &dec),
4132 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_DEC ) ;
4133 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_RA,
4134 CPL_TYPE_DOUBLE, &ra),
4135 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_RA ) ;
4136 returnvalue = sqrt( dec*dec + ra*ra ) ;
4137 xsh_msg_dbg_high( "dec: %lf, ra: %lf, reloffset: %lf", dec, ra, returnvalue ) ;
4138
4139 cleanup:
4140 return returnvalue;
4141}
4142
4151double xsh_pfits_get_nod_cumoffset( const cpl_propertylist * plist)
4152{
4153 double returnvalue = 0 ;
4154 double dec = 0., ra = 0. ;
4155
4156 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_DEC,
4157 CPL_TYPE_DOUBLE, &dec),
4158 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_DEC ) ;
4159 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_RA,
4160 CPL_TYPE_DOUBLE, &ra),
4161 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_RA ) ;
4162 returnvalue = sqrt( dec*dec + ra*ra ) ;
4163 xsh_msg_dbg_high ("dec: %lf, ra: %lf, cumoffset: %lf", dec, ra, returnvalue ) ;
4164
4165 cleanup:
4166 return returnvalue;
4167
4168}
4169
4178double xsh_pfits_get_nod_jitterwidth( const cpl_propertylist * plist)
4179{
4180 double returnvalue = 0 ;
4181
4182 check_msg (xsh_get_property_value (plist, XSH_NOD_JITTER_BOX,
4183 CPL_TYPE_DOUBLE, &returnvalue),
4184 "Error reading keyword '%s'", XSH_NOD_JITTER_BOX );
4185
4186 cleanup:
4187 return returnvalue;
4188
4189}
4190
4199double xsh_pfits_get_nodthrow( const cpl_propertylist * plist)
4200{
4201 double returnvalue = 0 ;
4202
4203 check_msg (xsh_get_property_value (plist, XSH_NOD_THROW,
4204 CPL_TYPE_DOUBLE, &returnvalue),
4205 "Error reading keyword '%s'", XSH_NOD_THROW);
4206
4207 cleanup:
4208 return returnvalue;
4209
4210}
4211
4212
4221static cpl_error_code
4222xsh_plist_set_extra_common_keys(cpl_propertylist* plist)
4223{
4224
4225 cpl_propertylist_append_string(plist,"HDUCLASS", "ESO") ;
4226 cpl_propertylist_set_comment(plist,"HDUCLASS","hdu classification") ;
4227
4228 cpl_propertylist_append_string(plist,"HDUDOC", "DICD") ;
4229 cpl_propertylist_set_comment(plist,"HDUDOC","hdu reference document") ;
4230
4231 cpl_propertylist_append_string(plist,"HDUVERS", "DICD V6.0") ;
4232 cpl_propertylist_set_comment(plist,"HDUVERS","hdu reference document version") ;
4233
4234 return cpl_error_get_code();
4235}
4236
4249cpl_error_code
4250xsh_plist_set_extra_keys(cpl_propertylist* plist,
4251 const char* hduclas1,
4252 const char* hduclas2,
4253 const char* hduclas3,
4254 const char* scidata,
4255 const char* errdata,
4256 const char* qualdata,
4257 const int type)
4258{
4259
4260 //XSH_ASSURE_NOT_ILLEGAL_MSG(type<3,"type < 3");
4261 XSH_ASSURE_NOT_ILLEGAL_MSG(type>=0,"type > 0");
4262
4263 xsh_plist_set_extra_common_keys(plist);
4264
4265 cpl_propertylist_append_string(plist,"HDUCLAS1",hduclas1) ;
4266 cpl_propertylist_set_comment(plist,"HDUCLAS1","hdu format classification") ;
4267
4268 cpl_propertylist_append_string(plist,"HDUCLAS2",hduclas2) ;
4269 cpl_propertylist_set_comment(plist,"HDUCLAS2","hdu type classification") ;
4270
4271 if(type == 0) {
4272 if(!cpl_propertylist_has(plist,"EXTNAME")) {
4273 cpl_propertylist_append_string(plist,"EXTNAME",scidata) ;
4274 cpl_propertylist_set_comment(plist,"EXTNAME","name of data extension") ;
4275 }
4276 }
4277
4278 if(type!=0) {
4279 if(!cpl_propertylist_has(plist,"HDUCLAS3")) {
4280 cpl_propertylist_append_string(plist,"HDUCLAS3",hduclas3) ;
4281 cpl_propertylist_set_comment(plist,"HDUCLAS3","hdu info classification") ;
4282 }
4283 if(!cpl_propertylist_has(plist,"SCIDATA")) {
4284 cpl_propertylist_append_string(plist,"SCIDATA",scidata) ;
4285 cpl_propertylist_set_comment(plist,"SCIDATA","name of data extension") ;
4286 }
4287 }
4288
4289 if(type!=1) {
4290 if(!cpl_propertylist_has(plist,"ERRDATA")) {
4291 cpl_propertylist_append_string(plist,"ERRDATA",errdata) ;
4292 cpl_propertylist_set_comment(plist,"ERRDATA","name of errs extension") ;
4293 }
4294 }
4295
4296 if(type!=2) {
4297 if(!cpl_propertylist_has(plist,"QUALDATA")) {
4298 cpl_propertylist_append_string(plist,"QUALDATA",qualdata) ;
4299 cpl_propertylist_set_comment(plist,"QUALDATA","name of qual extension") ;
4300 }
4301 }
4302 cleanup:
4303 return cpl_error_get_code();
4304}
4305
4306cpl_error_code
4307xsh_pfits_set_wcs1(cpl_propertylist* header,
4308 const double crpix1,
4309 const double crval1,
4310 const double cdelt1) {
4311
4312 cpl_propertylist_append_double(header, XSH_CRPIX1, crpix1);
4313 cpl_propertylist_append_double(header, XSH_CRVAL1, crval1);
4314 cpl_propertylist_append_double(header, XSH_CDELT1, cdelt1);
4315 cpl_propertylist_append_string(header, XSH_CTYPE1, "LINEAR");
4316
4317 return cpl_error_get_code();
4318}
4319
4320
4321cpl_error_code
4322xsh_pfits_set_wcs2(cpl_propertylist* header,
4323 const double crpix2,
4324 const double crval2,
4325 const double cdelt2) {
4326
4327 cpl_propertylist_append_double(header, XSH_CRPIX2, crpix2);
4328 cpl_propertylist_append_double(header, XSH_CRVAL2, crval2);
4329 cpl_propertylist_append_double(header, XSH_CDELT2, cdelt2);
4330 cpl_propertylist_append_string(header, XSH_CTYPE2, "LINEAR");
4331
4332 return cpl_error_get_code();
4333}
4334
4335cpl_error_code
4336xsh_pfits_set_wcs3(cpl_propertylist* header,
4337 const double crpix3,
4338 const double crval3,
4339 const double cdelt3) {
4340
4341 cpl_propertylist_append_double(header, XSH_CRPIX3, crpix3);
4342 cpl_propertylist_append_double(header, XSH_CRVAL3, crval3);
4343 cpl_propertylist_append_double(header, XSH_CDELT3, cdelt3);
4344 cpl_propertylist_append_string(header, XSH_CTYPE3, "LINEAR");
4345
4346 return cpl_error_get_code();
4347}
4348cpl_error_code
4349xsh_pfits_set_cd_matrix(cpl_propertylist* header,
4350 const double cdelt1,
4351 const double cdelt2) {
4352
4353 xsh_pfits_set_cd11(header, cdelt1);
4354 xsh_pfits_set_cd12(header, 0);
4355 xsh_pfits_set_cd21(header, 0);
4356 xsh_pfits_set_cd22(header, cdelt2);
4357
4358 return cpl_error_get_code();
4359}
4360
4361
4362
4363cpl_error_code
4364xsh_pfits_set_wcs(cpl_propertylist* header, const double crpix1,
4365 const double crval1, const double cdelt1, const double crpix2,
4366 const double crval2, const double cdelt2) {
4367
4368 xsh_pfits_set_wcs1(header, crpix1, crval1, cdelt1);
4369 xsh_pfits_set_wcs2(header, crpix2, crval2, cdelt2);
4370 xsh_pfits_set_cd_matrix(header, cdelt1, cdelt2);
4371
4372 return cpl_error_get_code();
4373}
4374
4375static cpl_error_code
4376xsh_key_bin_mult_by_fct(cpl_propertylist** plist,const char* kname,const int fct)
4377{
4378
4379 int value=0;
4380 if(cpl_propertylist_has(*plist,kname) > 0) {
4381 xsh_get_property_value(*plist,kname,CPL_TYPE_INT,&value);
4382 if(value<2) {
4383 check(cpl_propertylist_set_int(*plist,kname,value*fct));
4384 }
4385 } else {
4386 if(fct>1) {
4387 cpl_propertylist_append_int(*plist,kname,1);
4388 }
4389 }
4390
4391 cleanup:
4392 return cpl_error_get_code();
4393}
4394
4395static cpl_error_code
4396xsh_key_scan_div_by_fct(cpl_propertylist** plist,const char* kname,const int fct)
4397{
4398
4399 int value=0;
4400 if(cpl_propertylist_has(*plist,kname) > 0) {
4401 xsh_get_property_value(*plist,kname,CPL_TYPE_INT,&value);
4402 if(value<2) {
4403 check(cpl_propertylist_set_int(*plist,kname,value/fct));
4404 }
4405 } else {
4406 if(value>1) {
4407 cpl_propertylist_append_int(*plist,kname,1);
4408 }
4409 }
4410
4411 cleanup:
4412 return cpl_error_get_code();
4413}
4414
4415
4416cpl_error_code
4417xsh_plist_div_by_fct(cpl_propertylist** plist,const int fctx,const int fcty)
4418{
4419 xsh_key_bin_mult_by_fct(plist,XSH_WIN_BINX,fctx);
4420 xsh_key_bin_mult_by_fct(plist,XSH_WIN_BINY,fcty);
4421
4422 xsh_key_scan_div_by_fct(plist,XSH_PRSCX,fctx);
4423 xsh_key_scan_div_by_fct(plist,XSH_PRSCY,fcty);
4424 xsh_key_scan_div_by_fct(plist,XSH_OVSCX,fctx);
4425 xsh_key_scan_div_by_fct(plist,XSH_OVSCY,fcty);
4426
4427 return cpl_error_get_code();
4428}
4429
4430cpl_error_code
4431xsh_pfits_combine_headers(cpl_propertylist* header,cpl_frameset* set)
4432{
4433 int size=0;
4434 int i=0;
4435 int expno_min=999;
4436 int expno_max=-999;
4437 int expno_cur=0;
4438 int i_min=0;
4439 int i_max=0;
4440 cpl_propertylist* plist=NULL;
4441 cpl_propertylist* head_first=NULL;
4442 cpl_propertylist* head_last=NULL;
4443 const char* fname=NULL;
4444 cpl_frame* frame=NULL;
4445
4446 cpl_error_ensure(header != NULL, CPL_ERROR_NULL_INPUT,
4447 return CPL_ERROR_NULL_INPUT, "NULL input header");
4448 cpl_error_ensure(set != NULL, CPL_ERROR_NULL_INPUT,
4449 return CPL_ERROR_NULL_INPUT, "NULL input frameset");
4450
4451 size=cpl_frameset_get_size(set);
4452 if(size == 1) {
4453 return CPL_ERROR_NONE;
4454 }
4455 for(i=0;i<size;i++) {
4456 frame=cpl_frameset_get_frame(set,i);
4457 fname=cpl_frame_get_filename(frame);
4458 //xsh_msg("fname=%s",fname);
4459 //xsh_msg("i_min=%d i_max=%d",i_min,i_max);
4460 plist=cpl_propertylist_load(fname,0);
4461 expno_cur=xsh_pfits_get_tpl_expno(plist);
4462
4463 if(expno_cur < expno_min) {
4464 expno_min=expno_cur;
4465 i_min=i;
4466 }
4467 if(expno_cur > expno_max) {
4468 expno_max=expno_cur;
4469 i_max=i;
4470 }
4471 xsh_free_propertylist(&plist);
4472 }
4473 //xsh_msg("i_min=%d i_max=%d",i_min,i_max);
4474 frame=cpl_frameset_get_frame(set,i_min);
4475 fname=cpl_frame_get_filename(frame);
4476 //xsh_msg("fname=%s",fname);
4477 //xsh_msg("init airm start=%g end %g",xsh_pfits_get_airm_start(header),xsh_pfits_get_airm_end(header));
4478 head_first=cpl_propertylist_load_regexp(fname,0,"START",0);
4479 cpl_propertylist_copy_property_regexp(header,head_first,"START",0);
4480 //xsh_msg("first airm start=%g end %g",xsh_pfits_get_airm_start(header),xsh_pfits_get_airm_end(header));
4481
4482 frame=cpl_frameset_get_frame(set,i_max);
4483 fname=cpl_frame_get_filename(frame);
4484 //xsh_msg("fname=%s",fname);
4485
4486 head_last=cpl_propertylist_load_regexp(fname,0,"END",0);
4487 cpl_propertylist_copy_property_regexp(header,head_last,"END",0);
4488 //xsh_msg("last airm start=%g end %g",xsh_pfits_get_airm_start(header),xsh_pfits_get_airm_end(header));
4489
4490 xsh_free_propertylist(&head_first);
4491 xsh_free_propertylist(&head_last);
4492 xsh_free_propertylist(&plist);
4493
4494 return cpl_error_get_code();
4495
4496}
4497
4498
4499cpl_error_code
4500xsh_pfits_combine_two_frames_headers(cpl_frame* first, cpl_frame* second)
4501{
4502
4503 int expno_min = 999;
4504
4505 int expno_cur = 0;
4506 /*
4507 int expno_max = -999;
4508 int size = 0;
4509 int i = 0;
4510 int i_min = 0;
4511 int i_max = 0;
4512 cpl_frame* frame = NULL;
4513 */
4514 cpl_propertylist* plist = NULL;
4515 cpl_propertylist* head_first = NULL;
4516 cpl_propertylist* head_last = NULL;
4517 const char* fname = NULL;
4518
4519
4520 cpl_error_ensure(first != NULL, CPL_ERROR_NULL_INPUT,
4521 return CPL_ERROR_NULL_INPUT, "NULL input header");
4522 cpl_error_ensure(second != NULL, CPL_ERROR_NULL_INPUT,
4523 return CPL_ERROR_NULL_INPUT, "NULL input frameset");
4524
4525 fname = cpl_frame_get_filename(first);
4526 plist = cpl_propertylist_load(fname, 0);
4527 expno_cur = xsh_pfits_get_tpl_expno(plist);
4528 if (expno_cur < expno_min) {
4529 head_first = cpl_propertylist_duplicate(plist);
4530 expno_min=expno_cur;
4531 }
4532
4533 xsh_free_propertylist(&plist);
4534 fname = cpl_frame_get_filename(second);
4535 plist = cpl_propertylist_load(fname, 0);
4536 expno_cur = xsh_pfits_get_tpl_expno(plist);
4537 if (expno_cur < expno_min) {
4538 xsh_free_propertylist(&head_first);
4539 head_first = cpl_propertylist_load(cpl_frame_get_filename(second), 0);
4540 head_last = cpl_propertylist_load(cpl_frame_get_filename(first), 0);
4541 } else {
4542 head_last = cpl_propertylist_load(cpl_frame_get_filename(second), 0);
4543 }
4544 xsh_free_propertylist(&plist);
4545
4546
4547 /* we now adjust the final frame FITS header */
4548 plist = cpl_propertylist_load(cpl_frame_get_filename(first), 0);
4549
4550 cpl_propertylist_copy_property_regexp(plist,head_first, "START", 0);
4551 cpl_propertylist_copy_property_regexp(plist,head_last, "END", 0);
4552
4553 xsh_free_propertylist(&head_first);
4554 xsh_free_propertylist(&head_last);
4555 xsh_free_propertylist(&plist);
4556
4557 return cpl_error_get_code();
4558
4559}
4560
4561int
4562xsh_pfits_is_obs(cpl_propertylist* plist)
4563{
4564 int res=0;
4565 //xsh_msg("DPR TYPE: %s",xsh_pfits_get_dpr_catg (plist));
4566 if ( strcmp( xsh_pfits_get_dpr_catg (plist), "SCIENCE" ) == 0 ) {
4567 return 1;
4568 } else if ( strstr(xsh_pfits_get_dpr_type (plist), "STD" ) != NULL) {
4569 return 1;
4570 } else {
4571 return 0;
4572 }
4573
4574 return res;
4575}
4576
4577
4578int
4579xsh_pfits_is_flat(cpl_propertylist* plist)
4580{
4581 int res=0;
4582 //xsh_msg("DPR TYPE: %s",xsh_pfits_get_dpr_catg (plist));
4583 if ( strstr(xsh_pfits_get_dpr_type (plist), "FLAT" ) != NULL) {
4584 return 1;
4585 } else {
4586 return 0;
4587 }
4588
4589 return res;
4590}
instrument
static xsh_instrument * instrument
Definition: test-xsh_remove_crh_multiple.c:98
XSH_REGDEBUG
#define XSH_REGDEBUG(...)
Definition: xsh_error.h:132
check
#define check(COMMAND)
Definition: xsh_error.h:71
check_msg
#define check_msg(COMMAND,...)
Definition: xsh_error.h:62
XSH_ASSURE_NOT_ILLEGAL_MSG
#define XSH_ASSURE_NOT_ILLEGAL_MSG(cond, msg)
Definition: xsh_error.h:111
xsh_error_msg
#define xsh_error_msg(...)
Definition: xsh_error.h:94
XSH_ASSURE_NOT_NULL
#define XSH_ASSURE_NOT_NULL(pointer)
Definition: xsh_error.h:99
xsh_instrument_arm_tostring
const char * xsh_instrument_arm_tostring(xsh_instrument *i)
Get the string associated with an arm.
Definition: xsh_data_instrument.c:701
xsh_arm_get
XSH_ARM xsh_arm_get(const char *tag)
get the arm from the frame tag
Definition: xsh_data_instrument.c:140
xsh_instrument_get_arm
XSH_ARM xsh_instrument_get_arm(xsh_instrument *i)
Get an arm on instrument structure.
Definition: xsh_data_instrument.c:451
size
int size
Definition: xsh_model_metric.c:94
xsh_msg_error
#define xsh_msg_error(...)
Print an error message.
Definition: xsh_msg.h:62
xsh_msg
#define xsh_msg(...)
Print a message on info level.
Definition: xsh_msg.h:121
xsh_msg_dbg_high
#define xsh_msg_dbg_high(...)
Definition: xsh_msg.h:40
xsh_pfits_get_raw1catg
const char * xsh_pfits_get_raw1catg(const cpl_propertylist *plist)
find out the ESO.RAW1.CATG
Definition: xsh_pfits.c:1548
xsh_pfits_get_wavesol_lambda_min
double xsh_pfits_get_wavesol_lambda_min(cpl_propertylist *plist)
find out the min lambda
Definition: xsh_pfits.c:2919
xsh_pfits_set_wcs2
cpl_error_code xsh_pfits_set_wcs2(cpl_propertylist *header, const double crpix2, const double crval2, const double cdelt2)
Definition: xsh_pfits.c:4322
xsh_pfits_get_crval2
double xsh_pfits_get_crval2(const cpl_propertylist *plist)
find out the crval2
Definition: xsh_pfits.c:1926
xsh_pfits_set_cd1
void xsh_pfits_set_cd1(cpl_propertylist *plist, double value)
Write the CD1 value.
Definition: xsh_pfits.c:2308
xsh_pfits_get_rectify_space_max
double xsh_pfits_get_rectify_space_max(cpl_propertylist *plist)
find out the rectify SPACE max
Definition: xsh_pfits.c:3370
xsh_pfits_get_bunit
const char * xsh_pfits_get_bunit(const cpl_propertylist *plist)
find out the BUNIT
Definition: xsh_pfits.c:1467
xsh_pfits_get_bias_down_median
double xsh_pfits_get_bias_down_median(cpl_propertylist *plist)
find out the BIAS DOWN MEDIAN value
Definition: xsh_pfits.c:808
xsh_pfits_set_cd13
void xsh_pfits_set_cd13(cpl_propertylist *plist, double value)
Write the CD1_3 value.
Definition: xsh_pfits.c:2384
xsh_plist_set_extra_keys
cpl_error_code xsh_plist_set_extra_keys(cpl_propertylist *plist, const char *hduclas1, const char *hduclas2, const char *hduclas3, const char *scidata, const char *errdata, const char *qualdata, const int type)
set hdu keys
Definition: xsh_pfits.c:4250
xsh_pfits_set_b_ra_reloffset
void xsh_pfits_set_b_ra_reloffset(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:3675
xsh_pfits_get_dpr_type
const char * xsh_pfits_get_dpr_type(const cpl_propertylist *plist)
find out the DPR TECH
Definition: xsh_pfits.c:1667
xsh_pfits_get_cumoffsetx
double xsh_pfits_get_cumoffsetx(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3558
xsh_pfits_set_arm
void xsh_pfits_set_arm(cpl_propertylist *plist, xsh_instrument *instr)
Definition: xsh_pfits.c:988
xsh_pfits_set_cd22
void xsh_pfits_set_cd22(cpl_propertylist *plist, double value)
Write the CD2_2 value.
Definition: xsh_pfits.c:2369
xsh_pfits_get_wavesol_lambda_max
double xsh_pfits_get_wavesol_lambda_max(cpl_propertylist *plist)
find out the wavesol max lambda
Definition: xsh_pfits.c:2938
xsh_pfits_get_ovscx
int xsh_pfits_get_ovscx(const cpl_propertylist *plist)
find out the OVSCX value
Definition: xsh_pfits.c:391
xsh_pfits_set_shiftifu_slitcenref
void xsh_pfits_set_shiftifu_slitcenref(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:4074
xsh_pfits_get_pszx
double xsh_pfits_get_pszx(const cpl_propertylist *plist)
find out the PSZX (size of 1 pixel in Microns)
Definition: xsh_pfits.c:1765
xsh_pfits_get_ra_cumoffset
double xsh_pfits_get_ra_cumoffset(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3585
xsh_pfits_get_bias_up_median
double xsh_pfits_get_bias_up_median(cpl_propertylist *plist)
find out the BIAS UP MEDIAN value
Definition: xsh_pfits.c:788
xsh_pfits_set_pcatg
void xsh_pfits_set_pcatg(cpl_propertylist *plist, const char *value)
Write the PCATG value.
Definition: xsh_pfits.c:1008
xsh_pfits_set_cd21
void xsh_pfits_set_cd21(cpl_propertylist *plist, double value)
Write the CD2_1 value.
Definition: xsh_pfits.c:2354
xsh_pfits_set_slitmap_median_cen
void xsh_pfits_set_slitmap_median_cen(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:3881
xsh_pfits_get_out_ny
int xsh_pfits_get_out_ny(const cpl_propertylist *plist)
find out the OUT NY value
Definition: xsh_pfits.c:374
xsh_pfits_get_b_ra_reloffset
double xsh_pfits_get_b_ra_reloffset(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3615
xsh_pfits_get_lst
double xsh_pfits_get_lst(const cpl_propertylist *plist)
find out the LST value
Definition: xsh_pfits.c:478
xsh_pfits_get_cdelt2
double xsh_pfits_get_cdelt2(const cpl_propertylist *plist)
find out the cdelt2
Definition: xsh_pfits.c:2216
xsh_pfits_get_conad
double xsh_pfits_get_conad(const cpl_propertylist *plist)
find out the CONAD value
Definition: xsh_pfits.c:692
xsh_pfits_set_rectify_bin_lambda
void xsh_pfits_set_rectify_bin_lambda(cpl_propertylist *plist, double value)
WRITE the lambda binning.
Definition: xsh_pfits.c:3188
xsh_pfits_get_nb_pinhole
int xsh_pfits_get_nb_pinhole(const cpl_propertylist *plist)
Get the number of pinhole.
Definition: xsh_pfits.c:3409
xsh_pfits_set_rectify_lambda_max
void xsh_pfits_set_rectify_lambda_max(cpl_propertylist *plist, double value)
WRITE the lambda max value.
Definition: xsh_pfits.c:3236
xsh_pfits_set_total_frac_sat
void xsh_pfits_set_total_frac_sat(cpl_propertylist *plist, double value)
Write the fraction of saturated pixels value.
Definition: xsh_pfits.c:1138
xsh_pfits_set_dit
void xsh_pfits_set_dit(cpl_propertylist *plist, double dit)
Write the DIT value.
Definition: xsh_pfits.c:1352
xsh_plist_set_extra_common_keys
static cpl_error_code xsh_plist_set_extra_common_keys(cpl_propertylist *plist)
set hdu keys
Definition: xsh_pfits.c:4222
xsh_pfits_get_rectify_lambda_min
double xsh_pfits_get_rectify_lambda_min(cpl_propertylist *plist)
find out the rectify lambda min
Definition: xsh_pfits.c:3319
xsh_pfits_set_crpix1
void xsh_pfits_set_crpix1(cpl_propertylist *plist, double value)
Write the CRPIX1 value.
Definition: xsh_pfits.c:2463
xsh_pfits_get_rectify_space_min
double xsh_pfits_get_rectify_space_min(cpl_propertylist *plist)
find out the rectify space min
Definition: xsh_pfits.c:3353
xsh_pfits_get_shiftifu_lambdaref
double xsh_pfits_get_shiftifu_lambdaref(cpl_propertylist *plist)
Definition: xsh_pfits.c:4030
xsh_pfits_get_temp5
double xsh_pfits_get_temp5(const cpl_propertylist *plist)
find out the temp5 (VIS prism)
Definition: xsh_pfits.c:1845
xsh_pfits_set_dpr_tech
void xsh_pfits_set_dpr_tech(cpl_propertylist *plist, const char *value)
Write the DPR TECH value.
Definition: xsh_pfits.c:1059
xsh_pfits_get_nod_jitterwidth
double xsh_pfits_get_nod_jitterwidth(const cpl_propertylist *plist)
Get the Jitter Box size.
Definition: xsh_pfits.c:4178
xsh_pfits_get_cdelt3
double xsh_pfits_get_cdelt3(const cpl_propertylist *plist)
find out the cdelt3
Definition: xsh_pfits.c:2235
xsh_pfits_get_airm_end
double xsh_pfits_get_airm_end(const cpl_propertylist *plist)
find out the TEL AIRM END value
Definition: xsh_pfits.c:527
xsh_pfits_get_slitmap_median_edglo
double xsh_pfits_get_slitmap_median_edglo(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3914
xsh_pfits_set_ndit
void xsh_pfits_set_ndit(cpl_propertylist *plist, int ndit)
Write the NDIT value.
Definition: xsh_pfits.c:1369
xsh_pfits_get_binx
int xsh_pfits_get_binx(const cpl_propertylist *plist)
find out the BINX value
Definition: xsh_pfits.c:289
xsh_pfits_set_wavesol_x_min
void xsh_pfits_set_wavesol_x_min(cpl_propertylist *plist, double value)
WRITE the min x.
Definition: xsh_pfits.c:2850
xsh_pfits_set_ctype2
void xsh_pfits_set_ctype2(cpl_propertylist *plist, const char *value)
Write the CTYPE2 value.
Definition: xsh_pfits.c:2682
xsh_pfits_get_slitmap_median_cen
double xsh_pfits_get_slitmap_median_cen(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3930
xsh_pfits_set_slitmap_median_slicup
void xsh_pfits_set_slitmap_median_slicup(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:3864
xsh_pfits_get_rectify_bin_lambda
double xsh_pfits_get_rectify_bin_lambda(cpl_propertylist *plist)
find out the rectify lambda binning
Definition: xsh_pfits.c:3284
xsh_pfits_get_cd13
double xsh_pfits_get_cd13(const cpl_propertylist *plist)
find out the cd1_3
Definition: xsh_pfits.c:2096
xsh_pfits_get_wavesol_order_min
double xsh_pfits_get_wavesol_order_min(cpl_propertylist *plist)
find out the min order
Definition: xsh_pfits.c:2957
xsh_pfits_get_extname
const char * xsh_pfits_get_extname(const cpl_propertylist *plist)
find out the EXTNAME
Definition: xsh_pfits.c:1707
xsh_pfits_get_wavesol_y_max
double xsh_pfits_get_wavesol_y_max(cpl_propertylist *plist)
find out the wavesol max y position
Definition: xsh_pfits.c:3128
xsh_pfits_set_shiftifu_lambdaref
void xsh_pfits_set_shiftifu_lambdaref(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:4015
xsh_pfits_get_bias_up_stdev
double xsh_pfits_get_bias_up_stdev(cpl_propertylist *plist)
find out the BIAS UP STDEV value
Definition: xsh_pfits.c:867
xsh_pfits_get_wavesol_slit_min
double xsh_pfits_get_wavesol_slit_min(cpl_propertylist *plist)
find out the min slit
Definition: xsh_pfits.c:2995
xsh_pfits_get_det_gain
double xsh_pfits_get_det_gain(const cpl_propertylist *plist)
find out the ESO DET OUT1 GAIN value
Definition: xsh_pfits.c:730
xsh_pfits_get_chip_nx
int xsh_pfits_get_chip_nx(const cpl_propertylist *plist)
find out the CHIP NX value
Definition: xsh_pfits.c:323
xsh_pfits_set_rectify_space_max
void xsh_pfits_set_rectify_space_max(cpl_propertylist *plist, double value)
WRITE the space (slit) max value.
Definition: xsh_pfits.c:3268
xsh_pfits_set_b_dec_cumoffset
void xsh_pfits_set_b_dec_cumoffset(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:3712
xsh_pfits_get_lamp_on_off
bool xsh_pfits_get_lamp_on_off(const cpl_propertylist *plist)
find out the Lamp status (ON/OFF)
Definition: xsh_pfits.c:1607
xsh_pfits_get_det_win1_uit1
double xsh_pfits_get_det_win1_uit1(const cpl_propertylist *plist)
find out the user defined exposure time
Definition: xsh_pfits.c:2274
xsh_pfits_set_cdelt3
void xsh_pfits_set_cdelt3(cpl_propertylist *plist, double value)
Write the CDELT3 value.
Definition: xsh_pfits.c:2591
xsh_pfits_get_ndit
int xsh_pfits_get_ndit(const cpl_propertylist *plist)
find out the NDIT value
Definition: xsh_pfits.c:1426
xsh_pfits_get_bias_right_stdev
double xsh_pfits_get_bias_right_stdev(cpl_propertylist *plist)
find out the BIAS RIGHT STDEV value
Definition: xsh_pfits.c:847
xsh_pfits_get_pixscale
double xsh_pfits_get_pixscale(const cpl_propertylist *plist)
find out the number of chopping cycles
Definition: xsh_pfits.c:158
xsh_pfits_set_wavesol_y_min
void xsh_pfits_set_wavesol_y_min(cpl_propertylist *plist, double value)
WRITE the min y.
Definition: xsh_pfits.c:2885
xsh_pfits_set_cdelt1
void xsh_pfits_set_cdelt1(cpl_propertylist *plist, double value)
Write the CDELT1 value.
Definition: xsh_pfits.c:2496
xsh_pfits_get_dit
double xsh_pfits_get_dit(const cpl_propertylist *plist)
find out the DIT value
Definition: xsh_pfits.c:1405
xsh_pfits_get_arm
XSH_ARM xsh_pfits_get_arm(const cpl_propertylist *plist)
Definition: xsh_pfits.c:270
xsh_pfits_set_slitmap_order_cen
void xsh_pfits_set_slitmap_order_cen(cpl_propertylist *plist, int absorder, double value)
Definition: xsh_pfits.c:3794
xsh_pfits_get_seeing_start
double xsh_pfits_get_seeing_start(const cpl_propertylist *plist)
find out the TEL AMBI START value (Seeing)
Definition: xsh_pfits.c:544
xsh_pfits_get_win1_dit1
double xsh_pfits_get_win1_dit1(const cpl_propertylist *plist)
find out the DET WIN1 DIT1 value
Definition: xsh_pfits.c:1385
xsh_pfits_set_shiftifu_slitdownref
void xsh_pfits_set_shiftifu_slitdownref(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:4059
xsh_pfits_set_wcs3
cpl_error_code xsh_pfits_set_wcs3(cpl_propertylist *header, const double crpix3, const double crval3, const double cdelt3)
Definition: xsh_pfits.c:4336
xsh_key_scan_div_by_fct
static cpl_error_code xsh_key_scan_div_by_fct(cpl_propertylist **plist, const char *kname, const int fct)
Definition: xsh_pfits.c:4396
xsh_pfits_set_ctype1
void xsh_pfits_set_ctype1(cpl_propertylist *plist, const char *value)
Write the CTYPE1 value.
Definition: xsh_pfits.c:2667
xsh_pfits_set_extname
void xsh_pfits_set_extname(cpl_propertylist *plist, const char *value)
Write the EXTNAME value.
Definition: xsh_pfits.c:979
xsh_pfits_get_nodthrow
double xsh_pfits_get_nodthrow(const cpl_propertylist *plist)
Get the Nod Throw value.
Definition: xsh_pfits.c:4199
xsh_pfits_get_tpl_end
double xsh_pfits_get_tpl_end(const cpl_propertylist *plist)
Find out the template end.
Definition: xsh_pfits.c:100
xsh_pfits_set_nsat
void xsh_pfits_set_nsat(cpl_propertylist *plist, int value)
Write the number of saturated pixels value.
Definition: xsh_pfits.c:1076
xsh_pfits_get_geolon
double xsh_pfits_get_geolon(const cpl_propertylist *plist)
Find out the telescope longitude.
Definition: xsh_pfits.c:128
xsh_pfits_get_rectify_bin_space
double xsh_pfits_get_rectify_bin_space(cpl_propertylist *plist)
find out the rectify space (slit) binning
Definition: xsh_pfits.c:3302
xsh_pfits_get_extract_slit_max
double xsh_pfits_get_extract_slit_max(cpl_propertylist *plist)
find out the extraction min slit
Definition: xsh_pfits.c:3052
xsh_pfits_get_out_nx
int xsh_pfits_get_out_nx(const cpl_propertylist *plist)
find out the OUT NX value
Definition: xsh_pfits.c:357
xsh_pfits_get_cd31
double xsh_pfits_get_cd31(const cpl_propertylist *plist)
find out the cd3_1
Definition: xsh_pfits.c:2155
xsh_pfits_set_datancom
void xsh_pfits_set_datancom(cpl_propertylist *plist, int value)
Definition: xsh_pfits.c:1249
xsh_pfits_get_temp2
double xsh_pfits_get_temp2(const cpl_propertylist *plist)
find out the temp2 (UVB prism)
Definition: xsh_pfits.c:1866
xsh_pfits_set_wcs
cpl_error_code xsh_pfits_set_wcs(cpl_propertylist *header, const double crpix1, const double crval1, const double cdelt1, const double crpix2, const double crval2, const double cdelt2)
Definition: xsh_pfits.c:4364
xsh_pfits_set_total_nsat
void xsh_pfits_set_total_nsat(cpl_propertylist *plist, int value)
Write the total number of saturated pixels value.
Definition: xsh_pfits.c:1117
xsh_pfits_get_tel_targ_delta
double xsh_pfits_get_tel_targ_delta(const cpl_propertylist *plist)
Get the TEL TARG DELTA.
Definition: xsh_pfits.c:3459
xsh_pfits_get_b_ra_cumoffset
double xsh_pfits_get_b_ra_cumoffset(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3645
xsh_pfits_get_utc
double xsh_pfits_get_utc(const cpl_propertylist *plist)
Find out the observation time.
Definition: xsh_pfits.c:142
xsh_pfits_set_bias_right_median
void xsh_pfits_set_bias_right_median(cpl_propertylist *plist, double value)
Write the BIAS RIGHT MEDIAN value.
Definition: xsh_pfits.c:1212
xsh_pfits_get_cd32
double xsh_pfits_get_cd32(const cpl_propertylist *plist)
find out the cd3_2
Definition: xsh_pfits.c:2175
xsh_pfits_set_cd31
void xsh_pfits_set_cd31(cpl_propertylist *plist, double value)
Write the CD3_2 value.
Definition: xsh_pfits.c:2446
xsh_key_bin_mult_by_fct
static cpl_error_code xsh_key_bin_mult_by_fct(cpl_propertylist **plist, const char *kname, const int fct)
Definition: xsh_pfits.c:4376
xsh_pfits_get_pcatg
const char * xsh_pfits_get_pcatg(const cpl_propertylist *plist)
find out the pcatg
Definition: xsh_pfits.c:1627
xsh_pfits_set_cd32
void xsh_pfits_set_cd32(cpl_propertylist *plist, double value)
Write the CD3_2 value.
Definition: xsh_pfits.c:2430
xsh_pfits_get_raw1name
const char * xsh_pfits_get_raw1name(const cpl_propertylist *plist)
find out the ESO.RAW1.NAME
Definition: xsh_pfits.c:1446
xsh_pfits_set_shiftifu_slitref
void xsh_pfits_set_shiftifu_slitref(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:4044
xsh_pfits_set_bias_up_median
void xsh_pfits_set_bias_up_median(cpl_propertylist *plist, double value)
Write the BIAS UP MEDIAN value.
Definition: xsh_pfits.c:1229
xsh_pfits_get_shiftifu_slitref
double xsh_pfits_get_shiftifu_slitref(cpl_propertylist *plist)
Definition: xsh_pfits.c:4104
xsh_pfits_set_cd23
void xsh_pfits_set_cd23(cpl_propertylist *plist, double value)
Write the CD2_3 value.
Definition: xsh_pfits.c:2399
xsh_pfits_get_slit_width
double xsh_pfits_get_slit_width(const cpl_propertylist *plist, xsh_instrument *instrument)
find out the INS OPTIx NAME value (the width of the slit)
Definition: xsh_pfits.c:580
xsh_pfits_get_wavesol_x_max
double xsh_pfits_get_wavesol_x_max(cpl_propertylist *plist)
find out the wavesol max x position
Definition: xsh_pfits.c:3090
xsh_pfits_set_rectify_space_min
void xsh_pfits_set_rectify_space_min(cpl_propertylist *plist, double value)
WRITE the space (slit) min value.
Definition: xsh_pfits.c:3252
xsh_pfits_get_cunit2
const char * xsh_pfits_get_cunit2(const cpl_propertylist *plist)
find out the CUNIT2
Definition: xsh_pfits.c:1507
xsh_pfits_get_dec
double xsh_pfits_get_dec(const cpl_propertylist *plist)
Get the Right Ascension.
Definition: xsh_pfits.c:3500
xsh_pfits_set_wavesol_y_max
void xsh_pfits_set_wavesol_y_max(cpl_propertylist *plist, double value)
WRITE the max y position.
Definition: xsh_pfits.c:2902
xsh_pfits_set_frac_sat
void xsh_pfits_set_frac_sat(cpl_propertylist *plist, double value)
Write the fraction of saturated pixels value.
Definition: xsh_pfits.c:1097
xsh_pfits_set_b_dec_reloffset
void xsh_pfits_set_b_dec_reloffset(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:3687
xsh_pfits_get_date
const char * xsh_pfits_get_date(const cpl_propertylist *plist)
find out the DATE
Definition: xsh_pfits.c:1726
xsh_pfits_set_slitmap_median_edglo
void xsh_pfits_set_slitmap_median_edglo(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:3830
xsh_pfits_get_posang
double xsh_pfits_get_posang(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3513
xsh_pfits_get_wavesol_y_min
double xsh_pfits_get_wavesol_y_min(cpl_propertylist *plist)
find out the min y position
Definition: xsh_pfits.c:3109
xsh_pfits_set_cunit3
void xsh_pfits_set_cunit3(cpl_propertylist *plist, const char *value)
Write the CUNIT1 value.
Definition: xsh_pfits.c:2652
xsh_pfits_get_telescop
const char * xsh_pfits_get_telescop(const cpl_propertylist *plist)
find out the TELESCOP value (telescope ID)
Definition: xsh_pfits.c:657
xsh_pfits_get_dec_cumoffset
double xsh_pfits_get_dec_cumoffset(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3600
xsh_pfits_get_dpr_catg
const char * xsh_pfits_get_dpr_catg(const cpl_propertylist *plist)
find out the DPR CATG
Definition: xsh_pfits.c:1688
xsh_pfits_set_ctype3
void xsh_pfits_set_ctype3(cpl_propertylist *plist, const char *value)
Write the CTYPE3 value.
Definition: xsh_pfits.c:2698
xsh_pfits_get_ovscy
int xsh_pfits_get_ovscy(const cpl_propertylist *plist)
find out the OVSCY value
Definition: xsh_pfits.c:408
xsh_pfits_set_shiftifu_slitupref
void xsh_pfits_set_shiftifu_slitupref(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:4089
xsh_pfits_set_wavesol_slit_min
void xsh_pfits_set_wavesol_slit_min(cpl_propertylist *plist, double value)
WRITE the min slit.
Definition: xsh_pfits.c:2781
xsh_pfits_get_cd12
double xsh_pfits_get_cd12(const cpl_propertylist *plist)
find out the cd1_2
Definition: xsh_pfits.c:2038
xsh_pfits_set_frac_range_pix
void xsh_pfits_set_frac_range_pix(cpl_propertylist *plist, double value)
Write the fraction of range pixels value.
Definition: xsh_pfits.c:1176
xsh_pfits_set_slitmap_order_edgup
void xsh_pfits_set_slitmap_order_edgup(cpl_propertylist *plist, int absorder, double value)
Definition: xsh_pfits.c:3724
xsh_pfits_set_n_range_pix
void xsh_pfits_set_n_range_pix(cpl_propertylist *plist, int value)
Write the number of range pixels value.
Definition: xsh_pfits.c:1156
xsh_pfits_set_slitmap_median_edgup
void xsh_pfits_set_slitmap_median_edgup(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:3813
xsh_pfits_set_wavemap_order_lambda_max
void xsh_pfits_set_wavemap_order_lambda_max(cpl_propertylist *plist, int absorder, double value)
Definition: xsh_pfits.c:3997
xsh_pfits_get_date_obs
const char * xsh_pfits_get_date_obs(const cpl_propertylist *plist)
find out the DATE
Definition: xsh_pfits.c:1746
xsh_pfits_set_crpix3
void xsh_pfits_set_crpix3(cpl_propertylist *plist, double value)
Write the CRPIX3 value.
Definition: xsh_pfits.c:2528
xsh_pfits_set_dpr_catg
void xsh_pfits_set_dpr_catg(cpl_propertylist *plist, const char *value)
Write the DPR CATG value.
Definition: xsh_pfits.c:1042
xsh_pfits_set_wavesol_lambda_max
void xsh_pfits_set_wavesol_lambda_max(cpl_propertylist *plist, double value)
WRITE the max lambda.
Definition: xsh_pfits.c:2730
xsh_plist_div_by_fct
cpl_error_code xsh_plist_div_by_fct(cpl_propertylist **plist, const int fctx, const int fcty)
Definition: xsh_pfits.c:4417
xsh_pfits_get_slitmap_median_slicup
double xsh_pfits_get_slitmap_median_slicup(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3946
xsh_pfits_get_tpl_start
double xsh_pfits_get_tpl_start(const cpl_propertylist *plist)
Find out the template start.
Definition: xsh_pfits.c:86
xsh_pfits_get_tel_targ_alpha
double xsh_pfits_get_tel_targ_alpha(const cpl_propertylist *plist)
Get the TEL TARG ALPHA.
Definition: xsh_pfits.c:3439
xsh_pfits_get_crpix1
double xsh_pfits_get_crpix1(const cpl_propertylist *plist)
find out the CRPIX1 value
Definition: xsh_pfits.c:1965
xsh_pfits_set_wcs1
cpl_error_code xsh_pfits_set_wcs1(cpl_propertylist *header, const double crpix1, const double crval1, const double cdelt1)
Definition: xsh_pfits.c:4307
xsh_pfits_get_geolat
double xsh_pfits_get_geolat(const cpl_propertylist *plist)
Find out the telescope latitude.
Definition: xsh_pfits.c:114
xsh_pfits_get_gain
double xsh_pfits_get_gain(const cpl_propertylist *plist)
find out the GAIN value
Definition: xsh_pfits.c:675
xsh_pfits_set_wavesoltype
void xsh_pfits_set_wavesoltype(cpl_propertylist *plist, const char *value)
Write the WAVESOL TYPE value.
Definition: xsh_pfits.c:3172
xsh_pfits_get_cd22
double xsh_pfits_get_cd22(const cpl_propertylist *plist)
find out the cd2_2
Definition: xsh_pfits.c:2077
xsh_pfits_get_slitmap_median_edgup
double xsh_pfits_get_slitmap_median_edgup(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3898
xsh_pfits_get_naxis3
int xsh_pfits_get_naxis3(const cpl_propertylist *plist)
find out the NAXIS3 value
Definition: xsh_pfits.c:260
xsh_pfits_set_slitmap_order_slicup
void xsh_pfits_set_slitmap_order_slicup(cpl_propertylist *plist, int absorder, double value)
Definition: xsh_pfits.c:3759
xsh_pfits_set_wavesol_slit_max
void xsh_pfits_set_wavesol_slit_max(cpl_propertylist *plist, double value)
WRITE the max slit.
Definition: xsh_pfits.c:2798
xsh_pfits_set_wavesol_order_max
void xsh_pfits_set_wavesol_order_max(cpl_propertylist *plist, double value)
WRITE the max order.
Definition: xsh_pfits.c:2764
xsh_pfits_get_bias_left_stdev
double xsh_pfits_get_bias_left_stdev(cpl_propertylist *plist)
find out the BIAS LEFT STDEV value
Definition: xsh_pfits.c:828
xsh_pfits_get_obs_targ_name
const char * xsh_pfits_get_obs_targ_name(const cpl_propertylist *plist)
find out the ESO.OBS.TARG.NAME
Definition: xsh_pfits.c:1569
xsh_pfits_get_crpix3
double xsh_pfits_get_crpix3(const cpl_propertylist *plist)
find out the CRPIX3 value
Definition: xsh_pfits.c:1999
xsh_pfits_get_cdelt1
double xsh_pfits_get_cdelt1(const cpl_propertylist *plist)
find out the cdelt1
Definition: xsh_pfits.c:2196
xsh_pfits_get_pszy
double xsh_pfits_get_pszy(const cpl_propertylist *plist)
find out the PSZY (size of 1 pixel in Microns)
Definition: xsh_pfits.c:1784
xsh_pfits_set_exptime
void xsh_pfits_set_exptime(cpl_propertylist *plist, double value)
Write the EXPTIME value.
Definition: xsh_pfits.c:2292
xsh_pfits_set_cunit1
void xsh_pfits_set_cunit1(cpl_propertylist *plist, const char *value)
Write the CUNIT1 value.
Definition: xsh_pfits.c:2622
xsh_pfits_set_rectify_bin_space
void xsh_pfits_set_rectify_bin_space(cpl_propertylist *plist, double value)
WRITE the space (slit) binning.
Definition: xsh_pfits.c:3204
xsh_pfits_get_cd33
double xsh_pfits_get_cd33(const cpl_propertylist *plist)
find out the cd3_3
Definition: xsh_pfits.c:2136
xsh_pfits_get_arcfile
const char * xsh_pfits_get_arcfile(const cpl_propertylist *plist)
find out the arcfile
Definition: xsh_pfits.c:1589
xsh_pfits_get_biny
int xsh_pfits_get_biny(const cpl_propertylist *plist)
find out the BINY value
Definition: xsh_pfits.c:306
xsh_pfits_get_dec_reloffset
double xsh_pfits_get_dec_reloffset(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3543
xsh_pfits_get_nod_reloffset
double xsh_pfits_get_nod_reloffset(const cpl_propertylist *plist)
Get the Relative Jitter Offset.
Definition: xsh_pfits.c:4125
xsh_pfits_get_chip_ny
int xsh_pfits_get_chip_ny(const cpl_propertylist *plist)
find out the CHIP NY value
Definition: xsh_pfits.c:340
xsh_pfits_set_dpr_type
void xsh_pfits_set_dpr_type(cpl_propertylist *plist, const char *value)
Write the DPR TYPE value.
Definition: xsh_pfits.c:1025
xsh_pfits_set_bunit
void xsh_pfits_set_bunit(cpl_propertylist *plist, const char *value)
Write the BUNIT value.
Definition: xsh_pfits.c:2606
xsh_pfits_get_dpr_tech
const char * xsh_pfits_get_dpr_tech(const cpl_propertylist *plist)
find out the DPR TECH
Definition: xsh_pfits.c:1647
xsh_pfits_get_wavesol_x_min
double xsh_pfits_get_wavesol_x_min(cpl_propertylist *plist)
find out the min x position
Definition: xsh_pfits.c:3071
xsh_pfits_get_wavesol_slit_max
double xsh_pfits_get_wavesol_slit_max(cpl_propertylist *plist)
find out the wavesol max slit
Definition: xsh_pfits.c:3014
xsh_pfits_get_slitmap_median_sliclo
double xsh_pfits_get_slitmap_median_sliclo(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3962
xsh_pfits_get_obs_id
int xsh_pfits_get_obs_id(cpl_propertylist *plist)
find out the OBS ID
Definition: xsh_pfits.c:3388
xsh_pfits_get_bias_right_median
double xsh_pfits_get_bias_right_median(cpl_propertylist *plist)
find out the BIAS RIGHT MEDIAN value
Definition: xsh_pfits.c:769
xsh_pfits_set_cd33
void xsh_pfits_set_cd33(cpl_propertylist *plist, double value)
Write the CD3_3 value.
Definition: xsh_pfits.c:2415
xsh_pfits_get_exptime
double xsh_pfits_get_exptime(const cpl_propertylist *plist)
find out the exposure time
Definition: xsh_pfits.c:2254
xsh_pfits_is_flat
int xsh_pfits_is_flat(cpl_propertylist *plist)
Definition: xsh_pfits.c:4579
xsh_pfits_get_prscx
int xsh_pfits_get_prscx(const cpl_propertylist *plist)
find out the PRSCX value
Definition: xsh_pfits.c:425
xsh_pfits_get_ra
double xsh_pfits_get_ra(const cpl_propertylist *plist)
Get the Right Ascension.
Definition: xsh_pfits.c:3479
xsh_pfits_get_ron
double xsh_pfits_get_ron(const cpl_propertylist *plist)
find out the RON value
Definition: xsh_pfits.c:459
xsh_pfits_get_cunit3
const char * xsh_pfits_get_cunit3(const cpl_propertylist *plist)
find out the CUNIT3
Definition: xsh_pfits.c:1527
xsh_pfits_set_b_ra_cumoffset
void xsh_pfits_set_b_ra_cumoffset(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:3700
xsh_pfits_set_bias_left_median
void xsh_pfits_set_bias_left_median(cpl_propertylist *plist, double value)
Write the BIAS LEFT MEDIAN value.
Definition: xsh_pfits.c:1195
xsh_pfits_get_bias_down_stdev
double xsh_pfits_get_bias_down_stdev(cpl_propertylist *plist)
find out the BIAS DOWN STDEV value
Definition: xsh_pfits.c:886
xsh_pfits_get_b_dec_cumoffset
double xsh_pfits_get_b_dec_cumoffset(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3660
xsh_pfits_get_datancom
int xsh_pfits_get_datancom(const cpl_propertylist *plist)
find out the DATANCOM value
Definition: xsh_pfits.c:712
xsh_pfits_set_slitmap_median_sliclo
void xsh_pfits_set_slitmap_median_sliclo(cpl_propertylist *plist, double value)
Definition: xsh_pfits.c:3847
xsh_frame_force_pro_catg
cpl_error_code xsh_frame_force_pro_catg(const char *fname, const char *tag)
Force a frame PRO.CATG to a given value.
Definition: xsh_pfits.c:906
xsh_pfits_get_mjdobs
double xsh_pfits_get_mjdobs(const cpl_propertylist *plist)
Find out the modified julian observation date.
Definition: xsh_pfits.c:186
xsh_pfits_get_b_dec_reloffset
double xsh_pfits_get_b_dec_reloffset(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3630
xsh_pfits_set_cunit2
void xsh_pfits_set_cunit2(cpl_propertylist *plist, const char *value)
Write the CUNIT2 value.
Definition: xsh_pfits.c:2637
xsh_pfits_get_cd21
double xsh_pfits_get_cd21(const cpl_propertylist *plist)
find out the cd2_1
Definition: xsh_pfits.c:2057
xsh_pfits_get_airm_mean
double xsh_pfits_get_airm_mean(const cpl_propertylist *plist)
find out the mean airmass value
Definition: xsh_pfits.c:511
xsh_pfits_set_rectify_lambda_min
void xsh_pfits_set_rectify_lambda_min(cpl_propertylist *plist, double value)
WRITE the lambda min value.
Definition: xsh_pfits.c:3220
xsh_pfits_combine_headers
cpl_error_code xsh_pfits_combine_headers(cpl_propertylist *header, cpl_frameset *set)
Definition: xsh_pfits.c:4431
xsh_pfits_set_bias_down_stdev
void xsh_pfits_set_bias_down_stdev(cpl_propertylist *plist, double value)
Write the BIAS DOWN STDEV value.
Definition: xsh_pfits.c:1336
xsh_pfits_set_crval3
void xsh_pfits_set_crval3(cpl_propertylist *plist, double value)
Write the CRVAL3 value.
Definition: xsh_pfits.c:2559
xsh_pfits_set_crval1
void xsh_pfits_set_crval1(cpl_propertylist *plist, double value)
Write the CRVAL1 value.
Definition: xsh_pfits.c:2480
xsh_pfits_set_wavesol_lambda_min
void xsh_pfits_set_wavesol_lambda_min(cpl_propertylist *plist, double value)
WRITE the min lambda.
Definition: xsh_pfits.c:2713
xsh_pfits_set_bias_right_stdev
void xsh_pfits_set_bias_right_stdev(cpl_propertylist *plist, double value)
Write the BIAS RIGHT STDEV value.
Definition: xsh_pfits.c:1302
xsh_pfits_set_wavesol_x_max
void xsh_pfits_set_wavesol_x_max(cpl_propertylist *plist, double value)
WRITE the max x position.
Definition: xsh_pfits.c:2867
xsh_pfits_get_naxis1
int xsh_pfits_get_naxis1(const cpl_propertylist *plist)
find out the NAXIS1 value
Definition: xsh_pfits.c:227
xsh_pfits_get_ra_reloffset
double xsh_pfits_get_ra_reloffset(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3528
xsh_pfits_set_cd_matrix
cpl_error_code xsh_pfits_set_cd_matrix(cpl_propertylist *header, const double cdelt1, const double cdelt2)
Definition: xsh_pfits.c:4349
xsh_pfits_get_FOCU1ENC
int xsh_pfits_get_FOCU1ENC(const cpl_propertylist *plist)
find out the FOCU1 POS (UVB prism auto-focus temperature)
Definition: xsh_pfits.c:1824
xsh_pfits_set_bias_down_median
void xsh_pfits_set_bias_down_median(cpl_propertylist *plist, double value)
Write the BIAS DOWN MEDIAN value.
Definition: xsh_pfits.c:1268
xsh_pfits_get_crpix2
double xsh_pfits_get_crpix2(const cpl_propertylist *plist)
find out the CRPIX2 value
Definition: xsh_pfits.c:1982
xsh_pfits_get_tpl_expno
int xsh_pfits_get_tpl_expno(const cpl_propertylist *plist)
Find out the template start.
Definition: xsh_pfits.c:72
xsh_pfits_set_cdelt2
void xsh_pfits_set_cdelt2(cpl_propertylist *plist, double value)
Write the CDELT2 value.
Definition: xsh_pfits.c:2575
xsh_pfits_get_bias_left_median
double xsh_pfits_get_bias_left_median(cpl_propertylist *plist)
find out the BIAS LEFT MEDIAN value
Definition: xsh_pfits.c:749
xsh_pfits_get_crval1
double xsh_pfits_get_crval1(const cpl_propertylist *plist)
find out the crval1
Definition: xsh_pfits.c:1907
xsh_pfits_set_crpix2
void xsh_pfits_set_crpix2(cpl_propertylist *plist, double value)
Write the CRPIX2 value.
Definition: xsh_pfits.c:2513
xsh_pfits_set_cd12
void xsh_pfits_set_cd12(cpl_propertylist *plist, double value)
Write the CD1_2 value.
Definition: xsh_pfits.c:2339
xsh_pfits_set_crval2
void xsh_pfits_set_crval2(cpl_propertylist *plist, double value)
Write the CRVAL2 value.
Definition: xsh_pfits.c:2544
xsh_pfits_get_cd23
double xsh_pfits_get_cd23(const cpl_propertylist *plist)
find out the cd2_3
Definition: xsh_pfits.c:2116
xsh_pfits_get_seeing_end
double xsh_pfits_get_seeing_end(const cpl_propertylist *plist)
find out the TEL AMBI END value (Seeing)
Definition: xsh_pfits.c:561
xsh_pfits_set_bias_up_stdev
void xsh_pfits_set_bias_up_stdev(cpl_propertylist *plist, double value)
Write the BIAS UP STDEV value.
Definition: xsh_pfits.c:1319
xsh_pfits_set_extract_slit_min
void xsh_pfits_set_extract_slit_min(cpl_propertylist *plist, double value)
WRITE the min slit for extraction.
Definition: xsh_pfits.c:2815
xsh_pfits_get_wavesoltype
const char * xsh_pfits_get_wavesoltype(const cpl_propertylist *plist)
Find out the WAVESOL TYPE.
Definition: xsh_pfits.c:3151
xsh_pfits_set_bias_left_stdev
void xsh_pfits_set_bias_left_stdev(cpl_propertylist *plist, double value)
Write the BIAS LEFT STDEV value.
Definition: xsh_pfits.c:1285
xsh_pfits_set_cd11
void xsh_pfits_set_cd11(cpl_propertylist *plist, double value)
Write the CD1_1 value.
Definition: xsh_pfits.c:2324
xsh_pfits_get_prscy
int xsh_pfits_get_prscy(const cpl_propertylist *plist)
find out the PRSCY value
Definition: xsh_pfits.c:442
xsh_pfits_get_extract_slit_min
double xsh_pfits_get_extract_slit_min(cpl_propertylist *plist)
find out the extraction min slit
Definition: xsh_pfits.c:3033
xsh_pfits_set_extract_slit_max
void xsh_pfits_set_extract_slit_max(cpl_propertylist *plist, double value)
WRITE the min slit for extraction.
Definition: xsh_pfits.c:2834
xsh_pfits_get_nod_cumoffset
double xsh_pfits_get_nod_cumoffset(const cpl_propertylist *plist)
Get the Cumulative Jitter Offset.
Definition: xsh_pfits.c:4151
xsh_pfits_get_naxis
int xsh_pfits_get_naxis(const cpl_propertylist *plist)
find out the NAXIS value
Definition: xsh_pfits.c:209
xsh_pfits_set_slitmap_order_edglo
void xsh_pfits_set_slitmap_order_edglo(cpl_propertylist *plist, int absorder, double value)
Definition: xsh_pfits.c:3742
xsh_pfits_combine_two_frames_headers
cpl_error_code xsh_pfits_combine_two_frames_headers(cpl_frame *first, cpl_frame *second)
Definition: xsh_pfits.c:4500
xsh_pfits_get_cd11
double xsh_pfits_get_cd11(const cpl_propertylist *plist)
find out the cd1_1
Definition: xsh_pfits.c:2017
xsh_pfits_get_slit_value
char * xsh_pfits_get_slit_value(const cpl_propertylist *plist, xsh_instrument *instrument)
find out the INS OPTIx NAME value (the width of the slit)
Definition: xsh_pfits.c:619
xsh_pfits_get_cumoffsety
double xsh_pfits_get_cumoffsety(const cpl_propertylist *plist)
Definition: xsh_pfits.c:3571
xsh_pfits_get_cunit1
const char * xsh_pfits_get_cunit1(const cpl_propertylist *plist)
find out the CUNIT1
Definition: xsh_pfits.c:1487
xsh_pfits_get_rectify_lambda_max
double xsh_pfits_get_rectify_lambda_max(cpl_propertylist *plist)
find out the rectify lambda max
Definition: xsh_pfits.c:3336
xsh_pfits_get_airm_start
double xsh_pfits_get_airm_start(const cpl_propertylist *plist)
find out the TEL AIRM START value
Definition: xsh_pfits.c:496
xsh_pfits_get_posangle
double xsh_pfits_get_posangle(const cpl_propertylist *plist)
find out the value of the CUMOFFSETX keyword in a header
Definition: xsh_pfits.c:172
xsh_pfits_is_obs
int xsh_pfits_is_obs(cpl_propertylist *plist)
Definition: xsh_pfits.c:4562
xsh_pfits_get_det_pxspace
double xsh_pfits_get_det_pxspace(const cpl_propertylist *plist)
find out the DET CHIP PXSPACE
Definition: xsh_pfits.c:1803
xsh_pfits_set_slitmap_order_sliclo
void xsh_pfits_set_slitmap_order_sliclo(cpl_propertylist *plist, int absorder, double value)
Definition: xsh_pfits.c:3776
xsh_pfits_get_wavesol_order_max
double xsh_pfits_get_wavesol_order_max(cpl_propertylist *plist)
find out the wavesol max order
Definition: xsh_pfits.c:2976
xsh_pfits_set_wavemap_order_lambda_min
void xsh_pfits_set_wavemap_order_lambda_min(cpl_propertylist *plist, int absorder, double value)
Definition: xsh_pfits.c:3979
xsh_pfits_set_wavesol_order_min
void xsh_pfits_set_wavesol_order_min(cpl_propertylist *plist, double value)
WRITE the min order.
Definition: xsh_pfits.c:2747
xsh_pfits_get_naxis2
int xsh_pfits_get_naxis2(const cpl_propertylist *plist)
find out the NAXIS2 value
Definition: xsh_pfits.c:244
xsh_pfits_get_crval3
double xsh_pfits_get_crval3(const cpl_propertylist *plist)
find out the crval3
Definition: xsh_pfits.c:1946
xsh_pfits_get_temp82
double xsh_pfits_get_temp82(const cpl_propertylist *plist)
find out the temp82 (NIR prisms)
Definition: xsh_pfits.c:1887
xsh_free_image
void xsh_free_image(cpl_image **i)
Deallocate an image and set the pointer to NULL.
Definition: xsh_utils.c:2116
xsh_get_property_value
cpl_error_code xsh_get_property_value(const cpl_propertylist *plist, const char *keyword, cpl_type keywordtype, void *result)
Read a property value from a property list.
Definition: xsh_utils.c:1600
xsh_free_table
void xsh_free_table(cpl_table **t)
Deallocate a table and set the pointer to NULL.
Definition: xsh_utils.c:2133
xsh_free_propertylist
void xsh_free_propertylist(cpl_propertylist **p)
Deallocate a property list and set the pointer to NULL.
Definition: xsh_utils.c:2179
xsh_free_imagelist
void xsh_free_imagelist(cpl_imagelist **i)
Deallocate an image list and set the pointer to NULL.
Definition: xsh_utils.c:2164
first
unsigned int first
Definition: irplib_error.c:88
xsh_instrument
Definition: xsh_data_instrument.h:170
xsh_data_instrument.h
XSH_ARM
XSH_ARM
Definition: xsh_data_instrument.h:133
XSH_ARM_AGC
@ XSH_ARM_AGC
Definition: xsh_data_instrument.h:137
XSH_ARM_UNDEFINED
@ XSH_ARM_UNDEFINED
Definition: xsh_data_instrument.h:138
XSH_ARM_UVB
@ XSH_ARM_UVB
Definition: xsh_data_instrument.h:134
XSH_ARM_NIR
@ XSH_ARM_NIR
Definition: xsh_data_instrument.h:136
XSH_ARM_VIS
@ XSH_ARM_VIS
Definition: xsh_data_instrument.h:135
XSH_NB_PINHOLE
#define XSH_NB_PINHOLE
Definition: xsh_data_instrument.h:63
xsh_dump.h
xsh_error.h
xsh_msg.h
xsh_pfits.h
XSH_CTYPE2
#define XSH_CTYPE2
Definition: xsh_pfits.h:106
XSH_NOD_RELATIVE_B_OFFSET_DEC
#define XSH_NOD_RELATIVE_B_OFFSET_DEC
Definition: xsh_pfits.h:237
XSH_SLIT_NIR
#define XSH_SLIT_NIR
Definition: xsh_pfits.h:138
XSH_CRVAL3
#define XSH_CRVAL3
Definition: xsh_pfits.h:102
XSH_NOD_RELATIVE_OFFSET_DEC
#define XSH_NOD_RELATIVE_OFFSET_DEC
Definition: xsh_pfits.h:231
XSH_LST
#define XSH_LST
Definition: xsh_pfits.h:83
XSH_CD12
#define XSH_CD12
Definition: xsh_pfits.h:69
XSH_CDELT2
#define XSH_CDELT2
Definition: xsh_pfits.h:97
XSH_LAMP_ON_OFF
#define XSH_LAMP_ON_OFF
Definition: xsh_pfits.h:175
XSH_TEL_TARG_DELTA
#define XSH_TEL_TARG_DELTA
Definition: xsh_pfits.h:63
XSH_PSZY
#define XSH_PSZY
Definition: xsh_pfits.h:171
XSH_OVSCX
#define XSH_OVSCX
Definition: xsh_pfits.h:157
XSH_AIRM_START
#define XSH_AIRM_START
Definition: xsh_pfits.h:130
XSH_OUT_NX
#define XSH_OUT_NX
Definition: xsh_pfits.h:149
XSH_SLITMAP_ORDER_EDGLO
#define XSH_SLITMAP_ORDER_EDGLO
Definition: xsh_pfits.h:259
XSH_WAVESOL_X_MAX
#define XSH_WAVESOL_X_MAX
Definition: xsh_pfits.h:194
XSH_BIAS_DOWN_MEDIAN
#define XSH_BIAS_DOWN_MEDIAN
Definition: xsh_pfits.h:180
XSH_QC_NPIXRANGE_C
#define XSH_QC_NPIXRANGE_C
Definition: xsh_pfits.h:253
XSH_CTYPE3
#define XSH_CTYPE3
Definition: xsh_pfits.h:107
XSH_RAW1_NAME
#define XSH_RAW1_NAME
Definition: xsh_pfits.h:118
XSH_WAVESOL_Y_MAX
#define XSH_WAVESOL_Y_MAX
Definition: xsh_pfits.h:196
XSH_DET_WIN1_UIT1
#define XSH_DET_WIN1_UIT1
Definition: xsh_pfits.h:74
XSH_SLITMAP_MEDIAN_CEN
#define XSH_SLITMAP_MEDIAN_CEN
Definition: xsh_pfits.h:266
XSH_CRVAL1
#define XSH_CRVAL1
Definition: xsh_pfits.h:100
XSH_PCATG
#define XSH_PCATG
Definition: xsh_pfits.h:185
XSH_SEQ_ARM
#define XSH_SEQ_ARM
Definition: xsh_pfits.h:173
XSH_NOD_THROW
#define XSH_NOD_THROW
Definition: xsh_pfits.h:228
XSH_TEMP82_VAL
#define XSH_TEMP82_VAL
Definition: xsh_pfits.h:142
XSH_QC_FPIXSAT_C
#define XSH_QC_FPIXSAT_C
Definition: xsh_pfits.h:243
XSH_WAVESOL_LAMBDA_MAX
#define XSH_WAVESOL_LAMBDA_MAX
Definition: xsh_pfits.h:187
XSH_CD32
#define XSH_CD32
Definition: xsh_pfits.h:80
XSH_BIAS_RIGHT_STDEV
#define XSH_BIAS_RIGHT_STDEV
Definition: xsh_pfits.h:182
XSH_PRSCX
#define XSH_PRSCX
Definition: xsh_pfits.h:159
XSH_CD23
#define XSH_CD23
Definition: xsh_pfits.h:79
XSH_QC_NPIXSAT_TOT
#define XSH_QC_NPIXSAT_TOT
Definition: xsh_pfits.h:246
XSH_BUNIT
#define XSH_BUNIT
Definition: xsh_pfits.h:113
XSH_SEEING_START
#define XSH_SEEING_START
Definition: xsh_pfits.h:133
XSH_SLITMAP_ORDER_EDGUP
#define XSH_SLITMAP_ORDER_EDGUP
Definition: xsh_pfits.h:258
XSH_DPR_TECH_MULTI_PINHOLE
#define XSH_DPR_TECH_MULTI_PINHOLE
Definition: xsh_pfits.h:220
XSH_EXPTIME
#define XSH_EXPTIME
Definition: xsh_pfits.h:125
XSH_CHIP_NY
#define XSH_CHIP_NY
Definition: xsh_pfits.h:152
XSH_WAVESOL_ORDER_MIN
#define XSH_WAVESOL_ORDER_MIN
Definition: xsh_pfits.h:188
XSH_NOD_RELATIVE_B_OFFSET_RA
#define XSH_NOD_RELATIVE_B_OFFSET_RA
Definition: xsh_pfits.h:236
XSH_RECTIFY_BIN_SPACE
#define XSH_RECTIFY_BIN_SPACE
Definition: xsh_pfits.h:203
XSH_BIAS_RIGHT_MEDIAN
#define XSH_BIAS_RIGHT_MEDIAN
Definition: xsh_pfits.h:178
XSH_TEMP5_VAL
#define XSH_TEMP5_VAL
Definition: xsh_pfits.h:144
XSH_EXTRACT_SLIT_MIN
#define XSH_EXTRACT_SLIT_MIN
Definition: xsh_pfits.h:198
XSH_SLIT_VIS
#define XSH_SLIT_VIS
Definition: xsh_pfits.h:137
XSH_NAXIS1
#define XSH_NAXIS1
Definition: xsh_pfits.h:87
XSH_PSZX
#define XSH_PSZX
Definition: xsh_pfits.h:170
XSH_RA
#define XSH_RA
Definition: xsh_pfits.h:44
XSH_SLIT_UVB
#define XSH_SLIT_UVB
Definition: xsh_pfits.h:136
XSH_SHIFTIFU_SLITDOWNREF
#define XSH_SHIFTIFU_SLITDOWNREF
Definition: xsh_pfits.h:275
XSH_PRSCY
#define XSH_PRSCY
Definition: xsh_pfits.h:160
XSH_CD11
#define XSH_CD11
Definition: xsh_pfits.h:68
XSH_RAW1_CATG
#define XSH_RAW1_CATG
Definition: xsh_pfits.h:119
XSH_SEEING_END
#define XSH_SEEING_END
Definition: xsh_pfits.h:134
XSH_DET_PXSPACE
#define XSH_DET_PXSPACE
Definition: xsh_pfits.h:164
XSH_SHIFTIFU_SLITCENREF
#define XSH_SHIFTIFU_SLITCENREF
Definition: xsh_pfits.h:276
XSH_NAXIS2
#define XSH_NAXIS2
Definition: xsh_pfits.h:88
XSH_SLITMAP_ORDER_CEN
#define XSH_SLITMAP_ORDER_CEN
Definition: xsh_pfits.h:260
XSH_NOD_RELATIVE_OFFSET_RA
#define XSH_NOD_RELATIVE_OFFSET_RA
Definition: xsh_pfits.h:232
XSH_QC_NPIXRANGE
#define XSH_QC_NPIXRANGE
Definition: xsh_pfits.h:252
XSH_SLITMAP_ORDER_SLICUP
#define XSH_SLITMAP_ORDER_SLICUP
Definition: xsh_pfits.h:261
XSH_DATE
#define XSH_DATE
Definition: xsh_pfits.h:122
XSH_PFITS_GET
#define XSH_PFITS_GET(RET, LIST, KW, TYPE)
Definition: xsh_pfits.h:377
XSH_NOD_CUMULATIVE_OFFSETY
#define XSH_NOD_CUMULATIVE_OFFSETY
Definition: xsh_pfits.h:226
XSH_CRPIX3
#define XSH_CRPIX3
Definition: xsh_pfits.h:93
XSH_CUNIT1
#define XSH_CUNIT1
Definition: xsh_pfits.h:109
XSH_QC_FPIXSAT_TOT_C
#define XSH_QC_FPIXSAT_TOT_C
Definition: xsh_pfits.h:249
XSH_EXTNAME
#define XSH_EXTNAME
Definition: xsh_pfits.h:124
XSH_DET_WIN1_DIT1
#define XSH_DET_WIN1_DIT1
Definition: xsh_pfits.h:166
XSH_DET_NDIT
#define XSH_DET_NDIT
Definition: xsh_pfits.h:168
XSH_WAVESOL_LAMBDA_MIN
#define XSH_WAVESOL_LAMBDA_MIN
Definition: xsh_pfits.h:186
XSH_WAVESOL_X_MIN
#define XSH_WAVESOL_X_MIN
Definition: xsh_pfits.h:193
XSH_QC_FPIXRANGE_C
#define XSH_QC_FPIXRANGE_C
Definition: xsh_pfits.h:255
XSH_WAVESOL_Y_MIN
#define XSH_WAVESOL_Y_MIN
Definition: xsh_pfits.h:195
XSH_BIAS_LEFT_MEDIAN
#define XSH_BIAS_LEFT_MEDIAN
Definition: xsh_pfits.h:177
XSH_QC_NPIXSAT
#define XSH_QC_NPIXSAT
Definition: xsh_pfits.h:240
XSH_ARCFILE
#define XSH_ARCFILE
Definition: xsh_pfits.h:120
XSH_CDELT1
#define XSH_CDELT1
Definition: xsh_pfits.h:96
XSH_GEOLON
#define XSH_GEOLON
Definition: xsh_pfits.h:57
XSH_QC_FPIXSAT
#define XSH_QC_FPIXSAT
Definition: xsh_pfits.h:242
XSH_NOD_CUMULATIVE_OFFSET_RA
#define XSH_NOD_CUMULATIVE_OFFSET_RA
Definition: xsh_pfits.h:223
XSH_OUT_NY
#define XSH_OUT_NY
Definition: xsh_pfits.h:150
XSH_DPR_CATG
#define XSH_DPR_CATG
Definition: xsh_pfits.h:148
XSH_WAVESOL_ORDER_MAX
#define XSH_WAVESOL_ORDER_MAX
Definition: xsh_pfits.h:189
XSH_DATANCOM
#define XSH_DATANCOM
Definition: xsh_pfits.h:208
XSH_OVSCY
#define XSH_OVSCY
Definition: xsh_pfits.h:158
XSH_WAVESOL_SLIT_MAX
#define XSH_WAVESOL_SLIT_MAX
Definition: xsh_pfits.h:191
XSH_DPR_TECH
#define XSH_DPR_TECH
Definition: xsh_pfits.h:146
XSH_RECTIFY_SPACE_MAX
#define XSH_RECTIFY_SPACE_MAX
Definition: xsh_pfits.h:207
XSH_DEC
#define XSH_DEC
Definition: xsh_pfits.h:45
XSH_CD31
#define XSH_CD31
Definition: xsh_pfits.h:78
XSH_NOD_CUMULATIVE_OFFSET_DEC
#define XSH_NOD_CUMULATIVE_OFFSET_DEC
Definition: xsh_pfits.h:222
XSH_MJDOBS
#define XSH_MJDOBS
Definition: xsh_pfits.h:39
XSH_UTC
#define XSH_UTC
Definition: xsh_pfits.h:58
XSH_TPL_START
#define XSH_TPL_START
Definition: xsh_pfits.h:53
XSH_BIAS_UP_STDEV
#define XSH_BIAS_UP_STDEV
Definition: xsh_pfits.h:183
XSH_WIN_BINY
#define XSH_WIN_BINY
Definition: xsh_pfits.h:156
XSH_CHIP_NX
#define XSH_CHIP_NX
Definition: xsh_pfits.h:151
XSH_WAVESOL_SLIT_MIN
#define XSH_WAVESOL_SLIT_MIN
Definition: xsh_pfits.h:190
XSH_QC_NPIXSAT_TOT_C
#define XSH_QC_NPIXSAT_TOT_C
Definition: xsh_pfits.h:247
XSH_WIN_BINX
#define XSH_WIN_BINX
Definition: xsh_pfits.h:155
XSH_RECTIFY_BIN_LAMBDA
#define XSH_RECTIFY_BIN_LAMBDA
Definition: xsh_pfits.h:202
XSH_CD1
#define XSH_CD1
Definition: xsh_pfits.h:66
XSH_BIAS_DOWN_STDEV
#define XSH_BIAS_DOWN_STDEV
Definition: xsh_pfits.h:184
XSH_NAXIS3
#define XSH_NAXIS3
Definition: xsh_pfits.h:89
XSH_POSANG
#define XSH_POSANG
Definition: xsh_pfits.h:233
XSH_CD21
#define XSH_CD21
Definition: xsh_pfits.h:70
XSH_FOCU1ENC_VAL
#define XSH_FOCU1ENC_VAL
Definition: xsh_pfits.h:140
XSH_AIRM_END
#define XSH_AIRM_END
Definition: xsh_pfits.h:131
XSH_NOD_JITTER_BOX
#define XSH_NOD_JITTER_BOX
Definition: xsh_pfits.h:229
XSH_CTYPE1
#define XSH_CTYPE1
Definition: xsh_pfits.h:105
XSH_TPL_END
#define XSH_TPL_END
Definition: xsh_pfits.h:54
XSH_GEOLAT
#define XSH_GEOLAT
Definition: xsh_pfits.h:56
XSH_TELESCOP
#define XSH_TELESCOP
Definition: xsh_pfits.h:60
XSH_TEMP2_VAL
#define XSH_TEMP2_VAL
Definition: xsh_pfits.h:143
XSH_CUNIT2
#define XSH_CUNIT2
Definition: xsh_pfits.h:110
XSH_SLITMAP_MEDIAN_SLICUP
#define XSH_SLITMAP_MEDIAN_SLICUP
Definition: xsh_pfits.h:267
XSH_DPR_TECH_SINGLE_PINHOLE
#define XSH_DPR_TECH_SINGLE_PINHOLE
Definition: xsh_pfits.h:219
XSH_SHIFTIFU_WAVEREF
#define XSH_SHIFTIFU_WAVEREF
Definition: xsh_pfits.h:273
XSH_CD22
#define XSH_CD22
Definition: xsh_pfits.h:71
XSH_SHIFTIFU_SLITUPREF
#define XSH_SHIFTIFU_SLITUPREF
Definition: xsh_pfits.h:277
XSH_RON
#define XSH_RON
Definition: xsh_pfits.h:161
XSH_CRVAL2
#define XSH_CRVAL2
Definition: xsh_pfits.h:101
XSH_SLITMAP_MEDIAN_EDGUP
#define XSH_SLITMAP_MEDIAN_EDGUP
Definition: xsh_pfits.h:264
XSH_SLITMAP_ORDER_SLICLO
#define XSH_SLITMAP_ORDER_SLICLO
Definition: xsh_pfits.h:262
XSH_WAVEMAP_ORDER_LAMBDA_MAX
#define XSH_WAVEMAP_ORDER_LAMBDA_MAX
Definition: xsh_pfits.h:271
XSH_BIAS_LEFT_STDEV
#define XSH_BIAS_LEFT_STDEV
Definition: xsh_pfits.h:181
XSH_OBS_TARG_NAME
#define XSH_OBS_TARG_NAME
Definition: xsh_pfits.h:128
XSH_TPL_EXPNO
#define XSH_TPL_EXPNO
Definition: xsh_pfits.h:52
XSH_RECTIFY_LAMBDA_MIN
#define XSH_RECTIFY_LAMBDA_MIN
Definition: xsh_pfits.h:204
XSH_BIAS_UP_MEDIAN
#define XSH_BIAS_UP_MEDIAN
Definition: xsh_pfits.h:179
XSH_SHIFTIFU_SLITREF
#define XSH_SHIFTIFU_SLITREF
Definition: xsh_pfits.h:274
XSH_WAVESOLTYPE
#define XSH_WAVESOLTYPE
Definition: xsh_pfits.h:212
XSH_CD33
#define XSH_CD33
Definition: xsh_pfits.h:81
XSH_DPR_TYPE
#define XSH_DPR_TYPE
Definition: xsh_pfits.h:147
XSH_SLITMAP_MEDIAN_EDGLO
#define XSH_SLITMAP_MEDIAN_EDGLO
Definition: xsh_pfits.h:265
XSH_CD13
#define XSH_CD13
Definition: xsh_pfits.h:77
XSH_CUNIT3
#define XSH_CUNIT3
Definition: xsh_pfits.h:111
XSH_WAVEMAP_ORDER_LAMBDA_MIN
#define XSH_WAVEMAP_ORDER_LAMBDA_MIN
Definition: xsh_pfits.h:270
XSH_CRPIX2
#define XSH_CRPIX2
Definition: xsh_pfits.h:92
XSH_NOD_CUMULATIVE_B_OFFSET_DEC
#define XSH_NOD_CUMULATIVE_B_OFFSET_DEC
Definition: xsh_pfits.h:239
XSH_QC_NPIXSAT_C
#define XSH_QC_NPIXSAT_C
Definition: xsh_pfits.h:241
XSH_CDELT3
#define XSH_CDELT3
Definition: xsh_pfits.h:98
XSH_DATE_OBS
#define XSH_DATE_OBS
Definition: xsh_pfits.h:123
XSH_SLITMAP_MEDIAN_SLICLO
#define XSH_SLITMAP_MEDIAN_SLICLO
Definition: xsh_pfits.h:268
XSH_NOD_CUMULATIVE_B_OFFSET_RA
#define XSH_NOD_CUMULATIVE_B_OFFSET_RA
Definition: xsh_pfits.h:238
XSH_TEL_TARG_ALPHA
#define XSH_TEL_TARG_ALPHA
Definition: xsh_pfits.h:62
XSH_NOD_CUMULATIVE_OFFSETX
#define XSH_NOD_CUMULATIVE_OFFSETX
Definition: xsh_pfits.h:225
XSH_DET_GAIN
#define XSH_DET_GAIN
Definition: xsh_pfits.h:165
XSH_CONAD
#define XSH_CONAD
Definition: xsh_pfits.h:162
XSH_CRPIX1
#define XSH_CRPIX1
Definition: xsh_pfits.h:91
XSH_RECTIFY_LAMBDA_MAX
#define XSH_RECTIFY_LAMBDA_MAX
Definition: xsh_pfits.h:205
XSH_QC_FPIXRANGE
#define XSH_QC_FPIXRANGE
Definition: xsh_pfits.h:254
XSH_RECTIFY_SPACE_MIN
#define XSH_RECTIFY_SPACE_MIN
Definition: xsh_pfits.h:206
XSH_QC_FPIXSAT_TOT
#define XSH_QC_FPIXSAT_TOT
Definition: xsh_pfits.h:248
XSH_DET_DIT
#define XSH_DET_DIT
Definition: xsh_pfits.h:167
XSH_OBS_ID
#define XSH_OBS_ID
Definition: xsh_pfits.h:127
XSH_NAXIS
#define XSH_NAXIS
Definition: xsh_pfits.h:41
XSH_EXTRACT_SLIT_MAX
#define XSH_EXTRACT_SLIT_MAX
Definition: xsh_pfits.h:199
xsh_qc_handling.h
xsh_utils.h
Generated by doxygen 1.9.6