VIRCAM Pipeline 2.3.12
vircam_pfits.c
1/* $Id: vircam_pfits.c,v 1.34 2013-10-15 16:49:15 jim Exp $
2 *
3 * This file is part of the VIRCAM Pipeline
4 * Copyright (C) 2015 European Southern Observatory
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21/*
22 * $Author: jim $
23 * $Date: 2013-10-15 16:49:15 $
24 * $Revision: 1.34 $
25 * $Name: not supported by cvs2svn $
26 */
27
28/* Includes */
29
30#ifdef HAVE_CONFIG_H
31#include <config.h>
32#endif
33
34#include <cpl.h>
35#include <string.h>
36
37#include <casu_utils.h>
38#include "vircam_pfits.h"
39
40static int vircam_pfits_get_float(const cpl_propertylist *plist,
41 const char *key, float *fval);
42static int vircam_pfits_get_double(const cpl_propertylist *plist,
43 const char *key, double *fval);
44
58/*---------------------------------------------------------------------------*/
66/*---------------------------------------------------------------------------*/
67
68extern int vircam_pfits_get_crval1(const cpl_propertylist *plist,
69 double *crval1) {
70
71 return(vircam_pfits_get_double(plist,"CRVAL1",crval1));
72
73}
74
75/*---------------------------------------------------------------------------*/
83/*---------------------------------------------------------------------------*/
84
85extern int vircam_pfits_get_crpix1(const cpl_propertylist *plist,
86 double *crpix1) {
87
88 return(vircam_pfits_get_double(plist,"CRPIX1",crpix1));
89
90}
91
92/*---------------------------------------------------------------------------*/
100/*---------------------------------------------------------------------------*/
101
102extern int vircam_pfits_get_crval2(const cpl_propertylist *plist,
103 double *crval2) {
104
105 return(vircam_pfits_get_double(plist,"CRVAL2",crval2));
106
107}
108
109/*---------------------------------------------------------------------------*/
117/*---------------------------------------------------------------------------*/
118
119extern int vircam_pfits_get_crpix2(const cpl_propertylist *plist,
120 double *crpix2) {
121
122 return(vircam_pfits_get_double(plist,"CRPIX2",crpix2));
123}
124
125/*---------------------------------------------------------------------------*/
133/*---------------------------------------------------------------------------*/
134
135extern int vircam_pfits_get_cd11(const cpl_propertylist *plist, double *cd11) {
136
137 return(vircam_pfits_get_double(plist,"CD1_1",cd11));
138}
139
140/*---------------------------------------------------------------------------*/
148/*---------------------------------------------------------------------------*/
149
150extern int vircam_pfits_get_cd12(const cpl_propertylist *plist, double *cd12) {
151
152 return(vircam_pfits_get_double(plist,"CD1_2",cd12));
153
154}
155
156/*---------------------------------------------------------------------------*/
164/*---------------------------------------------------------------------------*/
165
166extern int vircam_pfits_get_cd21(const cpl_propertylist *plist, double *cd21) {
167
168 return(vircam_pfits_get_double(plist,"CD2_1",cd21));
169}
170
171/*---------------------------------------------------------------------------*/
179/*---------------------------------------------------------------------------*/
180
181extern int vircam_pfits_get_cd22(const cpl_propertylist *plist, double *cd22) {
182
183 return(vircam_pfits_get_double(plist,"CD2_2",cd22));
184
185}
186
187/*---------------------------------------------------------------------------*/
195/*---------------------------------------------------------------------------*/
196
197extern int vircam_pfits_get_pv21(const cpl_propertylist *plist, double *pv21) {
198
199 return(vircam_pfits_get_double(plist,"PV2_1",pv21));
200
201}
202
203/*---------------------------------------------------------------------------*/
211/*---------------------------------------------------------------------------*/
212
213extern int vircam_pfits_get_pv23(const cpl_propertylist *plist, double *pv23) {
214
215 return(vircam_pfits_get_double(plist,"PV2_3",pv23));
216
217}
218
219/*---------------------------------------------------------------------------*/
227/*---------------------------------------------------------------------------*/
228
229extern int vircam_pfits_get_pv25(const cpl_propertylist *plist, double *pv25) {
230
231 return(vircam_pfits_get_double(plist,"PV2_5",pv25));
232
233}
234
235/*---------------------------------------------------------------------------*/
243/*---------------------------------------------------------------------------*/
244
245extern int vircam_pfits_get_exptime(const cpl_propertylist *plist,
246 float *exptime) {
247
248 return(vircam_pfits_get_float(plist,"EXPTIME",exptime));
249
250}
251
252/*---------------------------------------------------------------------------*/
260/*---------------------------------------------------------------------------*/
261
262extern int vircam_pfits_get_mindit(const cpl_propertylist *plist,
263 float *mindit) {
264
265 return(vircam_pfits_get_float(plist,"ESO DET MINDIT",mindit));
266
267}
268
269/*---------------------------------------------------------------------------*/
277/*---------------------------------------------------------------------------*/
278
279extern int vircam_pfits_get_ditdelay(const cpl_propertylist *plist,
280 float *ditdelay) {
281
282 return(vircam_pfits_get_float(plist,"ESO DET DITDELAY",ditdelay));
283
284}
285
286/*---------------------------------------------------------------------------*/
294/*---------------------------------------------------------------------------*/
295
296extern int vircam_pfits_get_naxis1(const cpl_propertylist *plist,
297 long *naxis1) {
298 int val;
299
300 val = cpl_propertylist_get_int(plist,"NAXIS1");
301 if (cpl_error_get_code() == CPL_ERROR_NONE) {
302 *naxis1 = (long)val;
303 return(CASU_OK);
304 } else {
305 cpl_error_reset();
306 *naxis1 = 0;
307 return(CASU_FATAL);
308 }
309}
310
311/*---------------------------------------------------------------------------*/
319/*---------------------------------------------------------------------------*/
320
321extern int vircam_pfits_get_naxis2(const cpl_propertylist *plist,
322 long *naxis2) {
323 int val;
324
325 val = cpl_propertylist_get_int(plist,"NAXIS2");
326 if (cpl_error_get_code() == CPL_ERROR_NONE) {
327 *naxis2 = (long)val;
328 return(CASU_OK);
329 } else {
330 cpl_error_reset();
331 *naxis2 = 0;
332 return(CASU_FATAL);
333 }
334}
335
336/*---------------------------------------------------------------------------*/
344/*---------------------------------------------------------------------------*/
345
346extern int vircam_pfits_get_chipno(const cpl_propertylist *plist,
347 int *chipno) {
348 int val;
349
350 val = cpl_propertylist_get_int(plist,"ESO DET CHIP NO");
351 if (cpl_error_get_code() == CPL_ERROR_NONE) {
352 *chipno = val;
353 return(CASU_OK);
354 } else {
355 cpl_error_reset();
356 *chipno = 0;
357 return(CASU_FATAL);
358 }
359}
360
361/*---------------------------------------------------------------------------*/
369/*---------------------------------------------------------------------------*/
370
371extern int vircam_pfits_get_jxoff(const cpl_propertylist *plist,
372 float *xoff) {
373
374 return(vircam_pfits_get_float(plist,"ESO DRS XOFFDITHER",xoff));
375
376}
377
378/*---------------------------------------------------------------------------*/
386/*---------------------------------------------------------------------------*/
387
388extern int vircam_pfits_get_jyoff(const cpl_propertylist *plist,
389 float *yoff) {
390
391 return(vircam_pfits_get_float(plist,"ESO DRS YOFFDITHER",yoff));
392
393}
394
395/*---------------------------------------------------------------------------*/
403/*---------------------------------------------------------------------------*/
404
405extern int vircam_pfits_get_airmass(const cpl_propertylist *plist,
406 float *airmass) {
407
408 return(vircam_pfits_get_float(plist,"ESO TEL AIRM START",airmass));
409
410}
411
412/*---------------------------------------------------------------------------*/
420/*---------------------------------------------------------------------------*/
421
422extern int vircam_pfits_get_nusteps(const cpl_propertylist *plist,
423 int *nusteps) {
424 int val;
425
426 val = cpl_propertylist_get_int(plist,"NUSTEP");
427 if (cpl_error_get_code() == CPL_ERROR_NONE) {
428 *nusteps = val;
429 return(CASU_OK);
430 } else {
431 cpl_error_reset();
432 *nusteps = 0;
433 return(CASU_FATAL);
434 }
435
436}
437
438/*---------------------------------------------------------------------------*/
447/*---------------------------------------------------------------------------*/
448
449extern int vircam_pfits_get_ustepnum(const cpl_propertylist *plist,
450 int *ustepnum) {
451 int val;
452
453 val = cpl_propertylist_get_int(plist,"USTEPNUM");
454 if (cpl_error_get_code() == CPL_ERROR_NONE) {
455 *ustepnum = val;
456 return(CASU_OK);
457 } else {
458 cpl_error_reset();
459 *ustepnum = 0;
460 return(CASU_FATAL);
461 }
462
463}
464
465/*---------------------------------------------------------------------------*/
474/*---------------------------------------------------------------------------*/
475
476extern int vircam_pfits_get_njsteps(const cpl_propertylist *plist,
477 int *njsteps) {
478 int val;
479
480 val = cpl_propertylist_get_int(plist,"NJITTER");
481 if (cpl_error_get_code() == CPL_ERROR_NONE) {
482 *njsteps = val;
483 return(CASU_OK);
484 } else {
485 cpl_error_reset();
486 *njsteps = 0;
487 return(CASU_FATAL);
488 }
489
490}
491
492/*---------------------------------------------------------------------------*/
501/*---------------------------------------------------------------------------*/
502
503extern int vircam_pfits_get_jitternum(const cpl_propertylist *plist,
504 int *jitternum) {
505 int val;
506
507 val = cpl_propertylist_get_int(plist,"OFFSET_I");
508 if (cpl_error_get_code() == CPL_ERROR_NONE) {
509 *jitternum = val;
510 return(CASU_OK);
511 } else {
512 cpl_error_reset();
513 *jitternum = 0;
514 return(CASU_FATAL);
515 }
516
517}
518
519/*---------------------------------------------------------------------------*/
528/*---------------------------------------------------------------------------*/
529
530extern int vircam_pfits_get_jitteri(const cpl_propertylist *plist,
531 int *jitteri) {
532 int val;
533
534 val = cpl_propertylist_get_int(plist,"JITTER_I");
535 if (cpl_error_get_code() == CPL_ERROR_NONE) {
536 *jitteri = val;
537 return(CASU_OK);
538 } else {
539 cpl_error_reset();
540 *jitteri = 0;
541 return(CASU_FATAL);
542 }
543
544}
545
546/*---------------------------------------------------------------------------*/
555/*---------------------------------------------------------------------------*/
556
557extern int vircam_pfits_get_offsetnum(const cpl_propertylist *plist,
558 int *offsetnum) {
559 int val;
560
561 val = cpl_propertylist_get_int(plist,"OFFSTNUM");
562 if (cpl_error_get_code() == CPL_ERROR_NONE) {
563 *offsetnum = val;
564 return(CASU_OK);
565 } else {
566 cpl_error_reset();
567 *offsetnum = 0;
568 return(CASU_FATAL);
569 }
570
571}
572
573/*---------------------------------------------------------------------------*/
581/*---------------------------------------------------------------------------*/
582
583extern int vircam_pfits_get_ndit(const cpl_propertylist *plist,
584 int *ndit) {
585 int val;
586
587 val = cpl_propertylist_get_int(plist,"ESO DET NDIT");
588 if (cpl_error_get_code() == CPL_ERROR_NONE) {
589 *ndit = val;
590 return(CASU_OK);
591 } else {
592 cpl_error_reset();
593 *ndit = 1;
594 return(CASU_FATAL);
595 }
596}
597
598/*---------------------------------------------------------------------------*/
606/*---------------------------------------------------------------------------*/
607
608extern int vircam_pfits_get_dit(const cpl_propertylist *plist,
609 float *dit) {
610
611 return(vircam_pfits_get_float(plist,"ESO DET DIT",dit));
612}
613
614/*---------------------------------------------------------------------------*/
622/*---------------------------------------------------------------------------*/
623
624extern int vircam_pfits_get_detlive(const cpl_propertylist *plist,
625 int *detlive) {
626 int val;
627
628 val = cpl_propertylist_get_bool(plist,"ESO DET CHIP LIVE");
629 if (cpl_error_get_code() == CPL_ERROR_NONE) {
630 *detlive = val;
631 return(CASU_OK);
632 } else {
633 cpl_error_reset();
634 *detlive = 1;
635 return(CASU_FATAL);
636 }
637}
638
639/*---------------------------------------------------------------------------*/
647/*---------------------------------------------------------------------------*/
648
649extern int vircam_pfits_get_filter(const cpl_propertylist *plist, char *filt) {
650
651 if(cpl_propertylist_has(plist,"ESO INS FILT1 NAME") == 0) {
652 return(CASU_FATAL);
653 }
654
655 strcpy(filt,cpl_propertylist_get_string(plist,"ESO INS FILT1 NAME"));
656 if (cpl_error_get_code() == CPL_ERROR_NONE) {
657 return(CASU_OK);
658 } else {
659 cpl_error_reset();
660 return(CASU_FATAL);
661 }
662}
663
664/*---------------------------------------------------------------------------*/
672/*---------------------------------------------------------------------------*/
673
674extern int vircam_pfits_get_projid(const cpl_propertylist *plist,
675 char *projid) {
676
677 strcpy(projid,cpl_propertylist_get_string(plist,"ESO OBS PROG ID"));
678 if (cpl_error_get_code() == CPL_ERROR_NONE) {
679 return(CASU_OK);
680 } else {
681 cpl_error_reset();
682 return(CASU_FATAL);
683 }
684}
685
686/*---------------------------------------------------------------------------*/
694/*---------------------------------------------------------------------------*/
695
696extern int vircam_pfits_get_saturation(const cpl_propertylist *plist,
697 float *saturation) {
698
699 return(vircam_pfits_get_float(plist,"ESO DET SATURATION",saturation));
700
701}
702
703/*---------------------------------------------------------------------------*/
711/*---------------------------------------------------------------------------*/
712
713extern int vircam_pfits_get_gain(const cpl_propertylist *plist, float *gain) {
714
715 return(vircam_pfits_get_float(plist,"GAIN",gain));
716
717}
718
719/*---------------------------------------------------------------------------*/
727/*---------------------------------------------------------------------------*/
728
729extern int vircam_pfits_get_mjd(const cpl_propertylist *plist, double *mjd) {
730
731 return(vircam_pfits_get_double(plist,"MJD-OBS",mjd));
732
733}
734
735/*---------------------------------------------------------------------------*/
743/*---------------------------------------------------------------------------*/
744
745extern int vircam_pfits_get_ra(const cpl_propertylist *plist, double *ra) {
746
747 return(vircam_pfits_get_double(plist,"RA",ra));
748
749}
750
751/*---------------------------------------------------------------------------*/
759/*---------------------------------------------------------------------------*/
760
761extern int vircam_pfits_get_dec(const cpl_propertylist *plist, double *dec) {
762
763 return(vircam_pfits_get_double(plist,"DEC",dec));
764
765}
766
767/*---------------------------------------------------------------------------*/
775/*---------------------------------------------------------------------------*/
776
777extern int vircam_pfits_get_tplstart(cpl_propertylist *plist, char *tplstart) {
778 strcpy(tplstart,cpl_propertylist_get_string(plist,"ESO TPL START"));
779 if (cpl_error_get_code() == CPL_ERROR_NONE) {
780 return(CASU_OK);
781 } else {
782 cpl_error_reset();
783 return(CASU_FATAL);
784 }
785}
786
787/*---------------------------------------------------------------------------*/
796/*---------------------------------------------------------------------------*/
797
798static int vircam_pfits_get_float(const cpl_propertylist *plist,
799 const char *key, float *fval) {
800 cpl_type type;
801 const char *fctid = "vircam_pfits_get_float";
802
803 /* Get the type of this keyword */
804
805 type = cpl_propertylist_get_type(plist,key);
806 if (cpl_error_get_code() != CPL_ERROR_NONE) {
807 *fval = 0.0;
808 cpl_error_reset();
809 return(CASU_FATAL);
810 }
811
812 /* Switch of the property type */
813
814 switch (type) {
815 case CPL_TYPE_FLOAT:
816 *fval = cpl_propertylist_get_float(plist,key);
817 break;
818 case CPL_TYPE_DOUBLE:
819 *fval = (float)cpl_propertylist_get_double(plist,key);
820 break;
821 default:
822 *fval = 0.0;
823 cpl_msg_error(fctid,"Keyword %s is not floating point in header",key);
824 return(CASU_FATAL);
825 }
826 return(CASU_OK);
827}
828
829/*---------------------------------------------------------------------------*/
838/*---------------------------------------------------------------------------*/
839
840static int vircam_pfits_get_double(const cpl_propertylist *plist,
841 const char *key, double *fval) {
842 cpl_type type;
843 const char *fctid = "vircam_pfits_get_float";
844
845 /* Get the type of this keyword */
846
847 type = cpl_propertylist_get_type(plist,key);
848 if (cpl_error_get_code() != CPL_ERROR_NONE) {
849 *fval = 0.0;
850 cpl_error_reset();
851 return(CASU_FATAL);
852 }
853
854 /* Switch of the property type */
855
856 switch (type) {
857 case CPL_TYPE_FLOAT:
858 *fval = (double)cpl_propertylist_get_float(plist,key);
859 break;
860 case CPL_TYPE_DOUBLE:
861 *fval = cpl_propertylist_get_double(plist,key);
862 break;
863 default:
864 *fval = 0.0;
865 cpl_msg_error(fctid,"Keyword %s is not floating point in header",key);
866 return(CASU_FATAL);
867 }
868 return(CASU_OK);
869}
870
873/*
874
875$Log: not supported by cvs2svn $
876Revision 1.33 2010/09/09 12:11:09 jim
877Fixed problems with docs that make doxygen barf
878
879Revision 1.32 2010/03/09 16:48:14 jim
880Restored get_gain but with different keyword
881
882Revision 1.31 2010/03/09 14:30:45 jim
883Removed redundant routine
884
885Revision 1.30 2009/02/20 10:58:14 jim
886Added vircam_pfits_get_njsteps and vircam_pfits_get_jitteri. Tidied up some
887comments
888
889Revision 1.29 2008/12/08 06:41:56 jim
890Added vircam_pfits_get_ra and vircam_pfits_get_dec
891
892Revision 1.28 2008/11/21 10:11:48 jim
893Added vircam_pfits_get_pv25
894
895Revision 1.27 2008/10/21 08:41:34 jim
896Saturation is now floating point
897
898Revision 1.26 2007/11/22 12:35:33 jim
899Modified vircam_pfits_get_saturation so that the value of the
900saturation is read as an integer, but passed back as a float
901
902Revision 1.25 2007/11/20 09:39:39 jim
903added vircam_pfits_get_mjd
904
905Revision 1.24 2007/11/14 10:45:23 jim
906Added vircam_pfits_get_saturation
907
908Revision 1.23 2007/10/25 17:34:01 jim
909Modified to remove lint warnings
910
911Revision 1.22 2007/10/19 09:25:10 jim
912Fixed problems with missing includes
913
914Revision 1.21 2007/03/23 10:53:22 jim
915Fixed little documentation errors
916
917Revision 1.20 2007/03/01 12:42:42 jim
918Modified slightly after code checking
919
920Revision 1.19 2006/07/17 09:33:00 jim
921Changed keyword for detlive routine
922
923Revision 1.18 2006/07/11 14:52:13 jim
924Added vircam_pfits_get_detlive
925
926Revision 1.17 2006/06/20 19:00:06 jim
927Added vircam_pfits_get_ndit
928
929Revision 1.16 2006/06/13 14:08:12 jim
930Added vircam_pfits_get_gain
931
932Revision 1.15 2006/06/09 11:26:26 jim
933Small changes to keep lint happy
934
935Revision 1.14 2006/05/24 13:35:23 jim
936Added _get_nusteps, _get_ustepnum, _get_jitternum and _get_filter
937
938Revision 1.13 2006/05/17 12:05:48 jim
939Add vircam_pfits_get_airmass
940
941Revision 1.12 2006/05/15 13:15:11 jim
942Added vircam_pfits_j[x,y]off
943
944Revision 1.11 2006/04/21 15:17:48 jim
945Added vircam_pfits_get_float and vircam_pfits_get_double static routines
946
947Revision 1.10 2006/03/01 10:59:25 jim
948Added vircam_pfits_get_ditdelay
949
950Revision 1.9 2006/02/18 11:48:03 jim
951added routines to get mindit and chip number
952
953Revision 1.8 2006/01/23 10:30:49 jim
954Mainly documentation mods
955
956Revision 1.7 2005/12/14 22:17:33 jim
957Updated docs
958
959Revision 1.6 2005/11/25 15:33:22 jim
960Some code fixes to keep splint happy
961
962Revision 1.5 2005/11/25 09:56:15 jim
963Tidied up some more documentation
964
965Revision 1.4 2005/11/07 13:15:16 jim
966Fixed lots of bugs and added some error checking
967
968Revision 1.3 2005/11/07 11:23:41 jim
969fixed call to cpl_error_get_code
970
971Revision 1.2 2005/11/03 13:28:50 jim
972All sorts of changes to tighten up error handling
973
974Revision 1.1.1.1 2005/08/05 08:29:09 jim
975Initial import
976
977
978*/
int vircam_pfits_get_crpix2(const cpl_propertylist *plist, double *crpix2)
Get the value of crpix2.
Definition: vircam_pfits.c:119
int vircam_pfits_get_ra(const cpl_propertylist *plist, double *ra)
Get the value of RA.
Definition: vircam_pfits.c:745
int vircam_pfits_get_cd12(const cpl_propertylist *plist, double *cd12)
Get the value of cd1_2.
Definition: vircam_pfits.c:150
int vircam_pfits_get_cd11(const cpl_propertylist *plist, double *cd11)
Get the value of cd1_1.
Definition: vircam_pfits.c:135
int vircam_pfits_get_jyoff(const cpl_propertylist *plist, float *yoff)
Get the value of the Y jitter offset.
Definition: vircam_pfits.c:388
int vircam_pfits_get_cd21(const cpl_propertylist *plist, double *cd21)
Get the value of cd2_1.
Definition: vircam_pfits.c:166
int vircam_pfits_get_ndit(const cpl_propertylist *plist, int *ndit)
Get the value of NDIT.
Definition: vircam_pfits.c:583
int vircam_pfits_get_dec(const cpl_propertylist *plist, double *dec)
Get the value of DEC.
Definition: vircam_pfits.c:761
int vircam_pfits_get_jitteri(const cpl_propertylist *plist, int *jitteri)
Get the position number of an observations in a jitter sequence.
Definition: vircam_pfits.c:530
int vircam_pfits_get_gain(const cpl_propertylist *plist, float *gain)
Get the value of the detector gain.
Definition: vircam_pfits.c:713
int vircam_pfits_get_jitternum(const cpl_propertylist *plist, int *jitternum)
Get the value of the first run number in the current jitter sequence.
Definition: vircam_pfits.c:503
int vircam_pfits_get_crval1(const cpl_propertylist *plist, double *crval1)
Get the value of crval1.
Definition: vircam_pfits.c:68
int vircam_pfits_get_ditdelay(const cpl_propertylist *plist, float *ditdelay)
Get the value of dit delay time.
Definition: vircam_pfits.c:279
int vircam_pfits_get_mjd(const cpl_propertylist *plist, double *mjd)
Get the value of the modified Julian date.
Definition: vircam_pfits.c:729
int vircam_pfits_get_naxis1(const cpl_propertylist *plist, long *naxis1)
Get the value of naxis1.
Definition: vircam_pfits.c:296
int vircam_pfits_get_projid(const cpl_propertylist *plist, char *projid)
Get the project id.
Definition: vircam_pfits.c:674
int vircam_pfits_get_dit(const cpl_propertylist *plist, float *dit)
Get the value of DIT.
Definition: vircam_pfits.c:608
int vircam_pfits_get_crval2(const cpl_propertylist *plist, double *crval2)
Get the value of crval2.
Definition: vircam_pfits.c:102
int vircam_pfits_get_jxoff(const cpl_propertylist *plist, float *xoff)
Get the value of the X jitter offset.
Definition: vircam_pfits.c:371
int vircam_pfits_get_detlive(const cpl_propertylist *plist, int *detlive)
Get the value of DET_LIVE.
Definition: vircam_pfits.c:624
int vircam_pfits_get_pv23(const cpl_propertylist *plist, double *pv23)
Get the value of pv2_3.
Definition: vircam_pfits.c:213
int vircam_pfits_get_njsteps(const cpl_propertylist *plist, int *njsteps)
Get the value of the number of observations in a jitter sequence.
Definition: vircam_pfits.c:476
int vircam_pfits_get_nusteps(const cpl_propertylist *plist, int *nusteps)
Get the value of the number of microsteps in a sequence.
Definition: vircam_pfits.c:422
int vircam_pfits_get_pv25(const cpl_propertylist *plist, double *pv25)
Get the value of pv2_5.
Definition: vircam_pfits.c:229
int vircam_pfits_get_tplstart(cpl_propertylist *plist, char *tplstart)
Get the value of template start time.
Definition: vircam_pfits.c:777
int vircam_pfits_get_exptime(const cpl_propertylist *plist, float *exptime)
Get the value of exposure time.
Definition: vircam_pfits.c:245
int vircam_pfits_get_mindit(const cpl_propertylist *plist, float *mindit)
Get the value of mindit time.
Definition: vircam_pfits.c:262
int vircam_pfits_get_saturation(const cpl_propertylist *plist, float *saturation)
Get the saturation level for this detector.
Definition: vircam_pfits.c:696
int vircam_pfits_get_ustepnum(const cpl_propertylist *plist, int *ustepnum)
Get the value of the first run number in the current microstep sequence.
Definition: vircam_pfits.c:449
int vircam_pfits_get_chipno(const cpl_propertylist *plist, int *chipno)
Get the value of chipno.
Definition: vircam_pfits.c:346
int vircam_pfits_get_pv21(const cpl_propertylist *plist, double *pv21)
Get the value of pv2_1.
Definition: vircam_pfits.c:197
int vircam_pfits_get_cd22(const cpl_propertylist *plist, double *cd22)
Get the value of cd2_2.
Definition: vircam_pfits.c:181
int vircam_pfits_get_crpix1(const cpl_propertylist *plist, double *crpix1)
Get the value of crpix1.
Definition: vircam_pfits.c:85
int vircam_pfits_get_airmass(const cpl_propertylist *plist, float *airmass)
Get the value of the airmass.
Definition: vircam_pfits.c:405
int vircam_pfits_get_filter(const cpl_propertylist *plist, char *filt)
Get the name of the current filter.
Definition: vircam_pfits.c:649
int vircam_pfits_get_offsetnum(const cpl_propertylist *plist, int *offsetnum)
Get the value of the first run number in the current tile sequence.
Definition: vircam_pfits.c:557
int vircam_pfits_get_naxis2(const cpl_propertylist *plist, long *naxis2)
Get the value of naxis2.
Definition: vircam_pfits.c:321