VIRCAM Pipeline  2.3.12
create_table_2.c
1 /* $Id: create_table_2.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_HALLRAD 48
83 #define COL_PETFLUX 49
84 #define COL_PETFLUXERR 50
85 #define COL_KRONFLUX 51
86 #define COL_KRONFLUXERR 52
87 #define COL_HALLFLUX 53
88 #define COL_HALLFLUXERR 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","Hall_radius",
124  "Petr_flux","Petr_flux_err",
125  "Kron_flux","Kron_flux_err","Hall_flux","Hall_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 float apertures[NRADS];
206 
207 static int areal_cols[NAREAL] = {COL_AREAL1,COL_AREAL2,COL_AREAL3,COL_AREAL4,
208  COL_AREAL5,COL_AREAL6,COL_AREAL7,COL_AREAL8};
211 /*---------------------------------------------------------------------------*/
233 /*---------------------------------------------------------------------------*/
234 
235 extern void imcore_tabinit_2(int *imcore_xcol, int *imcore_ycol,
236  cpl_table **tab) {
237 
238  /* Call the generic routine to open a new output table */
239 
240  imcore_tabinit_gen(NCOLS,ttype,tunit,tform,tab);
241 
242  /* Define RA and Dec columns */
243 
244  *imcore_xcol = COL_X;
245  *imcore_ycol = COL_Y;
246 
247 }
248 
249 /*---------------------------------------------------------------------------*/
274 /*---------------------------------------------------------------------------*/
275 
276 extern int imcore_do_seeing_2(ap_t *ap, int nobjects, cpl_table *tab) {
277  int retval,i;
278  char *areal_colnames[NAREAL];
279 
280  /* Sort out the areal profile column names */
281 
282  for (i = 0; i < NAREAL; i++)
283  areal_colnames[i] = (char *)ttype[areal_cols[i]-1];
284 
285  /* Just call the generic seeing routine */
286 
287  retval = imcore_do_seeing_gen(ap,ttype[COL_ELLIPT-1],ttype[COL_PEAKHEIGHT-1],
288  areal_colnames,nobjects,tab);
289 
290  /* Get out of here */
291 
292  return(retval);
293 }
294 
295 /*---------------------------------------------------------------------------*/
322 /*---------------------------------------------------------------------------*/
323 
324 extern int imcore_process_results_2(ap_t *ap, float gain, int *nobjects,
325  cpl_table *tab) {
326  float momresults[8],ttotal,parmall[IMNUM][NPAR],cflux[NRADS*IMNUM];
327  float sxx,syy,srr,sxy,ecc,temp,xx,theta,radeg,ell,iso_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;
331  float skylev,skyrms,exp_rad[IMNUM],exp_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,exp_fluxe;
336  float petr_fluxe,avconf[IMNUM];
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  imcore_moments(ap,momresults);
343  if (momresults[0] < 0)
344  return(CASU_FATAL);
345  imcore_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(CASU_OK);
352 
353  /* Work out the total flux */
354 
355  imcore_extend(ap,momresults[3],momresults[1],momresults[2],
356  momresults[4],momresults[5],momresults[6],
357  (float)iareal[0],momresults[7],&ttotal);
358 
359  /* Try and deblend the images if it is requested and justified */
360 
361  if (iareal[0] >= ap->mulpix && ap->icrowd)
362  imcore_overlp(ap,parmall,&nbit,momresults[1],momresults[2],
363  momresults[3],iareal[0],momresults[7]);
364  else
365  nbit = 1;
366  if (nbit == 1) {
367  parmall[0][0] = momresults[3];
368  parmall[0][1] = momresults[1];
369  parmall[0][2] = momresults[2];
370  parmall[0][3] = ap->thresh;
371  for (i = 4; i < 8; i++)
372  parmall[0][i] = momresults[i];
373  for (i = 0; i < NAREAL; i++)
374  parmall[0][i+8] = (float)iareal[i];
375  } else {
376  mbit = 0;
377  for (i = 0; i < nbit; i++) {
378  if (parmall[i][1] > 1.0 && parmall[i][1] < ap->lsiz &&
379  parmall[i][2] > 1.0 && parmall[i][2] < ap->csiz) {
380  for (j = 0; j < NPAR; j++)
381  parmall[mbit][j] = parmall[i][j];
382  mbit++;
383  }
384  }
385  nbit = mbit;
386  if (nbit == 0)
387  return(CASU_OK);
388  }
389 
390  /* Create a list of apertures */
391 
392  for (i = 0; i < NRADS; i++) {
393  apertures[i] = rmults[i]*(ap->rcore);
394  skyvar[i] = CPL_MATH_PI*apertures[i]*apertures[i];
395  }
396 
397  /* Initialise the badpix accumulator */
398 
399  for (i = 0; i < nbit; i++) {
400  badpix[i] = 0.0;
401  avconf[i] = 0.0;
402  }
403 
404  /* Get the core fluxes in all apertures */
405 
406  imcore_phopt(ap,parmall,nbit,NRADS,apertures,cflux,badpix,nrcore,avconf);
407 
408  /* Get exponential radius for all images and get the flux */
409 
410  for (k = 0; k < nbit; k++) {
411  peak = parmall[k][7];
412  areal1 = parmall[k][8];
413  exp_rad[k] = imcore_exprad(parmall[k][3],peak,areal1,apertures,NRADS);
414  }
415  imcore_flux(ap,parmall,nbit,exp_rad,exp_flux,NRADS,apertures,cflux);
416 
417  /* Get Kron radius for all images and get the flux */
418 
419  for (k = 0; k < nbit; k++) {
420  areal1 = parmall[k][8];
421  kron_rad[k] = imcore_kronrad(areal1,apertures,cflux+k*NRADS,NRADS);
422  }
423  imcore_flux(ap,parmall,nbit,kron_rad,kron_flux,NRADS,apertures,cflux);
424 
425  /* Get Petrosian radius for all images and get the flux */
426 
427  for (k = 0; k < nbit; k++) {
428  areal1 = parmall[k][8];
429  petr_rad[k] = imcore_petrad(areal1,apertures,cflux+k*NRADS,NRADS);
430  }
431  imcore_flux(ap,parmall,nbit,petr_rad,petr_flux,NRADS,apertures,cflux);
432 
433  /* Massage the results and write them to the fits table */
434 
435  sigsq = powf(ap->sigma,2.0);
436  radeg = 180.0/CPL_MATH_PI;
437  for (k = 0; k < nbit; k++) {
438  sxx = parmall[k][4];
439  sxy = parmall[k][5];
440  syy = parmall[k][6];
441  if(sxy > 0.0)
442  sxy = MAX(1.0e-4,MIN(sxy,sqrtf(sxx*syy)));
443  else
444  sxy = MIN(-1.0e-4,MAX(sxy,-sqrtf(sxx*syy)));
445  srr = MAX(0.5,sxx+syy);
446  ecc = sqrtf((syy-sxx)*(syy-sxx)+4.0*sxy*sxy)/srr;
447  temp = MAX((1.0-ecc)/(1.0+ecc),0.0);
448  ell = 1.0 - sqrtf(temp);
449  ell = MIN(0.99,MAX(0.0,ell));
450  xx = 0.5*(1.0+ecc)*srr-sxx;
451  if(xx == 0.0)
452  theta = 0.0;
453  else
454  theta = 90.0 - radeg*atanf(sxy/xx);
455  theta_ra = theta/radeg;
456  cc = (1.0 + ecc)*pow(cos(theta_ra),2.0) + (1.0 - ecc)*pow(sin(theta_ra),2.0);
457  dd = (1.0 + ecc)*pow(sin(theta_ra),2.0) + (1.0 - ecc)*pow(cos(theta_ra),2.0);
458 
459  /* Create a list of values */
460 
461  nrows = cpl_table_get_nrow(tab);
462  (*nobjects)++;
463  if (*nobjects > nrows)
464  (void)cpl_table_set_size(tab,nrows+INITROWS);
465  nr = *nobjects - 1;
466  iso_flux = parmall[k][0];
467  apflux1 = cflux[k*NRADS + 0];
468  apflux2 = cflux[k*NRADS + 1];
469  apflux3 = cflux[k*NRADS + 2];
470  apflux4 = cflux[k*NRADS + 3];
471  apflux5 = cflux[k*NRADS + 4];
472  apflux6 = cflux[k*NRADS + 5];
473  apflux7 = cflux[k*NRADS + 6];
474  apflux8 = cflux[k*NRADS + 7];
475  apflux9 = cflux[k*NRADS + 8];
476  apflux10 = cflux[k*NRADS + 9];
477  apflux11 = cflux[k*NRADS + 10];
478  apflux12 = cflux[k*NRADS + 11];
479  apflux13 = cflux[k*NRADS + 12];
480  peak = parmall[k][7];
481  xx = parmall[k][1];
482  xxe = sqrtf((2.0*sigsq/(CPL_MATH_PI*peak*peak)) + cc/(2.0*CPL_MATH_PI*gain*peak) +
483  0.0001);
484  yy = parmall[k][2];
485  yye = sqrtf((2.0*sigsq/(CPL_MATH_PI*peak*peak)) + dd/(2.0*CPL_MATH_PI*gain*peak) +
486  0.0001);
487  sigma = sqrt(srr);
488  areal1 = parmall[k][8];
489  areal2 = parmall[k][9];
490  areal3 = parmall[k][10];
491  areal4 = parmall[k][11];
492  areal5 = parmall[k][12];
493  areal6 = parmall[k][13];
494  areal7 = parmall[k][14];
495  if (nbit > 1 && k == 0)
496  areal8 = 0.0;
497  else
498  areal8 = parmall[k][15];
499  imcore_backest(ap,xx,yy,&skylev,&skyrms);
500  peake = sqrtf(peak/gain + sigsq + skyrms*skyrms);
501  kron_fluxe = sqrt(kron_flux[k]/gain +
502  (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(kron_rad[k],2.0));
503  exp_fluxe = sqrt(exp_flux[k]/gain +
504  (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(exp_rad[k],2.0));
505  petr_fluxe = sqrt(petr_flux[k]/gain +
506  (sigsq + skyrms*skyrms)*CPL_MATH_PI*powf(petr_rad[k],2.0));
507  apflux1e = sqrt(MAX(0.0,apflux1/gain) + skyvar[0]*(sigsq + skyrms*skyrms));
508  apflux2e = sqrt(MAX(0.0,apflux2/gain) + skyvar[1]*(sigsq + skyrms*skyrms));
509  apflux3e = sqrt(MAX(0.0,apflux3/gain) + skyvar[2]*(sigsq + skyrms*skyrms));
510  apflux4e = sqrt(MAX(0.0,apflux4/gain) + skyvar[3]*(sigsq + skyrms*skyrms));
511  apflux5e = sqrt(MAX(0.0,apflux5/gain) + skyvar[4]*(sigsq + skyrms*skyrms));
512  apflux6e = sqrt(MAX(0.0,apflux6/gain) + skyvar[5]*(sigsq + skyrms*skyrms));
513  apflux7e = sqrt(MAX(0.0,apflux7/gain) + skyvar[6]*(sigsq + skyrms*skyrms));
514  apflux8e = sqrt(MAX(0.0,apflux8/gain) + skyvar[7]*(sigsq + skyrms*skyrms));
515  apflux9e = sqrt(MAX(0.0,apflux9/gain) + skyvar[8]*(sigsq + skyrms*skyrms));
516  apflux10e = sqrt(MAX(0.0,apflux10/gain) + skyvar[9]*(sigsq + skyrms*skyrms));
517  apflux11e = sqrt(MAX(0.0,apflux11/gain) + skyvar[10]*(sigsq + skyrms*skyrms));
518  apflux12e = sqrt(MAX(0.0,apflux12/gain) + skyvar[11]*(sigsq + skyrms*skyrms));
519  apflux13e = sqrt(MAX(0.0,apflux13/gain) + skyvar[12]*(sigsq + skyrms*skyrms));
520 
521  /* Store away the results for this object */
522 
523  zero = 0.0;
524  cpl_table_set_int(tab,ttype[COL_NUMBER-1],nr,*nobjects);
525  cpl_table_set_float(tab,ttype[COL_FLUXISO-1],nr,iso_flux);
526  cpl_table_set_float(tab,ttype[COL_X-1],nr,xx);
527  cpl_table_set_float(tab,ttype[COL_XERR-1],nr,xxe);
528  cpl_table_set_float(tab,ttype[COL_Y-1],nr,yy);
529  cpl_table_set_float(tab,ttype[COL_YERR-1],nr,yye);
530  cpl_table_set_float(tab,ttype[COL_SIGMA-1],nr,sigma);
531  cpl_table_set_float(tab,ttype[COL_ELLIPT-1],nr,ell);
532  cpl_table_set_float(tab,ttype[COL_PA-1],nr,theta);
533  cpl_table_set_float(tab,ttype[COL_AREAL1-1],nr,areal1);
534  cpl_table_set_float(tab,ttype[COL_AREAL2-1],nr,areal2);
535  cpl_table_set_float(tab,ttype[COL_AREAL3-1],nr,areal3);
536  cpl_table_set_float(tab,ttype[COL_AREAL4-1],nr,areal4);
537  cpl_table_set_float(tab,ttype[COL_AREAL5-1],nr,areal5);
538  cpl_table_set_float(tab,ttype[COL_AREAL6-1],nr,areal6);
539  cpl_table_set_float(tab,ttype[COL_AREAL7-1],nr,areal7);
540  cpl_table_set_float(tab,ttype[COL_AREAL8-1],nr,areal8);
541  cpl_table_set_float(tab,ttype[COL_PEAKHEIGHT-1],nr,peak);
542  cpl_table_set_float(tab,ttype[COL_PKHTERR-1],nr,peake);
543  cpl_table_set_float(tab,ttype[COL_APFLUX1-1],nr,apflux1);
544  cpl_table_set_float(tab,ttype[COL_APFLUX1ERR-1],nr,apflux1e);
545  cpl_table_set_float(tab,ttype[COL_APFLUX2-1],nr,apflux2);
546  cpl_table_set_float(tab,ttype[COL_APFLUX2ERR-1],nr,apflux2e);
547  cpl_table_set_float(tab,ttype[COL_APFLUX3-1],nr,apflux3);
548  cpl_table_set_float(tab,ttype[COL_APFLUX3ERR-1],nr,apflux3e);
549  cpl_table_set_float(tab,ttype[COL_APFLUX4-1],nr,apflux4);
550  cpl_table_set_float(tab,ttype[COL_APFLUX4ERR-1],nr,apflux4e);
551  cpl_table_set_float(tab,ttype[COL_APFLUX5-1],nr,apflux5);
552  cpl_table_set_float(tab,ttype[COL_APFLUX5ERR-1],nr,apflux5e);
553  cpl_table_set_float(tab,ttype[COL_APFLUX6-1],nr,apflux6);
554  cpl_table_set_float(tab,ttype[COL_APFLUX6ERR-1],nr,apflux6e);
555  cpl_table_set_float(tab,ttype[COL_APFLUX7-1],nr,apflux7);
556  cpl_table_set_float(tab,ttype[COL_APFLUX7ERR-1],nr,apflux7e);
557  cpl_table_set_float(tab,ttype[COL_APFLUX8-1],nr,apflux8);
558  cpl_table_set_float(tab,ttype[COL_APFLUX8ERR-1],nr,apflux8e);
559  cpl_table_set_float(tab,ttype[COL_APFLUX9-1],nr,apflux9);
560  cpl_table_set_float(tab,ttype[COL_APFLUX9ERR-1],nr,apflux9e);
561  cpl_table_set_float(tab,ttype[COL_APFLUX10-1],nr,apflux10);
562  cpl_table_set_float(tab,ttype[COL_APFLUX10ERR-1],nr,apflux10e);
563  cpl_table_set_float(tab,ttype[COL_APFLUX11-1],nr,apflux11);
564  cpl_table_set_float(tab,ttype[COL_APFLUX11ERR-1],nr,apflux11e);
565  cpl_table_set_float(tab,ttype[COL_APFLUX12-1],nr,apflux12);
566  cpl_table_set_float(tab,ttype[COL_APFLUX12ERR-1],nr,apflux12e);
567  cpl_table_set_float(tab,ttype[COL_APFLUX13-1],nr,apflux13);
568  cpl_table_set_float(tab,ttype[COL_APFLUX13ERR-1],nr,apflux13e);
569  cpl_table_set_float(tab,ttype[COL_PETRAD-1],nr,0.5*petr_rad[k]);
570  cpl_table_set_float(tab,ttype[COL_KRONRAD-1],nr,0.5*kron_rad[k]);
571  cpl_table_set_float(tab,ttype[COL_HALLRAD-1],nr,exp_rad[k]);
572  cpl_table_set_float(tab,ttype[COL_PETFLUX-1],nr,petr_flux[k]);
573  cpl_table_set_float(tab,ttype[COL_PETFLUXERR-1],nr,petr_fluxe);
574  cpl_table_set_float(tab,ttype[COL_KRONFLUX-1],nr,kron_flux[k]);
575  cpl_table_set_float(tab,ttype[COL_KRONFLUXERR-1],nr,kron_fluxe);
576  cpl_table_set_float(tab,ttype[COL_HALLFLUX-1],nr,exp_flux[k]);
577  cpl_table_set_float(tab,ttype[COL_HALLFLUXERR-1],nr,exp_fluxe);
578  cpl_table_set_float(tab,ttype[COL_ERRFLAG-1],nr,badpix[k]);
579  cpl_table_set_float(tab,ttype[COL_SKYLEVEL-1],nr,skylev);
580  cpl_table_set_float(tab,ttype[COL_SKYSIGMA-1],nr,skyrms);
581  cpl_table_set_float(tab,ttype[COL_CHLDPARENT-1],nr,zero);
582 
583  /* Store away some dummy values to avoid problems later on */
584 
585  cpl_table_set_float(tab,ttype[COL_RA-1],nr,zero);
586  cpl_table_set_float(tab,ttype[COL_DEC-1],nr,zero);
587  cpl_table_set_float(tab,ttype[COL_CLASS-1],nr,100.0);
588  cpl_table_set_float(tab,ttype[COL_STAT-1],nr,zero);
589  }
590 
591  /* Get outta here */
592 
593  return(CASU_OK);
594 }
595 
598 /*
599 
600 $Log: create_table_2.c,v $
601 Revision 1.4 2015/09/15 07:38:13 jim
602 Trap for when nbit = 0 in phopt
603 
604 Revision 1.3 2015/08/12 11:16:55 jim
605 Modified procedure names to protect namespace
606 
607 Revision 1.2 2015/08/07 13:06:54 jim
608 Fixed copyright to ESO
609 
610 Revision 1.1.1.1 2015/06/12 10:44:32 jim
611 Initial import
612 
613 Revision 1.4 2015/01/09 11:42:36 jim
614 Fixed routines to remove globals
615 
616 Revision 1.3 2014/04/09 11:08:21 jim
617 Get rid of a couple of compiler moans
618 
619 Revision 1.2 2014/04/09 09:09:51 jim
620 Detabbed
621 
622 Revision 1.1.1.1 2013/08/27 12:07:48 jim
623 Imported
624 
625 
626 */
void imcore_areals(ap_t *ap, int iareal[NAREAL])
Work out the areal profiles for an object.
Definition: areals.c:67
float imcore_exprad(float thresh, float peak, float areal0, float rcores[], int naper)
Work out the exponential radius for an object.
Definition: imcore_radii.c:142
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_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_2(ap_t *ap, int nobjects, cpl_table *tab)
Do seeing estimate for type 2 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
int imcore_process_results_2(ap_t *ap, float gain, int *nobjects, cpl_table *tab)
Process results for type 2 catalogue.
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
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
void imcore_tabinit_2(int *imcore_xcol, int *imcore_ycol, cpl_table **tab)
Initialise type 2 catalogue.