create_table_2.c

00001 /*
00002 
00003 $Id: create_table_2.c,v 1.12 2007/05/03 11:15:34 jim Exp $
00004 
00005 */
00006 
00007 #include <stdio.h>
00008 #include <math.h>
00009 #include "imcore.h"
00010 #include "imcore_radii.h"
00011 #include "util.h"
00012 #include "floatmath.h"
00013  
00014 #define COL_NUMBER      1
00015 #define COL_FLUXISO     2
00016 #define COL_X           3
00017 #define COL_XERR        4
00018 #define COL_Y           5
00019 #define COL_YERR        6
00020 #define COL_SIGMA       7
00021 #define COL_ELLIPT      8
00022 #define COL_PA          9
00023 #define COL_AREAL1     10
00024 #define COL_AREAL2     11
00025 #define COL_AREAL3     12
00026 #define COL_AREAL4     13
00027 #define COL_AREAL5     14
00028 #define COL_AREAL6     15
00029 #define COL_AREAL7     16
00030 #define COL_AREAL8     17
00031 #define COL_PEAKHEIGHT 18
00032 #define COL_PKHTERR    19
00033 #define COL_APFLUX1    20
00034 #define COL_APFLUX1ERR 21
00035 #define COL_APFLUX2    22
00036 #define COL_APFLUX2ERR 23
00037 #define COL_APFLUX3    24
00038 #define COL_APFLUX3ERR 25
00039 #define COL_APFLUX4    26
00040 #define COL_APFLUX4ERR 27
00041 #define COL_APFLUX5    28
00042 #define COL_APFLUX5ERR 29
00043 #define COL_APFLUX6    30
00044 #define COL_APFLUX6ERR 31
00045 #define COL_APFLUX7    32
00046 #define COL_APFLUX7ERR 33
00047 #define COL_APFLUX8    34
00048 #define COL_APFLUX8ERR 35
00049 #define COL_APFLUX9    36
00050 #define COL_APFLUX9ERR 37
00051 #define COL_APFLUX10    38
00052 #define COL_APFLUX10ERR 39
00053 #define COL_APFLUX11    40
00054 #define COL_APFLUX11ERR 41
00055 #define COL_APFLUX12    42
00056 #define COL_APFLUX12ERR 43
00057 #define COL_APFLUX13    44
00058 #define COL_APFLUX13ERR 45
00059 #define COL_PETRAD      46
00060 #define COL_KRONRAD     47
00061 #define COL_HALLRAD     48
00062 #define COL_PETFLUX     49
00063 #define COL_PETFLUXERR  50
00064 #define COL_KRONFLUX    51
00065 #define COL_KRONFLUXERR 52
00066 #define COL_HALLFLUX    53
00067 #define COL_HALLFLUXERR 54
00068 #define COL_ERRFLAG     55
00069 #define COL_SKYLEVEL    56
00070 #define COL_SKYSIGMA    57
00071 #define COL_CHLDPARENT  58
00072 #define COL_RA          59
00073 #define COL_DEC         60
00074 #define COL_CLASS       61
00075 #define COL_STAT        62
00076  
00077 /* Number of columns in the table */
00078  
00079 #define NCOLS 80
00080 
00081 static const char *ttype[NCOLS]={"Sequence_number","Isophotal_flux",
00082                                  "X_coordinate","X_coordinate_err",
00083                                  "Y_coordinate","Y_coordinate_err",
00084                                  "Gaussian_sigma","Ellipticity","Position_angle",
00085                                  "Areal_1_profile","Areal_2_profile","Areal_3_profile",
00086                                  "Areal_4_profile","Areal_5_profile","Areal_6_profile",
00087                                  "Areal_7_profile","Areal_8_profile",
00088                                  "Peak_height","Peak_height_err",
00089                                  "Aper_flux_1","Aper_flux_1_err",
00090                                  "Aper_flux_2","Aper_flux_2_err",
00091                                  "Aper_flux_3","Aper_flux_3_err",
00092                                  "Aper_flux_4","Aper_flux_4_err",
00093                                  "Aper_flux_5","Aper_flux_5_err",
00094                                  "Aper_flux_6","Aper_flux_6_err",
00095                                  "Aper_flux_7","Aper_flux_7_err",
00096                                  "Aper_flux_8","Aper_flux_8_err",
00097                                  "Aper_flux_9","Aper_flux_9_err",
00098                                  "Aper_flux_10","Aper_flux_10_err",
00099                                  "Aper_flux_11","Aper_flux_11_err",
00100                                  "Aper_flux_12","Aper_flux_12_err",
00101                                  "Aper_flux_13","Aper_flux_13_err",
00102                                  "Petr_radius","Kron_radius","Hall_radius",
00103                                  "Petr_flux","Petr_flux_err",
00104                                  "Kron_flux","Kron_flux_err","Hall_flux","Hall_flux_err",
00105                                  "Error_bit_flag","Sky_level","Sky_rms",
00106                                  "Parent_or_child",
00107                                  "RA","DEC","Classification","Statistic",
00108                                  "Blank63","Blank64","Blank65","Blank66","Blank67",
00109                                  "Blank68","Blank69","Blank70","Blank71","Blank72",
00110                                  "Blank73","Blank74","Blank75","Blank76","Blank77",
00111                                  "Blank78","Blank79","Blank80"};
00112 
00113 static const char *tunit[NCOLS]={"Number","ADU",
00114                                  "Pixels","Pixels",
00115                                  "Pixels","Pixels",
00116                                  "Pixels","Number","Degrees",
00117                                  "Pixels","Pixels","Pixels",
00118                                  "Pixels","Pixels","Pixels",
00119                                  "Pixels","Pixels",
00120                                  "ADU","ADU",
00121                                  "ADU","ADU",
00122                                  "ADU","ADU",
00123                                  "ADU","ADU",
00124                                  "ADU","ADU",
00125                                  "ADU","ADU",
00126                                  "ADU","ADU",
00127                                  "ADU","ADU",
00128                                  "ADU","ADU",
00129                                  "ADU","ADU",
00130                                  "ADU","ADU",
00131                                  "ADU","ADU",
00132                                  "ADU","ADU",
00133                                  "ADU","ADU",
00134                                  "Pixels","Pixels","Pixels",
00135                                  "ADU","ADU",
00136                                  "ADU","ADU","ADU","ADU",
00137                                  "Number","ADU","ADU","Number",
00138                                  "RADIANS","RADIANS","Flag","N-sigma",
00139                                  "Blank63","Blank64","Blank65","Blank66","Blank67",
00140                                  "Blank68","Blank69","Blank70","Blank71","Blank72",
00141                                  "Blank73","Blank74","Blank75","Blank76","Blank77",
00142                                  "Blank78","Blank79","Blank80"};
00143 
00144 static cpl_type tform[NCOLS]={CPL_TYPE_INT,CPL_TYPE_FLOAT,
00145                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00146                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00147                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00148                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00149                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00150                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00151                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00152                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00153                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00154                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00155                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00156                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00157                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00158                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00159                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00160                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00161                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00162                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00163                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00164                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00165                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00166                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00167                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00168                               CPL_TYPE_FLOAT,
00169                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00170                               CPL_TYPE_FLOAT,
00171                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00172                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00173                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00174                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00175                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00176                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00177                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00178                               CPL_TYPE_FLOAT};
00179 
00180 #define NRADS 13
00181 static float rmults[] = {0.5,1.0/M_SQRT2,1.0,M_SQRT2,2.0,2.0*M_SQRT2,4.0,
00182                          5.0,6.0,7.0,8.0,10,12.0};
00183 static int nrcore = 2;
00184 static float apertures[NRADS];
00185 
00186 static int areal_cols[NAREAL] = {COL_AREAL1,COL_AREAL2,COL_AREAL3,COL_AREAL4,
00187                                  COL_AREAL5,COL_AREAL6,COL_AREAL7,COL_AREAL8};
00188  
00189 extern void tabinit_2(void) {
00190 
00191     /* Call the generic routine to open a new output table */
00192 
00193     tabinit_gen(NCOLS,ttype,tunit,tform);
00194 
00195     /* Define RA and Dec columns */
00196 
00197     imcore_xcol = COL_X;
00198     imcore_ycol = COL_Y;
00199         
00200 }
00201 
00202 extern int do_seeing_2(ap_t *ap) {
00203     int retval,i;
00204     char *areal_colnames[NAREAL];
00205 
00206     /* Sort out the areal profile column names */
00207 
00208     for (i = 0; i < NAREAL; i++) 
00209         areal_colnames[i] = (char *)ttype[areal_cols[i]-1];
00210  
00211     /* Just call the generic seeing routine */
00212  
00213     retval = do_seeing_gen(ap,ttype[COL_ELLIPT-1],ttype[COL_PEAKHEIGHT-1],
00214                            areal_colnames);
00215 
00216     /* Get out of here */
00217  
00218     return(retval);
00219 }
00220 
00221 extern int process_results_2(ap_t *ap) {
00222     float momresults[8],ttotal,parmall[IMNUM][NPAR],ratio,cflux[NRADS*IMNUM];
00223     float sxx,syy,srr,sxy,ecc,temp,xx,theta,radeg,ell,iso_flux,total_flux;
00224     float apflux1,apflux2,apflux3,apflux4,apflux5,yy,sigma,peak,areal1,apflux6;
00225     float apflux7,apflux8,apflux9,apflux10,apflux11,apflux12,apflux13,zero;
00226     float areal2,areal3,areal4,areal5,areal6,areal7,areal8,aa,bb;
00227     float skylev,skyrms,exp_rad[IMNUM],exp_flux[IMNUM],kron_flux[IMNUM];
00228     float petr_flux[IMNUM],kron_rad[IMNUM],petr_rad[IMNUM],badpix[IMNUM];
00229     float theta_ra,skyvar[IMNUM],cc,dd,sigsq,xxe,yye,peake,kron_fluxe;
00230     float apflux1e,apflux2e,apflux3e,apflux4e,apflux5e,apflux6e,apflux7e;
00231     float apflux8e,apflux9e,apflux10e,apflux11e,apflux12e,apflux13e,exp_fluxe;
00232     float petr_fluxe;
00233     int iareal[NAREAL],nbit,i,k,nn,nr,mbit,j;
00234     long nrows;
00235     plstruct *pl;
00236     unsigned char *mflag;
00237 
00238     /* Do a basic moments analysis and work out the areal profiles*/
00239 
00240     moments(ap,momresults);
00241     if (momresults[0] < 0)
00242         return(VIR_FATAL);
00243     areals(ap,iareal);
00244 
00245     /* See if this object makes the cut in terms of its size.  If not, then
00246        just return with good status */
00247 
00248     if (iareal[0] < ap->ipnop || momresults[3] < ap->xintmin)
00249         return(VIR_OK);
00250 
00251     /* Work out the total flux */
00252 
00253     extend(ap,momresults[3],momresults[1],momresults[2],
00254            momresults[4],momresults[5],momresults[6],
00255            (float)iareal[0],momresults[7],&ttotal);
00256     ratio = MAX(ttotal,momresults[3])/momresults[3];
00257 
00258     /* Try and deblend the images if it is requested and justified */
00259 
00260     if (iareal[0] >= ap->mulpix && ap->icrowd)
00261         overlp(ap,parmall,&nbit,momresults[1],momresults[2],
00262                momresults[3],iareal[0],momresults[7]);
00263     else
00264         nbit = 1;
00265     if (nbit == 1) {
00266         parmall[0][0] = momresults[3];
00267         parmall[0][1] = momresults[1];
00268         parmall[0][2] = momresults[2];
00269         parmall[0][3] = ap->thresh;
00270         for (i = 4; i < 8; i++)
00271             parmall[0][i] = momresults[i];
00272         for (i = 0; i < NAREAL; i++)
00273             parmall[0][i+8] = (float)iareal[i];
00274     } else {
00275         mbit = 0;
00276         for (i = 0; i < nbit; i++) {
00277             if (parmall[i][1] > 1.0 && parmall[i][1] < ap->lsiz &&
00278                 parmall[i][2] > 1.0 && parmall[i][2] < ap->csiz) {
00279                 for (j = 0; j < NPAR; j++) 
00280                     parmall[mbit][j] = parmall[i][j];
00281                 mbit++;
00282             }
00283         }
00284         nbit = mbit;
00285     } 
00286 
00287     /* Create a list of apertures */
00288 
00289     for (i = 0; i < NRADS; i++) {
00290         apertures[i] = rmults[i]*(ap->rcore);
00291         skyvar[i] = M_PI*apertures[i]*apertures[i];
00292     }
00293 
00294     /* Initialise the badpix accumulator */
00295 
00296     for (i = 0; i < nbit; i++)
00297         badpix[i] = 0.0;
00298 
00299     /* Get the core fluxes in all apertures */
00300 
00301     phopt(ap,parmall,nbit,NRADS,apertures,cflux,badpix,nrcore);
00302 
00303     /* Get exponential radius for all images and get the flux */
00304 
00305     for (k = 0; k < nbit; k++) {
00306         peak = parmall[k][7];
00307         areal1 = parmall[k][8];
00308         exp_rad[k] = imcore_exprad(ap->thresh,peak,areal1,apertures,NRADS);
00309     }
00310     imcore_flux(ap,parmall,nbit,exp_rad,exp_flux);
00311 
00312     /* Get Kron radius for all images and get the flux */
00313 
00314     for (k = 0; k < nbit; k++) {
00315         areal1 = parmall[k][8];
00316         kron_rad[k] = imcore_kronrad(areal1,apertures,cflux,NRADS);
00317     }
00318     imcore_flux(ap,parmall,nbit,kron_rad,kron_flux);
00319 
00320     /* Get Petrosian radius for all images and get the flux */
00321 
00322     for (k = 0; k < nbit; k++) {
00323         areal1 = parmall[k][8];
00324         petr_rad[k] = imcore_petrad(areal1,apertures,cflux,NRADS);
00325     }
00326     imcore_flux(ap,parmall,nbit,petr_rad,petr_flux);
00327 
00328     /* Massage the results and write them to the fits table */
00329 
00330     sigsq = powf(ap->sigma,2.0);
00331     radeg = 180.0/M_PI;
00332     for (k = 0; k < nbit; k++) {
00333         sxx = parmall[k][4];
00334         sxy = parmall[k][5];
00335         syy = parmall[k][6];
00336         if(sxy > 0.0)
00337           sxy = MAX(1.0e-4,MIN(sxy,sqrtf(sxx*syy)));
00338         else
00339           sxy = MIN(-1.0e-4,MAX(sxy,-sqrtf(sxx*syy)));
00340         srr = MAX(0.5,sxx+syy);
00341         ecc = sqrtf((syy-sxx)*(syy-sxx)+4.0*sxy*sxy)/srr;
00342         temp = MAX((1.0-ecc)/(1.0+ecc),0.0);
00343         ell = 1.0 - sqrtf(temp);
00344         ell = MIN(0.99,MAX(0.0,ell));
00345         aa = 1.0;
00346         bb = aa*(1.0 - ell);
00347         xx = 0.5*(1.0+ecc)*srr-sxx;
00348         if(xx == 0.0)
00349             theta = 0.0;
00350         else
00351             theta = 90.0 - radeg*atanf(sxy/xx);
00352         theta_ra = theta/radeg;
00353         cc = (1.0 + ecc)*pow(cos(theta_ra),2.0) + (1.0 - ecc)*pow(sin(theta_ra),2.0);
00354         dd = (1.0 + ecc)*pow(sin(theta_ra),2.0) + (1.0 - ecc)*pow(cos(theta_ra),2.0);
00355 
00356         /* Create a list of values */
00357 
00358         nrows = cpl_table_get_nrow(tab);
00359         nobjects++;
00360         if (nobjects > nrows) 
00361             (void)cpl_table_set_size(tab,nrows+INITROWS);
00362         nr = nobjects - 1;
00363         iso_flux = parmall[k][0];
00364         total_flux = ratio*parmall[k][0];
00365         apflux1 = cflux[k*NRADS + 0];
00366         apflux2 = cflux[k*NRADS + 1];
00367         apflux3 = cflux[k*NRADS + 2];
00368         apflux4 = cflux[k*NRADS + 3];
00369         apflux5 = cflux[k*NRADS + 4];
00370         apflux6 = cflux[k*NRADS + 5];
00371         apflux7 = cflux[k*NRADS + 6];
00372         apflux8 = cflux[k*NRADS + 7];
00373         apflux9 = cflux[k*NRADS + 8];
00374         apflux10 = cflux[k*NRADS + 9];
00375         apflux11 = cflux[k*NRADS + 10];
00376         apflux12 = cflux[k*NRADS + 11];
00377         apflux13 = cflux[k*NRADS + 12];
00378         peak = parmall[k][7];
00379         xx = parmall[k][1];
00380         xxe = sqrtf((2.0*sigsq/(M_PI*peak*peak)) + cc/(2.0*M_PI*gain*peak) + 
00381                     0.0001);
00382         yy = parmall[k][2];
00383         yye = sqrtf((2.0*sigsq/(M_PI*peak*peak)) + dd/(2.0*M_PI*gain*peak) + 
00384                     0.0001);
00385         sigma = sqrt(srr);
00386         areal1 = parmall[k][8];
00387         areal2 = parmall[k][9];
00388         areal3 = parmall[k][10];
00389         areal4 = parmall[k][11];
00390         areal5 = parmall[k][12];
00391         areal6 = parmall[k][13];
00392         areal7 = parmall[k][14];
00393         if (nbit > 1 && k == 0) 
00394             areal8 = 0.0;
00395         else
00396             areal8 = parmall[k][15];
00397         imcore_backest(ap,xx,yy,&skylev,&skyrms);
00398         peake = sqrtf(peak/gain + sigsq + skyrms*skyrms);
00399         kron_fluxe = sqrt(kron_flux[k]/gain + 
00400                           (sigsq + skyrms*skyrms)*M_PI*powf(kron_rad[k],2.0));
00401         exp_fluxe = sqrt(exp_flux[k]/gain + 
00402                          (sigsq + skyrms*skyrms)*M_PI*powf(exp_rad[k],2.0));
00403         petr_fluxe = sqrt(petr_flux[k]/gain + 
00404                           (sigsq + skyrms*skyrms)*M_PI*powf(petr_rad[k],2.0));
00405         apflux1e = sqrt(MAX(0.0,apflux1/gain) + skyvar[0]*(sigsq + skyrms*skyrms));
00406         apflux2e = sqrt(MAX(0.0,apflux2/gain) + skyvar[1]*(sigsq + skyrms*skyrms));
00407         apflux3e = sqrt(MAX(0.0,apflux3/gain) + skyvar[2]*(sigsq + skyrms*skyrms));
00408         apflux4e = sqrt(MAX(0.0,apflux4/gain) + skyvar[3]*(sigsq + skyrms*skyrms));
00409         apflux5e = sqrt(MAX(0.0,apflux5/gain) + skyvar[4]*(sigsq + skyrms*skyrms));
00410         apflux6e = sqrt(MAX(0.0,apflux6/gain) + skyvar[5]*(sigsq + skyrms*skyrms));
00411         apflux7e = sqrt(MAX(0.0,apflux7/gain) + skyvar[6]*(sigsq + skyrms*skyrms));
00412         apflux8e = sqrt(MAX(0.0,apflux8/gain) + skyvar[7]*(sigsq + skyrms*skyrms));
00413         apflux9e = sqrt(MAX(0.0,apflux9/gain) + skyvar[8]*(sigsq + skyrms*skyrms));
00414         apflux10e = sqrt(MAX(0.0,apflux10/gain) + skyvar[9]*(sigsq + skyrms*skyrms));
00415         apflux11e = sqrt(MAX(0.0,apflux11/gain) + skyvar[10]*(sigsq + skyrms*skyrms));
00416         apflux12e = sqrt(MAX(0.0,apflux12/gain) + skyvar[11]*(sigsq + skyrms*skyrms));
00417         apflux13e = sqrt(MAX(0.0,apflux13/gain) + skyvar[12]*(sigsq + skyrms*skyrms));
00418 
00419         /* Store away the results for this object */
00420 
00421         zero = 0.0;
00422         cpl_table_set_int(tab,ttype[COL_NUMBER-1],nr,nobjects);
00423         cpl_table_set_float(tab,ttype[COL_FLUXISO-1],nr,iso_flux);
00424         cpl_table_set_float(tab,ttype[COL_X-1],nr,xx);
00425         cpl_table_set_float(tab,ttype[COL_XERR-1],nr,xxe);
00426         cpl_table_set_float(tab,ttype[COL_Y-1],nr,yy);
00427         cpl_table_set_float(tab,ttype[COL_YERR-1],nr,yye);
00428         cpl_table_set_float(tab,ttype[COL_SIGMA-1],nr,sigma);
00429         cpl_table_set_float(tab,ttype[COL_ELLIPT-1],nr,ell);
00430         cpl_table_set_float(tab,ttype[COL_PA-1],nr,theta);
00431         cpl_table_set_float(tab,ttype[COL_AREAL1-1],nr,areal1);
00432         cpl_table_set_float(tab,ttype[COL_AREAL2-1],nr,areal2);
00433         cpl_table_set_float(tab,ttype[COL_AREAL3-1],nr,areal3);
00434         cpl_table_set_float(tab,ttype[COL_AREAL4-1],nr,areal4);
00435         cpl_table_set_float(tab,ttype[COL_AREAL5-1],nr,areal5);
00436         cpl_table_set_float(tab,ttype[COL_AREAL6-1],nr,areal6);
00437         cpl_table_set_float(tab,ttype[COL_AREAL7-1],nr,areal7);
00438         cpl_table_set_float(tab,ttype[COL_AREAL8-1],nr,areal8);
00439         cpl_table_set_float(tab,ttype[COL_PEAKHEIGHT-1],nr,peak);
00440         cpl_table_set_float(tab,ttype[COL_PKHTERR-1],nr,peake);
00441         cpl_table_set_float(tab,ttype[COL_APFLUX1-1],nr,apflux1);
00442         cpl_table_set_float(tab,ttype[COL_APFLUX1ERR-1],nr,apflux1e);
00443         cpl_table_set_float(tab,ttype[COL_APFLUX2-1],nr,apflux2);
00444         cpl_table_set_float(tab,ttype[COL_APFLUX2ERR-1],nr,apflux2e);
00445         cpl_table_set_float(tab,ttype[COL_APFLUX3-1],nr,apflux3);
00446         cpl_table_set_float(tab,ttype[COL_APFLUX3ERR-1],nr,apflux3e);
00447         cpl_table_set_float(tab,ttype[COL_APFLUX4-1],nr,apflux4);
00448         cpl_table_set_float(tab,ttype[COL_APFLUX4ERR-1],nr,apflux4e);
00449         cpl_table_set_float(tab,ttype[COL_APFLUX5-1],nr,apflux5);
00450         cpl_table_set_float(tab,ttype[COL_APFLUX5ERR-1],nr,apflux5e);
00451         cpl_table_set_float(tab,ttype[COL_APFLUX6-1],nr,apflux6);
00452         cpl_table_set_float(tab,ttype[COL_APFLUX6ERR-1],nr,apflux6e);
00453         cpl_table_set_float(tab,ttype[COL_APFLUX7-1],nr,apflux7);
00454         cpl_table_set_float(tab,ttype[COL_APFLUX7ERR-1],nr,apflux7e);
00455         cpl_table_set_float(tab,ttype[COL_APFLUX8-1],nr,apflux8);
00456         cpl_table_set_float(tab,ttype[COL_APFLUX8ERR-1],nr,apflux8e);
00457         cpl_table_set_float(tab,ttype[COL_APFLUX9-1],nr,apflux9);
00458         cpl_table_set_float(tab,ttype[COL_APFLUX9ERR-1],nr,apflux9e);
00459         cpl_table_set_float(tab,ttype[COL_APFLUX10-1],nr,apflux10);
00460         cpl_table_set_float(tab,ttype[COL_APFLUX10ERR-1],nr,apflux10e);
00461         cpl_table_set_float(tab,ttype[COL_APFLUX11-1],nr,apflux11);
00462         cpl_table_set_float(tab,ttype[COL_APFLUX11ERR-1],nr,apflux11e);
00463         cpl_table_set_float(tab,ttype[COL_APFLUX12-1],nr,apflux12);
00464         cpl_table_set_float(tab,ttype[COL_APFLUX12ERR-1],nr,apflux12e);
00465         cpl_table_set_float(tab,ttype[COL_APFLUX13-1],nr,apflux13);
00466         cpl_table_set_float(tab,ttype[COL_APFLUX13ERR-1],nr,apflux13e);
00467         cpl_table_set_float(tab,ttype[COL_PETRAD-1],nr,petr_rad[k]);
00468         cpl_table_set_float(tab,ttype[COL_KRONRAD-1],nr,kron_rad[k]);
00469         cpl_table_set_float(tab,ttype[COL_HALLRAD-1],nr,exp_rad[k]);
00470         cpl_table_set_float(tab,ttype[COL_PETFLUX-1],nr,petr_flux[k]);
00471         cpl_table_set_float(tab,ttype[COL_PETFLUXERR-1],nr,petr_fluxe);
00472         cpl_table_set_float(tab,ttype[COL_KRONFLUX-1],nr,kron_flux[k]);
00473         cpl_table_set_float(tab,ttype[COL_KRONFLUXERR-1],nr,kron_fluxe);
00474         cpl_table_set_float(tab,ttype[COL_HALLFLUX-1],nr,exp_flux[k]);
00475         cpl_table_set_float(tab,ttype[COL_HALLFLUXERR-1],nr,exp_fluxe);
00476         cpl_table_set_float(tab,ttype[COL_ERRFLAG-1],nr,badpix[k]);
00477         cpl_table_set_float(tab,ttype[COL_SKYLEVEL-1],nr,skylev);
00478         cpl_table_set_float(tab,ttype[COL_SKYSIGMA-1],nr,skyrms);
00479         cpl_table_set_float(tab,ttype[COL_CHLDPARENT-1],nr,zero);
00480 
00481         /* Store away some dummy values to avoid problems later on */
00482 
00483         cpl_table_set_float(tab,ttype[COL_RA-1],nr,zero);
00484         cpl_table_set_float(tab,ttype[COL_DEC-1],nr,zero);
00485         cpl_table_set_float(tab,ttype[COL_CLASS-1],nr,100.0);
00486         cpl_table_set_float(tab,ttype[COL_STAT-1],nr,zero);
00487 
00488         /* Write out the .ell file info... */
00489 
00490         if (ellfp != NULL) {
00491             aa = sqrtf(areal1/(M_PI*(1.0 - ell)));
00492             bb = aa*(1.0 - ell);
00493             fprintf(ellfp,"image; ellipse %9.3f %9.3f %7.2f %7.2f %6.1f\n",
00494                     xx,yy,aa,bb,theta);
00495         }
00496     }
00497 
00498     /* Flag all pixels as object pixels */
00499 
00500     pl = ap->plarray;
00501     mflag = ap->mflag;
00502     for (k = 0; k < ap->npl_pix; k++) {
00503         nn = ap->lsiz*(pl[k].y - 1) + pl[k].x - 1;
00504         mflag[nn] = MF_POBJPIX;
00505     }
00506 
00507     /* Get outta here */
00508 
00509     return(VIR_OK);
00510 }
00511 
00512 
00513 /* 
00514 
00515 $Log: create_table_2.c,v $
00516 Revision 1.12  2007/05/03 11:15:34  jim
00517 Fixed little problem with table wcs
00518 
00519 Revision 1.11  2007/05/02 09:11:35  jim
00520 Modified to allow for inclusion of table WCS keywords into FITS header
00521 
00522 Revision 1.10  2007/03/01 12:38:26  jim
00523 Small modifications after a bit of code checking
00524 
00525 Revision 1.9  2007/02/25 06:33:57  jim
00526 removed spurious line of code
00527 
00528 Revision 1.8  2006/11/27 11:58:09  jim
00529 Modified so that deblended images that fall off the edge of the image are
00530 rejected
00531 
00532 Revision 1.7  2006/08/11 13:00:53  jim
00533 Modified to have 8th areal profile set to 0 at the start of a blend
00534 
00535 Revision 1.6  2006/06/13 14:07:44  jim
00536 Set some values in ra,dec,classification and statistic columns so that we
00537 don't have problems down stream with undefined values
00538 
00539 Revision 1.5  2006/05/30 12:14:08  jim
00540 Fixed indexing bug in table that was causing a memory overwrite
00541 
00542 Revision 1.4  2006/04/20 11:15:18  jim
00543 A few minor bugs fixed
00544 
00545 Revision 1.3  2005/09/22 08:40:42  jim
00546 Fixed some bugs in imcore and added classification Removed some unnecessary
00547 files
00548 
00549 Revision 1.2  2005/09/20 15:07:46  jim
00550 Fixed a few bugs and added a few things
00551 
00552 Revision 1.1  2005/09/13 13:25:28  jim
00553 Initial entry after modifications to make cpl compliant
00554 
00555 
00556 */

Generated on Sat Apr 6 04:03:06 2013 for VIRCAM Pipeline by  doxygen 1.5.1