Changeset 38852

Timestamp:

Oct 13, 2015, 11:40:43 AM (11 years ago)

Author:

eugene

Message:

add stack extensions

Location:

trunk/Ohana/src/addstar

Files:

• src/mkcmf.c (modified) (7 diffs)
• test (modified) (1 prop)

trunk/Ohana/src/addstar/src/mkcmf.c

@@ -25 +25 @@
 void writeStars_PS1_DEV_0 (FTable *ftable, double *X, double *Y, double *M, int Nstars);
 
+int WriteXSRCtable (FILE *fits, char *extroot, double *X, double *Y, double *M, unsigned int *Flag, int Nstars);
+int WriteXFITtable (FILE *fits, char *extroot, double *X, double *Y, double *M, unsigned int *Flag, int Nstars);
+int WriteXRADtable (FILE *fits, char *extroot, double *X, double *Y, double *M, unsigned int *Flag, int Nstars);
+int WriteDETFtable (FILE *fits, char *extroot, double *X, double *Y, double *M, unsigned int *Flag, int Nstars);
+
 int ADDNOISE = TRUE;
 float BAD_PSFQF_FRAC = 0.0;
@@ -54 +59 @@
   }
 
+  int WriteXSRC = FALSE;
+  int WriteXFIT = FALSE;
+  int WriteXRAD = FALSE;
+  int WriteDETF = FALSE;
+  if ((N = get_argument (argc, argv, "-stack"))) {
+    remove_argument (N, &argc, argv);
+    WriteXSRC = WriteXFIT = WriteXRAD = WriteDETF = TRUE;
+  }
+
   static char *photcode = "SIMTEST.r.Chip";
   if ((N = get_argument (argc, argv, "-photcode"))) {
@@ -83 +97 @@
   }
 
-  char extname[80], exthead[80];
+  char extname[80], exthead[80], extroot[80];
+  strcpy (extroot, "Chip");
   strcpy (extname, "Chip.psf");
   strcpy (exthead, "Chip.hdr");
