create_table_2.c

00001 /* $Id: create_table_2.c,v 1.19 2010/09/09 12:09:57 jim Exp $
00002  *
00003  * This file is part of the VIRCAM Pipeline
00004  * Copyright (C) 2005 Cambridge Astronomy Survey Unit
00005  *
00006  * This program is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * This program is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this program; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019  */
00020 
00021 /*
00022  * $Author: jim $
00023  * $Date: 2010/09/09 12:09:57 $
00024  * $Revision: 1.19 $
00025  * $Name: vcam-1_3_0 $
00026  */
00027 
00028 #include <stdio.h>
00029 #include <math.h>
00030 #include "imcore.h"
00031 #include "imcore_radii.h"
00032 #include "util.h"
00033 #include "floatmath.h"
00034  
00035 #define COL_NUMBER      1
00036 #define COL_FLUXISO     2
00037 #define COL_X           3
00038 #define COL_XERR        4
00039 #define COL_Y           5
00040 #define COL_YERR        6
00041 #define COL_SIGMA       7
00042 #define COL_ELLIPT      8
00043 #define COL_PA          9
00044 #define COL_AREAL1     10
00045 #define COL_AREAL2     11
00046 #define COL_AREAL3     12
00047 #define COL_AREAL4     13
00048 #define COL_AREAL5     14
00049 #define COL_AREAL6     15
00050 #define COL_AREAL7     16
00051 #define COL_AREAL8     17
00052 #define COL_PEAKHEIGHT 18
00053 #define COL_PKHTERR    19
00054 #define COL_APFLUX1    20
00055 #define COL_APFLUX1ERR 21
00056 #define COL_APFLUX2    22
00057 #define COL_APFLUX2ERR 23
00058 #define COL_APFLUX3    24
00059 #define COL_APFLUX3ERR 25
00060 #define COL_APFLUX4    26
00061 #define COL_APFLUX4ERR 27
00062 #define COL_APFLUX5    28
00063 #define COL_APFLUX5ERR 29
00064 #define COL_APFLUX6    30
00065 #define COL_APFLUX6ERR 31
00066 #define COL_APFLUX7    32
00067 #define COL_APFLUX7ERR 33
00068 #define COL_APFLUX8    34
00069 #define COL_APFLUX8ERR 35
00070 #define COL_APFLUX9    36
00071 #define COL_APFLUX9ERR 37
00072 #define COL_APFLUX10    38
00073 #define COL_APFLUX10ERR 39
00074 #define COL_APFLUX11    40
00075 #define COL_APFLUX11ERR 41
00076 #define COL_APFLUX12    42
00077 #define COL_APFLUX12ERR 43
00078 #define COL_APFLUX13    44
00079 #define COL_APFLUX13ERR 45
00080 #define COL_PETRAD      46
00081 #define COL_KRONRAD     47
00082 #define COL_HALLRAD     48
00083 #define COL_PETFLUX     49
00084 #define COL_PETFLUXERR  50
00085 #define COL_KRONFLUX    51
00086 #define COL_KRONFLUXERR 52
00087 #define COL_HALLFLUX    53
00088 #define COL_HALLFLUXERR 54
00089 #define COL_ERRFLAG     55
00090 #define COL_SKYLEVEL    56
00091 #define COL_SKYSIGMA    57
00092 #define COL_CHLDPARENT  58
00093 #define COL_RA          59
00094 #define COL_DEC         60
00095 #define COL_CLASS       61
00096 #define COL_STAT        62
00097  
00098 /* Number of columns in the table */
00099  
00100 #define NCOLS 80
00101 
00102 static const char *ttype[NCOLS]={"Sequence_number","Isophotal_flux",
00103                                  "X_coordinate","X_coordinate_err",
00104                                  "Y_coordinate","Y_coordinate_err",
00105                                  "Gaussian_sigma","Ellipticity","Position_angle",
00106                                  "Areal_1_profile","Areal_2_profile","Areal_3_profile",
00107                                  "Areal_4_profile","Areal_5_profile","Areal_6_profile",
00108                                  "Areal_7_profile","Areal_8_profile",
00109                                  "Peak_height","Peak_height_err",
00110                                  "Aper_flux_1","Aper_flux_1_err",
00111                                  "Aper_flux_2","Aper_flux_2_err",
00112                                  "Aper_flux_3","Aper_flux_3_err",
00113                                  "Aper_flux_4","Aper_flux_4_err",
00114                                  "Aper_flux_5","Aper_flux_5_err",
00115                                  "Aper_flux_6","Aper_flux_6_err",
00116                                  "Aper_flux_7","Aper_flux_7_err",
00117                                  "Aper_flux_8","Aper_flux_8_err",
00118                                  "Aper_flux_9","Aper_flux_9_err",
00119                                  "Aper_flux_10","Aper_flux_10_err",
00120                                  "Aper_flux_11","Aper_flux_11_err",
00121                                  "Aper_flux_12","Aper_flux_12_err",
00122                                  "Aper_flux_13","Aper_flux_13_err",
00123                                  "Petr_radius","Kron_radius","Hall_radius",
00124                                  "Petr_flux","Petr_flux_err",
00125                                  "Kron_flux","Kron_flux_err","Hall_flux","Hall_flux_err",
00126                                  "Error_bit_flag","Sky_level","Sky_rms",
00127                                  "Parent_or_child",
00128                                  "RA","DEC","Classification","Statistic",
00129                                  "Blank63","Blank64","Blank65","Blank66","Blank67",
00130                                  "Blank68","Blank69","Blank70","Blank71","Blank72",
00131                                  "Blank73","Blank74","Blank75","Blank76","Blank77",
00132                                  "Blank78","Blank79","Blank80"};
00133 
00134 static const char *tunit[NCOLS]={"Number","ADU",
00135                                  "Pixels","Pixels",
00136                                  "Pixels","Pixels",
00137                                  "Pixels","Number","Degrees",
00138                                  "Pixels","Pixels","Pixels",
00139                                  "Pixels","Pixels","Pixels",
00140                                  "Pixels","Pixels",
00141                                  "ADU","ADU",
00142                                  "ADU","ADU",
00143                                  "ADU","ADU",
00144                                  "ADU","ADU",
00145                                  "ADU","ADU",
00146                                  "ADU","ADU",
00147                                  "ADU","ADU",
00148                                  "ADU","ADU",
00149                                  "ADU","ADU",
00150                                  "ADU","ADU",
00151                                  "ADU","ADU",
00152                                  "ADU","ADU",
00153                                  "ADU","ADU",
00154                                  "ADU","ADU",
00155                                  "Pixels","Pixels","Pixels",
00156                                  "ADU","ADU",
00157                                  "ADU","ADU","ADU","ADU",
00158                                  "Number","ADU","ADU","Number",
00159                                  "Degrees","Degrees","Flag","N-sigma",
00160                                  "Blank63","Blank64","Blank65","Blank66","Blank67",
00161                                  "Blank68","Blank69","Blank70","Blank71","Blank72",
00162                                  "Blank73","Blank74","Blank75","Blank76","Blank77",
00163                                  "Blank78","Blank79","Blank80"};
00164 
00165 static cpl_type tform[NCOLS]={CPL_TYPE_INT,CPL_TYPE_FLOAT,
00166                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00167                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00168                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00169                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00170                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00171                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00172                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00173                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00174                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00175                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00176                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00177                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00178                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00179                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00180                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00181                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00182                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00183                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00184                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00185                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00186                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00187                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00188                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00189                               CPL_TYPE_FLOAT,
00190                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00191                               CPL_TYPE_FLOAT,
00192                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00193                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00194                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00195                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00196                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00197                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00198                               CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
00199                               CPL_TYPE_FLOAT};
00200 
00201 #define NRADS 13
00202 static float rmults[] = {0.5,1.0/CPL_MATH_SQRT2,1.0,CPL_MATH_SQRT2,2.0,
00203                          2.0*CPL_MATH_SQRT2,4.0,5.0,6.0,7.0,8.0,10,12.0};
00204 static int nrcore = 2;
00205 static float apertures[NRADS];
00206 
00207 static int areal_cols[NAREAL] = {COL_AREAL1,COL_AREAL2,COL_AREAL3,COL_AREAL4,
00208                                  COL_AREAL5,COL_AREAL6,COL_AREAL7,COL_AREAL8};
00211 /*---------------------------------------------------------------------------*/
00233 /*---------------------------------------------------------------------------*/
00234  
00235 extern void tabinit_2(void) {
00236 
00237     /* Call the generic routine to open a new output table */
00238 
00239     tabinit_gen(NCOLS,ttype,tunit,tform);
00240 
00241     /* Define RA and Dec columns */
00242 
00243     imcore_xcol = COL_X;
00244     imcore_ycol = COL_Y;
00245         
00246 }
00247 
00248 /*---------------------------------------------------------------------------*/
00273 /*---------------------------------------------------------------------------*/
00274 
00275 extern int do_seeing_2(ap_t *ap) {
00276     int retval,i;
00277     char *areal_colnames[NAREAL];
00278 
00279     /* Sort out the areal profile column names */
00280 
00281     for (i = 0; i < NAREAL; i++) 
00282         areal_colnames[i] = (char *)ttype[areal_cols[i]-1];
00283  
00284     /* Just call the generic seeing routine */
00285  
00286     retval = do_seeing_gen(ap,ttype[COL_ELLIPT-1],ttype[COL_PEAKHEIGHT-1],
00287                            areal_colnames);
00288 
00289     /* Get out of here */
00290  
00291     return(retval);
00292 }
00293         
00294 /*---------------------------------------------------------------------------*/
00321 /*---------------------------------------------------------------------------*/
00322 
00323 extern int process_results_2(ap_t *ap) {
00324     float momresults[8],ttotal,parmall[IMNUM][NPAR],ratio,cflux[NRADS*IMNUM];
00325     float sxx,syy,srr,sxy,ecc,temp,xx,theta,radeg,ell,iso_flux,total_flux;
00326     float apflux1,apflux2,apflux3,apflux4,apflux5,yy,sigma,peak,areal1,apflux6;
00327     float apflux7,apflux8,apflux9,apflux10,apflux11,apflux12,apflux13,zero;
00328     float areal2,areal3,areal4,areal5,areal6,areal7,areal8,aa,bb;
00329     float skylev,skyrms,exp_rad[IMNUM],exp_flux[IMNUM],kron_flux[IMNUM];
00330     float petr_flux[IMNUM],kron_rad[IMNUM],petr_rad[IMNUM],badpix[IMNUM];
00331     float theta_ra,skyvar[IMNUM],cc,dd,sigsq,xxe,yye,peake,kron_fluxe;
00332     float apflux1e,apflux2e,apflux3e,apflux4e,apflux5e,apflux6e,apflux7e;
00333     float apflux8e,apflux9e,apflux10e,apflux11e,apflux12e,apflux13e,exp_fluxe;
00334     float petr_fluxe;
00335     int iareal[NAREAL],nbit,i,k,nr,mbit,j;
00336     long nrows;
00337 
00338     /* Do a basic moments analysis and work out the areal profiles*/
00339 
00340     moments(ap,momresults);
00341     if (momresults[0] < 0)
00342         return(VIR_FATAL);
00343     areals(ap,iareal);
00344 
00345     /* See if this object makes the cut in terms of its size.  If not, then
00346        just return with good status */
00347 
00348     if (iareal[0] < ap->ipnop || momresults[3] < ap->xintmin)
00349         return(VIR_OK);
00350 
00351     /* Work out the total flux */
00352 
00353     extend(ap,momresults[3],momresults[1],momresults[2],
00354            momresults[4],momresults[5],momresults[6],
00355            (float)iareal[0],momresults[7],&ttotal);
00356     ratio = MAX(ttotal,momresults[3])/momresults[3];
00357 
00358     /* Try and deblend the images if it is requested and justified */
00359 
00360     if (iareal[0] >= ap->mulpix && ap->icrowd)
00361         overlp(ap,parmall,&nbit,momresults[1],momresults[2],
00362                momresults[3],iareal[0],momresults[7]);
00363     else
00364         nbit = 1;
00365     if (nbit == 1) {
00366         parmall[0][0] = momresults[3];
00367         parmall[0][1] = momresults[1];
00368         parmall[0][2] = momresults[2];
00369         parmall[0][3] = ap->thresh;
00370         for (i = 4; i < 8; i++)
00371             parmall[0][i] = momresults[i];
00372         for (i = 0; i < NAREAL; i++)
00373             parmall[0][i+8] = (float)iareal[i];
00374     } else {
00375         mbit = 0;
00376         for (i = 0; i < nbit; i++) {
00377             if (parmall[i][1] > 1.0 && parmall[i][1] < ap->lsiz &&
00378                 parmall[i][2] > 1.0 && parmall[i][2] < ap->csiz) {
00379                 for (j = 0; j < NPAR; j++) 
00380                     parmall[mbit][j] = parmall[i][j];
00381                 mbit++;
00382             }
00383         }
00384         nbit = mbit;
00385     } 
00386 
00387     /* Create a list of apertures */
00388 
00389     for (i = 0; i < NRADS; i++) {
00390         apertures[i] = rmults[i]*(ap->rcore);
00391         skyvar[i] = CPL_MATH_PI*apertures[i]*apertures[i];
00392     }
00393 
00394     /* Initialise the badpix accumulator */
00395 
00396     for (i = 0; i < nbit; i++)
00397         badpix[i] = 0.0;
00398 
00399     /* Get the core fluxes in all apertures */
00400 
00401     phopt(ap,parmall,nbit,NRADS,apertures,cflux,badpix,nrcore);
00402 
00403     /* Get exponential radius for all images and get the flux */
00404 
00405     for (k = 0; k < nbit; k++) {
00406         peak = parmall[k][7];
00407         areal1 = parmall[k][8];
00408         exp_rad[k] = imcore_exprad(parmall[k][3],peak,areal1,apertures,NRADS);
00409     }
00410     imcore_flux(ap,parmall,nbit,exp_rad,exp_flux,NRADS,apertures,cflux);
00411 
00412     /* Get Kron radius for all images and get the flux */
00413 
00414     for (k = 0; k < nbit; k++) {
00415         areal1 = parmall[k][8];
00416         kron_rad[k] = imcore_kronrad(areal1,apertures,cflux+k*NRADS,NRADS);
00417     }
00418     imcore_flux(ap,parmall,nbit,kron_rad,kron_flux,NRADS,apertures,cflux);
00419 
00420     /* Get Petrosian radius for all images and get the flux */
00421 
00422     for (k = 0; k < nbit; k++) {
00423         areal1 = parmall[k][8];
00424         petr_rad[k] = imcore_petrad(areal1,apertures,cflux+k*NRADS,NRADS);
00425     }
00426     imcore_flux(ap,parmall,nbit,petr_rad,petr_flux,NRADS,apertures,cflux); 
00427 
00428     /* Massage the results and write them to the fits table */
00429 
00430     sigsq = powf(ap->sigma,2.0);
00431     radeg = 180.0/CPL_MATH_PI;
00432     for (k = 0; k < nbit; k++) {
00433         sxx = parmall[k][4];
00434         sxy = parmall[k][5];
00435         syy = parmall[k][6];
00436         if(sxy > 0.0)
00437           sxy = MAX(1.0e-4,MIN(sxy,sqrtf(sxx*syy)));
00438         else
00439           sxy = MIN(-1.0e-4,MAX(sxy,-sqrtf(sxx*syy)));
00440         srr = MAX(0.5,sxx+syy);
00441         ecc = sqrtf((syy-sxx)*(syy-sxx)+4.0*sxy*sxy)/srr;
00442         temp = MAX((1.0-ecc)/(1.0+ecc),0.0);
00443         ell = 1.0 - sqrtf(temp);
00444         ell = MIN(0.99,MAX(0.0,ell));
00445         aa = 1.0;
00446         bb = aa*(1.0 - ell);
00447         xx = 0.5*(1.0+ecc)*srr-sxx;
00448         if(xx == 0.0)
00449             theta = 0.0;
00450         else
00451             theta = 90.0 - radeg*atanf(sxy/xx);
00452         theta_ra = theta/radeg;
00453         cc = (1.0 + ecc)*pow(cos(theta_ra),2.0) + (1.0 - ecc)*pow(sin(theta_ra),2.0);
00454         dd = (1.0 + ecc)*pow(sin(theta_ra),2.0) + (1.0 - ecc)*pow(cos(theta_ra),2.0);
00455 
00456         /* Create a list of values */
00457 
00458         nrows = cpl_table_get_nrow(tab);
00459         nobjects++;
00460         if (nobjects > nrows) 
00461             (void)cpl_table_set_size(tab,nrows+INITROWS);
00462         nr = nobjects - 1;
00463         iso_flux = parmall[k][0];
00464         total_flux = ratio*parmall[k][0];
00465         apflux1 = cflux[k*NRADS + 0];
00466         apflux2 = cflux[k*NRADS + 1];
00467         apflux3 = cflux[k*NRADS + 2];
00468         apflux4 = cflux[k*NRADS + 3];
00469         apflux5 = cflux[k*NRADS + 4];
00470         apflux6 = cflux[k*NRADS + 5];
00471         apflux7 = cflux[k*NRADS + 6];
00472         apflux8 = cflux[k*NRADS + 7];
00473         apflux9 = cflux[k*NRADS + 8];
00474         apflux10 = cflux[k*NRADS + 9];
00475         apflux11 = cflux[k*NRADS + 10];
00476         apflux12 = cflux[k*NRADS + 11];
00477         apflux13 = cflux[k*NRADS + 12];
00478         peak = parmall[k][7];
00479         xx = parmall[k][1];
00480         xxe = sqrtf((2.0*sigsq/(CPL_MATH_PI*peak*peak)) + cc/(2.0*CPL_MATH_PI*gain*peak) + 
00481                     0.0001);
00482         yy = parmall[k][2];
00483         yye = sqrtf((2.0*sigsq/(CPL_MATH_PI*peak*peak)) + dd/(2.0*CPL_MATH_PI*gain*peak) + 
00484                     0.0001);
00485         sigma = sqrt(srr);
00486         areal1 = parmall[k][8];
00487         areal2 = parmall[k][9];
00488         areal3 = parmall[k][10];
00489         areal4 = parmall[k][11];
00490         areal5 = parmall[k][12];
00491         areal6 = parmall[k][13];
00492         areal7 = parmall[k][14];
00493         if (nbit > 1 && k == 0) 
00494             areal8 = 0.0;
00495         else
00496             areal8 = parmall[k][15];
00497         imcore_backest(ap,xx,yy,&skylev,&skyrms);
00498         peake = sqrtf(peak/gain + sigsq + skyrms*skyrms);
00499         kron_fluxe = sqrt(kron_flux[k]/gain + 
00500                           (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(kron_rad[k],2.0));
00501         exp_fluxe = sqrt(exp_flux[k]/gain + 
00502                          (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(exp_rad[k],2.0));
00503         petr_fluxe = sqrt(petr_flux[k]/gain + 
00504                           (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(petr_rad[k],2.0));
00505         apflux1e = sqrt(MAX(0.0,apflux1/gain) + skyvar[0]*(sigsq + skyrms*skyrms));
00506         apflux2e = sqrt(MAX(0.0,apflux2/gain) + skyvar[1]*(sigsq + skyrms*skyrms));
00507         apflux3e = sqrt(MAX(0.0,apflux3/gain) + skyvar[2]*(sigsq + skyrms*skyrms));
00508         apflux4e = sqrt(MAX(0.0,apflux4/gain) + skyvar[3]*(sigsq + skyrms*skyrms));
00509         apflux5e = sqrt(MAX(0.0,apflux5/gain) + skyvar[4]*(sigsq + skyrms*skyrms));
00510         apflux6e = sqrt(MAX(0.0,apflux6/gain) + skyvar[5]*(sigsq + skyrms*skyrms));
00511         apflux7e = sqrt(MAX(0.0,apflux7/gain) + skyvar[6]*(sigsq + skyrms*skyrms));
00512         apflux8e = sqrt(MAX(0.0,apflux8/gain) + skyvar[7]*(sigsq + skyrms*skyrms));
00513         apflux9e = sqrt(MAX(0.0,apflux9/gain) + skyvar[8]*(sigsq + skyrms*skyrms));
00514         apflux10e = sqrt(MAX(0.0,apflux10/gain) + skyvar[9]*(sigsq + skyrms*skyrms));
00515         apflux11e = sqrt(MAX(0.0,apflux11/gain) + skyvar[10]*(sigsq + skyrms*skyrms));
00516         apflux12e = sqrt(MAX(0.0,apflux12/gain) + skyvar[11]*(sigsq + skyrms*skyrms));
00517         apflux13e = sqrt(MAX(0.0,apflux13/gain) + skyvar[12]*(sigsq + skyrms*skyrms));
00518 
00519         /* Store away the results for this object */
00520 
00521         zero = 0.0;
00522         cpl_table_set_int(tab,ttype[COL_NUMBER-1],nr,nobjects);
00523         cpl_table_set_float(tab,ttype[COL_FLUXISO-1],nr,iso_flux);
00524         cpl_table_set_float(tab,ttype[COL_X-1],nr,xx);
00525         cpl_table_set_float(tab,ttype[COL_XERR-1],nr,xxe);
00526         cpl_table_set_float(tab,ttype[COL_Y-1],nr,yy);
00527         cpl_table_set_float(tab,ttype[COL_YERR-1],nr,yye);
00528         cpl_table_set_float(tab,ttype[COL_SIGMA-1],nr,sigma);
00529         cpl_table_set_float(tab,ttype[COL_ELLIPT-1],nr,ell);
00530         cpl_table_set_float(tab,ttype[COL_PA-1],nr,theta);
00531         cpl_table_set_float(tab,ttype[COL_AREAL1-1],nr,areal1);
00532         cpl_table_set_float(tab,ttype[COL_AREAL2-1],nr,areal2);
00533         cpl_table_set_float(tab,ttype[COL_AREAL3-1],nr,areal3);
00534         cpl_table_set_float(tab,ttype[COL_AREAL4-1],nr,areal4);
00535         cpl_table_set_float(tab,ttype[COL_AREAL5-1],nr,areal5);
00536         cpl_table_set_float(tab,ttype[COL_AREAL6-1],nr,areal6);
00537         cpl_table_set_float(tab,ttype[COL_AREAL7-1],nr,areal7);
00538         cpl_table_set_float(tab,ttype[COL_AREAL8-1],nr,areal8);
00539         cpl_table_set_float(tab,ttype[COL_PEAKHEIGHT-1],nr,peak);
00540         cpl_table_set_float(tab,ttype[COL_PKHTERR-1],nr,peake);
00541         cpl_table_set_float(tab,ttype[COL_APFLUX1-1],nr,apflux1);
00542         cpl_table_set_float(tab,ttype[COL_APFLUX1ERR-1],nr,apflux1e);
00543         cpl_table_set_float(tab,ttype[COL_APFLUX2-1],nr,apflux2);
00544         cpl_table_set_float(tab,ttype[COL_APFLUX2ERR-1],nr,apflux2e);
00545         cpl_table_set_float(tab,ttype[COL_APFLUX3-1],nr,apflux3);
00546         cpl_table_set_float(tab,ttype[COL_APFLUX3ERR-1],nr,apflux3e);
00547         cpl_table_set_float(tab,ttype[COL_APFLUX4-1],nr,apflux4);
00548         cpl_table_set_float(tab,ttype[COL_APFLUX4ERR-1],nr,apflux4e);
00549         cpl_table_set_float(tab,ttype[COL_APFLUX5-1],nr,apflux5);
00550         cpl_table_set_float(tab,ttype[COL_APFLUX5ERR-1],nr,apflux5e);
00551         cpl_table_set_float(tab,ttype[COL_APFLUX6-1],nr,apflux6);
00552         cpl_table_set_float(tab,ttype[COL_APFLUX6ERR-1],nr,apflux6e);
00553         cpl_table_set_float(tab,ttype[COL_APFLUX7-1],nr,apflux7);
00554         cpl_table_set_float(tab,ttype[COL_APFLUX7ERR-1],nr,apflux7e);
00555         cpl_table_set_float(tab,ttype[COL_APFLUX8-1],nr,apflux8);
00556         cpl_table_set_float(tab,ttype[COL_APFLUX8ERR-1],nr,apflux8e);
00557         cpl_table_set_float(tab,ttype[COL_APFLUX9-1],nr,apflux9);
00558         cpl_table_set_float(tab,ttype[COL_APFLUX9ERR-1],nr,apflux9e);
00559         cpl_table_set_float(tab,ttype[COL_APFLUX10-1],nr,apflux10);
00560         cpl_table_set_float(tab,ttype[COL_APFLUX10ERR-1],nr,apflux10e);
00561         cpl_table_set_float(tab,ttype[COL_APFLUX11-1],nr,apflux11);
00562         cpl_table_set_float(tab,ttype[COL_APFLUX11ERR-1],nr,apflux11e);
00563         cpl_table_set_float(tab,ttype[COL_APFLUX12-1],nr,apflux12);
00564         cpl_table_set_float(tab,ttype[COL_APFLUX12ERR-1],nr,apflux12e);
00565         cpl_table_set_float(tab,ttype[COL_APFLUX13-1],nr,apflux13);
00566         cpl_table_set_float(tab,ttype[COL_APFLUX13ERR-1],nr,apflux13e);
00567         cpl_table_set_float(tab,ttype[COL_PETRAD-1],nr,0.5*petr_rad[k]);
00568         cpl_table_set_float(tab,ttype[COL_KRONRAD-1],nr,0.5*kron_rad[k]);
00569         cpl_table_set_float(tab,ttype[COL_HALLRAD-1],nr,exp_rad[k]);
00570         cpl_table_set_float(tab,ttype[COL_PETFLUX-1],nr,petr_flux[k]);
00571         cpl_table_set_float(tab,ttype[COL_PETFLUXERR-1],nr,petr_fluxe);
00572         cpl_table_set_float(tab,ttype[COL_KRONFLUX-1],nr,kron_flux[k]);
00573         cpl_table_set_float(tab,ttype[COL_KRONFLUXERR-1],nr,kron_fluxe);
00574         cpl_table_set_float(tab,ttype[COL_HALLFLUX-1],nr,exp_flux[k]);
00575         cpl_table_set_float(tab,ttype[COL_HALLFLUXERR-1],nr,exp_fluxe);
00576         cpl_table_set_float(tab,ttype[COL_ERRFLAG-1],nr,badpix[k]);
00577         cpl_table_set_float(tab,ttype[COL_SKYLEVEL-1],nr,skylev);
00578         cpl_table_set_float(tab,ttype[COL_SKYSIGMA-1],nr,skyrms);
00579         cpl_table_set_float(tab,ttype[COL_CHLDPARENT-1],nr,zero);
00580 
00581         /* Store away some dummy values to avoid problems later on */
00582 
00583         cpl_table_set_float(tab,ttype[COL_RA-1],nr,zero);
00584         cpl_table_set_float(tab,ttype[COL_DEC-1],nr,zero);
00585         cpl_table_set_float(tab,ttype[COL_CLASS-1],nr,100.0);
00586         cpl_table_set_float(tab,ttype[COL_STAT-1],nr,zero);
00587     }
00588 
00589     /* Get outta here */
00590 
00591     return(VIR_OK);
00592 }
00593 
00596 /* 
00597 
00598 $Log: create_table_2.c,v $
00599 Revision 1.19  2010/09/09 12:09:57  jim
00600 Added docs
00601 
00602 Revision 1.18  2009/09/09 09:40:12  jim
00603 Using CPL macros for various constants
00604 
00605 Revision 1.17  2009/03/19 10:05:46  jim
00606 Fixed RA,Dec column units
00607 
00608 Revision 1.16  2009/02/20 10:49:58  jim
00609 Removed superfluous declarations
00610 
00611 Revision 1.15  2009/01/30 08:27:31  jim
00612 use new version of imcore_flux
00613 
00614 Revision 1.14  2008/10/24 11:01:15  jim
00615 Fixed calculation of petrosian, kron and hall radii
00616 
00617 Revision 1.13  2008/10/13 08:09:31  jim
00618 Removed redundant code and fixed pixel flagging scheme
00619 
00620 Revision 1.12  2007/05/03 11:15:34  jim
00621 Fixed little problem with table wcs
00622 
00623 Revision 1.11  2007/05/02 09:11:35  jim
00624 Modified to allow for inclusion of table WCS keywords into FITS header
00625 
00626 Revision 1.10  2007/03/01 12:38:26  jim
00627 Small modifications after a bit of code checking
00628 
00629 Revision 1.9  2007/02/25 06:33:57  jim
00630 removed spurious line of code
00631 
00632 Revision 1.8  2006/11/27 11:58:09  jim
00633 Modified so that deblended images that fall off the edge of the image are
00634 rejected
00635 
00636 Revision 1.7  2006/08/11 13:00:53  jim
00637 Modified to have 8th areal profile set to 0 at the start of a blend
00638 
00639 Revision 1.6  2006/06/13 14:07:44  jim
00640 Set some values in ra,dec,classification and statistic columns so that we
00641 don't have problems down stream with undefined values
00642 
00643 Revision 1.5  2006/05/30 12:14:08  jim
00644 Fixed indexing bug in table that was causing a memory overwrite
00645 
00646 Revision 1.4  2006/04/20 11:15:18  jim
00647 A few minor bugs fixed
00648 
00649 Revision 1.3  2005/09/22 08:40:42  jim
00650 Fixed some bugs in imcore and added classification Removed some unnecessary
00651 files
00652 
00653 Revision 1.2  2005/09/20 15:07:46  jim
00654 Fixed a few bugs and added a few things
00655 
00656 Revision 1.1  2005/09/13 13:25:28  jim
00657 Initial entry after modifications to make cpl compliant
00658 
00659 
00660 */

Generated on 15 Mar 2012 for VIRCAM Pipeline by  doxygen 1.6.1