VIRCAM Pipeline 2.3.17
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
102static 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
134static 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
165static 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
202static 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};
204static int nrcore = 2;
205static float apertures[NRADS];
206
207static int areal_cols[NAREAL] = {COL_AREAL1,COL_AREAL2,COL_AREAL3,COL_AREAL4,
208 COL_AREAL5,COL_AREAL6,COL_AREAL7,COL_AREAL8};
210
211/*---------------------------------------------------------------------------*/
233/*---------------------------------------------------------------------------*/
234
235extern 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
276extern 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
324extern 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
597
598/*
599
600$Log: create_table_2.c,v $
601Revision 1.4 2015/09/15 07:38:13 jim
602Trap for when nbit = 0 in phopt
603
604Revision 1.3 2015/08/12 11:16:55 jim
605Modified procedure names to protect namespace
606
607Revision 1.2 2015/08/07 13:06:54 jim
608Fixed copyright to ESO
609
610Revision 1.1.1.1 2015/06/12 10:44:32 jim
611Initial import
612
613Revision 1.4 2015/01/09 11:42:36 jim
614Fixed routines to remove globals
615
616Revision 1.3 2014/04/09 11:08:21 jim
617Get rid of a couple of compiler moans
618
619Revision 1.2 2014/04/09 09:09:51 jim
620Detabbed
621
622Revision 1.1.1.1 2013/08/27 12:07:48 jim
623Imported
624
625
626*/
imcore_areals
void imcore_areals(ap_t *ap, int iareal[NAREAL])
Work out the areal profiles for an object.
Definition areals.c:67
imcore_exprad
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
imcore_flux
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
imcore_backest
void imcore_backest(ap_t *ap, float x, float y, float *skylev, float *skyrms)
Work out estimated sky for a pixel position.
Definition imcore_background.c:443
imcore_moments
void imcore_moments(ap_t *ap, float results[])
Do moments analysis on an object.
Definition moments.c:65
imcore_do_seeing_2
int imcore_do_seeing_2(ap_t *ap, int nobjects, cpl_table *tab)
Do seeing estimate for type 2 catalogue.
Definition create_table_2.c:276
imcore_do_seeing_gen
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
imcore_process_results_2
int imcore_process_results_2(ap_t *ap, float gain, int *nobjects, cpl_table *tab)
Process results for type 2 catalogue.
Definition create_table_2.c:324
imcore_tabinit_gen
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
imcore_kronrad
float imcore_kronrad(float areal0, float rcores[], float cflux[], int naper)
Work out the Kron radius for an object.
Definition imcore_radii.c:188
imcore_petrad
float imcore_petrad(float areal0, float rcores[], float cflux[], int naper)
Work out the Petrosian.
Definition imcore_radii.c:242
imcore_phopt
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
imcore_overlp
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
imcore_extend
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
imcore_tabinit_2
void imcore_tabinit_2(int *imcore_xcol, int *imcore_ycol, cpl_table **tab)
Initialise type 2 catalogue.
Definition create_table_2.c:235
Generated on Mon Jun 15 2026 22:51:00 for VIRCAM Pipeline by doxygen 1.13.2