Index: /trunk/Ohana/src/addstar/src/mkcmf.c =================================================================== --- /trunk/Ohana/src/addstar/src/mkcmf.c (revision 38851) +++ /trunk/Ohana/src/addstar/src/mkcmf.c (revision 38852) @@ -25,4 +25,9 @@ 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,4 +59,13 @@ } + 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,9 +97,11 @@ } - 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,4 +296,6 @@ 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,4 +319,36 @@ 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,4 +430,10 @@ 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,2 +1189,410 @@ } +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; +} +