VIRCAM Pipeline  1.3.3
create_table_6.c
1 /* $Id: create_table_6.c,v 1.1 2013-10-15 16:15:56 jim Exp $
2  *
3  * This file is part of the VIRCAM Pipeline
4  * Copyright (C) 2013 Cambridge Astronomy Survey Unit
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  */
20 
21 /*
22  * $Author: jim $
23  * $Date: 2013-10-15 16:15:56 $
24  * $Revision: 1.1 $
25  * $Name: not supported by cvs2svn $
26  */
27 
28 #include <stdio.h>
29 #include <math.h>
30 #include "imcore.h"
31 #include "imcore_radii.h"
32 #include "util.h"
33 #include "floatmath.h"
34 
35 #define COL_NUMBER 1
36 #define COL_FLUXISO 2
37 #define COL_X 3
38 #define COL_XERR 4
39 #define COL_Y 5
40 #define COL_YERR 6
41 #define COL_SIGMA 7
42 #define COL_ELLIPT 8
43 #define COL_PA 9
44 #define COL_AREAL1 10
45 #define COL_AREAL2 11
46 #define COL_AREAL3 12
47 #define COL_AREAL4 13
48 #define COL_AREAL5 14
49 #define COL_AREAL6 15
50 #define COL_AREAL7 16
51 #define COL_AREAL8 17
52 #define COL_PEAKHEIGHT 18
53 #define COL_PKHTERR 19
54 #define COL_APFLUX1 20
55 #define COL_APFLUX1ERR 21
56 #define COL_APFLUX2 22
57 #define COL_APFLUX2ERR 23
58 #define COL_APFLUX3 24
59 #define COL_APFLUX3ERR 25
60 #define COL_APFLUX4 26
61 #define COL_APFLUX4ERR 27
62 #define COL_APFLUX5 28
63 #define COL_APFLUX5ERR 29
64 #define COL_APFLUX6 30
65 #define COL_APFLUX6ERR 31
66 #define COL_APFLUX7 32
67 #define COL_APFLUX7ERR 33
68 #define COL_APFLUX8 34
69 #define COL_APFLUX8ERR 35
70 #define COL_APFLUX9 36
71 #define COL_APFLUX9ERR 37
72 #define COL_APFLUX10 38
73 #define COL_APFLUX10ERR 39
74 #define COL_APFLUX11 40
75 #define COL_APFLUX11ERR 41
76 #define COL_APFLUX12 42
77 #define COL_APFLUX12ERR 43
78 #define COL_APFLUX13 44
79 #define COL_APFLUX13ERR 45
80 #define COL_PETRAD 46
81 #define COL_KRONRAD 47
82 #define COL_HALFRAD 48
83 #define COL_PETFLUX 49
84 #define COL_PETFLUXERR 50
85 #define COL_KRONFLUX 51
86 #define COL_KRONFLUXERR 52
87 #define COL_HALFFLUX 53
88 #define COL_HALFFLUXERR 54
89 #define COL_ERRFLAG 55
90 #define COL_SKYLEVEL 56
91 #define COL_SKYSIGMA 57
92 #define COL_CHLDPARENT 58
93 #define COL_RA 59
94 #define COL_DEC 60
95 #define COL_CLASS 61
96 #define COL_STAT 62
97 
98 /* Number of columns in the table */
99 
100 #define NCOLS 80
101 
102 static const char *ttype[NCOLS]={"Sequence_number","Isophotal_flux",
103  "X_coordinate","X_coordinate_err",
104  "Y_coordinate","Y_coordinate_err",
105  "Gaussian_sigma","Ellipticity","Position_angle",
106  "Areal_1_profile","Areal_2_profile","Areal_3_profile",
107  "Areal_4_profile","Areal_5_profile","Areal_6_profile",
108  "Areal_7_profile","Areal_8_profile",
109  "Peak_height","Peak_height_err",
110  "Aper_flux_1","Aper_flux_1_err",
111  "Aper_flux_2","Aper_flux_2_err",
112  "Aper_flux_3","Aper_flux_3_err",
113  "Aper_flux_4","Aper_flux_4_err",
114  "Aper_flux_5","Aper_flux_5_err",
115  "Aper_flux_6","Aper_flux_6_err",
116  "Aper_flux_7","Aper_flux_7_err",
117  "Aper_flux_8","Aper_flux_8_err",
118  "Aper_flux_9","Aper_flux_9_err",
119  "Aper_flux_10","Aper_flux_10_err",
120  "Aper_flux_11","Aper_flux_11_err",
121  "Aper_flux_12","Aper_flux_12_err",
122  "Aper_flux_13","Aper_flux_13_err",
123  "Petr_radius","Kron_radius","Half_radius",
124  "Petr_flux","Petr_flux_err",
125  "Kron_flux","Kron_flux_err","Half_flux","Half_flux_err",
126  "Error_bit_flag","Sky_level","Sky_rms",
127  "Parent_or_child",
128  "RA","DEC","Classification","Statistic",
129  "Blank63","Blank64","Blank65","Blank66","Blank67",
130  "Blank68","Blank69","Blank70","Blank71","Blank72",
131  "Blank73","Blank74","Blank75","Blank76","Blank77",
132  "Blank78","Blank79","Blank80"};
133 
134 static const char *tunit[NCOLS]={"Number","ADU",
135  "Pixels","Pixels",
136  "Pixels","Pixels",
137  "Pixels","Number","Degrees",
138  "Pixels","Pixels","Pixels",
139  "Pixels","Pixels","Pixels",
140  "Pixels","Pixels",
141  "ADU","ADU",
142  "ADU","ADU",
143  "ADU","ADU",
144  "ADU","ADU",
145  "ADU","ADU",
146  "ADU","ADU",
147  "ADU","ADU",
148  "ADU","ADU",
149  "ADU","ADU",
150  "ADU","ADU",
151  "ADU","ADU",
152  "ADU","ADU",
153  "ADU","ADU",
154  "ADU","ADU",
155  "Pixels","Pixels","Pixels",
156  "ADU","ADU",
157  "ADU","ADU","ADU","ADU",
158  "Number","ADU","ADU","Number",
159  "Degrees","Degrees","Flag","N-sigma",
160  "Blank63","Blank64","Blank65","Blank66","Blank67",
161  "Blank68","Blank69","Blank70","Blank71","Blank72",
162  "Blank73","Blank74","Blank75","Blank76","Blank77",
163  "Blank78","Blank79","Blank80"};
164 
165 static cpl_type tform[NCOLS]={CPL_TYPE_INT,CPL_TYPE_FLOAT,
166  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
167  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
168  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
169  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
170  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
171  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
172  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
173  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
174  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
175  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
176  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
177  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
178  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
179  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
180  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
181  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
182  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
183  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
184  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
185  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
186  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
187  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
188  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
189  CPL_TYPE_FLOAT,
190  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
191  CPL_TYPE_FLOAT,
192  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
193  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
194  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
195  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
196  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
197  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
198  CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,CPL_TYPE_FLOAT,
199  CPL_TYPE_FLOAT};
200 
201 #define NRADS 13
202 static float rmults[] = {0.5,1.0/CPL_MATH_SQRT2,1.0,CPL_MATH_SQRT2,2.0,
203  2.0*CPL_MATH_SQRT2,4.0,5.0,6.0,7.0,8.0,10,12.0};
204 static int nrcore = 2;
205 static int n2rcore = 4;
206 static float apertures[NRADS];
207 
208 static int areal_cols[NAREAL] = {COL_AREAL1,COL_AREAL2,COL_AREAL3,COL_AREAL4,
209  COL_AREAL5,COL_AREAL6,COL_AREAL7,COL_AREAL8};
210 
213 /*---------------------------------------------------------------------------*/
235 /*---------------------------------------------------------------------------*/
236 
237 extern void tabinit_6(void) {
238 
239  /* Call the generic routine to open a new output table */
240 
241  tabinit_gen(NCOLS,ttype,tunit,tform);
242 
243  /* Define RA and Dec columns */
244 
245  imcore_xcol = COL_X;
246  imcore_ycol = COL_Y;
247 
248 }
249 
250 /*---------------------------------------------------------------------------*/
275 /*---------------------------------------------------------------------------*/
276 
277 extern int do_seeing_6(ap_t *ap) {
278  int retval,i;
279  char *areal_colnames[NAREAL];
280 
281  /* Sort out the areal profile column names */
282 
283  for (i = 0; i < NAREAL; i++)
284  areal_colnames[i] = (char *)ttype[areal_cols[i]-1];
285 
286  /* Just call the generic seeing routine */
287 
288  retval = do_seeing_gen(ap,ttype[COL_ELLIPT-1],ttype[COL_PEAKHEIGHT-1],
289  areal_colnames);
290 
291  /* Get out of here */
292 
293  return(retval);
294 }
295 
296 /*---------------------------------------------------------------------------*/
323 /*---------------------------------------------------------------------------*/
324 
325 extern int process_results_6(ap_t *ap) {
326  float momresults[8],ttotal,parmall[IMNUM][NPAR],ratio,cflux[NRADS*IMNUM];
327  float sxx,syy,srr,sxy,ecc,temp,xx,theta,radeg,ell,iso_flux,total_flux;
328  float apflux1,apflux2,apflux3,apflux4,apflux5,yy,sigma,peak,areal1,apflux6;
329  float apflux7,apflux8,apflux9,apflux10,apflux11,apflux12,apflux13,zero;
330  float areal2,areal3,areal4,areal5,areal6,areal7,areal8,aa,bb;
331  float skylev,skyrms,half_rad[IMNUM],half_flux[IMNUM],kron_flux[IMNUM];
332  float petr_flux[IMNUM],kron_rad[IMNUM],petr_rad[IMNUM],badpix[IMNUM];
333  float theta_ra,skyvar[IMNUM],cc,dd,sigsq,xxe,yye,peake,kron_fluxe;
334  float apflux1e,apflux2e,apflux3e,apflux4e,apflux5e,apflux6e,apflux7e;
335  float apflux8e,apflux9e,apflux10e,apflux11e,apflux12e,apflux13e,half_fluxe;
336  float petr_fluxe;
337  int iareal[NAREAL],nbit,i,k,nr,mbit,j;
338  long nrows;
339 
340  /* Do a basic moments analysis and work out the areal profiles*/
341 
342  moments(ap,momresults);
343  if (momresults[0] < 0)
344  return(VIR_FATAL);
345  areals(ap,iareal);
346 
347  /* See if this object makes the cut in terms of its size. If not, then
348  just return with good status */
349 
350  if (iareal[0] < ap->ipnop || momresults[3] < ap->xintmin)
351  return(VIR_OK);
352 
353  /* Work out the total flux */
354 
355  extend(ap,momresults[3],momresults[1],momresults[2],
356  momresults[4],momresults[5],momresults[6],
357  (float)iareal[0],momresults[7],&ttotal);
358  ratio = MAX(ttotal,momresults[3])/momresults[3];
359 
360  /* Try and deblend the images if it is requested and justified */
361 
362  if (iareal[0] >= ap->mulpix && ap->icrowd)
363  overlp(ap,parmall,&nbit,momresults[1],momresults[2],
364  momresults[3],iareal[0],momresults[7]);
365  else
366  nbit = 1;
367  if (nbit == 1) {
368  parmall[0][0] = momresults[3];
369  parmall[0][1] = momresults[1];
370  parmall[0][2] = momresults[2];
371  parmall[0][3] = ap->thresh;
372  for (i = 4; i < 8; i++)
373  parmall[0][i] = momresults[i];
374  for (i = 0; i < NAREAL; i++)
375  parmall[0][i+8] = (float)iareal[i];
376  } else {
377  mbit = 0;
378  for (i = 0; i < nbit; i++) {
379  if (parmall[i][1] > 1.0 && parmall[i][1] < ap->lsiz &&
380  parmall[i][2] > 1.0 && parmall[i][2] < ap->csiz) {
381  for (j = 0; j < NPAR; j++)
382  parmall[mbit][j] = parmall[i][j];
383  mbit++;
384  }
385  }
386  nbit = mbit;
387  }
388 
389  /* Create a list of apertures */
390 
391  for (i = 0; i < NRADS; i++) {
392  apertures[i] = rmults[i]*(ap->rcore);
393  skyvar[i] = CPL_MATH_PI*apertures[i]*apertures[i];
394  }
395 
396  /* Initialise the badpix accumulator */
397 
398  for (i = 0; i < nbit; i++)
399  badpix[i] = 0.0;
400 
401  /* Get the core fluxes in all apertures */
402 
403  phopt(ap,parmall,nbit,NRADS,apertures,cflux,badpix,nrcore);
404 
405  /* Get half-light radius for all images */
406 
407  for (k = 0; k < nbit; k++) {
408  half_flux[k] = 0.5*(MAX(parmall[k][0],cflux[k*NRADS+n2rcore]));
409  half_rad[k] = imcore_halflight(apertures,cflux+k*NRADS,half_flux[k],
410  parmall[k][7],NRADS);
411  }
412 
413  /* Get Kron radius for all images and get the flux */
414 
415  for (k = 0; k < nbit; k++) {
416  areal1 = parmall[k][8];
417  kron_rad[k] = imcore_kronrad(areal1,apertures,cflux+k*NRADS,NRADS);
418  }
419  imcore_flux(ap,parmall,nbit,kron_rad,kron_flux,NRADS,apertures,cflux);
420 
421  /* Get Petrosian radius for all images and get the flux */
422 
423  for (k = 0; k < nbit; k++) {
424  areal1 = parmall[k][8];
425  petr_rad[k] = imcore_petrad(areal1,apertures,cflux+k*NRADS,NRADS);
426  }
427  imcore_flux(ap,parmall,nbit,petr_rad,petr_flux,NRADS,apertures,cflux);
428 
429  /* Massage the results and write them to the fits table */
430 
431  sigsq = powf(ap->sigma,2.0);
432  radeg = 180.0/CPL_MATH_PI;
433  for (k = 0; k < nbit; k++) {
434  sxx = parmall[k][4];
435  sxy = parmall[k][5];
436  syy = parmall[k][6];
437  if(sxy > 0.0)
438  sxy = MAX(1.0e-4,MIN(sxy,sqrtf(sxx*syy)));
439  else
440  sxy = MIN(-1.0e-4,MAX(sxy,-sqrtf(sxx*syy)));
441  srr = MAX(0.5,sxx+syy);
442  ecc = sqrtf((syy-sxx)*(syy-sxx)+4.0*sxy*sxy)/srr;
443  temp = MAX((1.0-ecc)/(1.0+ecc),0.0);
444  ell = 1.0 - sqrtf(temp);
445  ell = MIN(0.99,MAX(0.0,ell));
446  aa = 1.0;
447  bb = aa*(1.0 - ell);
448  xx = 0.5*(1.0+ecc)*srr-sxx;
449  if(xx == 0.0)
450  theta = 0.0;
451  else
452  theta = 90.0 - radeg*atanf(sxy/xx);
453  theta_ra = theta/radeg;
454  cc = (1.0 + ecc)*pow(cos(theta_ra),2.0) + (1.0 - ecc)*pow(sin(theta_ra),2.0);
455  dd = (1.0 + ecc)*pow(sin(theta_ra),2.0) + (1.0 - ecc)*pow(cos(theta_ra),2.0);
456 
457  /* Create a list of values */
458 
459  nrows = cpl_table_get_nrow(tab);
460  nobjects++;
461  if (nobjects > nrows)
462  (void)cpl_table_set_size(tab,nrows+INITROWS);
463  nr = nobjects - 1;
464  iso_flux = parmall[k][0];
465  total_flux = ratio*parmall[k][0];
466  apflux1 = cflux[k*NRADS + 0];
467  apflux2 = cflux[k*NRADS + 1];
468  apflux3 = cflux[k*NRADS + 2];
469  apflux4 = cflux[k*NRADS + 3];
470  apflux5 = cflux[k*NRADS + 4];
471  apflux6 = cflux[k*NRADS + 5];
472  apflux7 = cflux[k*NRADS + 6];
473  apflux8 = cflux[k*NRADS + 7];
474  apflux9 = cflux[k*NRADS + 8];
475  apflux10 = cflux[k*NRADS + 9];
476  apflux11 = cflux[k*NRADS + 10];
477  apflux12 = cflux[k*NRADS + 11];
478  apflux13 = cflux[k*NRADS + 12];
479  peak = parmall[k][7];
480  xx = parmall[k][1];
481  xxe = sqrtf((2.0*sigsq/(CPL_MATH_PI*peak*peak)) + cc/(2.0*CPL_MATH_PI*gain*peak) +
482  0.0001);
483  yy = parmall[k][2];
484  yye = sqrtf((2.0*sigsq/(CPL_MATH_PI*peak*peak)) + dd/(2.0*CPL_MATH_PI*gain*peak) +
485  0.0001);
486  sigma = sqrt(srr);
487  areal1 = parmall[k][8];
488  areal2 = parmall[k][9];
489  areal3 = parmall[k][10];
490  areal4 = parmall[k][11];
491  areal5 = parmall[k][12];
492  areal6 = parmall[k][13];
493  areal7 = parmall[k][14];
494  if (nbit > 1 && k == 0)
495  areal8 = 0.0;
496  else
497  areal8 = parmall[k][15];
498  imcore_backest(ap,xx,yy,&skylev,&skyrms);
499  peake = sqrtf(peak/gain + sigsq + skyrms*skyrms);
500  kron_fluxe = sqrt(kron_flux[k]/gain +
501  (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(kron_rad[k],2.0));
502  half_fluxe = sqrt(MAX(half_flux[k],0.0)/gain +
503  (sigsq + skyrms*skyrms)*M_PI*powf(half_rad[k],2.0));
504  petr_fluxe = sqrt(petr_flux[k]/gain +
505  (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(petr_rad[k],2.0));
506  apflux1e = sqrt(MAX(0.0,apflux1/gain) + skyvar[0]*(sigsq + skyrms*skyrms));
507  apflux2e = sqrt(MAX(0.0,apflux2/gain) + skyvar[1]*(sigsq + skyrms*skyrms));
508  apflux3e = sqrt(MAX(0.0,apflux3/gain) + skyvar[2]*(sigsq + skyrms*skyrms));
509  apflux4e = sqrt(MAX(0.0,apflux4/gain) + skyvar[3]*(sigsq + skyrms*skyrms));
510  apflux5e = sqrt(MAX(0.0,apflux5/gain) + skyvar[4]*(sigsq + skyrms*skyrms));
511  apflux6e = sqrt(MAX(0.0,apflux6/gain) + skyvar[5]*(sigsq + skyrms*skyrms));
512  apflux7e = sqrt(MAX(0.0,apflux7/gain) + skyvar[6]*(sigsq + skyrms*skyrms));
513  apflux8e = sqrt(MAX(0.0,apflux8/gain) + skyvar[7]*(sigsq + skyrms*skyrms));
514  apflux9e = sqrt(MAX(0.0,apflux9/gain) + skyvar[8]*(sigsq + skyrms*skyrms));
515  apflux10e = sqrt(MAX(0.0,apflux10/gain) + skyvar[9]*(sigsq + skyrms*skyrms));
516  apflux11e = sqrt(MAX(0.0,apflux11/gain) + skyvar[10]*(sigsq + skyrms*skyrms));
517  apflux12e = sqrt(MAX(0.0,apflux12/gain) + skyvar[11]*(sigsq + skyrms*skyrms));
518  apflux13e = sqrt(MAX(0.0,apflux13/gain) + skyvar[12]*(sigsq + skyrms*skyrms));
519 
520  /* Store away the results for this object */
521 
522  zero = 0.0;
523  cpl_table_set_int(tab,ttype[COL_NUMBER-1],nr,nobjects);
524  cpl_table_set_float(tab,ttype[COL_FLUXISO-1],nr,iso_flux);
525  cpl_table_set_float(tab,ttype[COL_X-1],nr,xx);
526  cpl_table_set_float(tab,ttype[COL_XERR-1],nr,xxe);
527  cpl_table_set_float(tab,ttype[COL_Y-1],nr,yy);
528  cpl_table_set_float(tab,ttype[COL_YERR-1],nr,yye);
529  cpl_table_set_float(tab,ttype[COL_SIGMA-1],nr,sigma);
530  cpl_table_set_float(tab,ttype[COL_ELLIPT-1],nr,ell);
531  cpl_table_set_float(tab,ttype[COL_PA-1],nr,theta);
532  cpl_table_set_float(tab,ttype[COL_AREAL1-1],nr,areal1);
533  cpl_table_set_float(tab,ttype[COL_AREAL2-1],nr,areal2);
534  cpl_table_set_float(tab,ttype[COL_AREAL3-1],nr,areal3);
535  cpl_table_set_float(tab,ttype[COL_AREAL4-1],nr,areal4);
536  cpl_table_set_float(tab,ttype[COL_AREAL5-1],nr,areal5);
537  cpl_table_set_float(tab,ttype[COL_AREAL6-1],nr,areal6);
538  cpl_table_set_float(tab,ttype[COL_AREAL7-1],nr,areal7);
539  cpl_table_set_float(tab,ttype[COL_AREAL8-1],nr,areal8);
540  cpl_table_set_float(tab,ttype[COL_PEAKHEIGHT-1],nr,peak);
541  cpl_table_set_float(tab,ttype[COL_PKHTERR-1],nr,peake);
542  cpl_table_set_float(tab,ttype[COL_APFLUX1-1],nr,apflux1);
543  cpl_table_set_float(tab,ttype[COL_APFLUX1ERR-1],nr,apflux1e);
544  cpl_table_set_float(tab,ttype[COL_APFLUX2-1],nr,apflux2);
545  cpl_table_set_float(tab,ttype[COL_APFLUX2ERR-1],nr,apflux2e);
546  cpl_table_set_float(tab,ttype[COL_APFLUX3-1],nr,apflux3);
547  cpl_table_set_float(tab,ttype[COL_APFLUX3ERR-1],nr,apflux3e);
548  cpl_table_set_float(tab,ttype[COL_APFLUX4-1],nr,apflux4);
549  cpl_table_set_float(tab,ttype[COL_APFLUX4ERR-1],nr,apflux4e);
550  cpl_table_set_float(tab,ttype[COL_APFLUX5-1],nr,apflux5);
551  cpl_table_set_float(tab,ttype[COL_APFLUX5ERR-1],nr,apflux5e);
552  cpl_table_set_float(tab,ttype[COL_APFLUX6-1],nr,apflux6);
553  cpl_table_set_float(tab,ttype[COL_APFLUX6ERR-1],nr,apflux6e);
554  cpl_table_set_float(tab,ttype[COL_APFLUX7-1],nr,apflux7);
555  cpl_table_set_float(tab,ttype[COL_APFLUX7ERR-1],nr,apflux7e);
556  cpl_table_set_float(tab,ttype[COL_APFLUX8-1],nr,apflux8);
557  cpl_table_set_float(tab,ttype[COL_APFLUX8ERR-1],nr,apflux8e);
558  cpl_table_set_float(tab,ttype[COL_APFLUX9-1],nr,apflux9);
559  cpl_table_set_float(tab,ttype[COL_APFLUX9ERR-1],nr,apflux9e);
560  cpl_table_set_float(tab,ttype[COL_APFLUX10-1],nr,apflux10);
561  cpl_table_set_float(tab,ttype[COL_APFLUX10ERR-1],nr,apflux10e);
562  cpl_table_set_float(tab,ttype[COL_APFLUX11-1],nr,apflux11);
563  cpl_table_set_float(tab,ttype[COL_APFLUX11ERR-1],nr,apflux11e);
564  cpl_table_set_float(tab,ttype[COL_APFLUX12-1],nr,apflux12);
565  cpl_table_set_float(tab,ttype[COL_APFLUX12ERR-1],nr,apflux12e);
566  cpl_table_set_float(tab,ttype[COL_APFLUX13-1],nr,apflux13);
567  cpl_table_set_float(tab,ttype[COL_APFLUX13ERR-1],nr,apflux13e);
568  cpl_table_set_float(tab,ttype[COL_PETRAD-1],nr,0.5*petr_rad[k]);
569  cpl_table_set_float(tab,ttype[COL_KRONRAD-1],nr,0.5*kron_rad[k]);
570  cpl_table_set_float(tab,ttype[COL_HALFRAD-1],nr,half_rad[k]);
571  cpl_table_set_float(tab,ttype[COL_PETFLUX-1],nr,petr_flux[k]);
572  cpl_table_set_float(tab,ttype[COL_PETFLUXERR-1],nr,petr_fluxe);
573  cpl_table_set_float(tab,ttype[COL_KRONFLUX-1],nr,kron_flux[k]);
574  cpl_table_set_float(tab,ttype[COL_KRONFLUXERR-1],nr,kron_fluxe);
575  cpl_table_set_float(tab,ttype[COL_HALFFLUX-1],nr,half_flux[k]);
576  cpl_table_set_float(tab,ttype[COL_HALFFLUXERR-1],nr,half_fluxe);
577  cpl_table_set_float(tab,ttype[COL_ERRFLAG-1],nr,badpix[k]);
578  cpl_table_set_float(tab,ttype[COL_SKYLEVEL-1],nr,skylev);
579  cpl_table_set_float(tab,ttype[COL_SKYSIGMA-1],nr,skyrms);
580  cpl_table_set_float(tab,ttype[COL_CHLDPARENT-1],nr,zero);
581 
582  /* Store away some dummy values to avoid problems later on */
583 
584  cpl_table_set_float(tab,ttype[COL_RA-1],nr,zero);
585  cpl_table_set_float(tab,ttype[COL_DEC-1],nr,zero);
586  cpl_table_set_float(tab,ttype[COL_CLASS-1],nr,100.0);
587  cpl_table_set_float(tab,ttype[COL_STAT-1],nr,zero);
588  }
589 
590  /* Get outta here */
591 
592  return(VIR_OK);
593 }
594 
597 /*
598 
599 $Log: not supported by cvs2svn $
600 
601 */