VIRCAM Pipeline  1.3.4
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) 2005 Cambridge Astronomy Survey Unit
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 "vircam_utils.h"
38 #include "vircam_pfits.h"
39 
40 static int vircam_pfits_get_float(const cpl_propertylist *plist,
41  const char *key, float *fval);
42 static int vircam_pfits_get_double(const cpl_propertylist *plist,
43  const char *key, double *fval);
44 
58 /*---------------------------------------------------------------------------*/
66 /*---------------------------------------------------------------------------*/
67 
68 extern 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 
85 extern 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 
102 extern 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 
119 extern 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 
135 extern 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 
150 extern 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 
166 extern 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 
181 extern 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 
197 extern 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 
213 extern 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 
229 extern 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 
245 extern 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 
262 extern 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 
279 extern 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 
296 extern 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(VIR_OK);
304  } else {
305  cpl_error_reset();
306  *naxis1 = 0;
307  return(VIR_FATAL);
308  }
309 }
310 
311 /*---------------------------------------------------------------------------*/
319 /*---------------------------------------------------------------------------*/
320 
321 extern 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(VIR_OK);
329  } else {
330  cpl_error_reset();
331  *naxis2 = 0;
332  return(VIR_FATAL);
333  }
334 }
335 
336 /*---------------------------------------------------------------------------*/
344 /*---------------------------------------------------------------------------*/
345 
346 extern 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(VIR_OK);
354  } else {
355  cpl_error_reset();
356  *chipno = 0;
357  return(VIR_FATAL);
358  }
359 }
360 
361 /*---------------------------------------------------------------------------*/
369 /*---------------------------------------------------------------------------*/
370 
371 extern 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 
388 extern 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 
405 extern 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 
422 extern 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(VIR_OK);
430  } else {
431  cpl_error_reset();
432  *nusteps = 0;
433  return(VIR_FATAL);
434  }
435 
436 }
437 
438 /*---------------------------------------------------------------------------*/
447 /*---------------------------------------------------------------------------*/
448 
449 extern 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(VIR_OK);
457  } else {
458  cpl_error_reset();
459  *ustepnum = 0;
460  return(VIR_FATAL);
461  }
462 
463 }
464 
465 /*---------------------------------------------------------------------------*/
474 /*---------------------------------------------------------------------------*/
475 
476 extern 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(VIR_OK);
484  } else {
485  cpl_error_reset();
486  *njsteps = 0;
487  return(VIR_FATAL);
488  }
489 
490 }
491 
492 /*---------------------------------------------------------------------------*/
501 /*---------------------------------------------------------------------------*/
502 
503 extern int vircam_pfits_get_jitternum(const cpl_propertylist *plist,
504  int *jitternum) {
505  int val;
506 
507  val = cpl_propertylist_get_int(plist,"JITTRNUM");
508  if (cpl_error_get_code() == CPL_ERROR_NONE) {
509  *jitternum = val;
510  return(VIR_OK);
511  } else {
512  cpl_error_reset();
513  *jitternum = 0;
514  return(VIR_FATAL);
515  }
516 
517 }
518 
519 /*---------------------------------------------------------------------------*/
528 /*---------------------------------------------------------------------------*/
529 
530 extern 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(VIR_OK);
538  } else {
539  cpl_error_reset();
540  *jitteri = 0;
541  return(VIR_FATAL);
542  }
543 
544 }
545 
546 /*---------------------------------------------------------------------------*/
555 /*---------------------------------------------------------------------------*/
556 
557 extern 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(VIR_OK);
565  } else {
566  cpl_error_reset();
567  *offsetnum = 0;
568  return(VIR_FATAL);
569  }
570 
571 }
572 
573 /*---------------------------------------------------------------------------*/
581 /*---------------------------------------------------------------------------*/
582 
583 extern 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(VIR_OK);
591  } else {
592  cpl_error_reset();
593  *ndit = 1;
594  return(VIR_FATAL);
595  }
596 }
597 
598 /*---------------------------------------------------------------------------*/
606 /*---------------------------------------------------------------------------*/
607 
608 extern 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 
624 extern 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(VIR_OK);
632  } else {
633  cpl_error_reset();
634  *detlive = 1;
635  return(VIR_FATAL);
636  }
637 }
638 
639 /*---------------------------------------------------------------------------*/
647 /*---------------------------------------------------------------------------*/
648 
649 extern int vircam_pfits_get_filter(const cpl_propertylist *plist, char *filt) {
650 
651  strcpy(filt,cpl_propertylist_get_string(plist,"ESO INS FILT1 NAME"));
652  if (cpl_error_get_code() == CPL_ERROR_NONE) {
653  return(VIR_OK);
654  } else {
655  cpl_error_reset();
656  return(VIR_FATAL);
657  }
658 }
659 
660 /*---------------------------------------------------------------------------*/
668 /*---------------------------------------------------------------------------*/
669 
670 extern int vircam_pfits_get_projid(const cpl_propertylist *plist,
671  char *projid) {
672 
673  strcpy(projid,cpl_propertylist_get_string(plist,"ESO OBS PROG ID"));
674  if (cpl_error_get_code() == CPL_ERROR_NONE) {
675  return(VIR_OK);
676  } else {
677  cpl_error_reset();
678  return(VIR_FATAL);
679  }
680 }
681 
682 /*---------------------------------------------------------------------------*/
690 /*---------------------------------------------------------------------------*/
691 
692 extern int vircam_pfits_get_saturation(const cpl_propertylist *plist,
693  float *saturation) {
694 
695  return(vircam_pfits_get_float(plist,"ESO DET SATURATION",saturation));
696 
697 }
698 
699 /*---------------------------------------------------------------------------*/
707 /*---------------------------------------------------------------------------*/
708 
709 extern int vircam_pfits_get_gain(const cpl_propertylist *plist, float *gain) {
710 
711  return(vircam_pfits_get_float(plist,"GAIN",gain));
712 
713 }
714 
715 /*---------------------------------------------------------------------------*/
723 /*---------------------------------------------------------------------------*/
724 
725 extern int vircam_pfits_get_mjd(const cpl_propertylist *plist, double *mjd) {
726 
727  return(vircam_pfits_get_double(plist,"MJD-OBS",mjd));
728 
729 }
730 
731 /*---------------------------------------------------------------------------*/
739 /*---------------------------------------------------------------------------*/
740 
741 extern int vircam_pfits_get_ra(const cpl_propertylist *plist, double *ra) {
742 
743  return(vircam_pfits_get_double(plist,"RA",ra));
744 
745 }
746 
747 /*---------------------------------------------------------------------------*/
755 /*---------------------------------------------------------------------------*/
756 
757 extern int vircam_pfits_get_dec(const cpl_propertylist *plist, double *dec) {
758 
759  return(vircam_pfits_get_double(plist,"DEC",dec));
760 
761 }
762 
763 /*---------------------------------------------------------------------------*/
772 /*---------------------------------------------------------------------------*/
773 
774 static int vircam_pfits_get_float(const cpl_propertylist *plist,
775  const char *key, float *fval) {
776  cpl_type type;
777  const char *fctid = "vircam_pfits_get_float";
778 
779  /* Get the type of this keyword */
780 
781  type = cpl_propertylist_get_type(plist,key);
782  if (cpl_error_get_code() != CPL_ERROR_NONE) {
783  *fval = 0.0;
784  cpl_error_reset();
785  return(VIR_FATAL);
786  }
787 
788  /* Switch of the property type */
789 
790  switch (type) {
791  case CPL_TYPE_FLOAT:
792  *fval = cpl_propertylist_get_float(plist,key);
793  break;
794  case CPL_TYPE_DOUBLE:
795  *fval = (float)cpl_propertylist_get_double(plist,key);
796  break;
797  default:
798  *fval = 0.0;
799  cpl_msg_error(fctid,"Keyword %s is not floating point in header",key);
800  return(VIR_FATAL);
801  }
802  return(VIR_OK);
803 }
804 
805 /*---------------------------------------------------------------------------*/
814 /*---------------------------------------------------------------------------*/
815 
816 static int vircam_pfits_get_double(const cpl_propertylist *plist,
817  const char *key, double *fval) {
818  cpl_type type;
819  const char *fctid = "vircam_pfits_get_float";
820 
821  /* Get the type of this keyword */
822 
823  type = cpl_propertylist_get_type(plist,key);
824  if (cpl_error_get_code() != CPL_ERROR_NONE) {
825  *fval = 0.0;
826  cpl_error_reset();
827  return(VIR_FATAL);
828  }
829 
830  /* Switch of the property type */
831 
832  switch (type) {
833  case CPL_TYPE_FLOAT:
834  *fval = (double)cpl_propertylist_get_float(plist,key);
835  break;
836  case CPL_TYPE_DOUBLE:
837  *fval = cpl_propertylist_get_double(plist,key);
838  break;
839  default:
840  *fval = 0.0;
841  cpl_msg_error(fctid,"Keyword %s is not floating point in header",key);
842  return(VIR_FATAL);
843  }
844  return(VIR_OK);
845 }
846 
849 /*
850 
851 $Log: not supported by cvs2svn $
852 Revision 1.33 2010/09/09 12:11:09 jim
853 Fixed problems with docs that make doxygen barf
854 
855 Revision 1.32 2010/03/09 16:48:14 jim
856 Restored get_gain but with different keyword
857 
858 Revision 1.31 2010/03/09 14:30:45 jim
859 Removed redundant routine
860 
861 Revision 1.30 2009/02/20 10:58:14 jim
862 Added vircam_pfits_get_njsteps and vircam_pfits_get_jitteri. Tidied up some
863 comments
864 
865 Revision 1.29 2008/12/08 06:41:56 jim
866 Added vircam_pfits_get_ra and vircam_pfits_get_dec
867 
868 Revision 1.28 2008/11/21 10:11:48 jim
869 Added vircam_pfits_get_pv25
870 
871 Revision 1.27 2008/10/21 08:41:34 jim
872 Saturation is now floating point
873 
874 Revision 1.26 2007/11/22 12:35:33 jim
875 Modified vircam_pfits_get_saturation so that the value of the
876 saturation is read as an integer, but passed back as a float
877 
878 Revision 1.25 2007/11/20 09:39:39 jim
879 added vircam_pfits_get_mjd
880 
881 Revision 1.24 2007/11/14 10:45:23 jim
882 Added vircam_pfits_get_saturation
883 
884 Revision 1.23 2007/10/25 17:34:01 jim
885 Modified to remove lint warnings
886 
887 Revision 1.22 2007/10/19 09:25:10 jim
888 Fixed problems with missing includes
889 
890 Revision 1.21 2007/03/23 10:53:22 jim
891 Fixed little documentation errors
892 
893 Revision 1.20 2007/03/01 12:42:42 jim
894 Modified slightly after code checking
895 
896 Revision 1.19 2006/07/17 09:33:00 jim
897 Changed keyword for detlive routine
898 
899 Revision 1.18 2006/07/11 14:52:13 jim
900 Added vircam_pfits_get_detlive
901 
902 Revision 1.17 2006/06/20 19:00:06 jim
903 Added vircam_pfits_get_ndit
904 
905 Revision 1.16 2006/06/13 14:08:12 jim
906 Added vircam_pfits_get_gain
907 
908 Revision 1.15 2006/06/09 11:26:26 jim
909 Small changes to keep lint happy
910 
911 Revision 1.14 2006/05/24 13:35:23 jim
912 Added _get_nusteps, _get_ustepnum, _get_jitternum and _get_filter
913 
914 Revision 1.13 2006/05/17 12:05:48 jim
915 Add vircam_pfits_get_airmass
916 
917 Revision 1.12 2006/05/15 13:15:11 jim
918 Added vircam_pfits_j[x,y]off
919 
920 Revision 1.11 2006/04/21 15:17:48 jim
921 Added vircam_pfits_get_float and vircam_pfits_get_double static routines
922 
923 Revision 1.10 2006/03/01 10:59:25 jim
924 Added vircam_pfits_get_ditdelay
925 
926 Revision 1.9 2006/02/18 11:48:03 jim
927 added routines to get mindit and chip number
928 
929 Revision 1.8 2006/01/23 10:30:49 jim
930 Mainly documentation mods
931 
932 Revision 1.7 2005/12/14 22:17:33 jim
933 Updated docs
934 
935 Revision 1.6 2005/11/25 15:33:22 jim
936 Some code fixes to keep splint happy
937 
938 Revision 1.5 2005/11/25 09:56:15 jim
939 Tidied up some more documentation
940 
941 Revision 1.4 2005/11/07 13:15:16 jim
942 Fixed lots of bugs and added some error checking
943 
944 Revision 1.3 2005/11/07 11:23:41 jim
945 fixed call to cpl_error_get_code
946 
947 Revision 1.2 2005/11/03 13:28:50 jim
948 All sorts of changes to tighten up error handling
949 
950 Revision 1.1.1.1 2005/08/05 08:29:09 jim
951 Initial import
952 
953 
954 */
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_ditdelay(const cpl_propertylist *plist, float *ditdelay)
Get the value of dit delay time.
Definition: vircam_pfits.c:279
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_jxoff(const cpl_propertylist *plist, float *xoff)
Get the value of the X jitter offset.
Definition: vircam_pfits.c:371
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_crpix2(const cpl_propertylist *plist, double *crpix2)
Get the value of crpix2.
Definition: vircam_pfits.c:119
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_exptime(const cpl_propertylist *plist, float *exptime)
Get the value of exposure time.
Definition: vircam_pfits.c:245
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_ra(const cpl_propertylist *plist, double *ra)
Get the value of RA.
Definition: vircam_pfits.c:741
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_jyoff(const cpl_propertylist *plist, float *yoff)
Get the value of the Y jitter offset.
Definition: vircam_pfits.c:388
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_gain(const cpl_propertylist *plist, float *gain)
Get the value of the detector gain.
Definition: vircam_pfits.c:709
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_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_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_mindit(const cpl_propertylist *plist, float *mindit)
Get the value of mindit time.
Definition: vircam_pfits.c:262
int vircam_pfits_get_projid(const cpl_propertylist *plist, char *projid)
Get the project id.
Definition: vircam_pfits.c:670
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_cd21(const cpl_propertylist *plist, double *cd21)
Get the value of cd2_1.
Definition: vircam_pfits.c:166
int vircam_pfits_get_naxis2(const cpl_propertylist *plist, long *naxis2)
Get the value of naxis2.
Definition: vircam_pfits.c:321
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_naxis1(const cpl_propertylist *plist, long *naxis1)
Get the value of naxis1.
Definition: vircam_pfits.c:296
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_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_airmass(const cpl_propertylist *plist, float *airmass)
Get the value of the airmass.
Definition: vircam_pfits.c:405
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_cd11(const cpl_propertylist *plist, double *cd11)
Get the value of cd1_1.
Definition: vircam_pfits.c:135
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_dit(const cpl_propertylist *plist, float *dit)
Get the value of DIT.
Definition: vircam_pfits.c:608
int vircam_pfits_get_saturation(const cpl_propertylist *plist, float *saturation)
Get the saturation level for this detector.
Definition: vircam_pfits.c:692
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_mjd(const cpl_propertylist *plist, double *mjd)
Get the value of the modified Julian date.
Definition: vircam_pfits.c:725
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_dec(const cpl_propertylist *plist, double *dec)
Get the value of DEC.
Definition: vircam_pfits.c:757