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
00436
00437 double xsh_pfits_get_airm_start (const cpl_propertylist * plist)
00438 {
00439 double ret = 1. ;
00440
00441 xsh_get_property_value( plist, XSH_AIRM_START, CPL_TYPE_DOUBLE, &ret ) ;
00442
00443 return ret;
00444 }
00445
00451
00452 double xsh_pfits_get_airm_mean (const cpl_propertylist * plist)
00453 {
00454 double airmass_start=0;
00455 double airmass_end=0;
00456 airmass_start = xsh_pfits_get_airm_start(plist);
00457 airmass_end = xsh_pfits_get_airm_end(plist);
00458
00459 return 0.5*(airmass_start+airmass_end);
00460 }
00461
00467
00468 double xsh_pfits_get_airm_end (const cpl_propertylist * plist)
00469 {
00470 double ret = 1. ;
00471
00472 xsh_get_property_value( plist, XSH_AIRM_END, CPL_TYPE_DOUBLE, &ret ) ;
00473
00474 return ret;
00475 }
00476
00477
00478
00484
00485 double xsh_pfits_get_seeing_start (const cpl_propertylist * plist)
00486 {
00487 double ret = 0;
00488
00489 XSH_PFITS_GET( ret, plist, XSH_SEEING_START, CPL_TYPE_DOUBLE);
00490
00491 cleanup:
00492 return ret;
00493 }
00494
00495
00501
00502 double xsh_pfits_get_seeing_end (const cpl_propertylist * plist)
00503 {
00504 double ret = 0;
00505
00506 XSH_PFITS_GET( ret, plist, XSH_SEEING_END, CPL_TYPE_DOUBLE);
00507
00508 cleanup:
00509 return ret;
00510 }
00511
00512
00520
00521 double xsh_pfits_get_slit_width (const cpl_propertylist * plist,
00522 xsh_instrument * instrument )
00523 {
00524 char * str ;
00525 double ret = 0;
00526 XSH_ARM arm ;
00527
00528 arm = xsh_instrument_get_arm( instrument ) ;
00529
00530 switch ( arm ) {
00531 case XSH_ARM_UVB:
00532 XSH_PFITS_GET( str, plist, XSH_SLIT_UVB, CPL_TYPE_STRING);
00533 break ;
00534 case XSH_ARM_VIS:
00535 XSH_PFITS_GET( str, plist, XSH_SLIT_VIS, CPL_TYPE_STRING);
00536 break ;
00537 case XSH_ARM_NIR:
00538 XSH_PFITS_GET( str, plist, XSH_SLIT_NIR, CPL_TYPE_STRING);
00539 break ;
00540 case XSH_ARM_UNDEFINED:
00541 xsh_msg("arm undefined");
00542 break;
00543 }
00544 sscanf( str, "%lf", &ret ) ;
00545 cleanup:
00546 return ret;
00547 }
00548
00549
00550
00558
00559 char* xsh_pfits_get_slit_value (const cpl_propertylist * plist,
00560 xsh_instrument * instrument )
00561 {
00562 char * str ;
00563 XSH_ARM arm ;
00564
00565 arm = xsh_instrument_get_arm( instrument ) ;
00566
00567 switch ( arm ) {
00568 case XSH_ARM_UVB:
00569 XSH_PFITS_GET( str, plist, XSH_SLIT_UVB, CPL_TYPE_STRING);
00570 break ;
00571 case XSH_ARM_VIS:
00572 XSH_PFITS_GET( str, plist, XSH_SLIT_VIS, CPL_TYPE_STRING);
00573 break ;
00574 case XSH_ARM_NIR:
00575 XSH_PFITS_GET( str, plist, XSH_SLIT_NIR, CPL_TYPE_STRING);
00576 break ;
00577 case XSH_ARM_UNDEFINED:
00578 xsh_msg("arm undefined");
00579 break;
00580 }
00581
00582 cleanup:
00583 return str;
00584 }
00585
00586
00587
00593
00594 double xsh_pfits_get_gain (const cpl_propertylist * plist)
00595 {
00596 double ret = 0;
00597
00598 XSH_PFITS_GET( ret, plist, XSH_DET_GAIN, CPL_TYPE_DOUBLE);
00599
00600 cleanup:
00601 return ret;
00602 }
00603
00604
00610
00611 double xsh_pfits_get_conad (const cpl_propertylist * plist)
00612 {
00613 double ret = 0;
00614
00615 XSH_PFITS_GET( ret, plist, XSH_CONAD, CPL_TYPE_DOUBLE);
00616
00617 cleanup:
00618 return ret;
00619 }
00620
00621
00630
00631 int xsh_pfits_get_datancom( const cpl_propertylist *plist)
00632 {
00633 int ret = 0;
00634
00635 XSH_PFITS_GET( ret, plist, XSH_DATANCOM, CPL_TYPE_INT);
00636
00637 cleanup:
00638 return ret;
00639 }
00640
00641
00647
00648 double
00649 xsh_pfits_get_det_gain (const cpl_propertylist * plist)
00650 {
00651 double returnvalue = 0;
00652
00653 check_msg (xsh_get_property_value (plist, XSH_DET_GAIN, CPL_TYPE_DOUBLE,
00654 &returnvalue),
00655 "Error reading keyword '%s'", XSH_DET_GAIN);
00656
00657 cleanup:
00658 return returnvalue;
00659 }
00660
00661
00667
00668 double xsh_pfits_get_bias_left_median(cpl_propertylist * plist)
00669 {
00670 double returnvalue = 0;
00671
00672 check_msg (xsh_get_property_value (plist, XSH_BIAS_LEFT_MEDIAN,
00673 CPL_TYPE_DOUBLE,&returnvalue),
00674 "Error reading keyword '%s'", XSH_BIAS_LEFT_MEDIAN);
00675
00676 cleanup:
00677 return returnvalue;
00678 }
00679
00680
00681
00687
00688 double xsh_pfits_get_bias_right_median(cpl_propertylist * plist)
00689 {
00690 double returnvalue = 0;
00691
00692 check_msg (xsh_get_property_value (plist, XSH_BIAS_RIGHT_MEDIAN,
00693 CPL_TYPE_DOUBLE,&returnvalue),
00694 "Error reading keyword '%s'", XSH_BIAS_RIGHT_MEDIAN);
00695
00696 cleanup:
00697 return returnvalue;
00698 }
00699
00700
00706
00707 double xsh_pfits_get_bias_up_median(cpl_propertylist * plist)
00708 {
00709 double returnvalue = 0;
00710
00711 check_msg (xsh_get_property_value (plist, XSH_BIAS_UP_MEDIAN,
00712 CPL_TYPE_DOUBLE,&returnvalue),
00713 "Error reading keyword '%s'", XSH_BIAS_UP_MEDIAN);
00714
00715 cleanup:
00716 return returnvalue;
00717 }
00718
00719
00720
00726
00727 double xsh_pfits_get_bias_down_median(cpl_propertylist * plist)
00728 {
00729 double returnvalue = 0;
00730
00731 check_msg (xsh_get_property_value (plist, XSH_BIAS_DOWN_MEDIAN,
00732 CPL_TYPE_DOUBLE,&returnvalue),
00733 "Error reading keyword '%s'", XSH_BIAS_DOWN_MEDIAN);
00734
00735 cleanup:
00736 return returnvalue;
00737 }
00738
00739
00745
00746
00747 double xsh_pfits_get_bias_left_stdev(cpl_propertylist * plist)
00748 {
00749 double returnvalue = 0;
00750
00751 check_msg (xsh_get_property_value (plist, XSH_BIAS_LEFT_STDEV,
00752 CPL_TYPE_DOUBLE,&returnvalue),
00753 "Error reading keyword '%s'", XSH_BIAS_LEFT_STDEV);
00754
00755 cleanup:
00756 return returnvalue;
00757 }
00758
00759
00765
00766 double xsh_pfits_get_bias_right_stdev(cpl_propertylist * plist)
00767 {
00768 double returnvalue = 0;
00769
00770 check_msg (xsh_get_property_value (plist, XSH_BIAS_RIGHT_STDEV,
00771 CPL_TYPE_DOUBLE,&returnvalue),
00772 "Error reading keyword '%s'", XSH_BIAS_RIGHT_STDEV);
00773
00774 cleanup:
00775 return returnvalue;
00776 }
00777
00778
00784
00785
00786 double xsh_pfits_get_bias_up_stdev(cpl_propertylist * plist)
00787 {
00788 double returnvalue = 0;
00789
00790 check_msg (xsh_get_property_value (plist, XSH_BIAS_UP_STDEV,
00791 CPL_TYPE_DOUBLE,&returnvalue),
00792 "Error reading keyword '%s'", XSH_BIAS_UP_STDEV);
00793
00794 cleanup:
00795 return returnvalue;
00796 }
00797
00798
00804
00805 double xsh_pfits_get_bias_down_stdev(cpl_propertylist * plist)
00806 {
00807 double returnvalue = 0;
00808
00809 check_msg (xsh_get_property_value (plist, XSH_BIAS_DOWN_STDEV,
00810 CPL_TYPE_DOUBLE,&returnvalue),
00811 "Error reading keyword '%s'", XSH_BIAS_DOWN_STDEV);
00812
00813 cleanup:
00814 return returnvalue;
00815 }
00816
00824 cpl_error_code
00825 xsh_frame_force_pro_catg(const char* fname,
00826 const char* tag) {
00827
00828
00829 cpl_propertylist* plist=NULL;
00830 int naxis=0;
00831 int update=0;
00832 const char* current_tag=NULL;
00833 cpl_table* tab=NULL;
00834 cpl_image* ima=NULL;
00835 cpl_imagelist* iml=NULL;
00836
00837
00838
00839 check(plist=cpl_propertylist_load(fname,0));
00840 check(naxis=xsh_pfits_get_naxis(plist));
00841 if(cpl_propertylist_has(plist,XSH_PCATG)) {
00842
00843 check(current_tag=cpl_propertylist_get_string(plist,XSH_PCATG));
00844 if(strcmp(current_tag,tag)!= 0) {
00845 check(cpl_propertylist_set_string(plist,XSH_PCATG,tag)) ;
00846 update=1;
00847 }
00848
00849 } else {
00850 check(cpl_propertylist_append_string(plist,XSH_PCATG,tag)) ;
00851 update=1;
00852 }
00853
00854 if(update) {
00855 check(naxis=xsh_pfits_get_naxis(plist));
00856 switch (naxis) {
00857 case 0:
00858 check(tab=cpl_table_load(fname,1,0));
00859 check(cpl_table_save(tab,plist,NULL,fname,CPL_IO_DEFAULT));
00860 xsh_free_table(&tab);
00861 break;
00862 case 1:
00863 case 2:
00864 check(ima=cpl_image_load(fname,CPL_TYPE_FLOAT,0,0));
00865 check(cpl_image_save(ima,fname,CPL_BPP_IEEE_FLOAT,plist,CPL_IO_DEFAULT));
00866 xsh_free_image(&ima);
00867 break;
00868 case 3:
00869 check(iml=cpl_imagelist_load(fname,CPL_TYPE_FLOAT,0));
00870 check(cpl_image_save(ima,fname,CPL_BPP_IEEE_FLOAT,plist,CPL_IO_DEFAULT));
00871 xsh_free_imagelist(&iml);
00872 break;
00873 default:
00874 xsh_msg_error("naxis=%d not supported",naxis);
00875 }
00876
00877 }
00878
00879 cleanup:
00880 xsh_free_propertylist(&plist);
00881 xsh_free_table(&tab);
00882 xsh_free_image(&ima);
00883 xsh_free_imagelist(&iml);
00884
00885 return cpl_error_get_code();
00886
00887 }
00888
00889
00890
00896
00897 void
00898 xsh_pfits_set_extname (cpl_propertylist * plist, const char *value)
00899 {
00900 check_msg (cpl_propertylist_update_string (plist, XSH_EXTNAME, value),
00901 "Error writing keyword '%s'", XSH_EXTNAME);
00902 cleanup:
00903 return;
00904 }
00905
00906
00907 void xsh_pfits_set_arm( cpl_propertylist * plist, xsh_instrument* instr)
00908 {
00909
00910 const char* value = NULL;
00911
00912 check( value = xsh_instrument_arm_tostring( instr));
00913 check_msg (cpl_propertylist_update_string (plist, XSH_SEQ_ARM, value),
00914 "Error writing keyword '%s'", XSH_SEQ_ARM);
00915
00916 cleanup:
00917 return;
00918 }
00919
00925
00926 void
00927 xsh_pfits_set_pcatg (cpl_propertylist * plist, const char *value)
00928 {
00929 check_msg (cpl_propertylist_update_string (plist, XSH_PCATG, value),
00930 "Error writing keyword '%s'", XSH_PCATG);
00931 cleanup:
00932 return;
00933 }
00934
00935
00936
00942
00943 void
00944 xsh_pfits_set_dpr_type (cpl_propertylist * plist, const char *value)
00945 {
00946 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_TYPE, value),
00947 "Error writing keyword '%s'", XSH_DPR_TYPE);
00948 cleanup:
00949 return;
00950 }
00951
00952
00953
00959
00960 void
00961 xsh_pfits_set_dpr_catg (cpl_propertylist * plist, const char *value)
00962 {
00963 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_CATG, value),
00964 "Error writing keyword '%s'", XSH_DPR_CATG);
00965 cleanup:
00966 return;
00967 }
00968
00969
00970
00976
00977 void
00978 xsh_pfits_set_dpr_tech (cpl_propertylist * plist, const char *value)
00979 {
00980 check_msg (cpl_propertylist_update_string (plist, XSH_DPR_TECH, value),
00981 "Error writing keyword '%s'", XSH_DPR_TECH);
00982 cleanup:
00983 return;
00984 }
00985
00986
00987
00993
00994 void
00995 xsh_pfits_set_nsat(cpl_propertylist * plist, int value)
00996 {
00997 check_msg (cpl_propertylist_update_double
00998 (plist, XSH_QC_NPIXSAT, value),
00999 "Error writing keyword '%s'", XSH_QC_NPIXSAT);
01000 cpl_propertylist_set_comment(plist, XSH_QC_NPIXSAT, XSH_QC_NPIXSAT_C);
01001
01002 cleanup:
01003 return;
01004 }
01005
01006
01007
01013
01014 void
01015 xsh_pfits_set_frac_sat(cpl_propertylist * plist, double value)
01016 {
01017 check_msg (cpl_propertylist_update_double
01018 (plist, XSH_QC_FPIXSAT, value),
01019 "Error writing keyword '%s'", XSH_QC_FPIXSAT);
01020 cpl_propertylist_set_comment(plist, XSH_QC_FPIXSAT, XSH_QC_FPIXSAT_C);
01021 cleanup:
01022 return;
01023 }
01024
01025
01026
01032
01033 void
01034 xsh_pfits_set_bias_left_median (cpl_propertylist * plist, double value)
01035 {
01036 check_msg (cpl_propertylist_update_double
01037 (plist, XSH_BIAS_LEFT_MEDIAN, value),
01038 "Error writing keyword '%s'", XSH_BIAS_LEFT_MEDIAN);
01039 cleanup:
01040 return;
01041 }
01042
01043
01049
01050 void
01051 xsh_pfits_set_bias_right_median (cpl_propertylist * plist, double value)
01052 {
01053 check_msg (cpl_propertylist_update_double
01054 (plist, XSH_BIAS_RIGHT_MEDIAN, value),
01055 "Error writing keyword '%s'", XSH_BIAS_RIGHT_MEDIAN);
01056 cleanup:
01057 return;
01058 }
01059
01060
01066
01067 void
01068 xsh_pfits_set_bias_up_median (cpl_propertylist * plist, double value)
01069 {
01070 check_msg (cpl_propertylist_update_double
01071 (plist, XSH_BIAS_UP_MEDIAN, value),
01072 "Error writing keyword '%s'", XSH_BIAS_UP_MEDIAN);
01073 cleanup:
01074 return;
01075 }
01076
01077
01078
01079
01080
01081
01082
01083
01084
01085
01086
01087 void
01088 xsh_pfits_set_datancom (cpl_propertylist * plist, int value)
01089 {
01090 check_msg (cpl_propertylist_update_int
01091 (plist, XSH_DATANCOM, value),
01092 "Error writing keyword '%s'", XSH_DATANCOM);
01093 cleanup:
01094 return;
01095 }
01096
01097
01098
01099
01105
01106 void
01107 xsh_pfits_set_bias_down_median (cpl_propertylist * plist, double value)
01108 {
01109 check_msg (cpl_propertylist_update_double
01110 (plist, XSH_BIAS_DOWN_MEDIAN, value),
01111 "Error writing keyword '%s'", XSH_BIAS_DOWN_MEDIAN);
01112 cleanup:
01113 return;
01114 }
01115
01116
01122
01123 void
01124 xsh_pfits_set_bias_left_stdev (cpl_propertylist * plist, double value)
01125 {
01126 check_msg (cpl_propertylist_update_double
01127 (plist, XSH_BIAS_LEFT_STDEV, value), "Error writing keyword '%s'",
01128 XSH_BIAS_LEFT_STDEV);
01129 cleanup:
01130 return;
01131 }
01132
01133
01139
01140 void
01141 xsh_pfits_set_bias_right_stdev (cpl_propertylist * plist, double value)
01142 {
01143 check_msg (cpl_propertylist_update_double
01144 (plist, XSH_BIAS_RIGHT_STDEV, value), "Error writing keyword '%s'",
01145 XSH_BIAS_RIGHT_STDEV);
01146 cleanup:
01147 return;
01148 }
01149
01150
01156
01157 void
01158 xsh_pfits_set_bias_up_stdev (cpl_propertylist * plist, double value)
01159 {
01160 check_msg (cpl_propertylist_update_double
01161 (plist, XSH_BIAS_UP_STDEV, value), "Error writing keyword '%s'",
01162 XSH_BIAS_UP_STDEV);
01163 cleanup:
01164 return;
01165 }
01166
01167
01173
01174 void
01175 xsh_pfits_set_bias_down_stdev (cpl_propertylist * plist, double value)
01176 {
01177 check_msg (cpl_propertylist_update_double
01178 (plist, XSH_BIAS_DOWN_STDEV, value), "Error writing keyword '%s'",
01179 XSH_BIAS_DOWN_STDEV);
01180 cleanup:
01181 return;
01182 }
01183
01189
01190 void
01191 xsh_pfits_set_dit (cpl_propertylist * plist, double dit)
01192 {
01193 check_msg (cpl_propertylist_update_double (plist, XSH_DET_DIT, dit),
01194 "Error writing keyword '%s'", XSH_DET_DIT);
01195
01196 cleanup:
01197 return;
01198 }
01199
01205
01206 double
01207 xsh_pfits_get_win1_dit1 (const cpl_propertylist * plist)
01208 {
01209 double returnvalue = 0;
01210
01211 check_msg (xsh_get_property_value
01212 (plist, XSH_DET_WIN1_DIT1, CPL_TYPE_DOUBLE, &returnvalue),
01213 "Error reading keyword '%s'", XSH_DET_WIN1_DIT1);
01214
01215 cleanup:
01216 return returnvalue;
01217 }
01218
01219
01225
01226 double
01227 xsh_pfits_get_dit (const cpl_propertylist * plist)
01228 {
01229 double returnvalue = 0;
01230
01231 check_msg (xsh_get_property_value
01232 (plist, XSH_DET_DIT, CPL_TYPE_DOUBLE, &returnvalue),
01233 "Error reading keyword '%s'", XSH_DET_DIT);
01234
01235 cleanup:
01236 return returnvalue;
01237 }
01238
01239
01245
01246 const char *
01247 xsh_pfits_get_raw1name (const cpl_propertylist * plist)
01248 {
01249 const char *returnvalue = "";
01250
01251 check_msg (xsh_get_property_value
01252 (plist, XSH_RAW1_NAME, CPL_TYPE_STRING, &returnvalue),
01253 "Error reading keyword '%s'", XSH_RAW1_NAME);
01254
01255 cleanup:
01256 return returnvalue;
01257 }
01258
01259
01260
01261
01267
01268 const char *
01269 xsh_pfits_get_raw1catg (const cpl_propertylist * plist)
01270 {
01271 const char *returnvalue = "";
01272
01273 check_msg (xsh_get_property_value
01274 (plist, XSH_RAW1_CATG, CPL_TYPE_STRING, &returnvalue),
01275 "Error reading keyword '%s'", XSH_RAW1_CATG);
01276
01277 cleanup:
01278 return returnvalue;
01279 }
01280
01281
01282
01288
01289 const char *
01290 xsh_pfits_get_obs_targ_name (const cpl_propertylist * plist)
01291 {
01292 const char *returnvalue = "";
01293
01294 check_msg (xsh_get_property_value
01295 (plist, XSH_OBS_TARG_NAME, CPL_TYPE_STRING, &returnvalue),
01296 "Error reading keyword '%s'", XSH_OBS_TARG_NAME);
01297
01298 cleanup:
01299 return returnvalue;
01300 }
01301
01302
01308
01309 const char *
01310 xsh_pfits_get_arcfile (const cpl_propertylist * plist)
01311 {
01312 const char *returnvalue = "";
01313
01314 check_msg (xsh_get_property_value
01315 (plist, XSH_ARCFILE, CPL_TYPE_STRING, &returnvalue),
01316 "Error reading keyword '%s'", XSH_ARCFILE);
01317
01318 cleanup:
01319 return returnvalue;
01320 }
01326
01327 bool
01328 xsh_pfits_get_lamp_on_off (const cpl_propertylist * plist)
01329 {
01330 const char *returnvalue = "";
01331
01332 check_msg (xsh_get_property_value
01333 (plist, XSH_LAMP_ON_OFF, CPL_TYPE_BOOL, &returnvalue),
01334 "Error reading keyword '%s'", XSH_LAMP_ON_OFF);
01335
01336 cleanup:
01337 return returnvalue;
01338 }
01339
01340
01346
01347 const char *
01348 xsh_pfits_get_pcatg (const cpl_propertylist * plist)
01349 {
01350 const char *returnvalue = "";
01351
01352 check_msg (xsh_get_property_value
01353 (plist, XSH_PCATG, CPL_TYPE_STRING, &returnvalue),
01354 "Error reading keyword '%s'", XSH_PCATG);
01355 cleanup:
01356 return returnvalue;
01357 }
01358
01359
01360
01366
01367 const char *
01368 xsh_pfits_get_dpr_tech (const cpl_propertylist * plist)
01369 {
01370 const char *returnvalue = "";
01371
01372 check_msg (xsh_get_property_value
01373 (plist, XSH_DPR_TECH, CPL_TYPE_STRING, &returnvalue),
01374 "Error reading keyword '%s'", XSH_DPR_TECH);
01375 cleanup:
01376 return returnvalue;
01377 }
01378
01379
01380
01386
01387 const char *
01388 xsh_pfits_get_dpr_type (const cpl_propertylist * plist)
01389 {
01390 const char *returnvalue = "";
01391
01392 check_msg (xsh_get_property_value
01393 (plist, XSH_DPR_TYPE, CPL_TYPE_STRING, &returnvalue),
01394 "Error reading keyword '%s'", XSH_DPR_TYPE);
01395 cleanup:
01396 return returnvalue;
01397 }
01398
01399
01400
01401
01407
01408 const char *
01409 xsh_pfits_get_dpr_catg (const cpl_propertylist * plist)
01410 {
01411 const char *returnvalue = "";
01412
01413 check_msg (xsh_get_property_value
01414 (plist, XSH_DPR_CATG, CPL_TYPE_STRING, &returnvalue),
01415 "Error reading keyword '%s'", XSH_DPR_CATG);
01416 cleanup:
01417 return returnvalue;
01418 }
01419
01420
01426
01427 const char *
01428 xsh_pfits_get_extname (const cpl_propertylist * plist)
01429 {
01430 const char *returnvalue = "";
01431
01432 check_msg (xsh_get_property_value
01433 (plist, XSH_EXTNAME, CPL_TYPE_STRING, &returnvalue),
01434 "Error reading keyword '%s'", XSH_EXTNAME);
01435 cleanup:
01436 return returnvalue;
01437 }
01438
01439
01445
01446 const char *
01447 xsh_pfits_get_date (const cpl_propertylist * plist)
01448 {
01449 const char *returnvalue = "";
01450
01451 check_msg (xsh_get_property_value
01452 (plist, XSH_DATE, CPL_TYPE_STRING, &returnvalue),
01453 "Error reading keyword '%s'", XSH_DATE);
01454
01455 cleanup:
01456 return returnvalue;
01457 }
01458
01459
01465
01466 const char *
01467 xsh_pfits_get_date_obs (const cpl_propertylist * plist)
01468 {
01469 const char *returnvalue = "";
01470
01471 check_msg (xsh_get_property_value
01472 (plist, XSH_DATE_OBS, CPL_TYPE_STRING, &returnvalue),
01473 "Error reading keyword '%s'", XSH_DATE_OBS);
01474
01475 cleanup:
01476 return returnvalue;
01477 }
01478
01484
01485 double
01486 xsh_pfits_get_pszx (const cpl_propertylist * plist)
01487 {
01488 double returnvalue = 0.0;
01489
01490 check_msg (xsh_get_property_value (plist, XSH_PSZX, CPL_TYPE_DOUBLE,
01491 &returnvalue),
01492 "Error reading keyword '%s'", XSH_PSZX);
01493
01494 cleanup:
01495 return returnvalue;
01496 }
01497
01503
01504 double
01505 xsh_pfits_get_pszy (const cpl_propertylist * plist)
01506 {
01507 double returnvalue = 0.0;
01508
01509 check_msg (xsh_get_property_value (plist, XSH_PSZY, CPL_TYPE_DOUBLE,
01510 &returnvalue),
01511 "Error reading keyword '%s'", XSH_PSZY);
01512
01513 cleanup:
01514 return returnvalue;
01515 }
01516
01522
01523 double
01524 xsh_pfits_get_det_pxspace(const cpl_propertylist * plist)
01525 {
01526 double returnvalue = 0.0;
01527
01528 check_msg (xsh_get_property_value (plist, XSH_DET_PXSPACE, CPL_TYPE_DOUBLE,
01529 &returnvalue),
01530 "Error reading keyword '%s'", XSH_DET_PXSPACE);
01531
01532 cleanup:
01533 return returnvalue;
01534 }
01535
01536
01537
01538
01544
01545 int xsh_pfits_get_FOCU1ENC (const cpl_propertylist * plist)
01546 {
01547 int returnvalue = 0;
01548
01549 check_msg (xsh_get_property_value (plist, XSH_FOCU1ENC_VAL, CPL_TYPE_INT,
01550 &returnvalue),
01551 "Error reading keyword '%s'", XSH_FOCU1ENC_VAL);
01552
01553 cleanup:
01554 return returnvalue;
01555 }
01556
01557
01558
01559
01565
01566 double xsh_pfits_get_temp5 (const cpl_propertylist * plist)
01567 {
01568 double returnvalue = 0.0;
01569
01570 check_msg (xsh_get_property_value (plist, XSH_TEMP5_VAL, CPL_TYPE_DOUBLE,
01571 &returnvalue),
01572 "Error reading keyword '%s'", XSH_TEMP5_VAL);
01573
01574 cleanup:
01575 return returnvalue;
01576 }
01577
01578
01579
01580
01586
01587 double xsh_pfits_get_temp2 (const cpl_propertylist * plist)
01588 {
01589 double returnvalue = 0.0;
01590
01591 check_msg (xsh_get_property_value (plist, XSH_TEMP2_VAL, CPL_TYPE_DOUBLE,
01592 &returnvalue),
01593 "Error reading keyword '%s'", XSH_TEMP2_VAL);
01594
01595 cleanup:
01596 return returnvalue;
01597 }
01598
01599
01600
01601
01607
01608 double xsh_pfits_get_temp82 (const cpl_propertylist * plist)
01609 {
01610 double returnvalue = 0.0;
01611
01612 check_msg (xsh_get_property_value (plist, XSH_TEMP82_VAL, CPL_TYPE_DOUBLE,
01613 &returnvalue),
01614 "Error reading keyword '%s'", XSH_TEMP82_VAL);
01615
01616 cleanup:
01617 return returnvalue;
01618 }
01619
01620
01621
01627
01628 double xsh_pfits_get_crval1 (const cpl_propertylist * plist)
01629 {
01630 double returnvalue = 0.0;
01631
01632 check_msg (xsh_get_property_value (plist, XSH_CRVAL1, CPL_TYPE_DOUBLE,
01633 &returnvalue),
01634 "Error reading keyword '%s'", XSH_CRVAL1);
01635
01636 cleanup:
01637 return returnvalue;
01638 }
01639
01640
01646
01647 double xsh_pfits_get_crval2 (const cpl_propertylist * plist)
01648 {
01649 double returnvalue = 0.0;
01650
01651 check_msg (xsh_get_property_value (plist, XSH_CRVAL2, CPL_TYPE_DOUBLE,
01652 &returnvalue),
01653 "Error reading keyword '%s'", XSH_CRVAL2);
01654
01655 cleanup:
01656 return returnvalue;
01657 }
01658
01659
01660
01666
01667 double xsh_pfits_get_crval3 (const cpl_propertylist * plist)
01668 {
01669 double returnvalue = 0.0;
01670
01671 check_msg (xsh_get_property_value (plist, XSH_CRVAL3, CPL_TYPE_DOUBLE,
01672 &returnvalue),
01673 "Error reading keyword '%s'", XSH_CRVAL3);
01674
01675 cleanup:
01676 return returnvalue;
01677 }
01678
01679
01680
01685
01686 double xsh_pfits_get_crpix1(const cpl_propertylist * plist)
01687 {
01688 double returnvalue = 0.0;
01689 check_msg (xsh_get_property_value (plist, XSH_CRPIX1, CPL_TYPE_DOUBLE,
01690 &returnvalue),
01691 "Error reading keyword '%s'", XSH_CRPIX1);
01692
01693 cleanup:
01694 return returnvalue;
01695 }
01696
01697
01702
01703 double xsh_pfits_get_crpix2(const cpl_propertylist * plist)
01704 {
01705 double returnvalue = 0.0;
01706 check_msg (xsh_get_property_value (plist, XSH_CRPIX2, CPL_TYPE_DOUBLE,
01707 &returnvalue),
01708 "Error reading keyword '%s'", XSH_CRPIX2);
01709
01710 cleanup:
01711 return returnvalue;
01712 }
01713
01714
01719
01720 double xsh_pfits_get_crpix3(const cpl_propertylist * plist)
01721 {
01722 double returnvalue = 0.0;
01723 check_msg (xsh_get_property_value (plist, XSH_CRPIX3, CPL_TYPE_DOUBLE,
01724 &returnvalue),
01725 "Error reading keyword '%s'", XSH_CRPIX3);
01726
01727 cleanup:
01728 return returnvalue;
01729 }
01730
01731
01737
01738 double xsh_pfits_get_cd11 (const cpl_propertylist * plist)
01739 {
01740 double returnvalue = 0.0;
01741
01742 check_msg (xsh_get_property_value (plist, XSH_CD11, CPL_TYPE_DOUBLE,
01743 &returnvalue),
01744 "Error reading keyword '%s'", XSH_CD11);
01745
01746 cleanup:
01747 return returnvalue;
01748 }
01749
01750
01751
01752
01758
01759 double xsh_pfits_get_cd12 (const cpl_propertylist * plist)
01760 {
01761 double returnvalue = 0.0;
01762
01763 check_msg (xsh_get_property_value (plist, XSH_CD12, CPL_TYPE_DOUBLE,
01764 &returnvalue),
01765 "Error reading keyword '%s'", XSH_CD12);
01766
01767 cleanup:
01768 return returnvalue;
01769 }
01770
01771
01777
01778 double xsh_pfits_get_cd21 (const cpl_propertylist * plist)
01779 {
01780 double returnvalue = 0.0;
01781
01782 check_msg (xsh_get_property_value (plist, XSH_CD21, CPL_TYPE_DOUBLE,
01783 &returnvalue),
01784 "Error reading keyword '%s'", XSH_CD21);
01785
01786 cleanup:
01787 return returnvalue;
01788 }
01789
01790
01791
01797
01798 double xsh_pfits_get_cd22 (const cpl_propertylist * plist)
01799 {
01800 double returnvalue = 0.0;
01801
01802 check_msg (xsh_get_property_value (plist, XSH_CD22, CPL_TYPE_DOUBLE,
01803 &returnvalue),
01804 "Error reading keyword '%s'", XSH_CD22);
01805
01806 cleanup:
01807 return returnvalue;
01808 }
01809
01810
01816
01817 double xsh_pfits_get_cd13 (const cpl_propertylist * plist)
01818 {
01819 double returnvalue = 0.0;
01820
01821 check_msg (xsh_get_property_value (plist, XSH_CD13, CPL_TYPE_DOUBLE,
01822 &returnvalue),
01823 "Error reading keyword '%s'", XSH_CD13);
01824
01825 cleanup:
01826 return returnvalue;
01827 }
01828
01829
01830
01836
01837 double xsh_pfits_get_cd23 (const cpl_propertylist * plist)
01838 {
01839 double returnvalue = 0.0;
01840
01841 check_msg (xsh_get_property_value (plist, XSH_CD23, CPL_TYPE_DOUBLE,
01842 &returnvalue),
01843 "Error reading keyword '%s'", XSH_CD23);
01844
01845 cleanup:
01846 return returnvalue;
01847 }
01848
01849
01850
01856
01857 double xsh_pfits_get_cd33 (const cpl_propertylist * plist)
01858 {
01859 double returnvalue = 0.0;
01860
01861 check_msg (xsh_get_property_value (plist, XSH_CD33, CPL_TYPE_DOUBLE,
01862 &returnvalue),
01863 "Error reading keyword '%s'", XSH_CD33);
01864
01865 cleanup:
01866 return returnvalue;
01867 }
01868
01869
01875
01876 double xsh_pfits_get_cd31 (const cpl_propertylist * plist)
01877 {
01878 double returnvalue = 0.0;
01879
01880 check_msg (xsh_get_property_value (plist, XSH_CD31, CPL_TYPE_DOUBLE,
01881 &returnvalue),
01882 "Error reading keyword '%s'", XSH_CD31);
01883
01884 cleanup:
01885 return returnvalue;
01886 }
01887
01888
01889
01895
01896 double xsh_pfits_get_cd32 (const cpl_propertylist * plist)
01897 {
01898 double returnvalue = 0.0;
01899
01900 check_msg (xsh_get_property_value (plist, XSH_CD32, CPL_TYPE_DOUBLE,
01901 &returnvalue),
01902 "Error reading keyword '%s'", XSH_CD32);
01903
01904 cleanup:
01905 return returnvalue;
01906 }
01907
01908
01909
01910
01916
01917 double xsh_pfits_get_cdelt1 (const cpl_propertylist * plist)
01918 {
01919 double returnvalue = 0.0;
01920
01921 check_msg (xsh_get_property_value (plist, XSH_CDELT1, CPL_TYPE_DOUBLE,
01922 &returnvalue),
01923 "Error reading keyword '%s'", XSH_CDELT1);
01924
01925 cleanup:
01926 return returnvalue;
01927 }
01928
01929
01930
01936
01937 double xsh_pfits_get_cdelt2 (const cpl_propertylist * plist)
01938 {
01939 double returnvalue = 0.0;
01940
01941 check_msg (xsh_get_property_value (plist, XSH_CDELT2, CPL_TYPE_DOUBLE,
01942 &returnvalue),
01943 "Error reading keyword '%s'", XSH_CDELT2);
01944
01945 cleanup:
01946 return returnvalue;
01947 }
01948
01949
01955
01956 double xsh_pfits_get_cdelt3 (const cpl_propertylist * plist)
01957 {
01958 double returnvalue = 0.0;
01959
01960 check_msg (xsh_get_property_value (plist, XSH_CDELT3, CPL_TYPE_DOUBLE,
01961 &returnvalue),
01962 "Error reading keyword '%s'", XSH_CDELT3);
01963
01964 cleanup:
01965 return returnvalue;
01966 }
01967
01968
01974
01975 double xsh_pfits_get_exptime (const cpl_propertylist * plist)
01976 {
01977 double returnvalue = 0.0;
01978
01979 check_msg (xsh_get_property_value (plist, XSH_EXPTIME,CPL_TYPE_DOUBLE,
01980 &returnvalue),
01981 "Error reading keyword '%s'", XSH_EXPTIME);
01982
01983 cleanup:
01984 return returnvalue;
01985 }
01986
01992
01993 void
01994 xsh_pfits_set_exptime (cpl_propertylist * plist, double value)
01995 {
01996 check_msg (cpl_propertylist_update_double (plist, XSH_EXPTIME, value),
01997 "Error writing keyword '%s'", XSH_EXPTIME);
01998
01999 cleanup:
02000 return;
02001 }
02002
02003
02009
02010 void xsh_pfits_set_cd1(cpl_propertylist * plist, double value)
02011 {
02012 check_msg (cpl_propertylist_update_double (plist, XSH_CD1, value),
02013 "Error writing keyword '%s'", XSH_CD1);
02014 cleanup:
02015 return;
02016 }
02017
02018
02019
02025
02026 void xsh_pfits_set_cd11(cpl_propertylist * plist, double value)
02027 {
02028 check_msg (cpl_propertylist_update_double (plist, XSH_CD11, value),
02029 "Error writing keyword '%s'", XSH_CD11);
02030 cleanup:
02031 return;
02032 }
02033
02034
02040
02041 void xsh_pfits_set_cd12(cpl_propertylist * plist, double value)
02042 {
02043 check_msg (cpl_propertylist_update_double (plist, XSH_CD12, value),
02044 "Error writing keyword '%s'", XSH_CD12);
02045 cleanup:
02046 return;
02047 }
02048
02049
02055
02056 void xsh_pfits_set_cd21(cpl_propertylist * plist, double value)
02057 {
02058 check_msg (cpl_propertylist_update_double (plist, XSH_CD21, value),
02059 "Error writing keyword '%s'", XSH_CD21);
02060 cleanup:
02061 return;
02062 }
02063
02064
02070
02071 void xsh_pfits_set_cd22(cpl_propertylist * plist, double value)
02072 {
02073 check_msg (cpl_propertylist_update_double (plist, XSH_CD22, value),
02074 "Error writing keyword '%s'", XSH_CD22);
02075 cleanup:
02076 return;
02077 }
02078
02079
02085
02086 void xsh_pfits_set_cd13(cpl_propertylist * plist, double value)
02087 {
02088 check_msg (cpl_propertylist_update_double (plist, XSH_CD13, value),
02089 "Error writing keyword '%s'", XSH_CD13);
02090 cleanup:
02091 return;
02092 }
02093
02094
02100
02101 void xsh_pfits_set_cd23(cpl_propertylist * plist, double value)
02102 {
02103 check_msg (cpl_propertylist_update_double (plist, XSH_CD23, value),
02104 "Error writing keyword '%s'", XSH_CD23);
02105 cleanup:
02106 return;
02107 }
02108
02109
02110
02116
02117 void xsh_pfits_set_cd33(cpl_propertylist * plist, double value)
02118 {
02119 check_msg (cpl_propertylist_update_double (plist, XSH_CD33, value),
02120 "Error writing keyword '%s'", XSH_CD33);
02121 cleanup:
02122 return;
02123 }
02124
02125
02131
02132 void xsh_pfits_set_cd32(cpl_propertylist * plist, double value)
02133 {
02134 check_msg (cpl_propertylist_update_double (plist, XSH_CD32, value),
02135 "Error writing keyword '%s'", XSH_CD32);
02136 cleanup:
02137 return;
02138 }
02139
02140
02141
02147
02148 void xsh_pfits_set_cd31(cpl_propertylist * plist, double value)
02149 {
02150 check_msg (cpl_propertylist_update_double (plist, XSH_CD31, value),
02151 "Error writing keyword '%s'", XSH_CD31);
02152 cleanup:
02153 return;
02154 }
02155
02156
02157
02158
02164
02165 void xsh_pfits_set_crpix1(cpl_propertylist * plist, double value)
02166 {
02167 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX1, value),
02168 "Error writing keyword '%s'", XSH_CRPIX1);
02169 cleanup:
02170 return;
02171 }
02172
02173
02174
02175
02181
02182 void xsh_pfits_set_crval1(cpl_propertylist * plist, double value)
02183 {
02184 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL1, value),
02185 "Error writing keyword '%s'", XSH_CRVAL1);
02186 cleanup:
02187 return;
02188 }
02189
02190
02191
02197
02198 void xsh_pfits_set_cdelt1(cpl_propertylist * plist, double value)
02199 {
02200 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT1, value),
02201 "Error writing keyword '%s'", XSH_CDELT1);
02202 cleanup:
02203 return;
02204 }
02205
02206
02207
02208
02214
02215 void xsh_pfits_set_crpix2(cpl_propertylist * plist, double value)
02216 {
02217 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX2, value),
02218 "Error writing keyword '%s'", XSH_CRPIX2);
02219 cleanup:
02220 return;
02221 }
02222
02223
02229
02230 void xsh_pfits_set_crpix3(cpl_propertylist * plist, double value)
02231 {
02232 check_msg (cpl_propertylist_update_double (plist, XSH_CRPIX3, value),
02233 "Error writing keyword '%s'", XSH_CRPIX3);
02234 cleanup:
02235 return;
02236 }
02237
02238
02239
02245
02246 void xsh_pfits_set_crval2(cpl_propertylist * plist, double value)
02247 {
02248 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL2, value),
02249 "Error writing keyword '%s'", XSH_CRVAL2);
02250 cleanup:
02251 return;
02252 }
02253
02254
02260
02261 void xsh_pfits_set_crval3(cpl_propertylist * plist, double value)
02262 {
02263 check_msg (cpl_propertylist_update_double (plist, XSH_CRVAL3, value),
02264 "Error writing keyword '%s'", XSH_CRVAL3);
02265 cleanup:
02266 return;
02267 }
02268
02269
02270
02276
02277 void xsh_pfits_set_cdelt2(cpl_propertylist * plist, double value)
02278 {
02279 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT2, value),
02280 "Error writing keyword '%s'", XSH_CDELT2);
02281 cleanup:
02282 return;
02283 }
02284
02285
02286
02292
02293 void xsh_pfits_set_cdelt3(cpl_propertylist * plist, double value)
02294 {
02295 check_msg (cpl_propertylist_update_double (plist, XSH_CDELT3, value),
02296 "Error writing keyword '%s'", XSH_CDELT3);
02297 cleanup:
02298 return;
02299 }
02300
02301
02307
02308 void xsh_pfits_set_ctype1(cpl_propertylist * plist, const char* value)
02309 {
02310 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE1, value),
02311 "Error writing keyword '%s'", XSH_CTYPE1);
02312 cleanup:
02313 return;
02314 }
02315
02316
02322
02323 void xsh_pfits_set_ctype2(cpl_propertylist * plist, const char* value)
02324 {
02325 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE2, value),
02326 "Error writing keyword '%s'", XSH_CTYPE2);
02327 cleanup:
02328 return;
02329 }
02330
02331
02332
02338
02339 void xsh_pfits_set_ctype3(cpl_propertylist * plist, const char* value)
02340 {
02341 check_msg (cpl_propertylist_update_string (plist, XSH_CTYPE3, value),
02342 "Error writing keyword '%s'", XSH_CTYPE3);
02343 cleanup:
02344 return;
02345 }
02346
02347
02353
02354 void xsh_pfits_set_wavesol_lambda_min(cpl_propertylist * plist, double value)
02355 {
02356 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_LAMBDA_MIN,
02357 value),
02358 "Error writing keyword '%s'", XSH_WAVESOL_LAMBDA_MIN);
02359
02360 cleanup:
02361 return;
02362 }
02363
02364
02370
02371 void xsh_pfits_set_wavesol_lambda_max(cpl_propertylist * plist, double value)
02372 {
02373 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_LAMBDA_MAX,
02374 value),
02375 "Error writing keyword '%s'", XSH_WAVESOL_LAMBDA_MAX);
02376
02377 cleanup:
02378 return;
02379 }
02380
02381
02387
02388 void xsh_pfits_set_wavesol_order_min(cpl_propertylist * plist, double value)
02389 {
02390 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_ORDER_MIN,
02391 value),
02392 "Error writing keyword '%s'", XSH_WAVESOL_ORDER_MIN);
02393
02394 cleanup:
02395 return;
02396 }
02397
02398
02404
02405 void xsh_pfits_set_wavesol_order_max(cpl_propertylist * plist, double value)
02406 {
02407 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_ORDER_MAX,
02408 value),
02409 "Error writing keyword '%s'", XSH_WAVESOL_ORDER_MAX);
02410
02411 cleanup:
02412 return;
02413 }
02414
02415
02421
02422 void xsh_pfits_set_wavesol_slit_min(cpl_propertylist * plist, double value)
02423 {
02424 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_SLIT_MIN,
02425 value),
02426 "Error writing keyword '%s'", XSH_WAVESOL_SLIT_MIN);
02427
02428 cleanup:
02429 return;
02430 }
02431
02432
02438
02439 void xsh_pfits_set_wavesol_slit_max(cpl_propertylist * plist, double value)
02440 {
02441 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_SLIT_MAX,
02442 value),
02443 "Error writing keyword '%s'", XSH_WAVESOL_SLIT_MAX);
02444
02445 cleanup:
02446 return;
02447 }
02448
02449
02455
02456 void xsh_pfits_set_extract_slit_min(cpl_propertylist * plist, double value)
02457 {
02458 check_msg (cpl_propertylist_update_double (plist, XSH_EXTRACT_SLIT_MIN,
02459 value),
02460 "Error writing keyword '%s'", XSH_EXTRACT_SLIT_MIN);
02461
02462 cleanup:
02463 return;
02464 }
02465
02466
02467
02468
02474
02475 void xsh_pfits_set_extract_slit_max(cpl_propertylist * plist, double value)
02476 {
02477 check_msg (cpl_propertylist_update_double (plist, XSH_EXTRACT_SLIT_MAX,
02478 value),
02479 "Error writing keyword '%s'", XSH_EXTRACT_SLIT_MAX);
02480
02481 cleanup:
02482 return;
02483 }
02484
02490
02491 void xsh_pfits_set_wavesol_x_min(cpl_propertylist * plist, double value)
02492 {
02493 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_X_MIN,
02494 value),
02495 "Error writing keyword '%s'", XSH_WAVESOL_X_MIN);
02496
02497 cleanup:
02498 return;
02499 }
02500
02501
02507
02508 void xsh_pfits_set_wavesol_x_max(cpl_propertylist * plist, double value)
02509 {
02510 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_X_MAX,
02511 value),
02512 "Error writing keyword '%s'", XSH_WAVESOL_X_MAX);
02513
02514 cleanup:
02515 return;
02516 }
02517
02518
02519
02525
02526 void xsh_pfits_set_wavesol_y_min(cpl_propertylist * plist, double value)
02527 {
02528 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_Y_MIN,
02529 value),
02530 "Error writing keyword '%s'", XSH_WAVESOL_Y_MIN);
02531
02532 cleanup:
02533 return;
02534 }
02535
02536
02542
02543 void xsh_pfits_set_wavesol_y_max(cpl_propertylist * plist, double value)
02544 {
02545 check_msg (cpl_propertylist_update_double (plist, XSH_WAVESOL_Y_MAX,
02546 value),
02547 "Error writing keyword '%s'", XSH_WAVESOL_Y_MAX);
02548
02549 cleanup:
02550 return;
02551 }
02552
02553
02559
02560 double xsh_pfits_get_wavesol_lambda_min(cpl_propertylist * plist)
02561 {
02562 double returnvalue = 0.0;
02563
02564 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_LAMBDA_MIN,
02565 CPL_TYPE_DOUBLE, &returnvalue),
02566 "Error reading keyword '%s'", XSH_WAVESOL_LAMBDA_MIN);
02567
02568 cleanup:
02569 return returnvalue;
02570 }
02571
02572
02578
02579 double xsh_pfits_get_wavesol_lambda_max(cpl_propertylist * plist)
02580 {
02581 double returnvalue = 0.0;
02582
02583 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_LAMBDA_MAX,
02584 CPL_TYPE_DOUBLE, &returnvalue),
02585 "Error reading keyword '%s'", XSH_WAVESOL_LAMBDA_MAX);
02586
02587 cleanup:
02588 return returnvalue;
02589 }
02590
02591
02597
02598 double xsh_pfits_get_wavesol_order_min(cpl_propertylist * plist)
02599 {
02600 double returnvalue = 0.0;
02601
02602 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_ORDER_MIN,
02603 CPL_TYPE_DOUBLE, &returnvalue),
02604 "Error reading keyword '%s'", XSH_WAVESOL_ORDER_MIN);
02605
02606 cleanup:
02607 return returnvalue;
02608 }
02609
02610
02616
02617 double xsh_pfits_get_wavesol_order_max(cpl_propertylist * plist)
02618 {
02619 double returnvalue = 0.0;
02620
02621 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_ORDER_MAX,
02622 CPL_TYPE_DOUBLE, &returnvalue),
02623 "Error reading keyword '%s'", XSH_WAVESOL_ORDER_MAX);
02624
02625 cleanup:
02626 return returnvalue;
02627 }
02628
02629
02635
02636 double xsh_pfits_get_wavesol_slit_min(cpl_propertylist * plist)
02637 {
02638 double returnvalue = 0.0;
02639
02640 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_SLIT_MIN,
02641 CPL_TYPE_DOUBLE, &returnvalue),
02642 "Error reading keyword '%s'", XSH_WAVESOL_SLIT_MIN);
02643
02644 cleanup:
02645 return returnvalue;
02646 }
02647
02648
02654
02655 double xsh_pfits_get_wavesol_slit_max(cpl_propertylist * plist)
02656 {
02657 double returnvalue = 0.0;
02658
02659 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_SLIT_MAX,
02660 CPL_TYPE_DOUBLE, &returnvalue),
02661 "Error reading keyword '%s'", XSH_WAVESOL_SLIT_MAX);
02662
02663 cleanup:
02664 return returnvalue;
02665 }
02666
02667
02673
02674 double xsh_pfits_get_extract_slit_min(cpl_propertylist * plist)
02675 {
02676 double returnvalue = 0.0;
02677
02678 check_msg (xsh_get_property_value (plist, XSH_EXTRACT_SLIT_MIN,
02679 CPL_TYPE_DOUBLE, &returnvalue),
02680 "Error reading keyword '%s'", XSH_EXTRACT_SLIT_MIN);
02681
02682 cleanup:
02683 return returnvalue;
02684 }
02685
02686
02692
02693 double xsh_pfits_get_extract_slit_max(cpl_propertylist * plist)
02694 {
02695 double returnvalue = 0.0;
02696
02697 check_msg (xsh_get_property_value (plist, XSH_EXTRACT_SLIT_MAX,
02698 CPL_TYPE_DOUBLE, &returnvalue),
02699 "Error reading keyword '%s'", XSH_EXTRACT_SLIT_MAX);
02700
02701 cleanup:
02702 return returnvalue;
02703 }
02704
02705
02711
02712 double xsh_pfits_get_wavesol_x_min(cpl_propertylist * plist)
02713 {
02714 double returnvalue = 0.0;
02715
02716 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_X_MIN,
02717 CPL_TYPE_DOUBLE, &returnvalue),
02718 "Error reading keyword '%s'", XSH_WAVESOL_X_MIN);
02719
02720 cleanup:
02721 return returnvalue;
02722 }
02723
02724
02730
02731 double xsh_pfits_get_wavesol_x_max(cpl_propertylist * plist)
02732 {
02733 double returnvalue = 0.0;
02734
02735 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_X_MAX,
02736 CPL_TYPE_DOUBLE, &returnvalue),
02737 "Error reading keyword '%s'", XSH_WAVESOL_X_MAX);
02738
02739 cleanup:
02740 return returnvalue;
02741 }
02742
02743
02749
02750 double xsh_pfits_get_wavesol_y_min(cpl_propertylist * plist)
02751 {
02752 double returnvalue = 0.0;
02753
02754 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_Y_MIN,
02755 CPL_TYPE_DOUBLE, &returnvalue),
02756 "Error reading keyword '%s'", XSH_WAVESOL_Y_MIN);
02757
02758 cleanup:
02759 return returnvalue;
02760 }
02761
02762
02768
02769 double xsh_pfits_get_wavesol_y_max(cpl_propertylist * plist)
02770 {
02771 double returnvalue = 0.0;
02772
02773 check_msg (xsh_get_property_value (plist, XSH_WAVESOL_Y_MAX,
02774 CPL_TYPE_DOUBLE, &returnvalue),
02775 "Error reading keyword '%s'", XSH_WAVESOL_Y_MAX);
02776
02777 cleanup:
02778 return returnvalue;
02779 }
02780
02781
02790
02791 const char *
02792 xsh_pfits_get_wavesoltype( const cpl_propertylist * plist)
02793 {
02794 const char *returnvalue = "";
02795
02796 check_msg (xsh_get_property_value
02797 (plist, XSH_WAVESOLTYPE, CPL_TYPE_STRING, &returnvalue),
02798 "Error reading keyword '%s'", XSH_WAVESOLTYPE);
02799 cleanup:
02800 return returnvalue;
02801 }
02802
02803
02812
02813 void xsh_pfits_set_wavesoltype( cpl_propertylist * plist, const char* value)
02814 {
02815 XSH_REGDEBUG("writing keyword %s = %s", XSH_WAVESOLTYPE, value);
02816 check_msg (cpl_propertylist_update_string (plist, XSH_WAVESOLTYPE, value),
02817 "Error writing keyword '%s'", XSH_WAVESOLTYPE);
02818 cleanup:
02819 return;
02820 }
02821
02822
02828
02829 void xsh_pfits_set_rectify_bin_lambda(cpl_propertylist * plist, double value)
02830 {
02831 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_BIN_LAMBDA,
02832 value),
02833 "Error writing keyword '%s'", XSH_RECTIFY_BIN_LAMBDA);
02834
02835 cleanup:
02836 return;
02837 }
02838
02844
02845 void xsh_pfits_set_rectify_bin_space(cpl_propertylist * plist, double value)
02846 {
02847 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_BIN_SPACE,
02848 value),
02849 "Error writing keyword '%s'", XSH_RECTIFY_BIN_SPACE);
02850
02851 cleanup:
02852 return;
02853 }
02854
02860
02861 void xsh_pfits_set_rectify_lambda_min(cpl_propertylist * plist, double value)
02862 {
02863 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_LAMBDA_MIN,
02864 value),
02865 "Error writing keyword '%s'", XSH_RECTIFY_LAMBDA_MIN);
02866
02867 cleanup:
02868 return;
02869 }
02870
02876
02877 void xsh_pfits_set_rectify_lambda_max(cpl_propertylist * plist, double value)
02878 {
02879 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_LAMBDA_MAX,
02880 value),
02881 "Error writing keyword '%s'", XSH_RECTIFY_LAMBDA_MAX);
02882
02883 cleanup:
02884 return;
02885 }
02886
02892
02893 void xsh_pfits_set_rectify_space_min(cpl_propertylist * plist, double value)
02894 {
02895 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_SPACE_MIN,
02896 value),
02897 "Error writing keyword '%s'", XSH_RECTIFY_SPACE_MIN);
02898
02899 cleanup:
02900 return;
02901 }
02902
02908
02909 void xsh_pfits_set_rectify_space_max(cpl_propertylist * plist, double value)
02910 {
02911 check_msg (cpl_propertylist_update_double (plist, XSH_RECTIFY_SPACE_MAX,
02912 value),
02913 "Error writing keyword '%s'", XSH_RECTIFY_SPACE_MAX);
02914
02915 cleanup:
02916 return;
02917 }
02918
02924
02925 double xsh_pfits_get_rectify_bin_lambda(cpl_propertylist * plist)
02926 {
02927 double returnvalue = 0.0;
02928
02929 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_BIN_LAMBDA,
02930 CPL_TYPE_DOUBLE, &returnvalue),
02931 "Error reading keyword '%s'", XSH_RECTIFY_BIN_LAMBDA);
02932
02933 cleanup:
02934 return returnvalue;
02935 }
02936
02942
02943 double xsh_pfits_get_rectify_bin_space(cpl_propertylist * plist)
02944 {
02945 double returnvalue = 0.0;
02946
02947 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_BIN_SPACE,
02948 CPL_TYPE_DOUBLE, &returnvalue),
02949 "Error reading keyword '%s'", XSH_RECTIFY_BIN_SPACE);
02950
02951 cleanup:
02952 return returnvalue;
02953 }
02954
02960 double xsh_pfits_get_rectify_lambda_min(cpl_propertylist * plist)
02961 {
02962 double returnvalue = 0.0;
02963
02964 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_LAMBDA_MIN,
02965 CPL_TYPE_DOUBLE, &returnvalue),
02966 "Error reading keyword '%s'", XSH_RECTIFY_LAMBDA_MIN);
02967
02968 cleanup:
02969 return returnvalue;
02970 }
02971
02977 double xsh_pfits_get_rectify_lambda_max(cpl_propertylist * plist)
02978 {
02979 double returnvalue = 0.0;
02980
02981 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_LAMBDA_MAX,
02982 CPL_TYPE_DOUBLE, &returnvalue),
02983 "Error reading keyword '%s'", XSH_RECTIFY_LAMBDA_MAX);
02984
02985 cleanup:
02986 return returnvalue;
02987 }
02988
02994 double xsh_pfits_get_rectify_space_min(cpl_propertylist * plist)
02995 {
02996 double returnvalue = 0.0;
02997
02998 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_SPACE_MIN,
02999 CPL_TYPE_DOUBLE, &returnvalue),
03000 "Error reading keyword '%s'", XSH_RECTIFY_SPACE_MIN);
03001
03002 cleanup:
03003 return returnvalue;
03004 }
03005
03011 double xsh_pfits_get_rectify_space_max(cpl_propertylist * plist)
03012 {
03013 double returnvalue = 0.0;
03014
03015 check_msg (xsh_get_property_value (plist, XSH_RECTIFY_SPACE_MAX,
03016 CPL_TYPE_DOUBLE, &returnvalue),
03017 "Error reading keyword '%s'", XSH_RECTIFY_SPACE_MAX);
03018
03019 cleanup:
03020 return returnvalue;
03021 }
03022
03023
03029 int xsh_pfits_get_obs_id(cpl_propertylist * plist)
03030 {
03031 int returnvalue = 0;
03032
03033 check_msg (xsh_get_property_value (plist, XSH_OBS_ID,
03034 CPL_TYPE_INT, &returnvalue),
03035 "Error reading keyword '%s'", XSH_OBS_ID);
03036
03037 cleanup:
03038 return returnvalue;
03039 }
03040
03041
03050 int xsh_pfits_get_nb_pinhole( const cpl_propertylist * plist){
03051 int nb_pinhole=1;
03052 const char* pinhole = NULL;
03053
03054 XSH_ASSURE_NOT_NULL( plist);
03055 check( pinhole = xsh_pfits_get_dpr_tech( plist));
03056
03057 if ( strcmp( pinhole, XSH_DPR_TECH_MULTI_PINHOLE) == 0 ){
03058 nb_pinhole = XSH_NB_PINHOLE;
03059 }
03060 else if (strcmp( pinhole, XSH_DPR_TECH_SINGLE_PINHOLE) == 0){
03061 nb_pinhole = 1;
03062 }
03063 else{
03064 xsh_error_msg( "Undefined pinhole : can't identify DPR keyword %s\n\
03065 Authorized keyword are ( single %s multi %s )", pinhole,
03066 XSH_DPR_TECH_SINGLE_PINHOLE, XSH_DPR_TECH_MULTI_PINHOLE);
03067 }
03068 cleanup:
03069 return nb_pinhole;
03070 }
03071
03080 double xsh_pfits_get_tel_targ_alpha( const cpl_propertylist * plist)
03081 {
03082 double returnvalue = 0. ;
03083
03084 check_msg (xsh_get_property_value (plist, XSH_TEL_TARG_ALPHA,
03085 CPL_TYPE_DOUBLE, &returnvalue),
03086 "Error reading keyword '%s'", XSH_TEL_TARG_ALPHA ) ;
03087
03088 cleanup:
03089 return returnvalue;
03090 }
03091
03100 double xsh_pfits_get_tel_targ_delta( const cpl_propertylist * plist)
03101 {
03102 double returnvalue = 0. ;
03103
03104 check_msg (xsh_get_property_value (plist, XSH_TEL_TARG_DELTA,
03105 CPL_TYPE_DOUBLE, &returnvalue),
03106 "Error reading keyword '%s'", XSH_TEL_TARG_DELTA ) ;
03107
03108 cleanup:
03109 return returnvalue;
03110 }
03111
03120 double xsh_pfits_get_ra( const cpl_propertylist * plist)
03121 {
03122 double returnvalue = 0. ;
03123
03124 check_msg (xsh_get_property_value (plist, XSH_RA,
03125 CPL_TYPE_DOUBLE, &returnvalue),
03126 "Error reading keyword '%s'", XSH_RA ) ;
03127
03128 cleanup:
03129 return returnvalue;
03130 }
03131
03132
03141 double xsh_pfits_get_dec( const cpl_propertylist * plist)
03142 {
03143 double returnvalue = 0. ;
03144
03145 check_msg (xsh_get_property_value (plist, XSH_DEC,
03146 CPL_TYPE_DOUBLE, &returnvalue),
03147 "Error reading keyword '%s'", XSH_DEC ) ;
03148
03149 cleanup:
03150 return returnvalue;
03151 }
03152
03153
03154 double xsh_pfits_get_posang( const cpl_propertylist *plist)
03155 {
03156 double returnvalue = 0. ;
03157
03158 check_msg (xsh_get_property_value (plist, XSH_POSANG,
03159 CPL_TYPE_DOUBLE, &returnvalue),
03160 "Error reading keyword '%s'", XSH_POSANG) ;
03161
03162 cleanup:
03163 return returnvalue;
03164 }
03165
03166
03167
03168
03169 double xsh_pfits_get_ra_reloffset( const cpl_propertylist *plist)
03170 {
03171 double returnvalue = 0. ;
03172
03173 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_RA,
03174 CPL_TYPE_DOUBLE, &returnvalue),
03175 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_RA) ;
03176
03177 cleanup:
03178 return returnvalue;
03179 }
03180
03181
03182
03183
03184 double xsh_pfits_get_dec_reloffset( const cpl_propertylist *plist)
03185 {
03186 double returnvalue = 0. ;
03187
03188 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_DEC,
03189 CPL_TYPE_DOUBLE, &returnvalue),
03190 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_DEC) ;
03191
03192 cleanup:
03193 return returnvalue;
03194 }
03195
03196
03197
03198
03199 double xsh_pfits_get_cumoffsetx( const cpl_propertylist *plist)
03200 {
03201 double returnvalue = 0. ;
03202
03203 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSETX,
03204 CPL_TYPE_DOUBLE, &returnvalue),
03205 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSETX) ;
03206
03207 cleanup:
03208 return returnvalue;
03209 }
03210
03211
03212 double xsh_pfits_get_cumoffsety( const cpl_propertylist *plist)
03213 {
03214 double returnvalue = 0. ;
03215
03216 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSETY,
03217 CPL_TYPE_DOUBLE, &returnvalue),
03218 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSETY) ;
03219
03220 cleanup:
03221 return returnvalue;
03222 }
03223
03224
03225
03226 double xsh_pfits_get_ra_cumoffset( const cpl_propertylist *plist)
03227 {
03228 double returnvalue = 0. ;
03229
03230 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_RA,
03231 CPL_TYPE_DOUBLE, &returnvalue),
03232 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_RA) ;
03233
03234 cleanup:
03235 return returnvalue;
03236 }
03237
03238
03239
03240
03241 double xsh_pfits_get_dec_cumoffset( const cpl_propertylist *plist)
03242 {
03243 double returnvalue = 0. ;
03244
03245 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_DEC,
03246 CPL_TYPE_DOUBLE, &returnvalue),
03247 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_DEC) ;
03248
03249 cleanup:
03250 return returnvalue;
03251 }
03252
03253
03254
03255
03256 double xsh_pfits_get_b_ra_reloffset( const cpl_propertylist *plist)
03257 {
03258 double returnvalue = 0. ;
03259
03260 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_B_OFFSET_RA,
03261 CPL_TYPE_DOUBLE, &returnvalue),
03262 "Error reading keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_RA) ;
03263
03264 cleanup:
03265 return returnvalue;
03266 }
03267
03268
03269
03270
03271 double xsh_pfits_get_b_dec_reloffset( const cpl_propertylist *plist)
03272 {
03273 double returnvalue = 0. ;
03274
03275 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_B_OFFSET_DEC,
03276 CPL_TYPE_DOUBLE, &returnvalue),
03277 "Error reading keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_DEC) ;
03278
03279 cleanup:
03280 return returnvalue;
03281 }
03282
03283
03284
03285
03286 double xsh_pfits_get_b_ra_cumoffset( const cpl_propertylist *plist)
03287 {
03288 double returnvalue = 0. ;
03289
03290 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_B_OFFSET_RA,
03291 CPL_TYPE_DOUBLE, &returnvalue),
03292 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_RA) ;
03293
03294 cleanup:
03295 return returnvalue;
03296 }
03297
03298
03299
03300
03301 double xsh_pfits_get_b_dec_cumoffset( const cpl_propertylist *plist)
03302 {
03303 double returnvalue = 0. ;
03304
03305 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_B_OFFSET_DEC,
03306 CPL_TYPE_DOUBLE, &returnvalue),
03307 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_DEC);
03308
03309 cleanup:
03310 return returnvalue;
03311 }
03312
03313
03314
03315
03316 void xsh_pfits_set_b_ra_reloffset(cpl_propertylist * plist, double value)
03317 {
03318 check_msg( cpl_propertylist_update_double
03319 (plist, XSH_NOD_RELATIVE_B_OFFSET_RA, value),
03320 "Error writing keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_RA);
03321 cleanup:
03322 return;
03323 }
03324
03325
03326
03327
03328 void xsh_pfits_set_b_dec_reloffset(cpl_propertylist * plist, double value)
03329 {
03330 check_msg( cpl_propertylist_update_double
03331 (plist, XSH_NOD_RELATIVE_B_OFFSET_DEC, value),
03332 "Error writing keyword '%s'", XSH_NOD_RELATIVE_B_OFFSET_DEC);
03333 cleanup:
03334 return;
03335 }
03336
03337
03338
03339
03340
03341 void xsh_pfits_set_b_ra_cumoffset(cpl_propertylist * plist, double value)
03342 {
03343 check_msg( cpl_propertylist_update_double
03344 (plist, XSH_NOD_CUMULATIVE_B_OFFSET_RA, value),
03345 "Error writing keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_RA);
03346 cleanup:
03347 return;
03348 }
03349
03350
03351
03352
03353 void xsh_pfits_set_b_dec_cumoffset(cpl_propertylist * plist, double value)
03354 {
03355 check_msg( cpl_propertylist_update_double
03356 (plist, XSH_NOD_CUMULATIVE_B_OFFSET_DEC, value),
03357 "Error writing keyword '%s'", XSH_NOD_CUMULATIVE_B_OFFSET_DEC);
03358 cleanup:
03359 return;
03360 }
03361
03362
03363
03364
03365 void xsh_pfits_set_slitmap_order_edgup( cpl_propertylist * plist, int absorder,
03366 double value)
03367 {
03368 char name[256];
03369
03370 sprintf( name, XSH_SLITMAP_ORDER_EDGUP, absorder);
03371
03372 check_msg( cpl_propertylist_update_double
03373 (plist, name, value),
03374 "Error writing keyword '%s'", name);
03375
03376 cleanup:
03377 return;
03378 }
03379
03380
03381
03382
03383 void xsh_pfits_set_slitmap_order_edglo( cpl_propertylist * plist, int absorder,
03384 double value)
03385 {
03386 char name[256];
03387
03388 sprintf( name, XSH_SLITMAP_ORDER_EDGLO, absorder);
03389
03390 check_msg( cpl_propertylist_update_double
03391 (plist, name, value),
03392 "Error writing keyword '%s'", name);
03393
03394 cleanup:
03395 return;
03396 }
03397
03398
03399
03400 void xsh_pfits_set_slitmap_order_slicup( cpl_propertylist * plist, int absorder,
03401 double value)
03402 {
03403 char name[256];
03404
03405 sprintf( name, XSH_SLITMAP_ORDER_SLICUP, absorder);
03406
03407 check_msg( cpl_propertylist_update_double
03408 (plist, name, value),
03409 "Error writing keyword '%s'", name);
03410
03411 cleanup:
03412 return;
03413 }
03414
03415
03416
03417 void xsh_pfits_set_slitmap_order_sliclo( cpl_propertylist * plist, int absorder,
03418 double value)
03419 {
03420 char name[256];
03421
03422 sprintf( name, XSH_SLITMAP_ORDER_SLICLO, absorder);
03423
03424 check_msg( cpl_propertylist_update_double
03425 (plist, name, value),
03426 "Error writing keyword '%s'", name);
03427
03428 cleanup:
03429 return;
03430 }
03431
03432
03433
03434
03435 void xsh_pfits_set_slitmap_order_cen( cpl_propertylist * plist, int absorder,
03436 double value)
03437 {
03438 char name[256];
03439
03440 sprintf( name, XSH_SLITMAP_ORDER_CEN, absorder);
03441
03442 check_msg( cpl_propertylist_update_double
03443 (plist, name, value),
03444 "Error writing keyword '%s'", name);
03445
03446 cleanup:
03447 return;
03448 }
03449
03450
03451
03452
03453
03454 void xsh_pfits_set_slitmap_median_edgup( cpl_propertylist * plist,
03455 double value)
03456 {
03457 const char* name = XSH_SLITMAP_MEDIAN_EDGUP;
03458
03459
03460 check_msg( cpl_propertylist_update_double
03461 (plist, name, value),
03462 "Error writing keyword '%s'", name);
03463
03464 cleanup:
03465 return;
03466 }
03467
03468
03469
03470
03471 void xsh_pfits_set_slitmap_median_edglo( cpl_propertylist * plist,
03472 double value)
03473 {
03474 const char* name = XSH_SLITMAP_MEDIAN_EDGLO;
03475
03476
03477 check_msg( cpl_propertylist_update_double
03478 (plist, name, value),
03479 "Error writing keyword '%s'", name);
03480
03481 cleanup:
03482 return;
03483 }
03484
03485
03486
03487
03488 void xsh_pfits_set_slitmap_median_sliclo( cpl_propertylist * plist,
03489 double value)
03490 {
03491 const char* name = XSH_SLITMAP_MEDIAN_SLICLO;
03492
03493
03494 check_msg( cpl_propertylist_update_double
03495 (plist, name, value),
03496 "Error writing keyword '%s'", name);
03497
03498 cleanup:
03499 return;
03500 }
03501
03502
03503
03504
03505 void xsh_pfits_set_slitmap_median_slicup( cpl_propertylist * plist,
03506 double value)
03507 {
03508 const char* name = XSH_SLITMAP_MEDIAN_SLICUP;
03509
03510
03511 check_msg( cpl_propertylist_update_double
03512 (plist, name, value),
03513 "Error writing keyword '%s'", name);
03514
03515 cleanup:
03516 return;
03517 }
03518
03519
03520
03521
03522 void xsh_pfits_set_slitmap_median_cen( cpl_propertylist * plist,
03523 double value)
03524 {
03525 const char* name = XSH_SLITMAP_MEDIAN_CEN;
03526
03527
03528 check_msg( cpl_propertylist_update_double
03529 (plist, name, value),
03530 "Error writing keyword '%s'", name);
03531
03532 cleanup:
03533 return;
03534 }
03535
03536
03537
03538
03539 double xsh_pfits_get_slitmap_median_edgup(const cpl_propertylist * plist)
03540 {
03541 double returnvalue = 0.;
03542 const char *name = XSH_SLITMAP_MEDIAN_EDGUP;
03543
03544 check_msg( xsh_get_property_value (plist, name,
03545 CPL_TYPE_DOUBLE, &returnvalue),
03546 "Error reading keyword '%s'", name);
03547
03548 cleanup:
03549 return returnvalue;
03550 }
03551
03552
03553
03554
03555 double xsh_pfits_get_slitmap_median_edglo(const cpl_propertylist * plist)
03556 {
03557 double returnvalue = 0.;
03558 const char *name = XSH_SLITMAP_MEDIAN_EDGLO;
03559
03560 check_msg( xsh_get_property_value (plist, name,
03561 CPL_TYPE_DOUBLE, &returnvalue),
03562 "Error reading keyword '%s'", name);
03563
03564 cleanup:
03565 return returnvalue;
03566 }
03567
03568
03569
03570
03571 double xsh_pfits_get_slitmap_median_cen(const cpl_propertylist * plist)
03572 {
03573 double returnvalue = 0.;
03574 const char *name = XSH_SLITMAP_MEDIAN_CEN;
03575
03576 check_msg( xsh_get_property_value (plist, name,
03577 CPL_TYPE_DOUBLE, &returnvalue),
03578 "Error reading keyword '%s'", name);
03579
03580 cleanup:
03581 return returnvalue;
03582 }
03583
03584
03585
03586
03587 double xsh_pfits_get_slitmap_median_slicup(const cpl_propertylist * plist)
03588 {
03589 double returnvalue = 0.;
03590 const char *name = XSH_SLITMAP_MEDIAN_SLICUP;
03591
03592 check_msg( xsh_get_property_value (plist, name,
03593 CPL_TYPE_DOUBLE, &returnvalue),
03594 "Error reading keyword '%s'", name);
03595
03596 cleanup:
03597 return returnvalue;
03598 }
03599
03600
03601
03602
03603 double xsh_pfits_get_slitmap_median_sliclo(const cpl_propertylist * plist)
03604 {
03605 double returnvalue = 0.;
03606 const char *name = XSH_SLITMAP_MEDIAN_SLICLO;
03607
03608 check_msg( xsh_get_property_value (plist, name,
03609 CPL_TYPE_DOUBLE, &returnvalue),
03610 "Error reading keyword '%s'", name);
03611
03612 cleanup:
03613 return returnvalue;
03614 }
03615
03616
03617
03618
03619
03620 void xsh_pfits_set_wavemap_order_lambda_min( cpl_propertylist * plist, int absorder,
03621 double value)
03622 {
03623 char name[256];
03624
03625 sprintf( name, XSH_WAVEMAP_ORDER_LAMBDA_MIN, absorder);
03626
03627 check_msg( cpl_propertylist_update_double
03628 (plist, name, value),
03629 "Error writing keyword '%s'", name);
03630
03631 cleanup:
03632 return;
03633 }
03634
03635
03636
03637
03638 void xsh_pfits_set_wavemap_order_lambda_max( cpl_propertylist * plist, int absorder,
03639 double value)
03640 {
03641 char name[256];
03642
03643 sprintf( name, XSH_WAVEMAP_ORDER_LAMBDA_MAX, absorder);
03644
03645 check_msg( cpl_propertylist_update_double
03646 (plist, name, value),
03647 "Error writing keyword '%s'", name);
03648
03649 cleanup:
03650 return;
03651 }
03652
03653
03654
03655
03664 double xsh_pfits_get_nod_reloffset( const cpl_propertylist * plist)
03665 {
03666 double returnvalue = 0. ;
03667 double dec = 0., ra = 0. ;
03668
03669 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_DEC,
03670 CPL_TYPE_DOUBLE, &dec),
03671 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_DEC ) ;
03672 check_msg (xsh_get_property_value (plist, XSH_NOD_RELATIVE_OFFSET_RA,
03673 CPL_TYPE_DOUBLE, &ra),
03674 "Error reading keyword '%s'", XSH_NOD_RELATIVE_OFFSET_RA ) ;
03675 returnvalue = sqrt( dec*dec + ra*ra ) ;
03676 xsh_msg_dbg_high( "dec: %lf, ra: %lf, reloffset: %lf", dec, ra, returnvalue ) ;
03677
03678 cleanup:
03679 return returnvalue;
03680 }
03681
03690 double xsh_pfits_get_nod_cumoffset( const cpl_propertylist * plist)
03691 {
03692 double returnvalue = 0 ;
03693 double dec = 0., ra = 0. ;
03694
03695 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_DEC,
03696 CPL_TYPE_DOUBLE, &dec),
03697 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_DEC ) ;
03698 check_msg (xsh_get_property_value (plist, XSH_NOD_CUMULATIVE_OFFSET_RA,
03699 CPL_TYPE_DOUBLE, &ra),
03700 "Error reading keyword '%s'", XSH_NOD_CUMULATIVE_OFFSET_RA ) ;
03701 returnvalue = sqrt( dec*dec + ra*ra ) ;
03702 xsh_msg_dbg_high ("dec: %lf, ra: %lf, cumoffset: %lf", dec, ra, returnvalue ) ;
03703
03704 cleanup:
03705 return returnvalue;
03706
03707 }
03708
03717 double xsh_pfits_get_nod_jitterwidth( const cpl_propertylist * plist)
03718 {
03719 double returnvalue = 0 ;
03720
03721 check_msg (xsh_get_property_value (plist, XSH_NOD_JITTER_BOX,
03722 CPL_TYPE_DOUBLE, &returnvalue),
03723 "Error reading keyword '%s'", XSH_NOD_JITTER_BOX );
03724
03725 cleanup:
03726 return returnvalue;
03727
03728 }
03729
03738 double xsh_pfits_get_nodthrow( const cpl_propertylist * plist)
03739 {
03740 double returnvalue = 0 ;
03741
03742 check_msg (xsh_get_property_value (plist, XSH_NOD_THROW,
03743 CPL_TYPE_DOUBLE, &returnvalue),
03744 "Error reading keyword '%s'", XSH_NOD_THROW);
03745
03746 cleanup:
03747 return returnvalue;
03748
03749 }
03750