00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifdef HAVE_CONFIG_H
00028 #include <config.h>
00029 #endif
00030
00031
00032
00033
00034 #include <math.h>
00035
00036 #include <xsh_dump.h>
00037 #include <xsh_utils.h>
00038 #include <xsh_error.h>
00039 #include <xsh_msg.h>
00040 #include <xsh_qc_handling.h>
00041 #include <xsh_data_instrument.h>
00042 #include <xsh_pfits.h>
00043 #include <string.h>
00044 #include <cpl.h>
00045 #include <stdbool.h>
00046
00054
00055
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00073
00074 double xsh_pfits_get_geolat(const cpl_propertylist * plist)
00075 {
00076 double returnvalue = 0;
00077 returnvalue=cpl_propertylist_get_double(plist,XSH_GEOLAT);
00078 return returnvalue;
00079 }
00080
00081
00087
00088 double xsh_pfits_get_geolon(const cpl_propertylist * plist)
00089 {
00090 double returnvalue = 0;
00091 returnvalue=cpl_propertylist_get_double(plist,XSH_GEOLON);
00092 return returnvalue;
00093 }
00094
00095
00101
00102 double xsh_pfits_get_utc(const cpl_propertylist * plist)
00103 {
00104 double returnvalue = 0;
00105 returnvalue=cpl_propertylist_get_double(plist,XSH_UTC);
00106 return returnvalue;
00107 }
00108
00109
00110
00111
00117
00118 double xsh_pfits_get_pixscale(const cpl_propertylist * plist)
00119 {
00120 const char* val=NULL;
00121 val=cpl_propertylist_get_string(plist,"ESO INS OPTI1 NAME");
00122 return atof(val);
00123 }
00124
00125
00131
00132 double xsh_pfits_get_posangle(const cpl_propertylist * plist)
00133 {
00134 return cpl_propertylist_get_double(plist,"ESO ADA POSANG");
00135 }
00136
00137
00138
00139
00145
00146 double xsh_pfits_get_mjdobs(const cpl_propertylist * plist)
00147 {
00148 double returnvalue = 0;
00149
00150 check_msg(xsh_get_property_value(plist, XSH_MJDOBS,
00151 CPL_TYPE_DOUBLE, &returnvalue),
00152 "Error reading keyword '%s'", XSH_MJDOBS);
00153
00154 cleanup:
00155 return returnvalue;
00156 }
00157
00158
00159
00160
00161
00167
00168
00169 int xsh_pfits_get_naxis (const cpl_propertylist * plist)
00170 {
00171 int ret = 0;
00172
00173 XSH_PFITS_GET( ret, plist, XSH_NAXIS, CPL_TYPE_INT);
00174
00175 cleanup:
00176 return ret;
00177 }
00178
00179
00185
00186 int
00187 xsh_pfits_get_naxis1 (const cpl_propertylist * plist)
00188 {
00189 int ret = 0;
00190
00191 XSH_PFITS_GET( ret, plist, XSH_NAXIS1, CPL_TYPE_INT);
00192
00193 cleanup:
00194 return ret;
00195 }
00196
00197
00203
00204 int xsh_pfits_get_naxis2 (const cpl_propertylist * plist)
00205 {
00206 int ret = 0;
00207
00208 XSH_PFITS_GET( ret, plist, XSH_NAXIS2, CPL_TYPE_INT);
00209
00210 cleanup:
00211 return ret;
00212 }
00213
00219
00220 int xsh_pfits_get_naxis3(const cpl_propertylist * plist)
00221 {
00222 int ret = 0;
00223
00224 XSH_PFITS_GET( ret, plist, XSH_NAXIS3, CPL_TYPE_INT);
00225
00226 cleanup:
00227 return ret;
00228 }
00229
00230 XSH_ARM xsh_pfits_get_arm( const cpl_propertylist * plist)
00231 {
00232 XSH_ARM ret = XSH_ARM_UNDEFINED;
00233 const char *arm = "";
00234
00235 XSH_PFITS_GET( arm, plist, XSH_SEQ_ARM, CPL_TYPE_STRING ) ;
00236 ret = xsh_arm_get( arm ) ;
00237
00238 cleanup:
00239 return ret ;
00240 }
00241
00242
00248
00249 int xsh_pfits_get_binx(const cpl_propertylist * plist)
00250 {
00251 int ret = 0;
00252
00253 XSH_PFITS_GET( ret, plist, XSH_WIN_BINX, CPL_TYPE_INT);
00254
00255 cleanup:
00256 return ret;
00257 }
00258
00259
00265
00266 int xsh_pfits_get_biny(const cpl_propertylist * plist)
00267 {
00268 int ret = 0;
00269
00270 XSH_PFITS_GET( ret, plist, XSH_WIN_BINY, CPL_TYPE_INT);
00271
00272 cleanup:
00273 return ret;
00274 }
00275
00276
00282
00283 int xsh_pfits_get_chip_nx (const cpl_propertylist * plist)
00284 {
00285 int ret = 0;
00286
00287 XSH_PFITS_GET( ret, plist, XSH_CHIP_NX, CPL_TYPE_INT);
00288
00289 cleanup:
00290 return ret;
00291 }
00292
00293
00299
00300 int xsh_pfits_get_chip_ny (const cpl_propertylist * plist)
00301 {
00302 int ret = 0;
00303
00304 XSH_PFITS_GET( ret, plist, XSH_CHIP_NY, CPL_TYPE_INT);
00305
00306 cleanup:
00307 return ret;
00308 }
00309
00310
00316
00317 int xsh_pfits_get_out_nx (const cpl_propertylist * plist)
00318 {
00319 int ret = 0;
00320
00321 XSH_PFITS_GET( ret, plist, XSH_OUT_NX, CPL_TYPE_INT);
00322
00323 cleanup:
00324 return ret;
00325 }
00326
00327
00333
00334 int xsh_pfits_get_out_ny (const cpl_propertylist * plist)
00335 {
00336 int ret = 0;
00337
00338 XSH_PFITS_GET( ret, plist, XSH_OUT_NY, CPL_TYPE_INT);
00339
00340 cleanup:
00341 return ret;
00342 }
00343
00344
00350
00351 int xsh_pfits_get_ovscx (const cpl_propertylist * plist)
00352 {
00353 int ret = 0;
00354
00355 XSH_PFITS_GET( ret, plist, XSH_OVSCX, CPL_TYPE_INT);
00356
00357 cleanup:
00358 return ret;
00359 }
00360
00361
00367
00368 int xsh_pfits_get_ovscy (const cpl_propertylist * plist)
00369 {
00370 int ret = 0;
00371
00372 XSH_PFITS_GET( ret, plist, XSH_OVSCY, CPL_TYPE_INT);
00373
00374 cleanup:
00375 return ret;
00376 }
00377
00378
00384
00385 int xsh_pfits_get_prscx (const cpl_propertylist * plist)
00386 {
00387 int ret = 0;
00388
00389 XSH_PFITS_GET( ret, plist, XSH_PRSCX, CPL_TYPE_INT);
00390
00391 cleanup:
00392 return ret;
00393 }
00394
00395
00401
00402 int xsh_pfits_get_prscy (const cpl_propertylist * plist)
00403 {
00404 int ret = 0;
00405
00406 XSH_PFITS_GET( ret, plist, XSH_PRSCY, CPL_TYPE_INT);
00407
00408 cleanup:
00409 return ret;
00410 }
00411
00412
00418
00419 double xsh_pfits_get_ron (const cpl_propertylist * plist)
00420 {
00421 double ret = 0;
00422
00423 XSH_PFITS_GET( ret, plist, XSH_RON, CPL_TYPE_DOUBLE);
00424
00425 cleanup:
00426 return ret;
00427 }
00428
00429
00430
00431
00437
00438 double xsh_pfits_get_lst (const cpl_propertylist * plist)
00439 {
00440 double ret = 0;
00441
00442 XSH_PFITS_GET( ret, plist, XSH_LST, CPL_TYPE_DOUBLE);
00443
00444 cleanup:
00445 return ret;
00446 }
00447
00448
00449
00455
00456 double xsh_pfits_get_airm_start (const cpl_propertylist * plist)
00457 {
00458 double ret = 1. ;
00459
00460 xsh_get_property_value( plist, XSH_AIRM_START, CPL_TYPE_DOUBLE, &ret ) ;
00461
00462 return ret;
00463 }
00464
00470
00471 double xsh_pfits_get_airm_mean (const cpl_propertylist * plist)
00472 {
00473 double airmass_start=0;
00474 double airmass_end=0;
00475 airmass_start = xsh_pfits_get_airm_start(plist);
00476 airmass_end = xsh_pfits_get_airm_end(plist);
00477
00478 return 0.5*(airmass_start+airmass_end);
00479 }
00480
00486
00487 double xsh_pfits_get_airm_end (const cpl_propertylist * plist)
00488 {
00489 double ret = 1. ;
00490
00491 xsh_get_property_value( plist, XSH_AIRM_END, CPL_TYPE_DOUBLE, &ret ) ;
00492
00493 return ret;
00494 }
00495
00496
00497
00503
00504 double xsh_pfits_get_seeing_start (const cpl_propertylist * plist)
00505 {
00506 double ret = 0;
00507
00508 XSH_PFITS_GET( ret, plist, XSH_SEEING_START, CPL_TYPE_DOUBLE);
00509
00510 cleanup:
00511 return ret;
00512 }
00513
00514
00520
00521 double xsh_pfits_get_seeing_end (const cpl_propertylist * plist)
00522 {
00523 double ret = 0;
00524
00525 XSH_PFITS_GET( ret, plist, XSH_SEEING_END, CPL_TYPE_DOUBLE);
00526
00527 cleanup:
00528 return ret;
00529 }
00530
00531
00539
00540 double xsh_pfits_get_slit_width (const cpl_propertylist * plist,
00541 xsh_instrument * instrument )
00542 {
00543 char * str ;
00544 double ret = 0;
00545 XSH_ARM arm ;
00546
00547 arm = xsh_instrument_get_arm( instrument ) ;
00548
00549 switch ( arm ) {
00550 case XSH_ARM_UVB:
00551 XSH_PFITS_GET( str, plist, XSH_SLIT_UVB, CPL_TYPE_STRING);
00552 break ;
00553 case XSH_ARM_VIS:
00554 XSH_PFITS_GET( str, plist, XSH_SLIT_VIS, CPL_TYPE_STRING);
00555 break ;
00556 case XSH_ARM_NIR:
00557 XSH_PFITS_GET( str, plist, XSH_SLIT_NIR, CPL_TYPE_STRING);
00558 break ;
00559 case XSH_ARM_UNDEFINED:
00560 xsh_msg("arm undefined");
00561 break;
00562 }
00563 sscanf( str, "%lf", &ret ) ;
00564 cleanup:
00565 return ret;
00566 }
00567
00568
00569
00577
00578 char* xsh_pfits_get_slit_value (const cpl_propertylist * plist,
00579 xsh_instrument * instrument )
00580 {
00581 char * str ;
00582 XSH_ARM arm ;
00583
00584 arm = xsh_instrument_get_arm( instrument ) ;
00585
00586 switch ( arm ) {
00587 case XSH_ARM_UVB:
00588 XSH_PFITS_GET( str, plist, XSH_SLIT_UVB, CPL_TYPE_STRING);
00589 break ;
00590 case XSH_ARM_VIS:
00591 XSH_PFITS_GET( str, plist, XSH_SLIT_VIS, CPL_TYPE_STRING);
00592 break ;
00593 case XSH_ARM_NIR:
00594 XSH_PFITS_GET( str, plist, XSH_SLIT_NIR, CPL_TYPE_STRING);
00595 break ;
00596 case XSH_ARM_UNDEFINED:
00597 xsh_msg("arm undefined");
00598 break;
00599 }
00600
00601 cleanup:
00602 return str;
00603 }
00604
00605
00606
00607
00614
00615 const char* xsh_pfits_get_telescop (const cpl_propertylist * plist)
00616 {
00617 const char * tel ;
00618 check_msg (xsh_get_property_value(plist, XSH_TELESCOP, CPL_TYPE_STRING, &tel),
00619 "Error reading keyword '%s'", XSH_TELESCOP);
00620
00621 cleanup:
00622 return tel;
00623 }
00624
00625
00626
00632
00633 double xsh_pfits_get_gain (const cpl_propertylist * plist)
00634 {
00635 double ret = 0;
00636
00637 XSH_PFITS_GET( ret, plist, XSH_DET_GAIN, CPL_TYPE_DOUBLE);
00638
00639 cleanup:
00640 return ret;
00641 }
00642
00643
00649
00650 double xsh_pfits_get_conad (const cpl_propertylist * plist)
00651 {
00652 double ret = 0;
00653
00654 XSH_PFITS_GET( ret, plist, XSH_CONAD, CPL_TYPE_DOUBLE);
00655
00656 cleanup:
00657 return ret;
00658 }
00659
00660
00669
00670 int xsh_pfits_get_datancom( const cpl_propertylist *plist)
00671 {
00672 int ret = 0;
00673
00674 XSH_PFITS_GET( ret, plist, XSH_DATANCOM, CPL_TYPE_INT);
00675
00676 cleanup:
00677 return ret;
00678 }
00679
00680
00686
00687 double
00688 xsh_pfits_get_det_gain (const cpl_propertylist * plist)
00689 {
00690 double returnvalue = 0;
00691
00692 check_msg (xsh_get_property_value (plist, XSH_DET_GAIN, CPL_TYPE_DOUBLE,
00693 &returnvalue),
00694 "Error reading keyword '%s'", XSH_DET_GAIN);
00695
00696 cleanup:
00697 return returnvalue;
00698 }
00699
00700
00706
00707 double xsh_pfits_get_bias_left_median(cpl_propertylist * plist)
00708 {
00709 double returnvalue = 0;
00710
00711 check_msg (xsh_get_property_value (plist, XSH_BIAS_LEFT_MEDIAN,
00712 CPL_TYPE_DOUBLE,&returnvalue),
00713 "Error reading keyword '%s'", XSH_BIAS_LEFT_MEDIAN);
00714
00715 cleanup:
00716 return returnvalue;
00717 }
00718
00719
00720
00726
00727 double xsh_pfits_get_bias_right_median(cpl_propertylist * plist)
00728 {
00729 double returnvalue = 0;
00730
00731 check_msg (xsh_get_property_value (plist, XSH_BIAS_RIGHT_MEDIAN,
00732 CPL_TYPE_DOUBLE,&returnvalue),
00733 "Error reading keyword '%s'", XSH_BIAS_RIGHT_MEDIAN);
00734
00735 cleanup:
00736 return returnvalue;
00737 }
00738
00739
00745
00746 double xsh_pfits_get_bias_up_median(cpl_propertylist * plist)
00747 {
00748 double returnvalue = 0;
00749
00750 check_msg (xsh_get_property_value (plist, XSH_BIAS_UP_MEDIAN,
00751 CPL_TYPE_DOUBLE,&returnvalue),
00752 "Error reading keyword '%s'", XSH_BIAS_UP_MEDIAN);
00753
00754 cleanup:
00755 return returnvalue;
00756 }
00757
00758
00759
00765
00766 double xsh_pfits_get_bias_down_median(cpl_propertylist * plist)
00767 {
00768 double returnvalue = 0;
00769
00770 check_msg (xsh_get_property_value (plist, XSH_BIAS_DOWN_MEDIAN,
00771 CPL_TYPE_DOUBLE,&returnvalue),
00772 "Error reading keyword '%s'", XSH_BIAS_DOWN_MEDIAN);
00773
00774 cleanup:
00775 return returnvalue;
00776 }
00777
00778
00784
00785
00786 double xsh_pfits_get_bias_left_stdev(cpl_propertylist * plist)
00787 {
00788 double returnvalue = 0;
00789
00790 check_msg (xsh_get_property_value (plist, XSH_BIAS_LEFT_STDEV,
00791 CPL_TYPE_DOUBLE,&returnvalue),
00792 "Error reading keyword '%s'", XSH_BIAS_LEFT_STDEV);
00793
00794 cleanup:
00795 return returnvalue;
00796 }
00797
00798
00804
00805 double xsh_pfits_get_bias_right_stdev(cpl_propertylist * plist)
00806 {
00807 double returnvalue = 0;
00808
00809 check_msg (xsh_get_property_value (plist, XSH_BIAS_RIGHT_STDEV,
00810 CPL_TYPE_DOUBLE,&returnvalue),
00811 "Error reading keyword '%s'", XSH_BIAS_RIGHT_STDEV);
00812
00813 cleanup:
00814 return returnvalue;
00815 }
00816
00817
00823
00824
00825 double xsh_pfits_get_bias_up_stdev(cpl_propertylist * plist)
00826 {
00827 double returnvalue = 0;
00828
00829 check_msg (xsh_get_property_value (plist, XSH_BIAS_UP_STDEV,
00830 CPL_TYPE_DOUBLE,&returnvalue),
00831 "Error reading keyword '%s'", XSH_BIAS_UP_STDEV);
00832
00833 cleanup:
00834 return returnvalue;
00835 }
00836
00837
00843
00844 double xsh_pfits_get_bias_down_stdev(cpl_propertylist * plist)
00845 {
00846 double returnvalue = 0;
00847
00848 check_msg (xsh_get_property_value (plist, XSH_BIAS_DOWN_STDEV,
00849 CPL_TYPE_DOUBLE,&returnvalue),
00850 "Error reading keyword '%s'", XSH_BIAS_DOWN_STDEV);
00851
00852 cleanup:
00853 return returnvalue;
00854 }
00855
00863 cpl_error_code
00864 xsh_frame_force_pro_catg(const char* fname,
00865 const char* tag) {
00866
00867
00868 cpl_propertylist* plist=NULL;
00869 int naxis=0;
00870 int update=0;
00871 const char* current_tag=NULL;
00872 cpl_table* tab=NULL;
00873 cpl_image* ima=NULL;
00874 cpl_imagelist* iml=NULL;
00875
00876
00877
00878 check(plist=cpl_propertylist_load(fname,0));
00879 check(naxis=xsh_pfits_get_naxis(plist));
00880 if(cpl_propertylist_has(plist,XSH_PCATG)) {
00881
00882 check(current_tag=cpl_propertylist_get_string(plist,XSH_PCATG));
00883 if(strcmp(current_tag,tag)!= 0) {
00884 check(cpl_propertylist_set_string(plist,XSH_PCATG,tag)) ;
00885 update=1;
00886 }
00887
00888 } else {
00889 check(cpl_propertylist_append_string(plist,XSH_PCATG,tag)) ;
00890 update=1;
00891 }
00892
00893 if(update) {
00894 check(naxis=xsh_pfits_get_naxis(plist));
00895 switch (naxis) {
00896 case 0:
00897 check(tab=cpl_table_load(fname,1,0));
00898 check(cpl_table_save(tab,plist,NULL,fname,CPL_IO_DEFAULT));
00899 xsh_free_table(&tab);
00900 break;
00901 case 1:
00902 case 2:
00903 check(ima=cpl_image_load(fname,CPL_TYPE_FLOAT,0,0));
00904 check(cpl_image_save(ima,fname,CPL_BPP_IEEE_FLOAT,plist,CPL_IO_DEFAULT));
00905 xsh_free_image(&ima);
00906 break;
00907 case 3:
00908 check(iml=cpl_imagelist_load(fname,CPL_TYPE_FLOAT,0));
00909 check(cpl_image_save(ima,fname,CPL_BPP_IEEE_FLOAT,plist,CPL_IO_DEFAULT));
00910 xsh_free_imagelist(&iml);
00911 break;
00912 default:
00913 xsh_msg_error("naxis=%d not supported",naxis);
00914 }
00915
00916 }
00917
00918 cleanup:
00919 xsh_free_propertylist(&plist);
00920 xsh_free_table(&tab);
00921 xsh_free_image(&ima);
00922 xsh_free_imagelist(&iml);
00923
00924 return cpl_error_get_code();
00925
00926 }
00927
00928
00929
00935
00936 void
00937 xsh_pfits_set_extname (cpl_propertylist * plist, const char *value)
00938 {
00939 check_msg (cpl_propertylist_update_string (plist, XSH_EXTNAME, value),
00940 "Error writing keyword '%s'", XSH_EXTNAME);
00941 cleanup:
00942 return;
00943 }
00944
00945
00946 void xsh_pfits_set_arm( cpl_propertylist * plist, xsh_instrument* instr)
00947 {
00948
00949 const char* value = NULL;
00950
00951 check( value = xsh_instrument_arm_tostring( instr));
00952 check_msg (cpl_propertylist_update_string (plist, XSH_SEQ_ARM, value),
00953 "Error writing keyword '%s'", XSH_SEQ_ARM);
00954
00955 cleanup:
00956 return;
00957 }
00958
00964
00965 void
00966 xsh_pfits_set_pcatg (cpl_propertylist * plist, const char *value)
00967 {
00968 check_msg (cpl_propertylist_update_string (plist, XSH_PCATG, value),
00969 "Error writing keyword '%s'", XSH_PCATG);
00970 cleanup:
00971 return;
00972 }
00973
00974
00975
00981
00982 void
00983 xsh_pfits_set_dpr_type (cpl_propertylist * plist, const char *value)
00984 {
00985 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_TYPE, value),
00986 "Error writing keyword '%s'", XSH_DPR_TYPE);
00987 cleanup:
00988 return;
00989 }
00990
00991
00992
00998
00999 void
01000 xsh_pfits_set_dpr_catg (cpl_propertylist * plist, const char *value)
01001 {
01002 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_CATG, value),
01003 "Error writing keyword '%s'", XSH_DPR_CATG);
01004 cleanup:
01005 return;
01006 }
01007
01008
01009
01015
01016 void
01017 xsh_pfits_set_dpr_tech (cpl_propertylist * plist, const char *value)
01018 {
01019 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_TECH, value),
01020 "Error writing keyword '%s'", XSH_DPR_TECH);
01021 cleanup:
01022 return;
01023 }
01024
01025
01026
01032
01033 void
01034 xsh_pfits_set_nsat(cpl_propertylist * plist, int value)
01035 {
01036 check_msg (cpl_propertylist_update_double
01037 (plist, XSH_QC_NPIXSAT, value),
01038 "Error writing keyword '%s'", XSH_QC_NPIXSAT);
01039 cpl_propertylist_set_comment(plist, XSH_QC_NPIXSAT, XSH_QC_NPIXSAT_C);
01040
01041 cleanup:
01042 return;
01043 }
01044
01045
01046
01052
01053 void
01054 xsh_pfits_set_frac_sat(cpl_propertylist * plist, double value)
01055 {
01056 check_msg (cpl_propertylist_update_double
01057 (plist, XSH_QC_FPIXSAT, value),
01058 "Error writing keyword '%s'", XSH_QC_FPIXSAT);
01059 cpl_propertylist_set_comment(plist, XSH_QC_FPIXSAT, XSH_QC_FPIXSAT_C);
01060 cleanup:
01061 return;
01062 }
01063
01064
01065
01071
01072 void
01073 xsh_pfits_set_bias_left_median (cpl_propertylist * plist, double value)
01074 {
01075 check_msg (cpl_propertylist_update_double
01076 (plist, XSH_BIAS_LEFT_MEDIAN, value),
01077 "Error writing keyword '%s'", XSH_BIAS_LEFT_MEDIAN);
01078 cleanup:
01079 return;
01080 }
01081
01082
01088
01089 void
01090 xsh_pfits_set_bias_right_median (cpl_propertylist * plist, double value)
01091 {
01092 check_msg (cpl_propertylist_update_double
01093 (plist, XSH_BIAS_RIGHT_MEDIAN, value),
01094 "Error writing keyword '%s'", XSH_BIAS_RIGHT_MEDIAN);
01095 cleanup:
01096 return;
01097 }
01098
01099
01105
01106 void
01107 xsh_pfits_set_bias_up_median (cpl_propertylist * plist, double value)
01108 {
01109 check_msg (cpl_propertylist_update_double
01110 (plist, XSH_BIAS_UP_MEDIAN, value),
01111 "Error writing keyword '%s'", XSH_BIAS_UP_MEDIAN);
01112 cleanup:
01113 return;
01114 }
01115
01116
01117
01118
01119
01120
01121
01122
01123
01124
01125
01126 void
01127 xsh_pfits_set_datancom (cpl_propertylist * plist, int value)
01128 {
01129 check_msg (cpl_propertylist_update_int
01130 (plist, XSH_DATANCOM, value),
01131 "Error writing keyword '%s'", XSH_DATANCOM);
01132 cleanup:
01133 return;
01134 }
01135
01136
01137
01138
01144
01145 void
01146 xsh_pfits_set_bias_down_median (cpl_propertylist * plist, double value)
01147 {
01148 check_msg (cpl_propertylist_update_double
01149 (plist, XSH_BIAS_DOWN_MEDIAN, value),
01150 "Error writing keyword '%s'", XSH_BIAS_DOWN_MEDIAN);
01151 cleanup:
01152 return;
01153 }
01154
01155
01161
01162 void
01163 xsh_pfits_set_bias_left_stdev (cpl_propertylist * plist, double value)
01164 {
01165 check_msg (cpl_propertylist_update_double
01166 (plist, XSH_BIAS_LEFT_STDEV, value), "Error writing keyword '%s'",
01167 XSH_BIAS_LEFT_STDEV);
01168 cleanup:
01169 return;
01170 }
01171
01172
01178
01179 void
01180 xsh_pfits_set_bias_right_stdev (cpl_propertylist * plist, double value)
01181 {
01182 check_msg (cpl_propertylist_update_double
01183 (plist, XSH_BIAS_RIGHT_STDEV, value), "Error writing keyword '%s'",
01184 XSH_BIAS_RIGHT_STDEV);
01185 cleanup:
01186 return;
01187 }
01188
01189
01195
01196 void
01197 xsh_pfits_set_bias_up_stdev (cpl_propertylist * plist, double value)
01198 {
01199 check_msg (cpl_propertylist_update_double
01200 (plist, XSH_BIAS_UP_STDEV, value), "Error writing keyword '%s'",
01201 XSH_BIAS_UP_STDEV);
01202 cleanup:
01203 return;
01204 }
01205
01206
01212
01213 void
01214 xsh_pfits_set_bias_down_stdev (cpl_propertylist * plist, double value)
01215 {
01216 check_msg (cpl_propertylist_update_double
01217 (plist, XSH_BIAS_DOWN_STDEV, value), "Error writing keyword '%s'",
01218 XSH_BIAS_DOWN_STDEV);
01219 cleanup:
01220 return;
01221 }
01222
01228
01229 void
01230 xsh_pfits_set_dit (cpl_propertylist * plist, double dit)
01231 {
01232 check_msg (cpl_propertylist_update_double (plist, XSH_DET_DIT, dit),
01233 "Error writing keyword '%s'", XSH_DET_DIT);
01234
01235 cleanup:
01236 return;
01237 }
01238
01244
01245 double
01246 xsh_pfits_get_win1_dit1 (const cpl_propertylist * plist)
01247 {
01248 double returnvalue = 0;
01249
01250 check_msg (xsh_get_property_value
01251 (plist, XSH_DET_WIN1_DIT1, CPL_TYPE_DOUBLE, &returnvalue),
01252 "Error reading keyword '%s'", XSH_DET_WIN1_DIT1);
01253
01254 cleanup:
01255 return returnvalue;
01256 }
01257
01258
01264
01265 double
01266 xsh_pfits_get_dit (const cpl_propertylist * plist)
01267 {
01268 double returnvalue = 0;
01269
01270 check_msg (xsh_get_property_value
01271 (plist, XSH_DET_DIT, CPL_TYPE_DOUBLE, &returnvalue),
01272 "Error reading keyword '%s'", XSH_DET_DIT);
01273
01274 cleanup:
01275 return returnvalue;
01276 }
01277
01278
01284
01285 const char *
01286 xsh_pfits_get_raw1name (const cpl_propertylist * plist)
01287 {
01288 const char *returnvalue = "";
01289
01290 check_msg (xsh_get_property_value
01291 (plist, XSH_RAW1_NAME, CPL_TYPE_STRING, &returnvalue),
01292 "Error reading keyword '%s'", XSH_RAW1_NAME);
01293
01294 cleanup:
01295 return returnvalue;
01296 }
01297
01298
01299
01305
01306 const char *
01307 xsh_pfits_get_bunit (const cpl_propertylist * plist)
01308 {
01309 const char *returnvalue = "";
01310
01311 check_msg (xsh_get_property_value
01312 (plist, XSH_BUNIT, CPL_TYPE_STRING, &returnvalue),
01313 "Error reading keyword '%s'", XSH_BUNIT);
01314
01315 cleanup:
01316 return returnvalue;
01317 }
01318
01319
01325
01326 const char *
01327 xsh_pfits_get_cunit1 (const cpl_propertylist * plist)
01328 {
01329 const char *returnvalue = "";
01330
01331 check_msg (xsh_get_property_value
01332 (plist, XSH_CUNIT1, CPL_TYPE_STRING, &returnvalue),
01333 "Error reading keyword '%s'", XSH_CUNIT1);
01334
01335 cleanup:
01336 return returnvalue;
01337 }
01338
01339
01345
01346 const char *
01347 xsh_pfits_get_cunit2 (const cpl_propertylist * plist)
01348 {
01349 const char *returnvalue = "";
01350
01351 check_msg (xsh_get_property_value
01352 (plist, XSH_CUNIT2, CPL_TYPE_STRING, &returnvalue),
01353 "Error reading keyword '%s'", XSH_CUNIT2);
01354
01355 cleanup:
01356 return returnvalue;
01357 }
01358
01359
01365
01366 const char *
01367 xsh_pfits_get_cunit3 (const cpl_propertylist * plist)
01368 {
01369 const char *returnvalue = "";
01370
01371 check_msg (xsh_get_property_value
01372 (plist, XSH_CUNIT3, CPL_TYPE_STRING, &returnvalue),
01373 "Error reading keyword '%s'", XSH_CUNIT3);
01374
01375 cleanup:
01376 return returnvalue;
01377 }
01378
01379
01380
01386
01387 const char *
01388 xsh_pfits_get_raw1catg (const cpl_propertylist * plist)
01389 {
01390 const char *returnvalue = "";
01391
01392 check_msg (xsh_get_property_value
01393 (plist, XSH_RAW1_CATG, CPL_TYPE_STRING, &returnvalue),
01394 "Error reading keyword '%s'", XSH_RAW1_CATG);
01395
01396 cleanup:
01397 return returnvalue;
01398 }
01399
01400
01401
01407
01408 const char *
01409 xsh_pfits_get_obs_targ_name (const cpl_propertylist * plist)
01410 {
01411 const char *returnvalue = "";
01412
01413 check_msg (xsh_get_property_value
01414 (plist, XSH_OBS_TARG_NAME, CPL_TYPE_STRING, &returnvalue),
01415 "Error reading keyword '%s'", XSH_OBS_TARG_NAME);
01416
01417 cleanup:
01418 return returnvalue;
01419 }
01420
01421
01427
01428 const char *
01429 xsh_pfits_get_arcfile (const cpl_propertylist * plist)
01430 {
01431 const char *returnvalue = "";
01432
01433 check_msg (xsh_get_property_value
01434 (plist, XSH_ARCFILE, CPL_TYPE_STRING, &returnvalue),
01435 "Error reading keyword '%s'", XSH_ARCFILE);
01436
01437 cleanup:
01438 return returnvalue;
01439 }
01445
01446 bool
01447 xsh_pfits_get_lamp_on_off (const cpl_propertylist * plist)
01448 {
01449 const char *returnvalue = "";
01450
01451 check_msg (xsh_get_property_value
01452 (plist, XSH_LAMP_ON_OFF, CPL_TYPE_BOOL, &returnvalue),
01453 "Error reading keyword '%s'", XSH_LAMP_ON_OFF);
01454
01455 cleanup:
01456 return returnvalue;
01457 }
01458
01459
01465
01466 const char *
01467 xsh_pfits_get_pcatg (const cpl_propertylist * plist)
01468 {
01469 const char *returnvalue = "";
01470
01471 check_msg (xsh_get_property_value
01472 (plist, XSH_PCATG, CPL_TYPE_STRING, &returnvalue),
01473 "Error reading keyword '%s'", XSH_PCATG);
01474 cleanup:
01475 return returnvalue;
01476 }
01477
01478
01479
01485
01486 const char *
01487 xsh_pfits_get_dpr_tech (const cpl_propertylist * plist)
01488 {
01489 const char *returnvalue = "";
01490
01491 check_msg (xsh_get_property_value
01492 (plist, XSH_DPR_TECH, CPL_TYPE_STRING, &returnvalue),
01493 "Error reading keyword '%s'", XSH_DPR_TECH);
01494 cleanup:
01495 return returnvalue;
01496 }
01497
01498
01499
01505
01506 const char *
01507 xsh_pfits_get_dpr_type (const cpl_propertylist * plist)
01508 {
01509 const char *returnvalue = "";
01510
01511 check_msg (xsh_get_property_value
01512 (plist, XSH_DPR_TYPE, CPL_TYPE_STRING, &returnvalue),
01513 "Error reading keyword '%s'", XSH_DPR_TYPE);
01514 cleanup:
01515 return returnvalue;
01516 }
01517
01518
01519
01520
01526
01527 const char *
01528 xsh_pfits_get_dpr_catg (const cpl_propertylist * plist)
01529 {
01530 const char *returnvalue = "";
01531
01532 check_msg (xsh_get_property_value
01533 (plist, XSH_DPR_CATG, CPL_TYPE_STRING, &returnvalue),
01534 "Error reading keyword '%s'", XSH_DPR_CATG);
01535 cleanup:
01536 return returnvalue;
01537 }
01538
01539
01545
01546 const char *
01547 xsh_pfits_get_extname (const cpl_propertylist * plist)
01548 {
01549 const char *returnvalue = "";
01550
01551 check_msg (xsh_get_property_value
01552 (plist, XSH_EXTNAME, CPL_TYPE_STRING, &returnvalue),
01553 "Error reading keyword '%s'", XSH_EXTNAME);
01554 cleanup:
01555 return returnvalue;
01556 }
01557
01558
01564
01565 const char *
01566 xsh_pfits_get_date (const cpl_propertylist * plist)
01567 {
01568 const char *returnvalue = "";
01569
01570 check_msg (xsh_get_property_value
01571 (plist, XSH_DATE, CPL_TYPE_STRING, &returnvalue),
01572 "Error reading keyword '%s'", XSH_DATE);
01573
01574 cleanup:
01575 return returnvalue;
01576 }
01577
01578
01584
01585 const char *
01586 xsh_pfits_get_date_obs (const cpl_propertylist * plist)
01587 {
01588 const char *returnvalue = "";
01589
01590 check_msg (xsh_get_property_value
01591 (plist, XSH_DATE_OBS, CPL_TYPE_STRING, &returnvalue),
01592 "Error reading keyword '%s'", XSH_DATE_OBS);
01593
01594 cleanup:
01595 return returnvalue;
01596 }
01597
01603
01604 double
01605 xsh_pfits_get_pszx (const cpl_propertylist * plist)
01606 {
01607 double returnvalue = 0.0;
01608
01609 check_msg (xsh_get_property_value (plist, XSH_PSZX, CPL_TYPE_DOUBLE,
01610 &returnvalue),
01611 "Error reading keyword '%s'", XSH_PSZX);
01612
01613 cleanup:
01614 return returnvalue;
01615 }
01616
01622
01623 double
01624 xsh_pfits_get_pszy (const cpl_propertylist * plist)
01625 {
01626 double returnvalue = 0.0;
01627
01628 check_msg (xsh_get_property_value (plist, XSH_PSZY, CPL_TYPE_DOUBLE,
01629 &returnvalue),
01630 "Error reading keyword '%s'", XSH_PSZY);
01631
01632 cleanup:
01633 return returnvalue;
01634 }
01635
01641
01642 double
01643 xsh_pfits_get_det_pxspace(const cpl_propertylist * plist)
01644 {
01645 double returnvalue = 0.0;
01646
01647 check_msg (xsh_get_property_value (plist, XSH_DET_PXSPACE, CPL_TYPE_DOUBLE,
01648 &returnvalue),
01649 "Error reading keyword '%s'", XSH_DET_PXSPACE);
01650
01651 cleanup:
01652 return returnvalue;
01653 }
01654
01655
01656
01657
01663
01664 int xsh_pfits_get_FOCU1ENC (const cpl_propertylist * plist)
01665 {
01666 int returnvalue = 0;
01667
01668 check_msg (xsh_get_property_value (plist, XSH_FOCU1ENC_VAL, CPL_TYPE_INT,
01669 &returnvalue),
01670 "Error reading keyword '%s'", XSH_FOCU1ENC_VAL);
01671
01672 cleanup:
01673 return returnvalue;
01674 }
01675
01676
01677
01678
01684
01685 double xsh_pfits_get_temp5 (const cpl_propertylist * plist)
01686 {
01687 double returnvalue = 0.0;
01688
01689 check_msg (xsh_get_property_value (plist, XSH_TEMP5_VAL, CPL_TYPE_DOUBLE,
01690 &returnvalue),
01691 "Error reading keyword '%s'", XSH_TEMP5_VAL);
01692
01693 cleanup:
01694 return returnvalue;
01695 }
01696
01697
01698
01699
01705
01706 double xsh_pfits_get_temp2 (const cpl_propertylist * plist)
01707 {
01708 double returnvalue = 0.0;
01709
01710 check_msg (xsh_get_property_value (plist, XSH_TEMP2_VAL, CPL_TYPE_DOUBLE,
01711 &returnvalue),
01712 "Error reading keyword '%s'", XSH_TEMP2_VAL);
01713
01714 cleanup:
01715 return returnvalue;
01716 }
01717
01718
01719
01720
01726
01727 double xsh_pfits_get_temp82 (const cpl_propertylist * plist)
01728 {
01729 double returnvalue = 0.0;
01730
01731 check_msg (xsh_get_property_value (plist, XSH_TEMP82_VAL, CPL_TYPE_DOUBLE,
01732 &returnvalue),
01733 "Error reading keyword '%s'", XSH_TEMP82_VAL);
01734
01735 cleanup:
01736 return returnvalue;
01737 }
01738
01739
01740
01746
01747 double xsh_pfits_get_crval1 (const cpl_propertylist * plist)
01748 {
01749 double returnvalue = 0.0;
01750
01751 check_msg (xsh_get_property_value (plist, XSH_CRVAL1, CPL_TYPE_DOUBLE,
01752 &returnvalue),
01753 "Error reading keyword '%s'", XSH_CRVAL1);
01754
01755 cleanup:
01756 return returnvalue;
01757 }
01758
01759
01765
01766 double xsh_pfits_get_crval2 (const cpl_propertylist * plist)
01767 {
01768 double returnvalue = 0.0;
01769
01770 check_msg (xsh_get_property_value (plist, XSH_CRVAL2, CPL_TYPE_DOUBLE,
01771 &returnvalue),
01772 "Error reading keyword '%s'", XSH_CRVAL2);
01773
01774 cleanup:
01775 return returnvalue;
01776 }
01777
01778
01779
01785
01786 double xsh_pfits_get_crval3 (const cpl_propertylist * plist)
01787 {
01788 double returnvalue = 0.0;
01789
01790 check_msg (xsh_get_property_value (plist, XSH_CRVAL3, CPL_TYPE_DOUBLE,
01791 &returnvalue),
01792 "Error reading keyword '%s'", XSH_CRVAL3);
01793
01794 cleanup:
01795 return returnvalue;
01796 }
01797
01798
01799
01804
01805 double xsh_pfits_get_crpix1(const cpl_propertylist * plist)
01806 {
01807 double returnvalue = 0.0;
01808 check_msg (xsh_get_property_value (plist, XSH_CRPIX1, CPL_TYPE_DOUBLE,
01809 &returnvalue),
01810 "Error reading keyword '%s'", XSH_CRPIX1);
01811
01812 cleanup:
01813 return returnvalue;
01814 }
01815
01816
01821
01822 double xsh_pfits_get_crpix2(const cpl_propertylist * plist)
01823 {
01824 double returnvalue = 0.0;
01825 check_msg (xsh_get_property_value (plist, XSH_CRPIX2, CPL_TYPE_DOUBLE,
01826 &returnvalue),
01827 "Error reading keyword '%s'", XSH_CRPIX2);
01828
01829 cleanup:
01830 return returnvalue;
01831 }
01832
01833
01838
01839 double xsh_pfits_get_crpix3(const cpl_propertylist * plist)
01840 {
01841 double returnvalue = 0.0;
01842 check_msg (xsh_get_property_value (plist, XSH_CRPIX3, CPL_TYPE_DOUBLE,
01843 &returnvalue),
01844 "Error reading keyword '%s'", XSH_CRPIX3);
01845
01846 cleanup:
01847 return returnvalue;
01848 }
01849
01850
01856
01857 double xsh_pfits_get_cd11 (const cpl_propertylist * plist)
01858 {
01859 double returnvalue = 0.0;
01860
01861 check_msg (xsh_get_property_value (plist, XSH_CD11, CPL_TYPE_DOUBLE,
01862 &returnvalue),
01863 "Error reading keyword '%s'", XSH_CD11);
01864
01865 cleanup:
01866 return returnvalue;
01867 }
01868
01869
01870
01871
01877
01878 double xsh_pfits_get_cd12 (const cpl_propertylist * plist)
01879 {
01880 double returnvalue = 0.0;
01881
01882 check_msg (xsh_get_property_value (plist, XSH_CD12, CPL_TYPE_DOUBLE,
01883 &returnvalue),
01884 "Error reading keyword '%s'", XSH_CD12);
01885
01886 cleanup:
01887 return returnvalue;
01888 }
01889
01890
01896
01897 double xsh_pfits_get_cd21 (const cpl_propertylist * plist)
01898 {
01899 double returnvalue = 0.0;
01900
01901 check_msg (xsh_get_property_value (plist, XSH_CD21, CPL_TYPE_DOUBLE,
01902 &returnvalue),
01903 "Error reading keyword '%s'", XSH_CD21);
01904
01905 cleanup:
01906 return returnvalue;
01907 }
01908
01909
01910
01916
01917 double xsh_pfits_get_cd22 (const cpl_propertylist * plist)
01918 {
01919 double returnvalue = 0.0;
01920
01921 check_msg (xsh_get_property_value (plist, XSH_CD22, CPL_TYPE_DOUBLE,
01922 &returnvalue),
01923 "Error reading keyword '%s'", XSH_CD22);
01924
01925 cleanup:
01926 return returnvalue;
01927 }
01928
01929
01935
01936 double xsh_pfits_get_cd13 (const cpl_propertylist * plist)
01937 {
01938 double returnvalue = 0.0;
01939
01940 check_msg (xsh_get_property_value (plist, XSH_CD13, CPL_TYPE_DOUBLE,
01941 &returnvalue),
01942 "Error reading keyword '%s'", XSH_CD13);
01943
01944 cleanup:
01945 return returnvalue;
01946 }
01947
01948
01949
01955
01956 double xsh_pfits_get_cd23 (const cpl_propertylist * plist)
01957 {
01958 double returnvalue = 0.0;
01959
01960 check_msg (xsh_get_property_value (plist, XSH_CD23, CPL_TYPE_DOUBLE,
01961 &returnvalue),
01962 "Error reading keyword '%s'", XSH_CD23);
01963
01964 cleanup:
01965 return returnvalue;
01966 }
01967
01968
01969
01975
01976 double xsh_pfits_get_cd33 (const cpl_propertylist * plist)
01977 {
01978 double returnvalue = 0.0;
01979
01980 check_msg (xsh_get_property_value (plist, XSH_CD33, CPL_TYPE_DOUBLE,
01981 &returnvalue),
01982 "Error reading keyword '%s'", XSH_CD33);
01983
01984 cleanup:
01985 return returnvalue;
01986 }
01987
01988
01994
01995 double xsh_pfits_get_cd31 (const cpl_propertylist * plist)
01996 {
01997 double returnvalue = 0.0;
01998
01999 check_msg (xsh_get_property_value (plist, XSH_CD31, CPL_TYPE_DOUBLE,
02000 &returnvalue),
02001 "Error reading keyword '%s'", XSH_CD31);
02002
02003 cleanup:
02004 return returnvalue;
02005 }
02006
02007
02008
02014
02015 double xsh_pfits_get_cd32 (const cpl_propertylist * plist)
02016 {
02017 double returnvalue = 0.0;
02018
02019 check_msg (xsh_get_property_value (plist, XSH_CD32, CPL_TYPE_DOUBLE,
02020 &returnvalue),
02021 "Error reading keyword '%s'", XSH_CD32);
02022
02023 cleanup:
02024 return returnvalue;
02025 }
02026
02027
02028
02029
02035
02036 double xsh_pfits_get_cdelt1 (const cpl_propertylist * plist)
02037 {
02038 double returnvalue = 0.0;
02039
02040 check_msg (xsh_get_property_value (plist, XSH_CDELT1, CPL_TYPE_DOUBLE,
02041 &returnvalue),
02042 "Error reading keyword '%s'", XSH_CDELT1);
02043
02044 cleanup:
02045 return returnvalue;
02046 }
02047
02048
02049
02055
02056 double xsh_pfits_get_cdelt2 (const cpl_propertylist * plist)
02057 {
02058 double returnvalue = 0.0;
02059
02060 check_msg (xsh_get_property_value (plist, XSH_CDELT2, CPL_TYPE_DOUBLE,
02061 &returnvalue),
02062 "Error reading keyword '%s'", XSH_CDELT2);
02063
02064 cleanup:
02065 return returnvalue;
02066 }
02067
02068
02074
02075 double xsh_pfits_get_cdelt3 (const cpl_propertylist * plist)
02076 {
02077 double returnvalue = 0.0;
02078
02079 check_msg (xsh_get_property_value (plist, XSH_CDELT3, CPL_TYPE_DOUBLE,
02080 &returnvalue),
02081 "Error reading keyword '%s'", XSH_CDELT3);
02082
02083 cleanup:
02084 return returnvalue;
02085 }
02086
02087
02093
02094 double xsh_pfits_get_exptime (const cpl_propertylist * plist)
02095 {
02096 double returnvalue = 0.0;
02097
02098 check_msg (xsh_get_property_value (plist, XSH_EXPTIME,CPL_TYPE_DOUBLE,
02099 &returnvalue),
02100 "Error reading keyword '%s'", XSH_EXPTIME);
02101
02102 cleanup:
02103 return returnvalue;
02104 }
02105
02111
02112 void
02113 xsh_pfits_set_exptime (cpl_propertylist * plist, double value)
02114 {
02115 check_msg (cpl_propertylist_update_double (plist, XSH_EXPTIME, value),
02116 "Error writing keyword '%s'", XSH_EXPTIME);
02117
02118 cleanup:
02119 return;
02120 }
02121
02122
02128
02129 void xsh_pfits_set_cd1(cpl_propertylist * plist, double value)
02130 {
02131 check_msg (cpl_propertylist_update_double (plist, XSH_CD1, value),
02132 "Error writing keyword '%s'", XSH_CD1);
02133 cleanup:
02134 return;
02135 }
02136
02137
02138
02144
02145 void xsh_pfits_set_cd11(cpl_propertylist * plist, double value)
02146 {
02147 check_msg (cpl_propertylist_update_double (plist, XSH_CD11, value),
02148 "Error writing keyword '%s'", XSH_CD11);
02149 cleanup:
02150 return;
02151 }
02152
02153
02159
02160 void xsh_pfits_set_cd12(cpl_propertylist * plist, double value)
02161 {
02162 check_msg (cpl_propertylist_update_double (plist, XSH_CD12, value),
02163 "Error writing keyword '%s'", XSH_CD12);
02164 cleanup:
02165 return;
02166 }
02167
02168
02174
02175 void xsh_pfits_set_cd21(cpl_propertylist * plist, double value)
02176 {
02177 check_msg (cpl_propertylist_update_double (plist, XSH_CD21, value),
02178 "Error writing keyword '%s'", XSH_CD21);
02179 cleanup:
02180 return;
02181 }
02182
02183
02189
02190 void xsh_pfits_set_cd22(cpl_propertylist * plist, double value)
02191 {
02192 check_msg (cpl_propertylist_update_double (plist, XSH_CD22, value),
02193 "Error writing keyword '%s'", XSH_CD22);
02194 cleanup:
02195 return;
02196 }
02197
02198
02204
02205 void xsh_pfits_set_cd13(cpl_propertylist * plist, double value)
02206 {
02207 check_msg (cpl_propertylist_update_double (plist, XSH_CD13, value),
02208 "Error writing keyword '%s'", XSH_CD13);
02209 cleanup:
02210 return;
02211 }
02212
02213
02219
02220 void xsh_pfits_set_cd23(cpl_propertylist * plist, double value)
02221 {
02222 check_msg (cpl_propertylist_update_double (plist, XSH_CD23, value),
02223 "Error writing keyword '%s'", XSH_CD23);
02224 cleanup:
02225 return;
02226 }
02227
02228
02229
02235
02236 void xsh_pfits_set_cd33(cpl_propertylist * plist, double value)
02237 {
02238 check_msg (cpl_propertylist_update_double (plist, XSH_CD33, value),
02239 "Error writing keyword '%s'", XSH_CD33);
02240 cleanup:
02241 return;
02242 }
02243
02244
02250
02251 void xsh_pfits_set_cd32(cpl_propertylist * plist, double value)
02252 {
02253 check_msg (cpl_propertylist_update_double (plist, XSH_CD32, value),
02254 "Error writing keyword '%s'", XSH_CD32);
02255 cleanup:
02256 return;
02257 }
02258
02259
02260
02266
02267 void xsh_pfits_set_cd31(cpl_propertylist * plist, double value)
02268 {
02269 check_msg (cpl_propertylist_update_double (plist, XSH_CD31, value),
02270 "Error writing keyword '%s'", XSH_CD31);
02271 cleanup:
02272 return;
02273 }
02274
02275
02276
02277
02283
02284 void xsh_pfits_set_crpix1(cpl_propertylist * plist, double value)
02285 {
02286 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX1, value),
02287 "Error writing keyword '%s'", XSH_CRPIX1);
02288 cleanup:
02289 return;
02290 }
02291
02292
02293
02294
02300
02301 void xsh_pfits_set_crval1(cpl_propertylist * plist, double value)
02302 {
02303 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL1, value),
02304 "Error writing keyword '%s'", XSH_CRVAL1);
02305 cleanup:
02306 return;
02307 }
02308
02309
02310
02316
02317 void xsh_pfits_set_cdelt1(cpl_propertylist * plist, double value)
02318 {
02319 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT1, value),
02320 "Error writing keyword '%s'", XSH_CDELT1);
02321 cleanup:
02322 return;
02323 }
02324
02325
02326
02327
02333
02334 void xsh_pfits_set_crpix2(cpl_propertylist * plist, double value)
02335 {
02336 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX2, value),
02337 "Error writing keyword '%s'", XSH_CRPIX2);
02338 cleanup:
02339 return;
02340 }
02341
02342
02348
02349 void xsh_pfits_set_crpix3(cpl_propertylist * plist, double value)
02350 {
02351 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX3, value),
02352 "Error writing keyword '%s'", XSH_CRPIX3);
02353 cleanup:
02354 return;
02355 }
02356
02357
02358
02364
02365 void xsh_pfits_set_crval2(cpl_propertylist * plist, double value)
02366 {
02367 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL2, value),
02368 "Error writing keyword '%s'", XSH_CRVAL2);
02369 cleanup:
02370 return;
02371 }
02372
02373
02379
02380 void xsh_pfits_set_crval3(cpl_propertylist * plist, double value)
02381 {
02382 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL3, value),
02383 "Error writing keyword '%s'", XSH_CRVAL3);
02384 cleanup:
02385 return;
02386 }
02387
02388
02389
02395
02396 void xsh_pfits_set_cdelt2(cpl_propertylist * plist, double value)
02397 {
02398 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT2, value),
02399 "Error writing keyword '%s'", XSH_CDELT2);
02400 cleanup:
02401 return;
02402 }
02403
02404
02405
02411
02412 void xsh_pfits_set_cdelt3(cpl_propertylist * plist, double value)
02413 {
02414 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT3, value),
02415 "Error writing keyword '%s'", XSH_CDELT3);
02416 cleanup:
02417 return;
02418 }
02419
02420
02426
02427 void xsh_pfits_set_bunit(cpl_propertylist * plist, const char* value)
02428 {
02429 check_msg (cpl_propertylist_update_string (plist, XSH_BUNIT, value),
02430 "Error writing keyword '%s'", XSH_BUNIT);
02431 cleanup:
02432 return;
02433 }
02434
02435
02436
02442
02443 void xsh_pfits_set_cunit1(cpl_propertylist * plist, const char* value)
02444 {
02445 check_msg (cpl_propertylist_update_string (plist, XSH_CUNIT1, value),
02446 "Error writing keyword '%s'", XSH_CUNIT1);
02447 cleanup:
02448 return;
02449 }
02450
02451
02457
02458 void xsh_pfits_set_cunit2(cpl_propertylist * plist, const char* value)
02459 {
02460 check_msg (cpl_propertylist_update_string (plist, XSH_CUNIT2, value),
02461 "Error writing keyword '%s'", XSH_CUNIT2);
02462 cleanup:
02463 return;
02464 }
02465
02466
02472
02473 void xsh_pfits_set_cunit3(cpl_propertylist * plist, const char* value)
02474 {
02475 check_msg (cpl_propertylist_update_string (plist, XSH_CUNIT3, value),
02476 "Error writing keyword '%s'", XSH_CUNIT3);
02477 cleanup:
02478 return;
02479 }
02480
02481
02487
02488 void xsh_pfits_set_ctype1(cpl_propertylist * plist, const char* value)
02489 {
02490 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE1, value),
02491 "Error writing keyword '%s'", XSH_CTYPE1);
02492 cleanup:
02493 return;
02494 }
02495
02496
02502
02503 void xsh_pfits_set_ctype2(cpl_propertylist * plist, const char* value)
02504 {
02505 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE2, value),
02506 "Error writing keyword '%s'", XSH_CTYPE2);
02507 cleanup:
02508 return;
02509 }
02510
02511
02512
02518
02519 void xsh_pfits_set_ctype3(cpl_propertylist * plist, const char* value)
02520 {
02521 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE3, value),
02522 "Error writing keyword '%s'", XSH_CTYPE3);
02523 cleanup:
02524 return;
02525 }
02526
02527
02533
02534 void xsh_pfits_set_wavesol_lambda_min(cpl_propertylist * plist, double value)
02535 {
02536 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_LAMBDA_MIN,
02537 value),
02538 "Error writing keyword '%s'", XSH_WAVESOL_LAMBDA_MIN);
02539
02540 cleanup:
02541 return;
02542 }
02543
02544
02550
02551 void xsh_pfits_set_wavesol_lambda_max(cpl_propertylist * plist, double value)
02552 {
02553 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_LAMBDA_MAX,
02554 value),
02555 "Error writing keyword '%s'", XSH_WAVESOL_LAMBDA_MAX);
02556
02557 cleanup:
02558 return;
02559 }
02560
02561
02567
02568 void xsh_pfits_set_wavesol_order_min(cpl_propertylist * plist, double value)
02569 {
02570 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_ORDER_MIN,
02571 value),
02572 "Error writing keyword '%s'", XSH_WAVESOL_ORDER_MIN);
02573
02574 cleanup:
02575 return;
02576 }
02577
02578
02584
02585 void xsh_pfits_set_wavesol_order_max(cpl_propertylist * plist, double value)
02586 {
02587 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_ORDER_MAX,
02588 value),
02589 "Error writing keyword '%s'", XSH_WAVESOL_ORDER_MAX);
02590
02591 cleanup:
02592 return;
02593 }
02594
02595
02601
02602 void xsh_pfits_set_wavesol_slit_min(cpl_propertylist * plist, double value)
02603 {
02604 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_SLIT_MIN,
02605 value),
02606 "Error writing keyword '%s'", XSH_WAVESOL_SLIT_MIN);
02607
02608 cleanup:
02609 return;
02610 }
02611
02612
02618
02619 void xsh_pfits_set_wavesol_slit_max(cpl_propertylist * plist, double value)
02620 {
02621 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_SLIT_MAX,
02622 value),
02623 "Error writing keyword '%s'", XSH_WAVESOL_SLIT_MAX);
02624
02625 cleanup:
02626 return;
02627 }
02628
02629
02635
02636 void xsh_pfits_set_extract_slit_min(cpl_propertylist * plist, double value)
02637 {
02638 check_msg (cpl_propertylist_update_double (plist, XSH_EXTRACT_SLIT_MIN,
02639 value),
02640 "Error writing keyword '%s'", XSH_EXTRACT_SLIT_MIN);
02641
02642 cleanup:
02643 return;
02644 }
02645
02646
02647
02648
02654
02655 void xsh_pfits_set_extract_slit_max(cpl_propertylist * plist, double value)
02656 {
02657 check_msg (cpl_propertylist_update_double (plist, XSH_EXTRACT_SLIT_MAX,
02658 value),
02659 "Error writing keyword '%s'", XSH_EXTRACT_SLIT_MAX);
02660
02661 cleanup:
02662 return;
02663 }
02664
02670
02671 void xsh_pfits_set_wavesol_x_min(cpl_propertylist * plist, double value)
02672 {
02673 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_X_MIN,
02674 value),
02675 "Error writing keyword '%s'", XSH_WAVESOL_X_MIN);
02676
02677 cleanup:
02678 return;
02679 }
02680
02681
02687
02688 void xsh_pfits_set_wavesol_x_max(cpl_propertylist * plist, double value)
02689 {
02690 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_X_MAX,
02691 value),
02692 "Error writing keyword '%s'", XSH_WAVESOL_X_MAX);
02693
02694 cleanup:
02695 return;
02696 }
02697
02698
02699
02705
02706 void xsh_pfits_set_wavesol_y_min(cpl_propertylist * plist, double value)
02707 {
02708 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_Y_MIN,
02709 value),
02710 "Error writing keyword '%s'", XSH_WAVESOL_Y_MIN);
02711
02712 cleanup:
02713 return;
02714 }
02715
02716
02722
02723 void xsh_pfits_set_wavesol_y_max(cpl_propertylist * plist, double value)
02724 {
02725 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_Y_MAX,
02726 value),
02727 "Error writing keyword '%s'", XSH_WAVESOL_Y_MAX);
02728
02729 cleanup:
02730 return;
02731 }
02732
02733
02739
02740 double xsh_pfits_get_wavesol_lambda_min(cpl_propertylist * plist)
02741 {
02742 double returnvalue = 0.0;
02743
02744 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_LAMBDA_MIN,
02745 CPL_TYPE_DOUBLE, &returnvalue),
02746 "Error reading keyword '%s'", XSH_WAVESOL_LAMBDA_MIN);
02747
02748 cleanup:
02749 return returnvalue;
02750 }
02751
02752
02758
02759 double xsh_pfits_get_wavesol_lambda_max(cpl_propertylist * plist)
02760 {
02761 double returnvalue = 0.0;
02762
02763 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_LAMBDA_MAX,
02764 CPL_TYPE_DOUBLE, &returnvalue),
02765 "Error reading keyword '%s'", XSH_WAVESOL_LAMBDA_MAX);
02766
02767 cleanup:
02768 return returnvalue;
02769 }
02770
02771
02777
02778 double xsh_pfits_get_wavesol_order_min(cpl_propertylist * plist)
02779 {
02780 double returnvalue = 0.0;
02781
02782 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_ORDER_MIN,
02783 CPL_TYPE_DOUBLE, &returnvalue),
02784 "Error reading keyword '%s'", XSH_WAVESOL_ORDER_MIN);
02785
02786 cleanup:
02787 return returnvalue;
02788 }
02789
02790
02796
02797 double xsh_pfits_get_wavesol_order_max(cpl_propertylist * plist)
02798 {
02799 double returnvalue = 0.0;
02800
02801 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_ORDER_MAX,
02802 CPL_TYPE_DOUBLE, &returnvalue),
02803 "Error reading keyword '%s'", XSH_WAVESOL_ORDER_MAX);
02804
02805 cleanup:
02806 return returnvalue;
02807 }
02808
02809
02815
02816 double xsh_pfits_get_wavesol_slit_min(cpl_propertylist * plist)
02817 {
02818 double returnvalue = 0.0;
02819
02820 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_SLIT_MIN,
02821 CPL_TYPE_DOUBLE, &returnvalue),
02822 "Error reading keyword '%s'", XSH_WAVESOL_SLIT_MIN);
02823
02824 cleanup:
02825 return returnvalue;
02826 }
02827
02828
02834
02835 double xsh_pfits_get_wavesol_slit_max(cpl_propertylist * plist)
02836 {
02837 double returnvalue = 0.0;
02838
02839 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_SLIT_MAX,
02840 CPL_TYPE_DOUBLE, &returnvalue),
02841 "Error reading keyword '%s'", XSH_WAVESOL_SLIT_MAX);
02842
02843 cleanup:
02844 return returnvalue;
02845 }
02846
02847
02853
02854 double xsh_pfits_get_extract_slit_min(cpl_propertylist * plist)
02855 {
02856 double returnvalue = 0.0;
02857
02858 check_msg (xsh_get_property_value (plist, XSH_EXTRACT_SLIT_MIN,
02859 CPL_TYPE_DOUBLE, &returnvalue),
02860 "Error reading keyword '%s'", XSH_EXTRACT_SLIT_MIN);
02861
02862 cleanup:
02863 return returnvalue;
02864 }
02865
02866
02872
02873 double xsh_pfits_get_extract_slit_max(cpl_propertylist * plist)
02874 {
02875 double returnvalue = 0.0;
02876
02877 check_msg (xsh_get_property_value (plist, XSH_EXTRACT_SLIT_MAX,
02878 CPL_TYPE_DOUBLE, &returnvalue),
02879 "Error reading keyword '%s'", XSH_EXTRACT_SLIT_MAX);
02880
02881 cleanup:
02882 return returnvalue;
02883 }
02884
02885
02891
02892 double xsh_pfits_get_wavesol_x_min(cpl_propertylist * plist)
02893 {
02894 double returnvalue = 0.0;
02895
02896 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_X_MIN,
02897 CPL_TYPE_DOUBLE, &returnvalue),
02898 "Error reading keyword '%s'", XSH_WAVESOL_X_MIN);
02899
02900 cleanup:
02901 return returnvalue;
02902 }
02903
02904
02910
02911 double xsh_pfits_get_wavesol_x_max(cpl_propertylist * plist)
02912 {
02913 double returnvalue = 0.0;
02914
02915 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_X_MAX,
02916 CPL_TYPE_DOUBLE, &returnvalue),
02917 "Error reading keyword '%s'", XSH_WAVESOL_X_MAX);
02918
02919 cleanup:
02920 return returnvalue;
02921 }
02922
02923
02929
02930 double xsh_pfits_get_wavesol_y_min(cpl_propertylist * plist)
02931 {
02932 double returnvalue = 0.0;
02933
02934 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_Y_MIN,
02935 CPL_TYPE_DOUBLE, &returnvalue),
02936 "Error reading keyword '%s'", XSH_WAVESOL_Y_MIN);
02937
02938 cleanup:
02939 return returnvalue;
02940 }
02941
02942
02948
02949 double xsh_pfits_get_wavesol_y_max(cpl_propertylist * plist)
02950 {
02951 double returnvalue = 0.0;
02952
02953 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_Y_MAX,
02954 CPL_TYPE_DOUBLE, &returnvalue),
02955 "Error reading keyword '%s'", XSH_WAVESOL_Y_MAX);
02956
02957 cleanup:
02958 return returnvalue;
02959 }
02960
02961
02970
02971 const char *
02972 xsh_pfits_get_wavesoltype( const cpl_propertylist * plist)
02973 {
02974 const char *returnvalue = "";
02975
02976 check_msg (xsh_get_property_value
02977 (plist, XSH_WAVESOLTYPE, CPL_TYPE_STRING, &returnvalue),
02978 "Error reading keyword '%s'", XSH_WAVESOLTYPE);
02979 cleanup:
02980 return returnvalue;
02981 }
02982
02983
02992
02993 void xsh_pfits_set_wavesoltype( cpl_propertylist * plist, const char* value)
02994 {
02995 XSH_REGDEBUG("writing keyword %s = %s", XSH_WAVESOLTYPE, value);
02996 check_msg (cpl_propertylist_update_string (plist, XSH_WAVESOLTYPE, value),
02997 "Error writing keyword '%s'", XSH_WAVESOLTYPE);
02998 cleanup:
02999 return;
03000 }
03001
03002
03008
03009 void xsh_pfits_set_rectify_bin_lambda(cpl_propertylist * plist, double value)
03010 {
03011 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_BIN_LAMBDA,
03012 value),
03013 "Error writing keyword '%s'", XSH_RECTIFY_BIN_LAMBDA);
03014
03015 cleanup:
03016 return;
03017 }
03018
03024
03025 void xsh_pfits_set_rectify_bin_space(cpl_propertylist * plist, double value)
03026 {
03027 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_BIN_SPACE,
03028 value),
03029 "Error writing keyword '%s'", XSH_RECTIFY_BIN_SPACE);
03030
03031 cleanup:
03032 return;
03033 }
03034
03040
03041 void xsh_pfits_set_rectify_lambda_min(cpl_propertylist * plist, double value)
03042 {
03043 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_LAMBDA_MIN,
03044 value),
03045 "Error writing keyword '%s'", XSH_RECTIFY_LAMBDA_MIN);
03046
03047 cleanup:
03048 return;
03049 }
03050
03056
03057 void xsh_pfits_set_rectify_lambda_max(cpl_propertylist * plist, double value)
03058 {
03059 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_LAMBDA_MAX,
03060 value),
03061 "Error writing keyword '%s'", XSH_RECTIFY_LAMBDA_MAX);
03062
03063 cleanup:
03064 return;
03065 }
03066
03072
03073 void xsh_pfits_set_rectify_space_min(cpl_propertylist * plist, double value)
03074 {
03075 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_SPACE_MIN,
03076 value),
03077 "Error writing keyword '%s'", XSH_RECTIFY_SPACE_MIN);
03078
03079 cleanup:
03080 return;
03081 }
03082
03088
03089 void xsh_pfits_set_rectify_space_max(cpl_propertylist * plist, double value)
03090 {
03091 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_SPACE_MAX,
03092 value),
03093 "Error writing keyword '%s'", XSH_RECTIFY_SPACE_MAX);
03094
03095 cleanup:
03096 return;
03097 }
03098
03104
03105 double xsh_pfits_get_rectify_bin_lambda(cpl_propertylist * plist)
03106 {
03107 double returnvalue = 0.0;
03108
03109 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_BIN_LAMBDA,
03110 CPL_TYPE_DOUBLE, &returnvalue),
03111 "Error reading keyword '%s'", XSH_RECTIFY_BIN_LAMBDA);
03112
03113 cleanup:
03114 return returnvalue;
03115 }
03116
03122
03123 double xsh_pfits_get_rectify_bin_space(cpl_propertylist * plist)
03124 {
03125 double returnvalue = 0.0;
03126
03127 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_BIN_SPACE,
03128 CPL_TYPE_DOUBLE, &returnvalue),
03129 "Error reading keyword '%s'", XSH_RECTIFY_BIN_SPACE);
03130
03131 cleanup:
03132 return returnvalue;
03133 }
03134
03140 double xsh_pfits_get_rectify_lambda_min(cpl_propertylist * plist)
03141 {
03142 double returnvalue = 0.0;
03143
03144 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_LAMBDA_MIN,
03145 CPL_TYPE_DOUBLE, &returnvalue),
03146 "Error reading keyword '%s'", XSH_RECTIFY_LAMBDA_MIN);
03147
03148 cleanup:
03149 return returnvalue;
03150 }
03151
03157 double xsh_pfits_get_rectify_lambda_max(cpl_propertylist * plist)
03158 {
03159 double returnvalue = 0.0;
03160
03161 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_LAMBDA_MAX,
03162 CPL_TYPE_DOUBLE, &returnvalue),
03163 "Error reading keyword '%s'", XSH_RECTIFY_LAMBDA_MAX);
03164
03165 cleanup:
03166 return returnvalue;
03167 }
03168
03174 double xsh_pfits_get_rectify_space_min(cpl_propertylist * plist)
03175 {
03176 double returnvalue = 0.0;
03177
03178 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_SPACE_MIN,
03179 CPL_TYPE_DOUBLE, &returnvalue),
03180 "Error reading keyword '%s'", XSH_RECTIFY_SPACE_MIN);
03181
03182 cleanup:
03183 return returnvalue;
03184 }
03185
03191 double xsh_pfits_get_rectify_space_max(cpl_propertylist * plist)
03192 {
03193 double returnvalue = 0.0;
03194
03195 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_SPACE_MAX,
03196 CPL_TYPE_DOUBLE, &returnvalue),
03197 "Error reading keyword '%s'", XSH_RECTIFY_SPACE_MAX);
03198
03199 cleanup:
03200 return returnvalue;
03201 }
03202
03203
03209 int xsh_pfits_get_obs_id(cpl_propertylist * plist)
03210 {
03211 int returnvalue = 0;
03212
03213 check_msg (xsh_get_property_value (plist, XSH_OBS_ID,
03214 CPL_TYPE_INT, &returnvalue),
03215 "Error reading keyword '%s'", XSH_OBS_ID);
03216
03217 cleanup:
03218 return returnvalue;
03219 }
03220
03221
03230 int xsh_pfits_get_nb_pinhole( const cpl_propertylist * plist){
03231 int nb_pinhole=1;
03232 const char* pinhole = NULL;
03233
03234 XSH_ASSURE_NOT_NULL( plist);
03235 check( pinhole = xsh_pfits_get_dpr_tech( plist));
03236
03237 if ( strcmp( pinhole, XSH_DPR_TECH_MULTI_PINHOLE) == 0 ){
03238 nb_pinhole = XSH_NB_PINHOLE;
03239 }
03240 else if (strcmp( pinhole, XSH_DPR_TECH_SINGLE_PINHOLE) == 0){
03241 nb_pinhole = 1;
03242 }
03243 else{
03244 xsh_error_msg( "Undefined pinhole : can't identify DPR keyword %s\n\
03245 Authorized keyword are ( single %s multi %s )", pinhole,
03246 XSH_DPR_TECH_SINGLE_PINHOLE, XSH_DPR_TECH_MULTI_PINHOLE);
03247 }
03248 cleanup:
03249 return nb_pinhole;
03250 }
03251
03260 double xsh_pfits_get_tel_targ_alpha( const cpl_propertylist * plist)
03261 {
03262 double returnvalue = 0. ;
03263
03264 check_msg (xsh_get_property_value (plist, XSH_TEL_TARG_ALPHA,
03265 CPL_TYPE_DOUBLE, &returnvalue),
03266 "Error reading keyword '%s'", XSH_TEL_TARG_ALPHA ) ;
03267
03268 cleanup:
03269 return returnvalue;
03270 }
03271
03280 double xsh_pfits_get_tel_targ_delta( const cpl_propertylist * plist)
03281 {
03282 double returnvalue = 0. ;
03283
03284 check_msg (xsh_get_property_value (plist, XSH_TEL_TARG_DELTA,
03285 CPL_TYPE_DOUBLE, &returnvalue),
03286 "Error reading keyword '%s'", XSH_TEL_TARG_DELTA ) ;
03287
03288 cleanup:
03289 return returnvalue;
03290 }
03291
03300 double xsh_pfits_get_ra( const cpl_propertylist * plist)
03301 {
03302 double returnvalue = 0. ;
03303
03304 check_msg (xsh_get_property_value (plist, XSH_RA,
03305 CPL_TYPE_DOUBLE, &returnvalue),
03306 "Error reading keyword '%s'", XSH_RA ) ;
03307
03308 cleanup:
03309 return returnvalue;
03310 }
03311
03312
03321 double xsh_pfits_get_dec( const cpl_propertylist * plist)
03322 {
03323 double returnvalue = 0. ;
03324
03325 check_msg (xsh_get_property_value (plist, XSH_DEC,
03326 CPL_TYPE_DOUBLE, &returnvalue),
03327 "Error reading keyword '%s'", XSH_DEC ) ;
03328
03329 cleanup:
03330 return returnvalue;
03331 }
03332
03333
03334 double xsh_pfits_get_posang( const cpl_propertylist *plist)
03335 {
03336 double returnvalue = 0. ;
03337
03338 check_msg (xsh_get_property_value (plist, XSH_POSANG,
03339 CPL_TYPE_DOUBLE, &returnvalue),
03340 "Error reading keyword '%s'", XSH_POSANG) ;
03341
03342 cleanup:
03343 return returnvalue;
03344 }
03345
03346
03347
03348
03349 double xsh_pfits_get_ra_reloffset( const cpl_propertylist *plist)
03350 {
03351 double returnvalue = 0. ;
03352
03353 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_RA,
03354 CPL_TYPE_DOUBLE, &returnvalue),
03355 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_RA) ;
03356
03357 cleanup:
03358 return returnvalue;
03359 }
03360
03361
03362
03363
03364 double xsh_pfits_get_dec_reloffset( const cpl_propertylist *plist)
03365 {
03366 double returnvalue = 0. ;
03367
03368 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_DEC,
03369 CPL_TYPE_DOUBLE, &returnvalue),
03370 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_DEC) ;
03371
03372 cleanup:
03373 return returnvalue;
03374 }
03375
03376
03377
03378
03379 double xsh_pfits_get_cumoffsetx( const cpl_propertylist *plist)
03380 {
03381 double returnvalue = 0. ;
03382
03383 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSETX,
03384 CPL_TYPE_DOUBLE, &returnvalue),
03385 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSETX) ;
03386
03387 cleanup:
03388 return returnvalue;
03389 }
03390
03391
03392 double xsh_pfits_get_cumoffsety( const cpl_propertylist *plist)
03393 {
03394 double returnvalue = 0. ;
03395
03396 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSETY,
03397 CPL_TYPE_DOUBLE, &returnvalue),
03398 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSETY) ;
03399
03400 cleanup:
03401 return returnvalue;
03402 }
03403
03404
03405
03406 double xsh_pfits_get_ra_cumoffset( const cpl_propertylist *plist)
03407 {
03408 double returnvalue = 0. ;
03409
03410 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_RA,
03411 CPL_TYPE_DOUBLE, &returnvalue),
03412 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_RA) ;
03413
03414 cleanup:
03415 return returnvalue;
03416 }
03417
03418
03419
03420
03421 double xsh_pfits_get_dec_cumoffset( const cpl_propertylist *plist)
03422 {
03423 double returnvalue = 0. ;
03424
03425 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_DEC,
03426 CPL_TYPE_DOUBLE, &returnvalue),
03427 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_DEC) ;
03428
03429 cleanup:
03430 return returnvalue;
03431 }
03432
03433
03434
03435
03436 double xsh_pfits_get_b_ra_reloffset( const cpl_propertylist *plist)
03437 {
03438 double returnvalue = 0. ;
03439
03440 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_B_OFFSET_RA,
03441 CPL_TYPE_DOUBLE, &returnvalue),
03442 "Error reading keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_RA) ;
03443
03444 cleanup:
03445 return returnvalue;
03446 }
03447
03448
03449
03450
03451 double xsh_pfits_get_b_dec_reloffset( const cpl_propertylist *plist)
03452 {
03453 double returnvalue = 0. ;
03454
03455 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_B_OFFSET_DEC,
03456 CPL_TYPE_DOUBLE, &returnvalue),
03457 "Error reading keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_DEC) ;
03458
03459 cleanup:
03460 return returnvalue;
03461 }
03462
03463
03464
03465
03466 double xsh_pfits_get_b_ra_cumoffset( const cpl_propertylist *plist)
03467 {
03468 double returnvalue = 0. ;
03469
03470 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_B_OFFSET_RA,
03471 CPL_TYPE_DOUBLE, &returnvalue),
03472 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_RA) ;
03473
03474 cleanup:
03475 return returnvalue;
03476 }
03477
03478
03479
03480
03481 double xsh_pfits_get_b_dec_cumoffset( const cpl_propertylist *plist)
03482 {
03483 double returnvalue = 0. ;
03484
03485 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_B_OFFSET_DEC,
03486 CPL_TYPE_DOUBLE, &returnvalue),
03487 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_DEC);
03488
03489 cleanup:
03490 return returnvalue;
03491 }
03492
03493
03494
03495
03496 void xsh_pfits_set_b_ra_reloffset(cpl_propertylist * plist, double value)
03497 {
03498 check_msg( cpl_propertylist_update_double
03499 (plist, XSH_NOD_RELATIVE_B_OFFSET_RA, value),
03500 "Error writing keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_RA);
03501 cleanup:
03502 return;
03503 }
03504
03505
03506
03507
03508 void xsh_pfits_set_b_dec_reloffset(cpl_propertylist * plist, double value)
03509 {
03510 check_msg( cpl_propertylist_update_double
03511 (plist, XSH_NOD_RELATIVE_B_OFFSET_DEC, value),
03512 "Error writing keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_DEC);
03513 cleanup:
03514 return;
03515 }
03516
03517
03518
03519
03520
03521 void xsh_pfits_set_b_ra_cumoffset(cpl_propertylist * plist, double value)
03522 {
03523 check_msg( cpl_propertylist_update_double
03524 (plist, XSH_NOD_CUMULATIVE_B_OFFSET_RA, value),
03525 "Error writing keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_RA);
03526 cleanup:
03527 return;
03528 }
03529
03530
03531
03532
03533 void xsh_pfits_set_b_dec_cumoffset(cpl_propertylist * plist, double value)
03534 {
03535 check_msg( cpl_propertylist_update_double
03536 (plist, XSH_NOD_CUMULATIVE_B_OFFSET_DEC, value),
03537 "Error writing keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_DEC);
03538 cleanup:
03539 return;
03540 }
03541
03542
03543
03544
03545 void xsh_pfits_set_slitmap_order_edgup( cpl_propertylist * plist, int absorder,
03546 double value)
03547 {
03548 char name[256];
03549
03550 sprintf( name, XSH_SLITMAP_ORDER_EDGUP, absorder);
03551
03552 check_msg( cpl_propertylist_update_double
03553 (plist, name, value),
03554 "Error writing keyword '%s'", name);
03555
03556 cleanup:
03557 return;
03558 }
03559
03560
03561
03562
03563 void xsh_pfits_set_slitmap_order_edglo( cpl_propertylist * plist, int absorder,
03564 double value)
03565 {
03566 char name[256];
03567
03568 sprintf( name, XSH_SLITMAP_ORDER_EDGLO, absorder);
03569
03570 check_msg( cpl_propertylist_update_double
03571 (plist, name, value),
03572 "Error writing keyword '%s'", name);
03573
03574 cleanup:
03575 return;
03576 }
03577
03578
03579
03580 void xsh_pfits_set_slitmap_order_slicup( cpl_propertylist * plist, int absorder,
03581 double value)
03582 {
03583 char name[256];
03584
03585 sprintf( name, XSH_SLITMAP_ORDER_SLICUP, absorder);
03586
03587 check_msg( cpl_propertylist_update_double
03588 (plist, name, value),
03589 "Error writing keyword '%s'", name);
03590
03591 cleanup:
03592 return;
03593 }
03594
03595
03596
03597 void xsh_pfits_set_slitmap_order_sliclo( cpl_propertylist * plist, int absorder,
03598 double value)
03599 {
03600 char name[256];
03601
03602 sprintf( name, XSH_SLITMAP_ORDER_SLICLO, absorder);
03603
03604 check_msg( cpl_propertylist_update_double
03605 (plist, name, value),
03606 "Error writing keyword '%s'", name);
03607
03608 cleanup:
03609 return;
03610 }
03611
03612
03613
03614
03615 void xsh_pfits_set_slitmap_order_cen( cpl_propertylist * plist, int absorder,
03616 double value)
03617 {
03618 char name[256];
03619
03620 sprintf( name, XSH_SLITMAP_ORDER_CEN, absorder);
03621
03622 check_msg( cpl_propertylist_update_double
03623 (plist, name, value),
03624 "Error writing keyword '%s'", name);
03625
03626 cleanup:
03627 return;
03628 }
03629
03630
03631
03632
03633
03634 void xsh_pfits_set_slitmap_median_edgup( cpl_propertylist * plist,
03635 double value)
03636 {
03637 const char* name = XSH_SLITMAP_MEDIAN_EDGUP;
03638
03639
03640 check_msg( cpl_propertylist_update_double
03641 (plist, name, value),
03642 "Error writing keyword '%s'", name);
03643
03644 cleanup:
03645 return;
03646 }
03647
03648
03649
03650
03651 void xsh_pfits_set_slitmap_median_edglo( cpl_propertylist * plist,
03652 double value)
03653 {
03654 const char* name = XSH_SLITMAP_MEDIAN_EDGLO;
03655
03656
03657 check_msg( cpl_propertylist_update_double
03658 (plist, name, value),
03659 "Error writing keyword '%s'", name);
03660
03661 cleanup:
03662 return;
03663 }
03664
03665
03666
03667
03668 void xsh_pfits_set_slitmap_median_sliclo( cpl_propertylist * plist,
03669 double value)
03670 {
03671 const char* name = XSH_SLITMAP_MEDIAN_SLICLO;
03672
03673
03674 check_msg( cpl_propertylist_update_double
03675 (plist, name, value),
03676 "Error writing keyword '%s'", name);
03677
03678 cleanup:
03679 return;
03680 }
03681
03682
03683
03684
03685 void xsh_pfits_set_slitmap_median_slicup( cpl_propertylist * plist,
03686 double value)
03687 {
03688 const char* name = XSH_SLITMAP_MEDIAN_SLICUP;
03689
03690
03691 check_msg( cpl_propertylist_update_double
03692 (plist, name, value),
03693 "Error writing keyword '%s'", name);
03694
03695 cleanup:
03696 return;
03697 }
03698
03699
03700
03701
03702 void xsh_pfits_set_slitmap_median_cen( cpl_propertylist * plist,
03703 double value)
03704 {
03705 const char* name = XSH_SLITMAP_MEDIAN_CEN;
03706
03707
03708 check_msg( cpl_propertylist_update_double
03709 (plist, name, value),
03710 "Error writing keyword '%s'", name);
03711
03712 cleanup:
03713 return;
03714 }
03715
03716
03717
03718
03719 double xsh_pfits_get_slitmap_median_edgup(const cpl_propertylist * plist)
03720 {
03721 double returnvalue = 0.;
03722 const char *name = XSH_SLITMAP_MEDIAN_EDGUP;
03723
03724 check_msg( xsh_get_property_value (plist, name,
03725 CPL_TYPE_DOUBLE, &returnvalue),
03726 "Error reading keyword '%s'", name);
03727
03728 cleanup:
03729 return returnvalue;
03730 }
03731
03732
03733
03734
03735 double xsh_pfits_get_slitmap_median_edglo(const cpl_propertylist * plist)
03736 {
03737 double returnvalue = 0.;
03738 const char *name = XSH_SLITMAP_MEDIAN_EDGLO;
03739
03740 check_msg( xsh_get_property_value (plist, name,
03741 CPL_TYPE_DOUBLE, &returnvalue),
03742 "Error reading keyword '%s'", name);
03743
03744 cleanup:
03745 return returnvalue;
03746 }
03747
03748
03749
03750
03751 double xsh_pfits_get_slitmap_median_cen(const cpl_propertylist * plist)
03752 {
03753 double returnvalue = 0.;
03754 const char *name = XSH_SLITMAP_MEDIAN_CEN;
03755
03756 check_msg( xsh_get_property_value (plist, name,
03757 CPL_TYPE_DOUBLE, &returnvalue),
03758 "Error reading keyword '%s'", name);
03759
03760 cleanup:
03761 return returnvalue;
03762 }
03763
03764
03765
03766
03767 double xsh_pfits_get_slitmap_median_slicup(const cpl_propertylist * plist)
03768 {
03769 double returnvalue = 0.;
03770 const char *name = XSH_SLITMAP_MEDIAN_SLICUP;
03771
03772 check_msg( xsh_get_property_value (plist, name,
03773 CPL_TYPE_DOUBLE, &returnvalue),
03774 "Error reading keyword '%s'", name);
03775
03776 cleanup:
03777 return returnvalue;
03778 }
03779
03780
03781
03782
03783 double xsh_pfits_get_slitmap_median_sliclo(const cpl_propertylist * plist)
03784 {
03785 double returnvalue = 0.;
03786 const char *name = XSH_SLITMAP_MEDIAN_SLICLO;
03787
03788 check_msg( xsh_get_property_value (plist, name,
03789 CPL_TYPE_DOUBLE, &returnvalue),
03790 "Error reading keyword '%s'", name);
03791
03792 cleanup:
03793 return returnvalue;
03794 }
03795
03796
03797
03798
03799
03800 void xsh_pfits_set_wavemap_order_lambda_min( cpl_propertylist * plist, int absorder,
03801 double value)
03802 {
03803 char name[256];
03804
03805 sprintf( name, XSH_WAVEMAP_ORDER_LAMBDA_MIN, absorder);
03806
03807 check_msg( cpl_propertylist_update_double
03808 (plist, name, value),
03809 "Error writing keyword '%s'", name);
03810
03811 cleanup:
03812 return;
03813 }
03814
03815
03816
03817
03818 void xsh_pfits_set_wavemap_order_lambda_max( cpl_propertylist * plist, int absorder,
03819 double value)
03820 {
03821 char name[256];
03822
03823 sprintf( name, XSH_WAVEMAP_ORDER_LAMBDA_MAX, absorder);
03824
03825 check_msg( cpl_propertylist_update_double
03826 (plist, name, value),
03827 "Error writing keyword '%s'", name);
03828
03829 cleanup:
03830 return;
03831 }
03832
03833
03834
03835
03836 void xsh_pfits_set_shiftifu_lambdaref( cpl_propertylist * plist,
03837 double value)
03838 {
03839
03840 check_msg( cpl_propertylist_update_double
03841 (plist, XSH_SHIFTIFU_WAVEREF, value),
03842 "Error writing keyword '%s'", XSH_SHIFTIFU_WAVEREF);
03843
03844 cleanup:
03845 return;
03846 }
03847
03848
03849
03850
03851 double xsh_pfits_get_shiftifu_lambdaref( cpl_propertylist * plist)
03852 {
03853 double returnvalue = 0;
03854
03855 check_msg (xsh_get_property_value (plist, XSH_SHIFTIFU_WAVEREF,
03856 CPL_TYPE_DOUBLE, &returnvalue),
03857 "Error reading keyword '%s'", XSH_SHIFTIFU_WAVEREF);
03858 cleanup:
03859 return returnvalue;
03860 }
03861
03862
03863
03864
03865 void xsh_pfits_set_shiftifu_slitref( cpl_propertylist * plist,
03866 double value)
03867 {
03868
03869 check_msg( cpl_propertylist_update_double
03870 (plist, XSH_SHIFTIFU_SLITREF, value),
03871 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITREF);
03872
03873 cleanup:
03874 return;
03875 }
03876
03877
03878
03879
03880 void xsh_pfits_set_shiftifu_slitdownref( cpl_propertylist * plist,
03881 double value)
03882 {
03883
03884 check_msg( cpl_propertylist_update_double
03885 (plist, XSH_SHIFTIFU_SLITDOWNREF, value),
03886 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITDOWNREF);
03887
03888 cleanup:
03889 return;
03890 }
03891
03892
03893
03894
03895 void xsh_pfits_set_shiftifu_slitcenref( cpl_propertylist * plist,
03896 double value)
03897 {
03898
03899 check_msg( cpl_propertylist_update_double
03900 (plist, XSH_SHIFTIFU_SLITCENREF, value),
03901 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITCENREF);
03902
03903 cleanup:
03904 return;
03905 }
03906
03907
03908
03909
03910 void xsh_pfits_set_shiftifu_slitupref( cpl_propertylist * plist,
03911 double value)
03912 {
03913
03914 check_msg( cpl_propertylist_update_double
03915 (plist, XSH_SHIFTIFU_SLITUPREF, value),
03916 "Error writing keyword '%s'", XSH_SHIFTIFU_SLITUPREF);
03917
03918 cleanup:
03919 return;
03920 }
03921
03922
03923
03924
03925 double xsh_pfits_get_shiftifu_slitref( cpl_propertylist * plist)
03926 {
03927 double returnvalue = 0;
03928
03929 check_msg (xsh_get_property_value (plist, XSH_SHIFTIFU_SLITREF,
03930 CPL_TYPE_DOUBLE, &returnvalue),
03931 "Error reading keyword '%s'", XSH_SHIFTIFU_SLITREF);
03932 cleanup:
03933 return returnvalue;
03934 }
03935
03936
03937
03946 double xsh_pfits_get_nod_reloffset( const cpl_propertylist * plist)
03947 {
03948 double returnvalue = 0. ;
03949 double dec = 0., ra = 0. ;
03950
03951 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_DEC,
03952 CPL_TYPE_DOUBLE, &dec),
03953 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_DEC ) ;
03954 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_RA,
03955 CPL_TYPE_DOUBLE, &ra),
03956 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_RA ) ;
03957 returnvalue = sqrt( dec*dec + ra*ra ) ;
03958 xsh_msg_dbg_high( "dec: %lf, ra: %lf, reloffset: %lf", dec, ra, returnvalue ) ;
03959
03960 cleanup:
03961 return returnvalue;
03962 }
03963
03972 double xsh_pfits_get_nod_cumoffset( const cpl_propertylist * plist)
03973 {
03974 double returnvalue = 0 ;
03975 double dec = 0., ra = 0. ;
03976
03977 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_DEC,
03978 CPL_TYPE_DOUBLE, &dec),
03979 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_DEC ) ;
03980 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_RA,
03981 CPL_TYPE_DOUBLE, &ra),
03982 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_RA ) ;
03983 returnvalue = sqrt( dec*dec + ra*ra ) ;
03984 xsh_msg_dbg_high ("dec: %lf, ra: %lf, cumoffset: %lf", dec, ra, returnvalue ) ;
03985
03986 cleanup:
03987 return returnvalue;
03988
03989 }
03990
03999 double xsh_pfits_get_nod_jitterwidth( const cpl_propertylist * plist)
04000 {
04001 double returnvalue = 0 ;
04002
04003 check_msg (xsh_get_property_value (plist, XSH_NOD_JITTER_BOX,
04004 CPL_TYPE_DOUBLE, &returnvalue),
04005 "Error reading keyword '%s'", XSH_NOD_JITTER_BOX );
04006
04007 cleanup:
04008 return returnvalue;
04009
04010 }
04011
04020 double xsh_pfits_get_nodthrow( const cpl_propertylist * plist)
04021 {
04022 double returnvalue = 0 ;
04023
04024 check_msg (xsh_get_property_value (plist, XSH_NOD_THROW,
04025 CPL_TYPE_DOUBLE, &returnvalue),
04026 "Error reading keyword '%s'", XSH_NOD_THROW);
04027
04028 cleanup:
04029 return returnvalue;
04030
04031 }
04032
04033
04042 static cpl_error_code
04043 xsh_plist_set_extra_common_keys(cpl_propertylist* plist)
04044 {
04045
04046 cpl_propertylist_append_string(plist,"HDUCLASS", "ESO") ;
04047 cpl_propertylist_set_comment(plist,"HDUCLASS","hdu classification") ;
04048
04049 cpl_propertylist_append_string(plist,"HDUDOC", "DICD") ;
04050 cpl_propertylist_set_comment(plist,"HDUDOC","hdu reference document") ;
04051
04052 cpl_propertylist_append_string(plist,"HDUVERS", "DICD V6.0") ;
04053 cpl_propertylist_set_comment(plist,"HDUVERS","hdu reference document version") ;
04054
04055 return cpl_error_get_code();
04056 }
04057
04070 cpl_error_code
04071 xsh_plist_set_extra_keys(cpl_propertylist* plist,
04072 const char* hduclas1,
04073 const char* hduclas2,
04074 const char* hduclas3,
04075 const char* scidata,
04076 const char* errdata,
04077 const char* qualdata,
04078 const int type)
04079 {
04080
04081 XSH_ASSURE_NOT_ILLEGAL_MSG(type<3,"type < 3");
04082 XSH_ASSURE_NOT_ILLEGAL_MSG(type>=0,"type > 0");
04083
04084 xsh_plist_set_extra_common_keys(plist);
04085
04086 cpl_propertylist_append_string(plist,"HDUCLAS1",hduclas1) ;
04087 cpl_propertylist_set_comment(plist,"HDUCLAS1","hdu format classification") ;
04088
04089 cpl_propertylist_append_string(plist,"HDUCLAS2",hduclas2) ;
04090 cpl_propertylist_set_comment(plist,"HDUCLAS2","hdu type classification") ;
04091
04092 if(type!=0) {
04093 cpl_propertylist_append_string(plist,"HDUCLAS3",hduclas3) ;
04094 cpl_propertylist_set_comment(plist,"HDUCLAS3","hdu info classification") ;
04095 cpl_propertylist_append_string(plist,"SCIDATA",scidata) ;
04096 cpl_propertylist_set_comment(plist,"SCIDATA","name of data extension") ;
04097 }
04098
04099 if(type!=1) {
04100 cpl_propertylist_append_string(plist,"ERRDATA",errdata) ;
04101 cpl_propertylist_set_comment(plist,"ERRDATA","name of errs extension") ;
04102 }
04103
04104 if(type!=2) {
04105 cpl_propertylist_append_string(plist,"QUALDATA",qualdata) ;
04106 cpl_propertylist_set_comment(plist,"QUALDATA","name of qual extension") ;
04107 }
04108 cleanup:
04109 return cpl_error_get_code();
04110 }
04111
04112
04113