VIRCAM Pipeline 2.3.17
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
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","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
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 int n2rcore = 4;
206static float apertures[NRADS];
207
208static int areal_cols[NAREAL] = {COL_AREAL1,COL_AREAL2,COL_AREAL3,COL_AREAL4,
209 COL_AREAL5,COL_AREAL6,COL_AREAL7,COL_AREAL8};
210
212
213/*---------------------------------------------------------------------------*/
235/*---------------------------------------------------------------------------*/
236
237extern 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
278extern 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
326extern 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
601
602/*
603
604$Log: create_table_6.c,v $
605Revision 1.4 2015/09/15 07:38:13 jim
606Trap for when nbit = 0 in phopt
607
608Revision 1.3 2015/08/12 11:16:55 jim
609Modified procedure names to protect namespace
610
611Revision 1.2 2015/08/07 13:06:54 jim
612Fixed copyright to ESO
613
614Revision 1.1.1.1 2015/06/12 10:44:32 jim
615Initial import
616
617Revision 1.5 2015/03/12 09:16:51 jim
618Modified to remove some compiler moans
619
620Revision 1.4 2015/01/09 11:42:36 jim
621Fixed routines to remove globals
622
623Revision 1.3 2014/04/09 11:08:21 jim
624Get rid of a couple of compiler moans
625
626Revision 1.2 2014/04/09 09:09:51 jim
627Detabbed
628
629Revision 1.1.1.1 2013/08/27 12:07:48 jim
630Imported
631
632
633*/
imcore_areals
void imcore_areals(ap_t *ap, int iareal[NAREAL])
Work out the areal profiles for an object.
Definition areals.c:67
imcore_process_results_6
int imcore_process_results_6(ap_t *ap, float gain, int *nobjects, cpl_table *tab)
Process results for type 6 catalogue.
Definition create_table_6.c:326
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_tabinit_6
void imcore_tabinit_6(int *imcore_xcol, int *imcore_ycol, cpl_table **tab)
Initialise type 6 catalogue.
Definition create_table_6.c:237
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_6
int imcore_do_seeing_6(ap_t *ap, int nobjects, cpl_table *tab)
Do seeing estimate for type 6 catalogue.
Definition create_table_6.c:278
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_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_halflight
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
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
Generated on Mon Jun 15 2026 22:51:00 for VIRCAM Pipeline by doxygen 1.13.2