VIRCAM Pipeline  2.3.12
create_table_6.c
1 /* $Id: create_table_6.c,v 1.4 2015/09/15 07:38:13 jim Exp $
2  *
3  * This file is part of the CASU Pipeline utilities
4  * Copyright (C) 2015 European Southern Observatory
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: 2015/09/15 07:38:13 $
24  * $Revision: 1.4 $
25  * $Name: $
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_AVCONF 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  "Av_conf",
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 imcore_tabinit_6(int *imcore_xcol, int *imcore_ycol,
238  cpl_table **tab) {
239 
240  /* Call the generic routine to open a new output table */
241 
242  imcore_tabinit_gen(NCOLS,ttype,tunit,tform,tab);
243 
244  /* Define RA and Dec columns */
245 
246  *imcore_xcol = COL_X;
247  *imcore_ycol = COL_Y;
248 
249 }
250 
251 /*---------------------------------------------------------------------------*/
276 /*---------------------------------------------------------------------------*/
277 
278 extern int imcore_do_seeing_6(ap_t *ap, int nobjects, cpl_table *tab) {
279  int retval,i;
280  char *areal_colnames[NAREAL];
281 
282  /* Sort out the areal profile column names */
283 
284  for (i = 0; i < NAREAL; i++)
285  areal_colnames[i] = (char *)ttype[areal_cols[i]-1];
286 
287  /* Just call the generic seeing routine */
288 
289  retval = imcore_do_seeing_gen(ap,ttype[COL_ELLIPT-1],ttype[COL_PEAKHEIGHT-1],
290  areal_colnames,nobjects,tab);
291 
292  /* Get out of here */
293 
294  return(retval);
295 }
296 
297 /*---------------------------------------------------------------------------*/
324 /*---------------------------------------------------------------------------*/
325 
326 extern int imcore_process_results_6(ap_t *ap, float gain, int *nobjects,
327  cpl_table *tab) {
328  float momresults[8],ttotal,parmall[IMNUM][NPAR],cflux[NRADS*IMNUM];
329  float sxx,syy,srr,sxy,ecc,temp,xx,theta,radeg,ell,iso_flux;
330  float apflux1,apflux2,apflux3,apflux4,apflux5,yy,sigma,peak,areal1,apflux6;
331  float apflux7,apflux8,apflux9,apflux10,apflux11,apflux12,apflux13,zero;
332  float areal2,areal3,areal4,areal5,areal6,areal7,areal8;
333  float skylev,skyrms,half_rad[IMNUM],half_flux[IMNUM],kron_flux[IMNUM];
334  float petr_flux[IMNUM],kron_rad[IMNUM],petr_rad[IMNUM],badpix[IMNUM];
335  float theta_ra,skyvar[IMNUM],cc,dd,sigsq,xxe,yye,peake,kron_fluxe;
336  float apflux1e,apflux2e,apflux3e,apflux4e,apflux5e,apflux6e,apflux7e;
337  float apflux8e,apflux9e,apflux10e,apflux11e,apflux12e,apflux13e,half_fluxe;
338  float petr_fluxe,avconf[IMNUM],rcore_area;
339  int iareal[NAREAL],nbit,i,k,nr,mbit,j;
340  long nrows;
341 
342  /* Do a basic moments analysis and work out the areal profiles*/
343 
344  imcore_moments(ap,momresults);
345  if (momresults[0] < 0)
346  return(CASU_FATAL);
347  imcore_areals(ap,iareal);
348 
349  /* See if this object makes the cut in terms of its size. If not, then
350  just return with good status */
351 
352  if (iareal[0] < ap->ipnop || momresults[3] < ap->xintmin)
353  return(CASU_OK);
354 
355  /* Work out the total flux */
356 
357  imcore_extend(ap,momresults[3],momresults[1],momresults[2],
358  momresults[4],momresults[5],momresults[6],
359  (float)iareal[0],momresults[7],&ttotal);
360 
361  /* Try and deblend the images if it is requested and justified */
362 
363  if (iareal[0] >= ap->mulpix && ap->icrowd)
364  imcore_overlp(ap,parmall,&nbit,momresults[1],momresults[2],
365  momresults[3],iareal[0],momresults[7]);
366  else
367  nbit = 1;
368  if (nbit == 1) {
369  parmall[0][0] = momresults[3];
370  parmall[0][1] = momresults[1];
371  parmall[0][2] = momresults[2];
372  parmall[0][3] = ap->thresh;
373  for (i = 4; i < 8; i++)
374  parmall[0][i] = momresults[i];
375  for (i = 0; i < NAREAL; i++)
376  parmall[0][i+8] = (float)iareal[i];
377  } else {
378  mbit = 0;
379  for (i = 0; i < nbit; i++) {
380  if (parmall[i][1] > 1.0 && parmall[i][1] < ap->lsiz &&
381  parmall[i][2] > 1.0 && parmall[i][2] < ap->csiz) {
382  for (j = 0; j < NPAR; j++)
383  parmall[mbit][j] = parmall[i][j];
384  mbit++;
385  }
386  }
387  nbit = mbit;
388  if (nbit == 0)
389  return(CASU_OK);
390  }
391 
392  /* Create a list of apertures */
393 
394  for (i = 0; i < NRADS; i++) {
395  apertures[i] = rmults[i]*(ap->rcore);
396  skyvar[i] = CPL_MATH_PI*apertures[i]*apertures[i];
397  }
398  rcore_area = CPL_MATH_PI*pow(ap->rcore,2.0);
399 
400  /* Initialise the badpix accumulator */
401 
402  for (i = 0; i < nbit; i++) {
403  badpix[i] = 0.0;
404  avconf[i] = 0.0;
405  }
406 
407  /* Get the core fluxes in all apertures */
408 
409  imcore_phopt(ap,parmall,nbit,NRADS,apertures,cflux,badpix,nrcore,avconf);
410  for (i = 0; i < nbit; i++)
411  avconf[i] /= rcore_area;
412 
413  /* Get half-light radius for all images */
414 
415  for (k = 0; k < nbit; k++) {
416  half_flux[k] = 0.5*(MAX(parmall[k][0],cflux[k*NRADS+n2rcore]));
417  half_rad[k] = imcore_halflight(apertures,cflux+k*NRADS,half_flux[k],
418  parmall[k][7],NRADS);
419  }
420 
421  /* Get Kron radius for all images and get the flux */
422 
423  for (k = 0; k < nbit; k++) {
424  areal1 = parmall[k][8];
425  kron_rad[k] = imcore_kronrad(areal1,apertures,cflux+k*NRADS,NRADS);
426  }
427  imcore_flux(ap,parmall,nbit,kron_rad,kron_flux,NRADS,apertures,cflux);
428 
429  /* Get Petrosian radius for all images and get the flux */
430 
431  for (k = 0; k < nbit; k++) {
432  areal1 = parmall[k][8];
433  petr_rad[k] = imcore_petrad(areal1,apertures,cflux+k*NRADS,NRADS);
434  }
435  imcore_flux(ap,parmall,nbit,petr_rad,petr_flux,NRADS,apertures,cflux);
436 
437  /* Massage the results and write them to the fits table */
438 
439  sigsq = powf(ap->sigma,2.0);
440  radeg = 180.0/CPL_MATH_PI;
441  for (k = 0; k < nbit; k++) {
442  sxx = parmall[k][4];
443  sxy = parmall[k][5];
444  syy = parmall[k][6];
445  if(sxy > 0.0)
446  sxy = MAX(1.0e-4,MIN(sxy,sqrtf(sxx*syy)));
447  else
448  sxy = MIN(-1.0e-4,MAX(sxy,-sqrtf(sxx*syy)));
449  srr = MAX(0.5,sxx+syy);
450  ecc = sqrtf((syy-sxx)*(syy-sxx)+4.0*sxy*sxy)/srr;
451  temp = MAX((1.0-ecc)/(1.0+ecc),0.0);
452  ell = 1.0 - sqrtf(temp);
453  ell = MIN(0.99,MAX(0.0,ell));
454  xx = 0.5*(1.0+ecc)*srr-sxx;
455  if(xx == 0.0)
456  theta = 0.0;
457  else
458  theta = 90.0 - radeg*atanf(sxy/xx);
459  theta_ra = theta/radeg;
460  cc = (1.0 + ecc)*pow(cos(theta_ra),2.0) + (1.0 - ecc)*pow(sin(theta_ra),2.0);
461  dd = (1.0 + ecc)*pow(sin(theta_ra),2.0) + (1.0 - ecc)*pow(cos(theta_ra),2.0);
462 
463  /* Create a list of values */
464 
465  nrows = cpl_table_get_nrow(tab);
466  (*nobjects)++;
467  if (*nobjects > nrows)
468  (void)cpl_table_set_size(tab,nrows+INITROWS);
469  nr = *nobjects - 1;
470  iso_flux = parmall[k][0];
471  apflux1 = cflux[k*NRADS + 0];
472  apflux2 = cflux[k*NRADS + 1];
473  apflux3 = cflux[k*NRADS + 2];
474  apflux4 = cflux[k*NRADS + 3];
475  apflux5 = cflux[k*NRADS + 4];
476  apflux6 = cflux[k*NRADS + 5];
477  apflux7 = cflux[k*NRADS + 6];
478  apflux8 = cflux[k*NRADS + 7];
479  apflux9 = cflux[k*NRADS + 8];
480  apflux10 = cflux[k*NRADS + 9];
481  apflux11 = cflux[k*NRADS + 10];
482  apflux12 = cflux[k*NRADS + 11];
483  apflux13 = cflux[k*NRADS + 12];
484  peak = parmall[k][7];
485  xx = parmall[k][1];
486  xxe = sqrtf((2.0*sigsq/(CPL_MATH_PI*peak*peak)) + cc/(2.0*CPL_MATH_PI*gain*peak) +
487  0.0001);
488  yy = parmall[k][2];
489  yye = sqrtf((2.0*sigsq/(CPL_MATH_PI*peak*peak)) + dd/(2.0*CPL_MATH_PI*gain*peak) +
490  0.0001);
491  sigma = sqrt(srr);
492  areal1 = parmall[k][8];
493  areal2 = parmall[k][9];
494  areal3 = parmall[k][10];
495  areal4 = parmall[k][11];
496  areal5 = parmall[k][12];
497  areal6 = parmall[k][13];
498  areal7 = parmall[k][14];
499  if (nbit > 1 && k == 0)
500  areal8 = 0.0;
501  else
502  areal8 = parmall[k][15];
503  imcore_backest(ap,xx,yy,&skylev,&skyrms);
504  peake = sqrtf(peak/gain + sigsq + skyrms*skyrms);
505  kron_fluxe = sqrt(kron_flux[k]/gain +
506  (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(kron_rad[k],2.0));
507  half_fluxe = sqrt(MAX(half_flux[k],0.0)/gain +
508  (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(half_rad[k],2.0));
509  petr_fluxe = sqrt(petr_flux[k]/gain +
510  (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(petr_rad[k],2.0));
511  apflux1e = sqrt(MAX(0.0,apflux1/gain) + skyvar[0]*(sigsq + skyrms*skyrms));
512  apflux2e = sqrt(MAX(0.0,apflux2/gain) + skyvar[1]*(sigsq + skyrms*skyrms));
513  apflux3e = sqrt(MAX(0.0,apflux3/gain) + skyvar[2]*(sigsq + skyrms*skyrms));
514  apflux4e = sqrt(MAX(0.0,apflux4/gain) + skyvar[3]*(sigsq + skyrms*skyrms));
515  apflux5e = sqrt(MAX(0.0,apflux5/gain) + skyvar[4]*(sigsq + skyrms*skyrms));
516  apflux6e = sqrt(MAX(0.0,apflux6/gain) + skyvar[5]*(sigsq + skyrms*skyrms));
517  apflux7e = sqrt(MAX(0.0,apflux7/gain) + skyvar[6]*(sigsq + skyrms*skyrms));
518  apflux8e = sqrt(MAX(0.0,apflux8/gain) + skyvar[7]*(sigsq + skyrms*skyrms));
519  apflux9e = sqrt(MAX(0.0,apflux9/gain) + skyvar[8]*(sigsq + skyrms*skyrms));
520  apflux10e = sqrt(MAX(0.0,apflux10/gain) + skyvar[9]*(sigsq + skyrms*skyrms));
521  apflux11e = sqrt(MAX(0.0,apflux11/gain) + skyvar[10]*(sigsq + skyrms*skyrms));
522  apflux12e = sqrt(MAX(0.0,apflux12/gain) + skyvar[11]*(sigsq + skyrms*skyrms));
523  apflux13e = sqrt(MAX(0.0,apflux13/gain) + skyvar[12]*(sigsq + skyrms*skyrms));
524 
525  /* Store away the results for this object */
526 
527  zero = 0.0;
528  cpl_table_set_int(tab,ttype[COL_NUMBER-1],nr,*nobjects);
529  cpl_table_set_float(tab,ttype[COL_FLUXISO-1],nr,iso_flux);
530  cpl_table_set_float(tab,ttype[COL_X-1],nr,xx);
531  cpl_table_set_float(tab,ttype[COL_XERR-1],nr,xxe);
532  cpl_table_set_float(tab,ttype[COL_Y-1],nr,yy);
533  cpl_table_set_float(tab,ttype[COL_YERR-1],nr,yye);
534  cpl_table_set_float(tab,ttype[COL_SIGMA-1],nr,sigma);
535  cpl_table_set_float(tab,ttype[COL_ELLIPT-1],nr,ell);
536  cpl_table_set_float(tab,ttype[COL_PA-1],nr,theta);
537  cpl_table_set_float(tab,ttype[COL_AREAL1-1],nr,areal1);
538  cpl_table_set_float(tab,ttype[COL_AREAL2-1],nr,areal2);
539  cpl_table_set_float(tab,ttype[COL_AREAL3-1],nr,areal3);
540  cpl_table_set_float(tab,ttype[COL_AREAL4-1],nr,areal4);
541  cpl_table_set_float(tab,ttype[COL_AREAL5-1],nr,areal5);
542  cpl_table_set_float(tab,ttype[COL_AREAL6-1],nr,areal6);
543  cpl_table_set_float(tab,ttype[COL_AREAL7-1],nr,areal7);
544  cpl_table_set_float(tab,ttype[COL_AREAL8-1],nr,areal8);
545  cpl_table_set_float(tab,ttype[COL_PEAKHEIGHT-1],nr,peak);
546  cpl_table_set_float(tab,ttype[COL_PKHTERR-1],nr,peake);
547  cpl_table_set_float(tab,ttype[COL_APFLUX1-1],nr,apflux1);
548  cpl_table_set_float(tab,ttype[COL_APFLUX1ERR-1],nr,apflux1e);
549  cpl_table_set_float(tab,ttype[COL_APFLUX2-1],nr,apflux2);
550  cpl_table_set_float(tab,ttype[COL_APFLUX2ERR-1],nr,apflux2e);
551  cpl_table_set_float(tab,ttype[COL_APFLUX3-1],nr,apflux3);
552  cpl_table_set_float(tab,ttype[COL_APFLUX3ERR-1],nr,apflux3e);
553  cpl_table_set_float(tab,ttype[COL_APFLUX4-1],nr,apflux4);
554  cpl_table_set_float(tab,ttype[COL_APFLUX4ERR-1],nr,apflux4e);
555  cpl_table_set_float(tab,ttype[COL_APFLUX5-1],nr,apflux5);
556  cpl_table_set_float(tab,ttype[COL_APFLUX5ERR-1],nr,apflux5e);
557  cpl_table_set_float(tab,ttype[COL_APFLUX6-1],nr,apflux6);
558  cpl_table_set_float(tab,ttype[COL_APFLUX6ERR-1],nr,apflux6e);
559  cpl_table_set_float(tab,ttype[COL_APFLUX7-1],nr,apflux7);
560  cpl_table_set_float(tab,ttype[COL_APFLUX7ERR-1],nr,apflux7e);
561  cpl_table_set_float(tab,ttype[COL_APFLUX8-1],nr,apflux8);
562  cpl_table_set_float(tab,ttype[COL_APFLUX8ERR-1],nr,apflux8e);
563  cpl_table_set_float(tab,ttype[COL_APFLUX9-1],nr,apflux9);
564  cpl_table_set_float(tab,ttype[COL_APFLUX9ERR-1],nr,apflux9e);
565  cpl_table_set_float(tab,ttype[COL_APFLUX10-1],nr,apflux10);
566  cpl_table_set_float(tab,ttype[COL_APFLUX10ERR-1],nr,apflux10e);
567  cpl_table_set_float(tab,ttype[COL_APFLUX11-1],nr,apflux11);
568  cpl_table_set_float(tab,ttype[COL_APFLUX11ERR-1],nr,apflux11e);
569  cpl_table_set_float(tab,ttype[COL_APFLUX12-1],nr,apflux12);
570  cpl_table_set_float(tab,ttype[COL_APFLUX12ERR-1],nr,apflux12e);
571  cpl_table_set_float(tab,ttype[COL_APFLUX13-1],nr,apflux13);
572  cpl_table_set_float(tab,ttype[COL_APFLUX13ERR-1],nr,apflux13e);
573  cpl_table_set_float(tab,ttype[COL_PETRAD-1],nr,0.5*petr_rad[k]);
574  cpl_table_set_float(tab,ttype[COL_KRONRAD-1],nr,0.5*kron_rad[k]);
575  cpl_table_set_float(tab,ttype[COL_HALFRAD-1],nr,half_rad[k]);
576  cpl_table_set_float(tab,ttype[COL_PETFLUX-1],nr,petr_flux[k]);
577  cpl_table_set_float(tab,ttype[COL_PETFLUXERR-1],nr,petr_fluxe);
578  cpl_table_set_float(tab,ttype[COL_KRONFLUX-1],nr,kron_flux[k]);
579  cpl_table_set_float(tab,ttype[COL_KRONFLUXERR-1],nr,kron_fluxe);
580  cpl_table_set_float(tab,ttype[COL_HALFFLUX-1],nr,half_flux[k]);
581  cpl_table_set_float(tab,ttype[COL_HALFFLUXERR-1],nr,half_fluxe);
582  cpl_table_set_float(tab,ttype[COL_ERRFLAG-1],nr,badpix[k]);
583  cpl_table_set_float(tab,ttype[COL_SKYLEVEL-1],nr,skylev);
584  cpl_table_set_float(tab,ttype[COL_SKYSIGMA-1],nr,skyrms);
585  cpl_table_set_float(tab,ttype[COL_AVCONF-1],nr,avconf[k]);
586 
587  /* Store away some dummy values to avoid problems later on */
588 
589  cpl_table_set_float(tab,ttype[COL_RA-1],nr,zero);
590  cpl_table_set_float(tab,ttype[COL_DEC-1],nr,zero);
591  cpl_table_set_float(tab,ttype[COL_CLASS-1],nr,100.0);
592  cpl_table_set_float(tab,ttype[COL_STAT-1],nr,zero);
593  }
594 
595  /* Get outta here */
596 
597  return(CASU_OK);
598 }
599 
602 /*
603 
604 $Log: create_table_6.c,v $
605 Revision 1.4 2015/09/15 07:38:13 jim
606 Trap for when nbit = 0 in phopt
607 
608 Revision 1.3 2015/08/12 11:16:55 jim
609 Modified procedure names to protect namespace
610 
611 Revision 1.2 2015/08/07 13:06:54 jim
612 Fixed copyright to ESO
613 
614 Revision 1.1.1.1 2015/06/12 10:44:32 jim
615 Initial import
616 
617 Revision 1.5 2015/03/12 09:16:51 jim
618 Modified to remove some compiler moans
619 
620 Revision 1.4 2015/01/09 11:42:36 jim
621 Fixed routines to remove globals
622 
623 Revision 1.3 2014/04/09 11:08:21 jim
624 Get rid of a couple of compiler moans
625 
626 Revision 1.2 2014/04/09 09:09:51 jim
627 Detabbed
628 
629 Revision 1.1.1.1 2013/08/27 12:07:48 jim
630 Imported
631 
632 
633 */
void imcore_areals(ap_t *ap, int iareal[NAREAL])
Work out the areal profiles for an object.
Definition: areals.c:67
int imcore_process_results_6(ap_t *ap, float gain, int *nobjects, cpl_table *tab)
Process results for type 6 catalogue.
void imcore_flux(ap_t *ap, float parm[IMNUM][NPAR], int nbit, float apers[], float fluxes[], int nr, float rcores[], float rfluxes[])
Work out the fluxes for special radii.
Definition: imcore_radii.c:316
void imcore_tabinit_6(int *imcore_xcol, int *imcore_ycol, cpl_table **tab)
Initialise type 6 catalogue.
void imcore_backest(ap_t *ap, float x, float y, float *skylev, float *skyrms)
Work out estimated sky for a pixel position.
void imcore_moments(ap_t *ap, float results[])
Do moments analysis on an object.
Definition: moments.c:65
int imcore_do_seeing_6(ap_t *ap, int nobjects, cpl_table *tab)
Do seeing estimate for type 6 catalogue.
int imcore_do_seeing_gen(ap_t *ap, const char *col_ellipt, const char *col_pkht, char *col_areals[NAREAL], int nobjects, cpl_table *tab)
Do seeing estimate (generic)
Definition: create_table.c:335
void imcore_tabinit_gen(int ncols, const char *ttype[], const char *tunit[], cpl_type tform[], cpl_table **tab)
Initialise tables (generic)
Definition: create_table.c:281
float imcore_kronrad(float areal0, float rcores[], float cflux[], int naper)
Work out the Kron radius for an object.
Definition: imcore_radii.c:188
float imcore_petrad(float areal0, float rcores[], float cflux[], int naper)
Work out the Petrosian.
Definition: imcore_radii.c:242
float imcore_halflight(float rcores[], float cflux[], float halflight, float peak, int naper)
Work out the half-light radius for an object.
Definition: imcore_radii.c:76
void imcore_phopt(ap_t *ap, float parm[IMNUM][NPAR], int nbit, int naper, float apertures[], float cflux[], float badpix[], int nrcore, float avconf[])
Do multiple profile fitting.
Definition: imcore_phopt.c:91
void imcore_overlp(ap_t *ap, float parm[IMNUM][NPAR], int *nbit, float xbar, float ybar, float total, int npix, float tmax)
Deblend overlapping images.
Definition: imcore_overlp.c:99
int imcore_extend(ap_t *ap, float xniso, float xbar, float ybar, float sxx, float sxy, float syy, float areal0, float tmax, float *ttotal)
Do aperture integration.
Definition: imcore_extend.c:89