-  if ((N = get_argument (argc, argv, "-extname"))) {
-    remove_argument (N, &argc, argv);
+  if ((N = get_argument (argc, argv, "-extroot"))) {
+    remove_argument (N, &argc, argv);
+    snprintf (extroot, 80, "%s", argv[N]);
     snprintf (extname, 80, "%s.psf", argv[N]);
     snprintf (exthead, 80, "%s.hdr", argv[N]);
@@ -280 +296 @@
   gfits_print (&header, "IMNAXIS1", "%d", 1, (int)(Xmax));
   gfits_print (&header, "IMNAXIS2", "%d", 1, (int)(Ymax));
+  gfits_print (&header, "NAXIS1",   "%d", 1, (int)(Xmax));
+  gfits_print (&header, "NAXIS2",   "%d", 1, (int)(Ymax));
 
   gfits_modify (&header, "NSTARS",   "%d", 1, Nstars);
@@ -301 +319 @@
   PutCoords (&coords, &header);
   gfits_modify (&header, "EXTNAME",   "%s", 1, exthead);
+
+  // various other fields needed to ipptopsps
+  gfits_modify (&header, "FWHM_MAJ",          "%f", 1, FX*2.8);
+  gfits_modify (&header, "FWHM_MIN",          "%f", 1, FY*2.8);
+  gfits_modify (&header, "MSKY_MN",           "%f", 1, SKY);
+  gfits_modify (&header, "MSKY_SIG",          "%f", 1, DSKY);
+  gfits_modify (&header, "DETEFF.MAGREF",     "%f", 1, -5.0);
+  gfits_modify (&header, "ZPT_OBS",           "%f", 1, 25.0);
+  gfits_modify (&header, "ZPT_ERR",           "%f", 1, 0.03);
+  gfits_modify (&header, "ANGLE",             "%f", 1, 0.1);
+  gfits_modify (&header, "IQ_FW1",            "%f", 1, FX*2.8);
+  gfits_modify (&header, "IQ_FW2",            "%f", 1, FX*2.8);
+  gfits_modify (&header, "IQ_M2C",            "%f", 1, FX*2.8);
+  gfits_modify (&header, "IQ_M2S",            "%f", 1, FX*2.8);
+  gfits_modify (&header, "IQ_M3",             "%f", 1, FX*2.8);
+  gfits_modify (&header, "IQ_M4",             "%f", 1, FX*2.8);
+  gfits_modify (&header, "APMIFIT",           "%f", 1, 0.1);
+  gfits_modify (&header, "DAPMIFIT",          "%f", 1, 0.03);
+  gfits_modify (&header, "DETECTOR",          "%s", 1, "CCID58-1-02a2");
+  gfits_modify (&header, "DETREND.MASK",      "%s", 1, "detref615.XY33.fits");
+  gfits_modify (&header, "DETREND.DARK",      "%s", 1, "GPC1.DARKTEST.norm.856.0.XY33.fits");
+  gfits_modify (&header, "DETREND.FLAT",      "%s", 1, "GPC1.FLATTEST.300.XY33.co.fits");
+  gfits_modify (&header, "DETREND.NOISEMAP",  "%s", 1, "GPC1.noisemap.norm.965.0.XY33.fits");
+  gfits_modify (&header, "DETREND.NONLIN",    "%s", 1, "linearity_data.XY33.fits");
+  gfits_modify (&header, "DETREND.VIDEODARK", "%s", 1, "GPC1.VIDEODARK.979.0.XY33.fits");
+
+  gfits_modify (&header, "PSFMODEL",          "%s", 1, "PS_MODEL_PS1_V1");
+  gfits_modify (&header, "AST_CDX",           "%f", 1, 0.05);
+  gfits_modify (&header, "AST_CDY",           "%f", 1, 0.04);
+
+  // gfits_modify (&header, "ZPT_OBS",       "%", 1, );
+  // gfits_modify (&header, "CERROR",        "%f", 1, );
 
   int i;
@@ -380 +430 @@
   gfits_fwrite_Theader (fits, ftable.header);
   gfits_fwrite_table   (fits, &ftable);
+
+  if (WriteXSRC) WriteXSRCtable (fits, extroot, X, Y, M, Flag, Nstars);
+  if (WriteXFIT) WriteXFITtable (fits, extroot, X, Y, M, Flag, Nstars);
+  if (WriteXRAD) WriteXRADtable (fits, extroot, X, Y, M, Flag, Nstars);
+  if (WriteDETF) WriteDETFtable (fits, extroot, X, Y, M, Flag, Nstars);
+
   fclose (fits);
 
@@ -1133 +1189 @@
 }
 
+int WriteXSRCtable (FILE *fits, char *extroot, double *X, double *Y, double *M, unsigned int *Flag, int Nstars) {
+
+  int i, j;
+  Header header;
+  FTable ftable;
+
+  char extdata[80];
+  snprintf (extdata, 80, "%s.xsrc", extroot);
+
+  /* Example Code to create a bintable */
+  {
+    gfits_create_table_header (&header, "BINTABLE", extdata);
+
+    gfits_define_bintable_column (&header, "1J", "IPP_IDET"           , "no comment", NULL, 1.0, FT_BZERO_INT32); // unsigned
+    gfits_define_bintable_column (&header, "1E", "X_EXT"              , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "Y_EXT"              , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "X_EXT_SIG"          , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "Y_EXT_SIG"          , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "F25_ARATIO"         , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "F25_THETA"          , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "PETRO_MAG"          , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "PETRO_MAG_ERR"      , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "PETRO_RADIUS"       , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "PETRO_RADIUS_ERR"   , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "PETRO_RADIUS_50"    , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "PETRO_RADIUS_50_ERR", "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "PETRO_RADIUS_90"    , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "PETRO_RADIUS_90_ERR", "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "PETRO_FILL"         , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "HALF_LIGHT_RADIUS"  , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "G_RT"               , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "G_RA"               , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "G_S2"               , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "G_A"                , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "1E", "G_BUMPY"            , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "9E", "PROF_SB"            , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "9E", "PROF_FLUX"          , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "9E", "PROF_FILL"          , "no comment", NULL, 1.0, 0.0);
+
+    // generate the output array that carries the data
+    gfits_create_table (&header, &ftable);
+
+    // create intermediate storage arrays
+    int    *IPP_IDET            ; ALLOCATE (IPP_IDET            ,  int   , Nstars);
+    float  *X_EXT               ; ALLOCATE (X_EXT               ,  float , Nstars);
+    float  *Y_EXT               ; ALLOCATE (Y_EXT               ,  float , Nstars);
+    float  *X_EXT_SIG           ; ALLOCATE (X_EXT_SIG           ,  float , Nstars);
+    float  *Y_EXT_SIG           ; ALLOCATE (Y_EXT_SIG           ,  float , Nstars);
+    float  *F25_ARATIO          ; ALLOCATE (F25_ARATIO          ,  float , Nstars);
+    float  *F25_THETA           ; ALLOCATE (F25_THETA           ,  float , Nstars);
+    float  *PETRO_MAG           ; ALLOCATE (PETRO_MAG           ,  float , Nstars);
+    float  *PETRO_MAG_ERR       ; ALLOCATE (PETRO_MAG_ERR       ,  float , Nstars);
+    float  *PETRO_RADIUS        ; ALLOCATE (PETRO_RADIUS        ,  float , Nstars);
+    float  *PETRO_RADIUS_ERR    ; ALLOCATE (PETRO_RADIUS_ERR    ,  float , Nstars);
+    float  *PETRO_RADIUS_50     ; ALLOCATE (PETRO_RADIUS_50     ,  float , Nstars);
+    float  *PETRO_RADIUS_50_ERR ; ALLOCATE (PETRO_RADIUS_50_ERR ,  float , Nstars);
+    float  *PETRO_RADIUS_90     ; ALLOCATE (PETRO_RADIUS_90     ,  float , Nstars);
+    float  *PETRO_RADIUS_90_ERR ; ALLOCATE (PETRO_RADIUS_90_ERR ,  float , Nstars);
+    float  *PETRO_FILL          ; ALLOCATE (PETRO_FILL          ,  float , Nstars);
+    float  *HALF_LIGHT_RADIUS   ; ALLOCATE (HALF_LIGHT_RADIUS   ,  float , Nstars);
+    float  *G_RT                ; ALLOCATE (G_RT                ,  float , Nstars);
+    float  *G_RA                ; ALLOCATE (G_RA                ,  float , Nstars);
+    float  *G_S2                ; ALLOCATE (G_S2                ,  float , Nstars);
+    float  *G_A                 ; ALLOCATE (G_A                 ,  float , Nstars);
+    float  *G_BUMPY             ; ALLOCATE (G_BUMPY             ,  float , Nstars);
+    float  *PROF_SB             ; ALLOCATE (PROF_SB             ,  float , 9*Nstars);
+    float  *PROF_FLUX           ; ALLOCATE (PROF_FLUX           ,  float , 9*Nstars);
+    float  *PROF_FILL           ; ALLOCATE (PROF_FILL           ,  float , 9*Nstars);
+
+    // assign the storage arrays
+    for (i = 0; i < Nstars; i++) {
+      float flux = pow (10.0, -0.4*M[i]);
+      float fSN = 1.0 / sqrt(flux);
+
+      IPP_IDET            [i] = i;
+      X_EXT               [i] = X[i];
+      Y_EXT               [i] = Y[i];
+      X_EXT_SIG           [i] = FX * fSN;
+      Y_EXT_SIG           [i] = FY * fSN;
+      F25_ARATIO          [i] = 0.9;
+      F25_THETA           [i] = 10.0;
+      PETRO_MAG           [i] = M[i];
+      PETRO_MAG_ERR       [i] = fSN;
+      PETRO_RADIUS        [i] = 8.0;
+      PETRO_RADIUS_ERR    [i] = 0.1;
+      PETRO_RADIUS_50     [i] = 4.0;
+      PETRO_RADIUS_50_ERR [i] = 0.1;
+      PETRO_RADIUS_90     [i] = 12.0;
+      PETRO_RADIUS_90_ERR [i] = 0.1;
+      PETRO_FILL          [i] = 0.95;
+      HALF_LIGHT_RADIUS   [i] = 6.0;
+      G_RT                [i] = 1.0;
+      G_RA                [i] = 1.0;
+      G_S2                [i] = 1.0;
+      G_A                 [i] = 1.0;
+      G_BUMPY             [i] = 1.0;
+      for (j = 0; j < 9; j++) {
+        PROF_SB             [j + 9*i] = flux / 10.0;
+        PROF_FLUX           [j + 9*i] = flux;
+        PROF_FILL           [j + 9*i] = 0.9;
+      }
+    }
+
+    // set the table data
+    gfits_set_bintable_column (&header, &ftable, "IPP_IDET"           , IPP_IDET            , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "X_EXT"              , X_EXT               , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "Y_EXT"              , Y_EXT               , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "X_EXT_SIG"          , X_EXT_SIG           , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "Y_EXT_SIG"          , Y_EXT_SIG           , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "F25_ARATIO"         , F25_ARATIO          , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "F25_THETA"          , F25_THETA           , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PETRO_MAG"          , PETRO_MAG           , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PETRO_MAG_ERR"      , PETRO_MAG_ERR       , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PETRO_RADIUS"       , PETRO_RADIUS        , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PETRO_RADIUS_ERR"   , PETRO_RADIUS_ERR    , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PETRO_RADIUS_50"    , PETRO_RADIUS_50     , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PETRO_RADIUS_50_ERR", PETRO_RADIUS_50_ERR , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PETRO_RADIUS_90"    , PETRO_RADIUS_90     , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PETRO_RADIUS_90_ERR", PETRO_RADIUS_90_ERR , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PETRO_FILL"         , PETRO_FILL          , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "HALF_LIGHT_RADIUS"  , HALF_LIGHT_RADIUS   , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "G_RT"               , G_RT                , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "G_RA"               , G_RA                , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "G_S2"               , G_S2                , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "G_A"                , G_A                 , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "G_BUMPY"            , G_BUMPY             , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PROF_SB"            , PROF_SB             , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PROF_FLUX"          , PROF_FLUX           , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PROF_FILL"          , PROF_FILL           , Nstars);
+  }
+
+  gfits_fwrite_Theader (fits, &header);
+  gfits_fwrite_table  (fits, &ftable);
+  gfits_free_header (&header);
+  gfits_free_table (&ftable);
+
+  return TRUE;
+}
+
+int WriteXFITtable (FILE *fits, char *extroot, double *X, double *Y, double *M, unsigned int *Flag, int Nstars) {
+
+  int i;
+  Header header;
+  FTable ftable;
+
+  char extdata[80];
+  snprintf (extdata, 80, "%s.xfit", extroot);
+
+  /* Example Code to create a bintable */
+  {
+    gfits_create_table_header (&header, "BINTABLE", extdata);
+
+    // define the table layout
+    gfits_define_bintable_column (&header, "J",   "IPP_IDET"         , "no comment", NULL, 1.0, FT_BZERO_INT32); // unsigned
+    gfits_define_bintable_column (&header, "E",   "X_EXT"            , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "Y_EXT"            , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "X_EXT_SIG"        , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "Y_EXT_SIG"        , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "SKY_EXT"          , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "RA_EXT"           , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "DEC_EXT"          , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "EXT_INST_MAG"     , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "EXT_INST_MAG_SIG" , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "EXT_CHISQ"        , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "J",   "EXT_NDOF"         , "no comment", NULL, 1.0, FT_BZERO_INT32); // unsigned
+    gfits_define_bintable_column (&header, "J",   "EXT_MODEL_TYPE"   , "no comment", NULL, 1.0, FT_BZERO_INT32); // unsigned
+    gfits_define_bintable_column (&header, "I",   "EXT_FLAGS"        , "no comment", NULL, 1.0, FT_BZERO_INT16); // unsigned
+    gfits_define_bintable_column (&header, "E",   "PSF_INST_MAG"     , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "AP_MAG"           , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "KRON_MAG"         , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "J",   "NPARAMS"          , "no comment", NULL, 1.0, FT_BZERO_INT32); // unsigned
+    gfits_define_bintable_column (&header, "15A", "MODEL_TYPE"       , "no comment", NULL, 1.0, 0.0); 
+    gfits_define_bintable_column (&header, "E",   "EXT_WIDTH_MAJ"    , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "EXT_WIDTH_MIN"    , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "EXT_THETA"        , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "EXT_WIDTH_MAJ_ERR", "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "EXT_WIDTH_MIN_ERR", "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "EXT_THETA_ERR"    , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "EXT_PAR_07"       , "no comment", NULL, 1.0, 0.0);
+
+    // generate the output array that carries the data
+    gfits_create_table (&header, &ftable);
+
+    // create intermediate storage arrays
+    int    *IPP_IDET           ; ALLOCATE (IPP_IDET         ,  int   , Nstars);
+    float  *X_EXT              ; ALLOCATE (X_EXT            ,  float , Nstars);
+    float  *Y_EXT              ; ALLOCATE (Y_EXT            ,  float , Nstars);
+    float  *X_EXT_SIG          ; ALLOCATE (X_EXT_SIG        ,  float , Nstars);
+    float  *Y_EXT_SIG          ; ALLOCATE (Y_EXT_SIG        ,  float , Nstars);
+    float  *SKY_EXT            ; ALLOCATE (SKY_EXT          ,  float , Nstars);
+    float  *RA_EXT             ; ALLOCATE (RA_EXT           ,  float , Nstars);
+    float  *DEC_EXT            ; ALLOCATE (DEC_EXT          ,  float , Nstars);
+    float  *EXT_INST_MAG       ; ALLOCATE (EXT_INST_MAG     ,  float , Nstars);
+    float  *EXT_INST_MAG_SIG   ; ALLOCATE (EXT_INST_MAG_SIG ,  float , Nstars);
+    float  *EXT_CHISQ          ; ALLOCATE (EXT_CHISQ        ,  float , Nstars);
+    int    *EXT_NDOF           ; ALLOCATE (EXT_NDOF         ,  int   , Nstars);
+    int    *EXT_MODEL_TYPE     ; ALLOCATE (EXT_MODEL_TYPE   ,  int   , Nstars);
+    short  *EXT_FLAGS          ; ALLOCATE (EXT_FLAGS        ,  short , Nstars);
+    float  *PSF_INST_MAG       ; ALLOCATE (PSF_INST_MAG     ,  float , Nstars);
+    float  *AP_MAG             ; ALLOCATE (AP_MAG           ,  float , Nstars);
+    float  *KRON_MAG           ; ALLOCATE (KRON_MAG         ,  float , Nstars);
+    int    *NPARAMS            ; ALLOCATE (NPARAMS          ,  int   , Nstars);
+    char   *MODEL_TYPE         ; ALLOCATE (MODEL_TYPE       ,  char  , Nstars*15);
+    float  *EXT_WIDTH_MAJ      ; ALLOCATE (EXT_WIDTH_MAJ    ,  float , Nstars);
+    float  *EXT_WIDTH_MIN      ; ALLOCATE (EXT_WIDTH_MIN    ,  float , Nstars);
+    float  *EXT_THETA          ; ALLOCATE (EXT_THETA        ,  float , Nstars);
+    float  *EXT_WIDTH_MAJ_ERR  ; ALLOCATE (EXT_WIDTH_MAJ_ERR,  float , Nstars);
+    float  *EXT_WIDTH_MIN_ERR  ; ALLOCATE (EXT_WIDTH_MIN_ERR,  float , Nstars);
+    float  *EXT_THETA_ERR      ; ALLOCATE (EXT_THETA_ERR    ,  float , Nstars);
+    float  *EXT_PAR_07         ; ALLOCATE (EXT_PAR_07       ,  float , Nstars);
+
+    // assign the storage arrays
+    for (i = 0; i < Nstars; i++) {
+      float flux = pow (10.0, -0.4*M[i]);
+      float fSN = 1.0 / sqrt(flux);
+
+      IPP_IDET         [i] = i;
+      X_EXT            [i] = X[i];
+      Y_EXT            [i] = Y[i];
+      X_EXT_SIG        [i] = FX * fSN;
+      Y_EXT_SIG        [i] = FY * fSN;
+      SKY_EXT          [i] = 0.1;
+      RA_EXT           [i] = NAN;
+      DEC_EXT          [i] = NAN;
+      EXT_INST_MAG     [i] = M[i];
+      EXT_INST_MAG_SIG [i] = fSN;
+      EXT_CHISQ        [i] = 1.0;
+      EXT_NDOF         [i] = 10;
+      EXT_MODEL_TYPE   [i] = -1;
+      EXT_FLAGS        [i] = 0x0010;
+      PSF_INST_MAG     [i] = M[i];
+      AP_MAG           [i] = M[i];
+      KRON_MAG         [i] = M[i];
+      NPARAMS          [i] = 7;
+      EXT_WIDTH_MAJ    [i] = FX*2.8;
+      EXT_WIDTH_MIN    [i] = FY*2.8;
+      EXT_THETA        [i] = 10.0;
+      EXT_WIDTH_MAJ_ERR[i] = FX*3.0;
+      EXT_WIDTH_MIN_ERR[i] = FY*3.0;
+      EXT_THETA_ERR    [i] = 0.5;
+      EXT_PAR_07       [i] = NAN;
+
+      strcpy (&MODEL_TYPE[15*i], "PS_MODEL_DEV");
+    }
+
+    // set the table data
+    gfits_set_bintable_column (&header, &ftable, "IPP_IDET"         , IPP_IDET         , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "X_EXT"            , X_EXT            , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "Y_EXT"            , Y_EXT            , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "X_EXT_SIG"        , X_EXT_SIG        , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "Y_EXT_SIG"        , Y_EXT_SIG        , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "SKY_EXT"          , SKY_EXT          , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "RA_EXT"           , RA_EXT           , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "DEC_EXT"          , DEC_EXT          , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_INST_MAG"     , EXT_INST_MAG     , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_INST_MAG_SIG" , EXT_INST_MAG_SIG , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_CHISQ"        , EXT_CHISQ        , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_NDOF"         , EXT_NDOF         , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_MODEL_TYPE"   , EXT_MODEL_TYPE   , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_FLAGS"        , EXT_FLAGS        , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PSF_INST_MAG"     , PSF_INST_MAG     , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "AP_MAG"           , AP_MAG           , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "KRON_MAG"         , KRON_MAG         , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "NPARAMS"          , NPARAMS          , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "MODEL_TYPE"       , MODEL_TYPE       , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_WIDTH_MAJ"    , EXT_WIDTH_MAJ    , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_WIDTH_MIN"    , EXT_WIDTH_MIN    , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_THETA"        , EXT_THETA        , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_WIDTH_MAJ_ERR", EXT_WIDTH_MAJ_ERR, Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_WIDTH_MIN_ERR", EXT_WIDTH_MIN_ERR, Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_THETA_ERR"    , EXT_THETA_ERR    , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "EXT_PAR_07"       , EXT_PAR_07       , Nstars);
+  }
+  /**/
+
+  gfits_fwrite_Theader (fits, &header);
+  gfits_fwrite_table  (fits, &ftable);
+  gfits_free_header (&header);
+  gfits_free_table (&ftable);
+
+  return TRUE;
+}
+
+int WriteXRADtable (FILE *fits, char *extroot, double *X, double *Y, double *M, unsigned int *Flag, int Nstars) {
+
+  int i, j;
+  Header header;
+  FTable ftable;
+
+  char extdata[80];
+  snprintf (extdata, 80, "%s.xrad", extroot);
+
+  /* Example Code to create a bintable */
+  {
+    gfits_create_table_header (&header, "BINTABLE", extdata);
+
+    // define the table layout
+    gfits_define_bintable_column (&header, "J",   "IPP_IDET"         , "no comment", NULL, 1.0, FT_BZERO_INT32); // unsigned
+    gfits_define_bintable_column (&header, "E",   "X_APER"           , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "Y_APER"           , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E",   "PSF_FWHM"         , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "9E",  "APER_FLUX"        , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "9E",  "APER_FLUX_ERR"    , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "9E",  "APER_FLUX_STDEV"  , "no comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "9E",  "APER_FILL"        , "no comment", NULL, 1.0, 0.0);
+
+    // generate the output array that carries the data
+    gfits_create_table (&header, &ftable);
+
+    // create intermediate storage arrays
+    int    *IPP_IDET           ; ALLOCATE (IPP_IDET         ,  int   , Nstars);
+    float  *X_APER             ; ALLOCATE (X_APER           ,  float , Nstars);
+    float  *Y_APER             ; ALLOCATE (Y_APER           ,  float , Nstars);
+    float  *PSF_FWHM           ; ALLOCATE (PSF_FWHM         ,  float , Nstars);
+    float  *APER_FLUX          ; ALLOCATE (APER_FLUX        ,  float , Nstars*9);
+    float  *APER_FLUX_ERR      ; ALLOCATE (APER_FLUX_ERR    ,  float , Nstars*9);
+    float  *APER_FLUX_STDEV    ; ALLOCATE (APER_FLUX_STDEV  ,  float , Nstars*9);
+    float  *APER_FILL          ; ALLOCATE (APER_FILL        ,  float , Nstars*9);
+
+    // assign the storage arrays
+    for (i = 0; i < Nstars; i++) {
+      float flux = pow (10.0, -0.4*M[i]);
+      // float fSN = 1.0 / sqrt(flux);
+
+      IPP_IDET         [i] = i;
+      X_APER           [i] = X[i];
+      Y_APER           [i] = Y[i];
+      PSF_FWHM         [i] = FX*2.8;
+      for (j = 0; j < 9; j ++) {
+        APER_FLUX      [j + 9*i] = flux;
+        APER_FLUX_ERR  [j + 9*i] = sqrt(flux);
+        APER_FLUX_STDEV[j + 9*i] = sqrt(flux);
+        APER_FILL      [j + 9*i] = 0.9;
+      }
+    }
+
+    // set the table data
+    gfits_set_bintable_column (&header, &ftable, "IPP_IDET"         , IPP_IDET         , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "X_APER"           , X_APER           , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "Y_APER"           , Y_APER           , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "PSF_FWHM"         , PSF_FWHM         , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "APER_FLUX"        , APER_FLUX        , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "APER_FLUX_ERR"    , APER_FLUX_ERR    , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "APER_FLUX_STDEV"  , APER_FLUX_STDEV  , Nstars);
+    gfits_set_bintable_column (&header, &ftable, "APER_FILL"        , APER_FILL        , Nstars);
+  }
+  /**/
+
+  gfits_fwrite_Theader (fits, &header);
+  gfits_fwrite_table  (fits, &ftable);
+  gfits_free_header (&header);
+  gfits_free_table (&ftable);
+
+  return TRUE;
+}
+
+int WriteDETFtable (FILE *fits, char *extroot, double *X, double *Y, double *M, unsigned int *Flag, int Nstars) {
+  return TRUE;
+}
+
+int WriteDummyTable (FILE *fits) {
+
+  Header header;
+  FTable ftable;
+
+  /* Example Code to create a bintable 
+  {
+    gfits_create_table_header (&header, "BINTABLE", extroot);
+
+    // define the table layout
+    gfits_define_bintable_column (&header, "D", "NAME", "comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "E", "NAME", "comment", NULL, 1.0, 0.0);
+    gfits_define_bintable_column (&header, "J", "NAME", "comment", NULL, 1.0, FT_BZERO_INT32); // unsigned
+    gfits_define_bintable_column (&header, "I", "NAME", "comment", NULL, 1.0, FT_BZERO_INT16); // unsigned
+
+    // generate the output array that carries the data
+    gfits_create_table (&header, &ftable);
+
+    // create intermediate storage arrays
+    double *R; ALLOCATE (R,  double, Nvalue);
+    float  *M; ALLOCATE (M,  float , Nvalue);
+    int    *I; ALLOCATE (I,  int   , Nvalue);
+    short  *P; ALLOCATE (P,  short , Nvalue);
+
+    // assign the storage arrays
+    for (i = 0; Nvalue; i++) {
+      R[i] = value;
+      M[i] = value;
+      I[i] = value;
+      P[i] = value;
+    }
+
+    // set the table data
+    gfits_set_bintable_column (&header, &ftable, "NAME", R, catalog->Nmeasure);
+    gfits_set_bintable_column (&header, &ftable, "NAME", M, catalog->Nmeasure);
+    gfits_set_bintable_column (&header, &ftable, "NAME", I, catalog->Nmeasure);
+    gfits_set_bintable_column (&header, &ftable, "NAME", P, catalog->Nmeasure);
+  }
+  */
+
+  gfits_fwrite_Theader (fits, &header);
+  gfits_fwrite_table  (fits, &ftable);
+  gfits_free_header (&header);
+  gfits_free_table (&ftable);
+  
+  return TRUE;
+}
+