MOONS Pipeline Reference Manual 0.13.1
moo_target_table.c
1/*
2 * This file is part of the MOONS Pipeline
3 * Copyright (C) 2002-2016 European Southern Observatory
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20#ifdef HAVE_CONFIG_H
21#include <config.h>
22#endif
23
24/*-----------------------------------------------------------------------------
25 Includes
26 -----------------------------------------------------------------------------*/
27#include <math.h>
28#include <string.h>
29#include <cpl.h>
30
31#include "moo_target_table.h"
32#include "moo_fibres_table.h"
33#include "moo_rbn_single.h"
34#include "moo_utils.h"
35/*----------------------------------------------------------------------------*/
40/*----------------------------------------------------------------------------*/
43/*-----------------------------------------------------------------------------
44 Function codes
45 -----------------------------------------------------------------------------*/
46
47/*----------------------------------------------------------------------------*/
58/*----------------------------------------------------------------------------*/
59const char *
60moo_target_table_mode_get_name(moo_target_table_mode m)
61{
62 const char *res[] = { "STARE", "STARENOD", "XSWITCH" };
63 int idx = m;
64 return res[idx];
65}
66/*----------------------------------------------------------------------------*/
74/*----------------------------------------------------------------------------*/
75moo_target_table *
76moo_target_table_new(void)
77{
78 moo_target_table *res = cpl_calloc(1, sizeof(moo_target_table));
79
80 return res;
81}
82
83/*----------------------------------------------------------------------------*/
91/*----------------------------------------------------------------------------*/
92moo_target_table *
93moo_target_table_duplicate(moo_target_table *self)
94{
95 moo_target_table *res = NULL;
96 cpl_ensure(self != NULL, CPL_ERROR_NULL_INPUT, NULL);
97
98 res = moo_target_table_new();
99 res->primary_header = cpl_propertylist_duplicate(self->primary_header);
100 res->table = cpl_table_duplicate(self->table);
101
102 return res;
103}
104
105const char *
106moo_target_table_get_mode_name(moo_target_table_mode mode)
107{
108 switch (mode) {
109 case MOO_MODE_STARE:
110 return "STARE";
111 case MOO_MODE_STARENOD:
112 return "STARENOD";
113 case MOO_MODE_XSWITCH:
114 return "XSWITCH";
115 default:
116 return "UNKKNOWN";
117 }
118}
119
120moo_target_table *
121moo_create_empty_target_table(void)
122{
123 moo_target_table *result = NULL;
124 cpl_table *table = NULL;
125
126 cpl_errorstate prestate = cpl_errorstate_get();
127 result = moo_target_table_new();
128 table = cpl_table_new(0);
129
130 moo_try_check(cpl_table_new_column(table, MOO_TARGET_TABLE_INDEXTARG,
131 CPL_TYPE_INT),
132 " ");
133 moo_try_check(cpl_table_new_column(table, MOO_TARGET_TABLE_TARGNAME,
134 CPL_TYPE_STRING),
135 " ");
136 moo_try_check(cpl_table_new_column(table, MOO_TARGET_TABLE_TARGALPHA,
137 CPL_TYPE_DOUBLE),
138 " ");
139 moo_try_check(cpl_table_new_column(table, MOO_TARGET_TABLE_TARGDELTA,
140 CPL_TYPE_DOUBLE),
141 " ");
142 moo_try_check(cpl_table_new_column(table, MOO_TARGET_TABLE_TYPE,
143 CPL_TYPE_STRING),
144 " ");
145 moo_try_check(cpl_table_new_column(table, MOO_TARGET_TABLE_FIBRE,
146 CPL_TYPE_STRING),
147 " ");
148 moo_try_check(cpl_table_new_column(table, MOO_TARGET_TABLE_INDEX,
149 CPL_TYPE_INT),
150 " ");
151 cpl_table_new_column(table, MOO_TARGET_TABLE_PAIREDFIBRE, CPL_TYPE_INT);
152 moo_try_check(cpl_table_new_column(table, MOO_TARGET_TABLE_MAG,
153 CPL_TYPE_DOUBLE),
154 " ");
155 moo_try_check(cpl_table_new_column(table, MOO_TARGET_TABLE_INDEXRBN,
156 CPL_TYPE_INT),
157 " ");
158 cpl_table_new_column(table, MOO_TARGET_TABLE_PAIREDINDEXRBN, CPL_TYPE_INT);
159 cpl_table_new_column(table, MOO_TARGET_TABLE_EXPTIMERI, CPL_TYPE_DOUBLE);
160 cpl_table_new_column(table, MOO_TARGET_TABLE_EXPTIMEYJ, CPL_TYPE_DOUBLE);
161 cpl_table_new_column(table, MOO_TARGET_TABLE_EXPTIMEH, CPL_TYPE_DOUBLE);
162 cpl_table_new_column(table, MOO_TARGET_TABLE_OBSTYPE, CPL_TYPE_STRING);
163 cpl_table_new_column(table, MOO_TARGET_TABLE_SUBSKYMODE, CPL_TYPE_STRING);
164 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRRI_SCI, CPL_TYPE_DOUBLE);
165 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRYJ_SCI, CPL_TYPE_DOUBLE);
166 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRH_SCI, CPL_TYPE_DOUBLE);
167 cpl_table_new_column(table, MOO_TARGET_TABLE_TRANSRI, CPL_TYPE_FLOAT);
168 cpl_table_new_column(table, MOO_TARGET_TABLE_TRANSYJ, CPL_TYPE_FLOAT);
169 cpl_table_new_column(table, MOO_TARGET_TABLE_TRANSH, CPL_TYPE_FLOAT);
170 cpl_table_new_column(table, MOO_TARGET_TABLE_NBSKY, CPL_TYPE_INT);
171 cpl_table_new_column(table, MOO_TARGET_TABLE_MAX_DIST_SLIT, CPL_TYPE_INT);
172 cpl_table_new_column(table, MOO_TARGET_TABLE_MAX_DIST_SKY, CPL_TYPE_FLOAT);
173 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRRI_EXT, CPL_TYPE_FLOAT);
174 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRYJ_EXT, CPL_TYPE_FLOAT);
175 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRH_EXT, CPL_TYPE_FLOAT);
176 cpl_table_new_column(table, MOO_TARGET_TABLE_DERSNRRI_EXT, CPL_TYPE_FLOAT);
177 cpl_table_new_column(table, MOO_TARGET_TABLE_DERSNRYJ_EXT, CPL_TYPE_FLOAT);
178 cpl_table_new_column(table, MOO_TARGET_TABLE_DERSNRH_EXT, CPL_TYPE_FLOAT);
179 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRRI_RBN, CPL_TYPE_FLOAT);
180 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRYJ_RBN, CPL_TYPE_FLOAT);
181 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRH_RBN, CPL_TYPE_FLOAT);
182 cpl_table_new_column(table, MOO_TARGET_TABLE_PTRANSRI, CPL_TYPE_FLOAT);
183 cpl_table_new_column(table, MOO_TARGET_TABLE_PTRANSYJ, CPL_TYPE_FLOAT);
184 cpl_table_new_column(table, MOO_TARGET_TABLE_PTRANSH, CPL_TYPE_FLOAT);
185 cpl_table_new_column(table, MOO_TARGET_TABLE_PNBSKY, CPL_TYPE_INT);
186 cpl_table_new_column(table, MOO_TARGET_TABLE_PMAX_DIST_SLIT, CPL_TYPE_INT);
187 cpl_table_new_column(table, MOO_TARGET_TABLE_PMAX_DIST_SKY, CPL_TYPE_FLOAT);
188 cpl_table_new_column(table, MOO_TARGET_TABLE_PMEDSNRRI_EXT, CPL_TYPE_FLOAT);
189 cpl_table_new_column(table, MOO_TARGET_TABLE_PMEDSNRYJ_EXT, CPL_TYPE_FLOAT);
190 cpl_table_new_column(table, MOO_TARGET_TABLE_PMEDSNRH_EXT, CPL_TYPE_FLOAT);
191 cpl_table_new_column(table, MOO_TARGET_TABLE_PDERSNRRI_EXT, CPL_TYPE_FLOAT);
192 cpl_table_new_column(table, MOO_TARGET_TABLE_PDERSNRYJ_EXT, CPL_TYPE_FLOAT);
193 cpl_table_new_column(table, MOO_TARGET_TABLE_PDERSNRH_EXT, CPL_TYPE_FLOAT);
194 cpl_table_new_column(table, MOO_TARGET_TABLE_PMEDSNRRI_RBN, CPL_TYPE_FLOAT);
195 cpl_table_new_column(table, MOO_TARGET_TABLE_PMEDSNRYJ_RBN, CPL_TYPE_FLOAT);
196 cpl_table_new_column(table, MOO_TARGET_TABLE_PMEDSNRH_RBN, CPL_TYPE_FLOAT);
197
198
199 result->table = table;
200 result->primary_header = cpl_propertylist_new();
201
202moo_try_cleanup:
203 if (!cpl_errorstate_is_equal(prestate)) {
204 moo_target_table_delete(result);
205 result = NULL;
206 }
207 return result;
208}
209
210static moo_target_table *
211_moo_create_target_table(moo_rbn *rbn, moo_target_table_params *params)
212{
213 moo_target_table *result = NULL;
214 cpl_table *table = NULL;
215 cpl_ensure(rbn != NULL, CPL_ERROR_NULL_INPUT, NULL);
216 cpl_table *fibre_table = moo_rbn_get_fibre_table(rbn);
217 cpl_ensure(fibre_table, CPL_ERROR_NULL_INPUT, NULL);
218
219 cpl_errorstate prestate = cpl_errorstate_get();
220 int nrow = cpl_table_get_nrow(fibre_table);
221 result = moo_target_table_new();
222 table = cpl_table_new(nrow);
223 moo_try_check(cpl_table_new_column(table, MOO_TARGET_TABLE_INDEXTARG,
224 CPL_TYPE_INT),
225 " ");
226 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_TARGNAME,
227 fibre_table,
228 MOO_FIBRES_TABLE_TARGNAME),
229 " ");
230 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_TARGALPHA,
231 fibre_table,
232 MOO_FIBRES_TABLE_TARGALPHA),
233 " ");
234 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_TARGDELTA,
235 fibre_table,
236 MOO_FIBRES_TABLE_TARGDELTA),
237 " ");
238 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_TYPE,
239 fibre_table,
240 MOO_FIBRES_TABLE_TYPE),
241 " ");
242 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_FIBRE,
243 fibre_table,
244 MOO_FIBRES_TABLE_FIBRE),
245 " ");
246 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_SPECTRO,
247 fibre_table,
248 MOO_FIBRES_TABLE_SPECTRO),
249 " ");
250 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_INDEX,
251 fibre_table,
252 MOO_FIBRES_TABLE_INDEX),
253 " ");
254 moo_try_check(cpl_table_duplicate_column(table,
255 MOO_TARGET_TABLE_PAIREDFIBRE,
256 fibre_table,
257 MOO_FIBRES_TABLE_PAIREDFIBRE),
258 " ");
259 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_MAG,
260 fibre_table, MOO_FIBRES_TABLE_MAG),
261 " ");
262 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_INDEXRBN,
263 fibre_table,
264 MOO_FIBRES_TABLE_INDEXRBN),
265 " ");
266 cpl_table_new_column(table, MOO_TARGET_TABLE_PAIREDINDEXRBN, CPL_TYPE_INT);
267 cpl_table_new_column(table, MOO_TARGET_TABLE_EXPTIMERI, CPL_TYPE_DOUBLE);
268 cpl_table_new_column(table, MOO_TARGET_TABLE_EXPTIMEYJ, CPL_TYPE_DOUBLE);
269 cpl_table_new_column(table, MOO_TARGET_TABLE_EXPTIMEH, CPL_TYPE_DOUBLE);
270 cpl_table_new_column(table, MOO_TARGET_TABLE_OBSTYPE, CPL_TYPE_STRING);
271 cpl_table_new_column(table, MOO_TARGET_TABLE_SUBSKYMODE, CPL_TYPE_STRING);
272 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRRI_SCI, CPL_TYPE_DOUBLE);
273 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRYJ_SCI, CPL_TYPE_DOUBLE);
274 cpl_table_new_column(table, MOO_TARGET_TABLE_MEDSNRH_SCI, CPL_TYPE_DOUBLE);
275 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_TRANSRI,
276 fibre_table,
277 MOO_FIBRES_TABLE_TRANS_RI),
278 " ");
279 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_TRANSYJ,
280 fibre_table,
281 MOO_FIBRES_TABLE_TRANS_YJ),
282 " ");
283 moo_try_check(cpl_table_duplicate_column(table, MOO_TARGET_TABLE_TRANSH,
284 fibre_table,
285 MOO_FIBRES_TABLE_TRANS_H),
286 " ");
287 cpl_table_new_column(table, MOO_TARGET_TABLE_NBSKY, CPL_TYPE_INT);
288 cpl_table_new_column(table, MOO_TARGET_TABLE_MAX_DIST_SLIT, CPL_TYPE_INT);
289 cpl_table_new_column(table, MOO_TARGET_TABLE_MAX_DIST_SKY, CPL_TYPE_FLOAT);
290 moo_try_check(cpl_table_duplicate_column(table,
291 MOO_TARGET_TABLE_MEDSNRRI_EXT,
292 fibre_table,
293 MOO_FIBRES_TABLE_MEDSNR_RI_EXT),
294 " ");
295 moo_try_check(cpl_table_duplicate_column(table,
296 MOO_TARGET_TABLE_MEDSNRYJ_EXT,
297 fibre_table,
298 MOO_FIBRES_TABLE_MEDSNR_YJ_EXT),
299 " ");
300 moo_try_check(cpl_table_duplicate_column(table,
301 MOO_TARGET_TABLE_MEDSNRH_EXT,
302 fibre_table,
303 MOO_FIBRES_TABLE_MEDSNR_H_EXT),
304 " ");
305 moo_try_check(cpl_table_duplicate_column(table,
306 MOO_TARGET_TABLE_DERSNRRI_EXT,
307 fibre_table,
308 MOO_FIBRES_TABLE_DERSNR_RI_EXT),
309 " ");
310 moo_try_check(cpl_table_duplicate_column(table,
311 MOO_TARGET_TABLE_DERSNRYJ_EXT,
312 fibre_table,
313 MOO_FIBRES_TABLE_DERSNR_YJ_EXT),
314 " ");
315 moo_try_check(cpl_table_duplicate_column(table,
316 MOO_TARGET_TABLE_DERSNRH_EXT,
317 fibre_table,
318 MOO_FIBRES_TABLE_DERSNR_H_EXT),
319 " ");
320 moo_try_check(cpl_table_duplicate_column(table,
321 MOO_TARGET_TABLE_MEDSNRRI_RBN,
322 fibre_table,
323 MOO_FIBRES_TABLE_MEDSNR_RI_RBN),
324 " ");
325 moo_try_check(cpl_table_duplicate_column(table,
326 MOO_TARGET_TABLE_MEDSNRYJ_RBN,
327 fibre_table,
328 MOO_FIBRES_TABLE_MEDSNR_YJ_RBN),
329 " ");
330 moo_try_check(cpl_table_duplicate_column(table,
331 MOO_TARGET_TABLE_MEDSNRH_RBN,
332 fibre_table,
333 MOO_FIBRES_TABLE_MEDSNR_H_RBN),
334 " ");
335
336 const int *healtht =
337 cpl_table_get_data_int_const(fibre_table, MOO_FIBRES_TABLE_HEALTH);
338 const char **typet =
339 cpl_table_get_data_string_const(fibre_table, MOO_FIBRES_TABLE_TYPE);
340 const int *indexrbnt =
341 cpl_table_get_data_int_const(fibre_table, MOO_FIBRES_TABLE_INDEXRBN);
342 cpl_table_select_all(table);
343
344 for (int i = 0; i < nrow; i++) {
345 int health = healtht[i];
346 const char *type = typet[i];
347 int indexrbn = indexrbnt[i];
348
349 if (health != 1 || indexrbn == 0) {
350 cpl_table_unselect_row(table, i);
351 }
352 else if (strcmp(type, MOO_FIBRES_TABLE_TYPE_SKYCONTAM) == 0 ||
353 strcmp(type, MOO_FIBRES_TABLE_TYPE_BLANK) == 0) {
354 cpl_table_unselect_row(table, i);
355 }
356 else if (params->nosky == 1 &&
357 strcmp(type, MOO_FIBRES_TABLE_TYPE_SKY) == 0) {
358 cpl_table_unselect_row(table, i);
359 }
360 else {
361 cpl_table_set_int(table, MOO_TARGET_TABLE_PAIREDINDEXRBN, i, -1);
362 cpl_table_set_double(table, MOO_TARGET_TABLE_EXPTIMERI, i, NAN);
363 cpl_table_set_double(table, MOO_TARGET_TABLE_EXPTIMEYJ, i, NAN);
364 cpl_table_set_double(table, MOO_TARGET_TABLE_EXPTIMEH, i, NAN);
365 cpl_table_set_double(table, MOO_TARGET_TABLE_MEDSNRRI_SCI, i, NAN);
366 cpl_table_set_double(table, MOO_TARGET_TABLE_MEDSNRYJ_SCI, i, NAN);
367 cpl_table_set_double(table, MOO_TARGET_TABLE_MEDSNRH_SCI, i, NAN);
368 cpl_table_set_int(table, MOO_TARGET_TABLE_NBSKY, i, -1);
369 cpl_table_set_int(table, MOO_TARGET_TABLE_MAX_DIST_SLIT, i, -1);
370 cpl_table_set_float(table, MOO_TARGET_TABLE_MAX_DIST_SKY, i, NAN);
371 }
372 }
373 cpl_table *good = cpl_table_extract_selected(table);
374 result->table = good;
375 result->primary_header = cpl_propertylist_new();
376
377moo_try_cleanup:
378 cpl_table_delete(table);
379 if (!cpl_errorstate_is_equal(prestate)) {
380 moo_target_table_delete(result);
381 result = NULL;
382 }
383 return result;
384}
385
386
387static moo_target_table *
388_moo_create_target_table_stare(moo_rbn *rbn, moo_target_table_params *params)
389{
390 moo_target_table *result = NULL;
391
392 cpl_ensure(rbn != NULL, CPL_ERROR_NULL_INPUT, NULL);
393 cpl_table *fibre_table = moo_rbn_get_fibre_table(rbn);
394 cpl_ensure(fibre_table, CPL_ERROR_NULL_INPUT, NULL);
395
396 cpl_errorstate prestate = cpl_errorstate_get();
397 moo_try_check(result = _moo_create_target_table(rbn, params), " ");
398 cpl_table *table = result->table;
399 int nrow = cpl_table_get_nrow(table);
400 char **obstype = cpl_table_get_data_string(table, MOO_TARGET_TABLE_OBSTYPE);
401 const char **types =
402 cpl_table_get_data_string_const(table, MOO_TARGET_TABLE_TYPE);
403
404 for (int i = 0; i < nrow; i++) {
405 const char *type = types[i];
406 if (strcmp(type, MOO_FIBRES_TABLE_TYPE_SKY) == 0) {
407 obstype[i] = cpl_strdup(MOO_OBSTYPE_SKYSTARE);
408 }
409 else {
410 obstype[i] = cpl_strdup(MOO_OBSTYPE_OBSSTARE);
411 }
412 cpl_table_set_int(table, MOO_TARGET_TABLE_PAIREDFIBRE, i, -1);
413 cpl_table_set_int(table, MOO_TARGET_TABLE_PAIREDINDEXRBN, i, -1);
414 }
415
416moo_try_cleanup:
417 if (!cpl_errorstate_is_equal(prestate)) {
418 moo_target_table_delete(result);
419 result = NULL;
420 }
421 return result;
422}
423
424cpl_error_code
425moo_target_table_set_snr(moo_target_table *self,
426 int idx,
427 cpl_table *fibre_table,
428 int ft_idx)
429{
430 cpl_table *target = self->table;
431 float snrriext =
432 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_RI_EXT, ft_idx,
433 NULL);
434 float dsnrriext =
435 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_DERSNR_RI_EXT, ft_idx,
436 NULL);
437 float snryjext =
438 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_YJ_EXT, ft_idx,
439 NULL);
440 float dsnryjext =
441 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_DERSNR_YJ_EXT, ft_idx,
442 NULL);
443 float snrhext =
444 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_H_EXT, ft_idx,
445 NULL);
446 float dsnrhext =
447 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_DERSNR_H_EXT, ft_idx,
448 NULL);
449 float snrrirbn =
450 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_RI_RBN, ft_idx,
451 NULL);
452 float snryjrbn =
453 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_YJ_RBN, ft_idx,
454 NULL);
455 float snrhrbn =
456 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_H_RBN, ft_idx,
457 NULL);
458
459 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRRI_EXT, idx, snrriext);
460 cpl_table_set_float(target, MOO_TARGET_TABLE_DERSNRRI_EXT, idx, dsnrriext);
461 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRYJ_EXT, idx, snryjext);
462 cpl_table_set_float(target, MOO_TARGET_TABLE_DERSNRYJ_EXT, idx, dsnryjext);
463 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRH_EXT, idx, snrhext);
464 cpl_table_set_float(target, MOO_TARGET_TABLE_DERSNRH_EXT, idx, dsnrhext);
465
466 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRRI_RBN, idx, snrrirbn);
467 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRYJ_RBN, idx, snryjrbn);
468 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRH_RBN, idx, snrhrbn);
469
470 return CPL_ERROR_NONE;
471}
472
473cpl_error_code
474moo_target_table_copy_row(moo_target_table *self,
475 int idx,
476 moo_target_table *tocopy,
477 int ft_idx)
478{
479 cpl_table *target = self->table;
480 cpl_table *origin = tocopy->table;
481 int nbsky = cpl_table_get_int(origin, MOO_TARGET_TABLE_NBSKY, ft_idx, NULL);
482 int maxdistslit =
483 cpl_table_get_int(origin, MOO_TARGET_TABLE_MAX_DIST_SLIT, ft_idx, NULL);
484 float maxdistsky =
485 cpl_table_get_float(origin, MOO_TARGET_TABLE_MAX_DIST_SKY, ft_idx,
486 NULL);
487 int pnbsky =
488 cpl_table_get_int(origin, MOO_TARGET_TABLE_PNBSKY, ft_idx, NULL);
489 int pmaxdistslit =
490 cpl_table_get_int(origin, MOO_TARGET_TABLE_PMAX_DIST_SLIT, ft_idx,
491 NULL);
492 float pmaxdistsky =
493 cpl_table_get_float(origin, MOO_TARGET_TABLE_PMAX_DIST_SKY, ft_idx,
494 NULL);
495 float snrriext = cpl_table_get_float(origin, MOO_TARGET_TABLE_MEDSNRRI_EXT,
496 ft_idx, NULL);
497 float dsnrriext = cpl_table_get_float(origin, MOO_TARGET_TABLE_DERSNRRI_EXT,
498 ft_idx, NULL);
499 float snryjext = cpl_table_get_float(origin, MOO_TARGET_TABLE_MEDSNRYJ_EXT,
500 ft_idx, NULL);
501 float dsnryjext = cpl_table_get_float(origin, MOO_TARGET_TABLE_DERSNRYJ_EXT,
502 ft_idx, NULL);
503 float snrhext =
504 cpl_table_get_float(origin, MOO_TARGET_TABLE_MEDSNRH_EXT, ft_idx, NULL);
505 float dsnrhext =
506 cpl_table_get_float(origin, MOO_TARGET_TABLE_DERSNRH_EXT, ft_idx, NULL);
507 float snrrirbn = cpl_table_get_float(origin, MOO_TARGET_TABLE_MEDSNRRI_RBN,
508 ft_idx, NULL);
509 float snryjrbn = cpl_table_get_float(origin, MOO_TARGET_TABLE_MEDSNRYJ_RBN,
510 ft_idx, NULL);
511 float snrhrbn =
512 cpl_table_get_float(origin, MOO_TARGET_TABLE_MEDSNRH_RBN, ft_idx, NULL);
513
514 float psnrriext =
515 cpl_table_get_float(origin, MOO_TARGET_TABLE_PMEDSNRRI_EXT, ft_idx,
516 NULL);
517 float pdsnrriext =
518 cpl_table_get_float(origin, MOO_TARGET_TABLE_PDERSNRRI_EXT, ft_idx,
519 NULL);
520 float psnryjext =
521 cpl_table_get_float(origin, MOO_TARGET_TABLE_PMEDSNRYJ_EXT, ft_idx,
522 NULL);
523 float pdsnryjext =
524 cpl_table_get_float(origin, MOO_TARGET_TABLE_PDERSNRYJ_EXT, ft_idx,
525 NULL);
526 float psnrhext = cpl_table_get_float(origin, MOO_TARGET_TABLE_PMEDSNRH_EXT,
527 ft_idx, NULL);
528 float pdsnrhext = cpl_table_get_float(origin, MOO_TARGET_TABLE_PDERSNRH_EXT,
529 ft_idx, NULL);
530 float psnrrirbn =
531 cpl_table_get_float(origin, MOO_TARGET_TABLE_PMEDSNRRI_RBN, ft_idx,
532 NULL);
533 float psnryjrbn =
534 cpl_table_get_float(origin, MOO_TARGET_TABLE_PMEDSNRYJ_RBN, ft_idx,
535 NULL);
536 float psnrhrbn = cpl_table_get_float(origin, MOO_TARGET_TABLE_PMEDSNRH_RBN,
537 ft_idx, NULL);
538
539 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRRI_EXT, idx, snrriext);
540 cpl_table_set_float(target, MOO_TARGET_TABLE_DERSNRRI_EXT, idx, dsnrriext);
541 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRYJ_EXT, idx, snryjext);
542 cpl_table_set_float(target, MOO_TARGET_TABLE_DERSNRYJ_EXT, idx, dsnryjext);
543 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRH_EXT, idx, snrhext);
544 cpl_table_set_float(target, MOO_TARGET_TABLE_DERSNRH_EXT, idx, dsnrhext);
545
546 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRRI_RBN, idx, snrrirbn);
547 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRYJ_RBN, idx, snryjrbn);
548 cpl_table_set_float(target, MOO_TARGET_TABLE_MEDSNRH_RBN, idx, snrhrbn);
549
550 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRRI_EXT, idx, psnrriext);
551 cpl_table_set_float(target, MOO_TARGET_TABLE_PDERSNRRI_EXT, idx,
552 pdsnrriext);
553 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRYJ_EXT, idx, psnryjext);
554 cpl_table_set_float(target, MOO_TARGET_TABLE_PDERSNRYJ_EXT, idx,
555 pdsnryjext);
556 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRH_EXT, idx, psnrhext);
557 cpl_table_set_float(target, MOO_TARGET_TABLE_PDERSNRH_EXT, idx, pdsnrhext);
558
559 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRRI_RBN, idx, psnrrirbn);
560 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRYJ_RBN, idx, psnryjrbn);
561 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRH_RBN, idx, psnrhrbn);
562
563 cpl_table_set_int(target, MOO_TARGET_TABLE_NBSKY, idx, nbsky);
564 cpl_table_set_int(target, MOO_TARGET_TABLE_MAX_DIST_SLIT, idx, maxdistslit);
565 cpl_table_set_float(target, MOO_TARGET_TABLE_MAX_DIST_SKY, idx, maxdistsky);
566
567 cpl_table_set_int(target, MOO_TARGET_TABLE_PNBSKY, idx, pnbsky);
568 cpl_table_set_int(target, MOO_TARGET_TABLE_PMAX_DIST_SLIT, idx,
569 pmaxdistslit);
570 cpl_table_set_float(target, MOO_TARGET_TABLE_PMAX_DIST_SKY, idx,
571 pmaxdistsky);
572 return CPL_ERROR_NONE;
573}
574
575cpl_error_code
576moo_target_table_set_ft_psnr(moo_target_table *self,
577 int idx,
578 cpl_table *fibre_table,
579 int ft_idx)
580{
581 cpl_table *target = self->table;
582 float snrriext =
583 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_RI_EXT, ft_idx,
584 NULL);
585 float dsnrriext =
586 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_DERSNR_RI_EXT, ft_idx,
587 NULL);
588 float snryjext =
589 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_YJ_EXT, ft_idx,
590 NULL);
591 float dsnryjext =
592 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_DERSNR_YJ_EXT, ft_idx,
593 NULL);
594 float snrhext =
595 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_H_EXT, ft_idx,
596 NULL);
597 float dsnrhext =
598 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_DERSNR_H_EXT, ft_idx,
599 NULL);
600 float snrrirbn =
601 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_RI_RBN, ft_idx,
602 NULL);
603 float snryjrbn =
604 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_YJ_RBN, ft_idx,
605 NULL);
606 float snrhrbn =
607 cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_MEDSNR_H_RBN, ft_idx,
608 NULL);
609
610 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRRI_EXT, idx, snrriext);
611 cpl_table_set_float(target, MOO_TARGET_TABLE_PDERSNRRI_EXT, idx, dsnrriext);
612 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRYJ_EXT, idx, snryjext);
613 cpl_table_set_float(target, MOO_TARGET_TABLE_PDERSNRYJ_EXT, idx, dsnryjext);
614 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRH_EXT, idx, snrhext);
615 cpl_table_set_float(target, MOO_TARGET_TABLE_PDERSNRH_EXT, idx, dsnrhext);
616 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRRI_RBN, idx, snrrirbn);
617 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRYJ_RBN, idx, snryjrbn);
618 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRH_RBN, idx, snrhrbn);
619
620 return CPL_ERROR_NONE;
621}
622
623cpl_error_code
624moo_target_table_set_psnr(moo_target_table *self,
625 int idx,
626 moo_target_table *torigin,
627 int ft_idx)
628{
629 cpl_table *target = self->table;
630 cpl_table *origin = torigin->table;
631 moo_target_table_set_ft_psnr(self, idx, origin, ft_idx);
632
633 int pnbsky =
634 cpl_table_get_int(origin, MOO_TARGET_TABLE_NBSKY, ft_idx, NULL);
635 int pmaxdistslit =
636 cpl_table_get_int(origin, MOO_TARGET_TABLE_MAX_DIST_SLIT, ft_idx, NULL);
637 float pmaxdistsky =
638 cpl_table_get_float(origin, MOO_TARGET_TABLE_MAX_DIST_SKY, ft_idx,
639 NULL);
640 cpl_table_set_int(target, MOO_TARGET_TABLE_PNBSKY, idx, pnbsky);
641 cpl_table_set_int(target, MOO_TARGET_TABLE_PMAX_DIST_SLIT, idx,
642 pmaxdistslit);
643 cpl_table_set_float(target, MOO_TARGET_TABLE_PMAX_DIST_SKY, idx,
644 pmaxdistsky);
645
646 return CPL_ERROR_NONE;
647}
648
649static cpl_error_code
650_moo_target_table_add_from_ft(cpl_table *target,
651 cpl_table *fibre_table,
652 cpl_table *pfibre_table,
653 int ft_idx,
654 int nrow,
655 const char *obstype)
656{
657 cpl_table_set_size(target, nrow);
658
659 const char *type =
660 cpl_table_get_string(fibre_table, MOO_FIBRES_TABLE_TYPE, ft_idx);
661 const char *targname =
662 cpl_table_get_string(fibre_table, MOO_FIBRES_TABLE_TARGNAME, ft_idx);
663 double targalpha =
664 cpl_table_get_double(fibre_table, MOO_FIBRES_TABLE_TARGALPHA, ft_idx,
665 NULL);
666 double targdelta =
667 cpl_table_get_double(fibre_table, MOO_FIBRES_TABLE_TARGDELTA, ft_idx,
668 NULL);
669 const char *fibre =
670 cpl_table_get_string(fibre_table, MOO_FIBRES_TABLE_FIBRE, ft_idx);
671 int index =
672 cpl_table_get_int(fibre_table, MOO_FIBRES_TABLE_INDEX, ft_idx, NULL);
673 int pfibre = cpl_table_get_int(fibre_table, MOO_FIBRES_TABLE_PAIREDFIBRE,
674 ft_idx, NULL);
675 int indexrbn =
676 cpl_table_get_int(fibre_table, MOO_FIBRES_TABLE_INDEXRBN, ft_idx, NULL);
677 int pindexrbn = -1;
678 float ptransri = NAN;
679 float ptransyj = NAN;
680 float ptransh = NAN;
681 if (pfibre >= 0) {
682 int health = cpl_table_get_int(pfibre_table, MOO_FIBRES_TABLE_HEALTH,
683 pfibre, NULL);
684 if (health > 0) {
685 pindexrbn =
686 cpl_table_get_int(pfibre_table, MOO_FIBRES_TABLE_INDEXRBN,
687 pfibre, NULL);
688 ptransri =
689 cpl_table_get_float(pfibre_table, MOO_FIBRES_TABLE_TRANS_RI,
690 pfibre, NULL);
691 ptransyj =
692 cpl_table_get_float(pfibre_table, MOO_FIBRES_TABLE_TRANS_YJ,
693 pfibre, NULL);
694 ptransh =
695 cpl_table_get_float(pfibre_table, MOO_FIBRES_TABLE_TRANS_H,
696 pfibre, NULL);
697 ptransri =
698 cpl_table_get_float(pfibre_table, MOO_FIBRES_TABLE_TRANS_RI,
699 pfibre, NULL);
700 }
701 }
702 double mag =
703 cpl_table_get_double(fibre_table, MOO_FIBRES_TABLE_MAG, ft_idx, NULL);
704 float transri = cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_TRANS_RI,
705 ft_idx, NULL);
706 float transyj = cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_TRANS_YJ,
707 ft_idx, NULL);
708 float transh = cpl_table_get_float(fibre_table, MOO_FIBRES_TABLE_TRANS_H,
709 ft_idx, NULL);
710
711 cpl_table_set_int(target, MOO_TARGET_TABLE_INDEXTARG, nrow - 1, -1);
712 cpl_table_set_int(target, MOO_TARGET_TABLE_NBSKY, nrow - 1, -1);
713 cpl_table_set_int(target, MOO_TARGET_TABLE_MAX_DIST_SLIT, nrow - 1, -1);
714 cpl_table_set_float(target, MOO_TARGET_TABLE_MAX_DIST_SKY, nrow - 1, NAN);
715 cpl_table_set_int(target, MOO_TARGET_TABLE_PNBSKY, nrow - 1, -1);
716 cpl_table_set_int(target, MOO_TARGET_TABLE_PMAX_DIST_SLIT, nrow - 1, -1);
717 cpl_table_set_float(target, MOO_TARGET_TABLE_PMAX_DIST_SKY, nrow - 1, NAN);
718
719 cpl_table_set_string(target, MOO_TARGET_TABLE_TARGNAME, nrow - 1, targname);
720 cpl_table_set_double(target, MOO_TARGET_TABLE_TARGALPHA, nrow - 1,
721 targalpha);
722 cpl_table_set_double(target, MOO_TARGET_TABLE_TARGDELTA, nrow - 1,
723 targdelta);
724 cpl_table_set_double(target, MOO_TARGET_TABLE_MAG, nrow - 1, mag);
725 cpl_table_set_string(target, MOO_TARGET_TABLE_FIBRE, nrow - 1, fibre);
726 cpl_table_set_int(target, MOO_TARGET_TABLE_INDEX, nrow - 1, index);
727 cpl_table_set_int(target, MOO_TARGET_TABLE_PAIREDFIBRE, nrow - 1, pfibre);
728 cpl_table_set_string(target, MOO_TARGET_TABLE_TYPE, nrow - 1, type);
729 cpl_table_set_string(target, MOO_TARGET_TABLE_OBSTYPE, nrow - 1, obstype);
730 cpl_table_set_int(target, MOO_TARGET_TABLE_INDEXRBN, nrow - 1, indexrbn);
731 cpl_table_set_int(target, MOO_TARGET_TABLE_PAIREDINDEXRBN, nrow - 1,
732 pindexrbn);
733 cpl_table_set_float(target, MOO_TARGET_TABLE_TRANSRI, nrow - 1, transri);
734 cpl_table_set_float(target, MOO_TARGET_TABLE_TRANSYJ, nrow - 1, transyj);
735 cpl_table_set_float(target, MOO_TARGET_TABLE_TRANSH, nrow - 1, transh);
736 cpl_table_set_float(target, MOO_TARGET_TABLE_PTRANSRI, nrow - 1, ptransri);
737 cpl_table_set_float(target, MOO_TARGET_TABLE_PTRANSYJ, nrow - 1, ptransyj);
738 cpl_table_set_float(target, MOO_TARGET_TABLE_PTRANSH, nrow - 1, ptransh);
739
740 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRRI_EXT, nrow - 1, NAN);
741 cpl_table_set_float(target, MOO_TARGET_TABLE_PDERSNRRI_EXT, nrow - 1, NAN);
742 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRYJ_EXT, nrow - 1, NAN);
743 cpl_table_set_float(target, MOO_TARGET_TABLE_PDERSNRYJ_EXT, nrow - 1, NAN);
744 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRH_EXT, nrow - 1, NAN);
745 cpl_table_set_float(target, MOO_TARGET_TABLE_PDERSNRH_EXT, nrow - 1, NAN);
746 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRRI_RBN, nrow - 1, NAN);
747 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRYJ_RBN, nrow - 1, NAN);
748 cpl_table_set_float(target, MOO_TARGET_TABLE_PMEDSNRH_RBN, nrow - 1, NAN);
749 return CPL_ERROR_NONE;
750}
751static moo_target_table *
752_moo_create_target_table_xswitch(moo_rbn *rbnA,
753 moo_rbn *rbnB,
754 moo_target_table_params *params)
755{
756 moo_target_table *result = NULL;
757
758 cpl_ensure(rbnA != NULL, CPL_ERROR_NULL_INPUT, NULL);
759 cpl_ensure(rbnB != NULL, CPL_ERROR_NULL_INPUT, NULL);
760 cpl_table *fibre_tableA = moo_rbn_get_fibre_table(rbnA);
761 cpl_table *fibre_tableB = moo_rbn_get_fibre_table(rbnB);
762
763 cpl_ensure(fibre_tableA, CPL_ERROR_NULL_INPUT, NULL);
764 cpl_ensure(fibre_tableB, CPL_ERROR_NULL_INPUT, NULL);
765
766 moo_fibres_table_by_index(fibre_tableA);
767 moo_fibres_table_by_index(fibre_tableB);
768
769 cpl_errorstate prestate = cpl_errorstate_get();
770 moo_try_check(result = moo_create_empty_target_table(), " ");
771 cpl_table *table = result->table;
772
773 int nrow = cpl_table_get_nrow(table);
774
775 int *hAt = cpl_table_get_data_int(fibre_tableA, MOO_FIBRES_TABLE_HEALTH);
776 int *indexrbnAt =
777 cpl_table_get_data_int(fibre_tableA, MOO_FIBRES_TABLE_INDEXRBN);
778 int *pfAt =
779 cpl_table_get_data_int(fibre_tableA, MOO_FIBRES_TABLE_PAIREDFIBRE);
780 char **typeAt =
781 cpl_table_get_data_string(fibre_tableA, MOO_FIBRES_TABLE_TYPE);
782 int frow = cpl_table_get_nrow(fibre_tableA);
783
784 int *pfBt =
785 cpl_table_get_data_int(fibre_tableB, MOO_FIBRES_TABLE_PAIREDFIBRE);
786 char **typeBt =
787 cpl_table_get_data_string(fibre_tableB, MOO_FIBRES_TABLE_TYPE);
788
789 int *fdone = cpl_calloc(sizeof(int), frow);
790
791 for (int i = 0; i < frow; i++) {
792 const char *obstype = NULL;
793 int hA = hAt[i];
794 int indexrbnA = indexrbnAt[i];
795 char *typeA = typeAt[i];
796 char *typeB = typeBt[i];
797 int pfA = pfAt[i];
798 int pfB = pfBt[i];
799
800 if (fdone[i] == 0 && hA != 0 && indexrbnA > 0) {
801 if (strcmp(typeA, MOO_FIBRES_TABLE_TYPE_SCIENCE) == 0) {
802 fdone[i] = 1;
803 if (pfA >= 0 && hAt[pfA] != 0) {
804 fdone[pfA] = 1;
805 char *ptypeA = typeAt[pfA];
806 if (strcmp(ptypeA, MOO_FIBRES_TABLE_TYPE_SKY) == 0) {
807 if (strcmp(typeB, MOO_FIBRES_TABLE_TYPE_SKY) == 0) {
808 obstype = MOO_OBSTYPE_OBSSWITCH;
809 }
810 else {
811 obstype = MOO_OBSTYPE_OBSPNODSTARE;
812 }
813 }
814 else {
815 if (strcmp(typeB, MOO_FIBRES_TABLE_TYPE_SKY) == 0) {
816 obstype = MOO_OBSTYPE_OBSNODSTARE;
817 }
818 else {
819 obstype = MOO_OBSTYPE_OBSSWITCHSTARE;
820 }
821 }
822 }
823 else {
824 if (strcmp(typeB, MOO_FIBRES_TABLE_TYPE_SKY) == 0) {
825 obstype = MOO_OBSTYPE_OBSNOD;
826 }
827 else {
828 obstype = MOO_OBSTYPE_OBSSTARE;
829 }
830 }
831 nrow++;
832 _moo_target_table_add_from_ft(table, fibre_tableA, fibre_tableB,
833 i, nrow, obstype);
834 }
835 else if (strcmp(typeB, MOO_FIBRES_TABLE_TYPE_SCIENCE) == 0) {
836 fdone[i] = 1;
837 if (pfB < 0 || hAt[pfB] == 0) {
838 if (strcmp(typeA, MOO_FIBRES_TABLE_TYPE_SKY) == 0) {
839 obstype = MOO_OBSTYPE_OBSPNOD;
840 }
841 else {
842 obstype = MOO_OBSTYPE_OBSPSTARE;
843 }
844 nrow++;
845 _moo_target_table_add_from_ft(table, fibre_tableB,
846 fibre_tableA, i, nrow,
847 obstype);
848 }
849 }
850 else if (strcmp(typeA, MOO_FIBRES_TABLE_TYPE_SKY) == 0 &&
851 strcmp(typeB, MOO_FIBRES_TABLE_TYPE_SKY) == 0 &&
852 params->nosky == 0) {
853 obstype = MOO_OBSTYPE_SKYRESNOD;
854 nrow++;
855 _moo_target_table_add_from_ft(table, fibre_tableA, fibre_tableB,
856 i, nrow, obstype);
857 }
858 else if (strcmp(typeA, MOO_FIBRES_TABLE_TYPE_SKY) == 0 &&
859 strcmp(typeB, MOO_FIBRES_TABLE_TYPE_SKYCONTAM) == 0 &&
860 params->nosky == 0) {
861 obstype = MOO_OBSTYPE_SKYRESSTARE;
862 nrow++;
863 _moo_target_table_add_from_ft(table, fibre_tableA, fibre_tableB,
864 i, nrow, obstype);
865 }
866 else if (strcmp(typeA, MOO_FIBRES_TABLE_TYPE_SKYCONTAM) == 0 &&
867 strcmp(typeB, MOO_FIBRES_TABLE_TYPE_SKY) == 0 &&
868 params->nosky == 0) {
869 obstype = MOO_OBSTYPE_SKYRESPSTARE;
870 nrow++;
871 _moo_target_table_add_from_ft(table, fibre_tableB, fibre_tableA,
872 i, nrow, obstype);
873 }
874 }
875 }
876 cpl_free(fdone);
877moo_try_cleanup:
878 if (!cpl_errorstate_is_equal(prestate)) {
879 moo_target_table_delete(result);
880 result = NULL;
881 }
882 return result;
883}
884/*----------------------------------------------------------------------------*/
899/*----------------------------------------------------------------------------*/
900moo_target_table *
901moo_create_target_table(moo_rbn *rbnA,
902 moo_rbn *rbnB,
903 moo_target_table_mode mode,
904 moo_target_table_params *params)
905{
906 cpl_ensure(rbnA != NULL, CPL_ERROR_NULL_INPUT, NULL);
907 cpl_ensure(params != NULL, CPL_ERROR_NULL_INPUT, NULL);
908 moo_target_table *result = NULL;
909
910 cpl_msg_info(__func__, "Create target table for mode %s",
911 moo_target_table_get_mode_name(mode));
912
913 if (mode == MOO_MODE_STARE) {
914 result = _moo_create_target_table_stare(rbnA, params);
915 }
916 else if (mode == MOO_MODE_XSWITCH || mode == MOO_MODE_STARENOD) {
917 result = _moo_create_target_table_xswitch(rbnA, rbnB, params);
918 }
919
920 return result;
921}
922
923
924cpl_error_code
925moo_target_table_save(moo_target_table *self, const char *filename)
926{
927 cpl_ensure_code(self != NULL, CPL_ERROR_NULL_INPUT);
928 cpl_ensure_code(filename != NULL, CPL_ERROR_NULL_INPUT);
929
930 self->filename = filename;
931 cpl_error_code status = cpl_table_save(self->table, self->primary_header,
932 NULL, filename, CPL_IO_CREATE);
933
934 return status;
935}
936
937/*----------------------------------------------------------------------------*/
946/*----------------------------------------------------------------------------*/
947
948void
949moo_target_table_delete(moo_target_table *self)
950{
951 if (self != NULL) {
952 if (self->table != NULL) {
953 cpl_table_delete(self->table);
954 }
955 if (self->primary_header != NULL) {
956 cpl_propertylist_delete(self->primary_header);
957 }
958 cpl_free(self);
959 }
960}
961
962/*----------------------------------------------------------------------------*/
970/*----------------------------------------------------------------------------*/
971
972cpl_array *
973moo_target_table_select_sky_index(moo_target_table *self, moo_rbn *sky_rbn)
974{
975 cpl_ensure(self != NULL, CPL_ERROR_NULL_INPUT, NULL);
976
977 cpl_table *table = self->table;
978 cpl_propertylist *order = cpl_propertylist_new();
979 cpl_propertylist_append_bool(order, MOO_TARGET_TABLE_INDEXRBN, CPL_FALSE);
980 cpl_table_sort(table, order);
981 cpl_propertylist_delete(order);
982
983 if (sky_rbn == NULL) {
984 cpl_table_unselect_all(table);
985 cpl_table_or_selected_string(table, MOO_TARGET_TABLE_OBSTYPE,
986 CPL_EQUAL_TO, MOO_OBSTYPE_SKYSTARE);
987 }
988 else {
989 if (cpl_table_has_column(table, MOO_TARGET_TABLE_TYPENOD)) {
990 cpl_table_select_all(table);
991 cpl_table_and_selected_string(table, MOO_TARGET_TABLE_TYPENOD,
992 CPL_NOT_EQUAL_TO,
993 MOO_FIBRES_TABLE_TYPE_SKYCONTAM);
994 }
995 else {
996 table = moo_rbn_get_fibre_table(sky_rbn);
997 moo_fibres_table_by_indexrbn(table);
998 cpl_table_unselect_all(table);
999 cpl_table_or_selected_string(table, MOO_FIBRES_TABLE_TYPE,
1000 CPL_EQUAL_TO,
1001 MOO_FIBRES_TABLE_TYPE_SKY);
1002 cpl_table_and_selected_string(table, MOO_FIBRES_TABLE_TYPE,
1003 CPL_NOT_EQUAL_TO,
1004 MOO_FIBRES_TABLE_TYPE_SKYCONTAM);
1005 cpl_table_and_selected_int(table, MOO_FIBRES_TABLE_HEALTH,
1006 CPL_GREATER_THAN, 0);
1007 cpl_table_and_selected_int(table, MOO_FIBRES_TABLE_INDEXRBN,
1008 CPL_GREATER_THAN, 0);
1009 }
1010 }
1011
1012 cpl_array *res = cpl_table_where_selected(table);
1013
1014 return res;
1015}
1016
1017/*----------------------------------------------------------------------------*/
1024/*----------------------------------------------------------------------------*/
1025
1026cpl_error_code
1027moo_target_table_select_stare(moo_target_table *self)
1028{
1029 cpl_ensure_code(self != NULL, CPL_ERROR_NULL_INPUT);
1030 cpl_ensure_code(self->table != NULL, CPL_ERROR_NULL_INPUT);
1031
1032 cpl_table_unselect_all(self->table);
1033 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1034 CPL_EQUAL_TO, MOO_OBSTYPE_OBSSTARE);
1035 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1036 CPL_EQUAL_TO, MOO_OBSTYPE_SKYSTARE);
1037 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1038 CPL_EQUAL_TO, MOO_OBSTYPE_SKYRESSTARE);
1039 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1040 CPL_EQUAL_TO, MOO_OBSTYPE_OBSPNODSTARE);
1041 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1042 CPL_EQUAL_TO, MOO_OBSTYPE_OBSSWITCHSTARE);
1043 return CPL_ERROR_NONE;
1044}
1045
1046/*----------------------------------------------------------------------------*/
1053/*----------------------------------------------------------------------------*/
1054
1055cpl_error_code
1056moo_target_table_select_pstare(moo_target_table *self)
1057{
1058 cpl_ensure_code(self != NULL, CPL_ERROR_NULL_INPUT);
1059 cpl_ensure_code(self->table != NULL, CPL_ERROR_NULL_INPUT);
1060
1061 cpl_table_unselect_all(self->table);
1062 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1063 CPL_EQUAL_TO, MOO_OBSTYPE_OBSPSTARE);
1064 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1065 CPL_EQUAL_TO, MOO_OBSTYPE_SKYRESPSTARE);
1066 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1067 CPL_EQUAL_TO, MOO_OBSTYPE_OBSNODSTARE);
1068 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1069 CPL_EQUAL_TO, MOO_OBSTYPE_OBSSWITCHSTARE);
1070 return CPL_ERROR_NONE;
1071}
1072
1073/*----------------------------------------------------------------------------*/
1080/*----------------------------------------------------------------------------*/
1081
1082cpl_error_code
1083moo_target_table_select_nod(moo_target_table *self)
1084{
1085 cpl_ensure_code(self != NULL, CPL_ERROR_NULL_INPUT);
1086 cpl_ensure_code(self->table != NULL, CPL_ERROR_NULL_INPUT);
1087
1088 cpl_table_unselect_all(self->table);
1089 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1090 CPL_EQUAL_TO, MOO_OBSTYPE_OBSNOD);
1091 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1092 CPL_EQUAL_TO, MOO_OBSTYPE_OBSSWITCH);
1093 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1094 CPL_EQUAL_TO, MOO_OBSTYPE_SKYRESNOD);
1095 return CPL_ERROR_NONE;
1096}
1097
1098/*----------------------------------------------------------------------------*/
1105/*----------------------------------------------------------------------------*/
1106
1107cpl_error_code
1108moo_target_table_select_pnod(moo_target_table *self)
1109{
1110 cpl_ensure_code(self != NULL, CPL_ERROR_NULL_INPUT);
1111 cpl_ensure_code(self->table != NULL, CPL_ERROR_NULL_INPUT);
1112
1113 cpl_table_unselect_all(self->table);
1114 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1115 CPL_EQUAL_TO, MOO_OBSTYPE_OBSPNOD);
1116 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1117 CPL_EQUAL_TO, MOO_OBSTYPE_OBSSWITCH);
1118 return CPL_ERROR_NONE;
1119}
1120
1121/*----------------------------------------------------------------------------*/
1128/*----------------------------------------------------------------------------*/
1129
1130int
1131moo_target_table_xswitch_paired(moo_target_table *self)
1132{
1133 cpl_error_code status = CPL_ERROR_NONE;
1134 cpl_ensure_code(self != NULL, CPL_ERROR_NULL_INPUT);
1135
1136 const char *transname[] = { MOO_TARGET_TABLE_TRANSRI,
1137 MOO_TARGET_TABLE_TRANSYJ,
1138 MOO_TARGET_TABLE_TRANSH };
1139 const char *ptransname[] = { MOO_TARGET_TABLE_PTRANSRI,
1140 MOO_TARGET_TABLE_PTRANSYJ,
1141 MOO_TARGET_TABLE_PTRANSH };
1142
1143 cpl_table *table = self->table;
1144 int nrow = cpl_table_get_nrow(table);
1145 for (int i = 0; i < nrow; i++) {
1146 int indexrbn =
1147 cpl_table_get_int(table, MOO_TARGET_TABLE_INDEXRBN, i, NULL);
1148 int pindexrbn =
1149 cpl_table_get_int(table, MOO_TARGET_TABLE_PAIREDINDEXRBN, i, NULL);
1150 int index = cpl_table_get_int(table, MOO_TARGET_TABLE_INDEX, i, NULL);
1151 int pindex =
1152 cpl_table_get_int(table, MOO_TARGET_TABLE_PAIREDFIBRE, i, NULL);
1153
1154 if (pindex != -1) {
1155 cpl_table_set_int(table, MOO_TARGET_TABLE_INDEX, i, pindex);
1156 cpl_table_set_int(table, MOO_TARGET_TABLE_PAIREDFIBRE, i, index);
1157 }
1158 if (pindexrbn != -1) {
1159 cpl_table_set_int(table, MOO_TARGET_TABLE_INDEXRBN, i, pindexrbn);
1160 cpl_table_set_int(table, MOO_TARGET_TABLE_PAIREDINDEXRBN, i,
1161 indexrbn);
1162 }
1163 for (int j = 0; j < 3; j++) {
1164 float trans = cpl_table_get_float(table, transname[j], i, NULL);
1165 float ptrans = cpl_table_get_float(table, ptransname[j], i, NULL);
1166 cpl_table_set_float(table, transname[j], i, ptrans);
1167 cpl_table_set_float(table, ptransname[j], i, trans);
1168 }
1169 }
1170
1171 return status;
1172}
1173/*----------------------------------------------------------------------------*/
1181/*----------------------------------------------------------------------------*/
1182
1183cpl_array *
1184moo_target_table_select_obj_index(moo_target_table *self, int ispaired)
1185{
1186 cpl_ensure(self != NULL, CPL_ERROR_NULL_INPUT, NULL);
1187 cpl_propertylist *order = cpl_propertylist_new();
1188 cpl_propertylist_append_bool(order, MOO_TARGET_TABLE_INDEXRBN, CPL_FALSE);
1189 cpl_table_sort(self->table, order);
1190 cpl_propertylist_delete(order);
1191
1192 cpl_table_unselect_all(self->table);
1193 if (ispaired) {
1194 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1195 CPL_EQUAL_TO, MOO_OBSTYPE_OBSSWITCHSTARE);
1196 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1197 CPL_EQUAL_TO, MOO_OBSTYPE_OBSNODSTARE);
1198 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1199 CPL_EQUAL_TO, MOO_OBSTYPE_SKYRESPSTARE);
1200 }
1201 else {
1202 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1203 CPL_EQUAL_TO, MOO_OBSTYPE_OBSSTARE);
1204 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1205 CPL_EQUAL_TO, MOO_OBSTYPE_SKYSTARE);
1206 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1207 CPL_EQUAL_TO, MOO_OBSTYPE_SKYRESSTARE);
1208 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1209 CPL_EQUAL_TO, MOO_OBSTYPE_OBSSWITCHSTARE);
1210 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1211 CPL_EQUAL_TO, MOO_OBSTYPE_OBSPNODSTARE);
1212 cpl_table_or_selected_string(self->table, MOO_TARGET_TABLE_OBSTYPE,
1213 CPL_EQUAL_TO, MOO_OBSTYPE_OBSPSTARE);
1214 }
1215
1216 cpl_array *res = cpl_table_where_selected(self->table);
1217
1218 return res;
1219}
1220
1221/*----------------------------------------------------------------------------*/
1232/*----------------------------------------------------------------------------*/
1233moo_target_table *
1234moo_target_table_load(const cpl_frame *frame)
1235{
1236 cpl_ensure(frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
1237 const char *filename = cpl_frame_get_filename(frame);
1238 cpl_ensure(filename != NULL, CPL_ERROR_NULL_INPUT, NULL);
1239
1240 cpl_errorstate prev_state = cpl_errorstate_get();
1241 moo_target_table *res = moo_target_table_new();
1242
1243 res->filename = filename;
1244 res->table = cpl_table_load(filename, 1, 0);
1245 res->primary_header = cpl_propertylist_load(filename, 0);
1246
1247 if (!cpl_errorstate_is_equal(prev_state)) {
1248 cpl_msg_error("moo_target_table", "can't load TARGET_TABLE %s",
1249 filename);
1250 moo_target_table_delete(res);
1251 res = NULL;
1252 cpl_errorstate_set(prev_state);
1253 }
1254 return res;
1255}
1256
1257static void
1258_moo_merge_row(cpl_table *a, cpl_size rowa, cpl_table *b, cpl_size rowb)
1259{
1260 int indexspecA =
1261 cpl_table_get_int(a, MOO_TARGET_TABLE_INDEXRBN, rowa, NULL);
1262 int indexspecB =
1263 cpl_table_get_int(b, MOO_TARGET_TABLE_INDEXRBN, rowb, NULL);
1264
1265 if (indexspecA != indexspecB) {
1266 cpl_table_set_invalid(a, MOO_TARGET_TABLE_INDEXRBN, rowa);
1267 cpl_table_set_int(a, MOO_TARGET_TABLE_INDEXRBN, rowa, 0);
1268 }
1269
1270 int pindexspecA =
1271 cpl_table_get_int(a, MOO_TARGET_TABLE_PAIREDINDEXRBN, rowa, NULL);
1272 int pindexspecB =
1273 cpl_table_get_int(b, MOO_TARGET_TABLE_PAIREDINDEXRBN, rowb, NULL);
1274
1275 if (pindexspecA != pindexspecB) {
1276 cpl_table_set_invalid(a, MOO_TARGET_TABLE_PAIREDINDEXRBN, rowa);
1277 cpl_table_set_int(a, MOO_TARGET_TABLE_PAIREDINDEXRBN, rowa, 0);
1278 }
1279}
1280
1281/*----------------------------------------------------------------------------*/
1292/*----------------------------------------------------------------------------*/
1293cpl_error_code
1294moo_target_table_merge(moo_target_table *self, moo_target_table *tomerge)
1295{
1296 cpl_ensure_code(self != NULL, CPL_ERROR_NULL_INPUT);
1297 cpl_ensure_code(tomerge != NULL, CPL_ERROR_NULL_INPUT);
1298
1299 cpl_table *res_table = self->table;
1300
1301 cpl_table *mtable = tomerge->table;
1302 const char **mtargnames =
1303 cpl_table_get_data_string_const(mtable, MOO_TARGET_TABLE_TARGNAME);
1304
1305 int nrow = cpl_table_get_nrow(mtable);
1306
1307
1308 for (int j = 0; j < nrow; j++) {
1309 const char *mtargname = mtargnames[j];
1310
1311 cpl_table_unselect_all(res_table);
1312 int nb = moo_table_or_selected_sequal_string(res_table,
1313 MOO_TARGET_TABLE_TARGNAME,
1314 mtargname);
1315 if (nb == 0) {
1316 /* add it */
1317 int rrow = cpl_table_get_nrow(res_table);
1318 cpl_table_unselect_all(mtable);
1319 cpl_table_or_selected_window(mtable, j, 1);
1320 cpl_table *sel = cpl_table_extract_selected(mtable);
1321 cpl_table_set_int(sel, MOO_TARGET_TABLE_INDEXTARG, 0, rrow + 1);
1322 cpl_table_insert(res_table, sel, rrow);
1323 cpl_table_delete(sel);
1324 }
1325 else if (nb == 1) {
1326 /* merge it */
1327 cpl_array *indexes = cpl_table_where_selected(res_table);
1328 int idx = cpl_array_get_cplsize(indexes, 0, NULL);
1329 _moo_merge_row(res_table, idx, mtable, j);
1330 cpl_array_delete(indexes);
1331 }
1332 else {
1333 cpl_error_set_message(
1334 "moo_target_table", CPL_ERROR_ILLEGAL_INPUT,
1335 "Error in merging %s : multiple objects (%d) found", mtargname,
1336 nb);
1337 return CPL_ERROR_ILLEGAL_INPUT;
1338 }
1339 }
1340 return CPL_ERROR_NONE;
1341}
1342
1343/*----------------------------------------------------------------------------*/
1355/*----------------------------------------------------------------------------*/
1356int
1357moo_target_table_find_target(moo_target_table *self, const char *targname)
1358{
1359 int index = -1;
1360 cpl_ensure(self != NULL, CPL_ERROR_NULL_INPUT, index);
1361 cpl_ensure(targname != NULL, CPL_ERROR_NULL_INPUT, index);
1362 cpl_ensure(self->table != NULL, CPL_ERROR_ILLEGAL_INPUT, index);
1363
1364 cpl_table_unselect_all(self->table);
1365 int nb = moo_table_or_selected_sequal_string(self->table,
1366 MOO_TARGET_TABLE_TARGNAME,
1367 targname);
1368
1369 const int *indextarg =
1370 cpl_table_get_data_int_const(self->table, MOO_TARGET_TABLE_INDEXTARG);
1371
1372 if (nb == 1) {
1373 cpl_array *indexes = cpl_table_where_selected(self->table);
1374 int idx = cpl_array_get_cplsize(indexes, 0, NULL);
1375 index = indextarg[idx];
1376 cpl_array_delete(indexes);
1377 }
1378 return index;
1379}
1380
1381
1382/*----------------------------------------------------------------------------*/
1388/*----------------------------------------------------------------------------*/
1389cpl_error_code
1390moo_target_table_remove_coadd_cols(moo_target_table *self)
1391{
1392 cpl_ensure_code(self != NULL, CPL_ERROR_NULL_INPUT);
1393 cpl_table *table = self->table;
1394 if (table != NULL) {
1395 cpl_errorstate prev_state = cpl_errorstate_get();
1396 cpl_table_erase_column(table, MOO_TARGET_TABLE_OBSTYPE);
1397 cpl_table_erase_column(table, MOO_TARGET_TABLE_MEDSNRRI_EXT);
1398 cpl_table_erase_column(table, MOO_TARGET_TABLE_MEDSNRYJ_EXT);
1399 cpl_table_erase_column(table, MOO_TARGET_TABLE_MEDSNRH_EXT);
1400
1401 cpl_table_erase_column(table, MOO_TARGET_TABLE_DERSNRRI_EXT);
1402 cpl_table_erase_column(table, MOO_TARGET_TABLE_DERSNRYJ_EXT);
1403 cpl_table_erase_column(table, MOO_TARGET_TABLE_DERSNRH_EXT);
1404 cpl_table_erase_column(table, MOO_TARGET_TABLE_MEDSNRRI_RBN);
1405 cpl_table_erase_column(table, MOO_TARGET_TABLE_MEDSNRYJ_RBN);
1406 cpl_table_erase_column(table, MOO_TARGET_TABLE_MEDSNRH_RBN);
1407 cpl_table_erase_column(table, MOO_TARGET_TABLE_PMEDSNRRI_EXT);
1408 cpl_table_erase_column(table, MOO_TARGET_TABLE_PMEDSNRYJ_EXT);
1409 cpl_table_erase_column(table, MOO_TARGET_TABLE_PMEDSNRH_EXT);
1410 cpl_table_erase_column(table, MOO_TARGET_TABLE_PDERSNRRI_EXT);
1411 cpl_table_erase_column(table, MOO_TARGET_TABLE_PDERSNRYJ_EXT);
1412 cpl_table_erase_column(table, MOO_TARGET_TABLE_PDERSNRH_EXT);
1413
1414 cpl_table_erase_column(table, MOO_TARGET_TABLE_PMEDSNRRI_RBN);
1415 cpl_table_erase_column(table, MOO_TARGET_TABLE_PMEDSNRYJ_RBN);
1416 cpl_table_erase_column(table, MOO_TARGET_TABLE_PMEDSNRH_RBN);
1417
1418 cpl_errorstate_set(prev_state);
1419 int nrow = cpl_table_get_nrow(table);
1420 for (int i = 0; i < nrow; i++) {
1421 cpl_table_set(table, MOO_TARGET_TABLE_MEDSNRRI_SCI, i, NAN);
1422 cpl_table_set(table, MOO_TARGET_TABLE_MEDSNRYJ_SCI, i, NAN);
1423 cpl_table_set(table, MOO_TARGET_TABLE_MEDSNRH_SCI, i, NAN);
1424 }
1425 }
1426 return CPL_ERROR_NONE;
1427}
1428
1429/*----------------------------------------------------------------------------*/
1441/*----------------------------------------------------------------------------*/
1442int
1443moo_target_table_find_index(moo_target_table *self, const char *targname)
1444{
1445 int index = -1;
1446 cpl_ensure(self != NULL, CPL_ERROR_NULL_INPUT, index);
1447 cpl_ensure(targname != NULL, CPL_ERROR_NULL_INPUT, index);
1448 cpl_ensure(self->table != NULL, CPL_ERROR_ILLEGAL_INPUT, index);
1449
1450 cpl_table_unselect_all(self->table);
1451 int nb = moo_table_or_selected_sequal_string(self->table,
1452 MOO_TARGET_TABLE_TARGNAME,
1453 targname);
1454
1455
1456 if (nb == 1) {
1457 cpl_array *indexes = cpl_table_where_selected(self->table);
1458 int idx = cpl_array_get_cplsize(indexes, 0, NULL);
1459 index = idx;
1460 cpl_array_delete(indexes);
1461 }
1462 return index;
1463}
1464
1465const char *
1466moo_target_table_get_std_name(moo_target_table *self)
1467{
1468 cpl_ensure(self != NULL, CPL_ERROR_NULL_INPUT, NULL);
1469
1470 return moo_fibres_table_get_std_name(self->table);
1471}
1472
1473cpl_error_code
1474moo_target_table_set_exptimes(moo_target_table *self,
1475 double *exptimeA,
1476 double *exptimeB)
1477{
1478 cpl_ensure_code(self != NULL, CPL_ERROR_NULL_INPUT);
1479 cpl_ensure_code(exptimeA != NULL, CPL_ERROR_NULL_INPUT);
1480 cpl_ensure_code(exptimeB != NULL, CPL_ERROR_NULL_INPUT);
1481
1482 int nrow = cpl_table_get_nrow(self->table);
1483 char **obstypet =
1484 cpl_table_get_data_string(self->table, MOO_TARGET_TABLE_OBSTYPE);
1485
1486 for (int i = 0; i < nrow; i++) {
1487 const char *obstype = obstypet[i];
1488 for (int j = 0; j < 3; j++) {
1489 double exptime = exptimeA[j];
1490
1491 if (strcmp(obstype, MOO_OBSTYPE_OBSSWITCH) == 0) {
1492 exptime += exptimeB[j];
1493 }
1494 moo_target_table_set_exptime(self, i, j, exptime);
1495 }
1496 }
1497 return CPL_ERROR_NONE;
1498}
1499
1500cpl_error_code
1501moo_target_table_set_exptime(moo_target_table *self,
1502 int i,
1503 int j,
1504 double exptime)
1505{
1506 cpl_ensure_code(self != NULL, CPL_ERROR_NULL_INPUT);
1507
1508 const char *exptimecols[] = { MOO_TARGET_TABLE_EXPTIMERI,
1509 MOO_TARGET_TABLE_EXPTIMEYJ,
1510 MOO_TARGET_TABLE_EXPTIMEH };
1511
1512 cpl_table_set_double(self->table, exptimecols[j], i, exptime);
1513
1514 return CPL_ERROR_NONE;
1515}
1516
1517/*----------------------------------------------------------------------------*/
1525/*----------------------------------------------------------------------------*/
1526
1527double
1528moo_target_table_get_exptime(moo_target_table *self, int i, int j)
1529{
1530 double res = 0.0;
1531
1532 const char *exptimecols[] = { MOO_TARGET_TABLE_EXPTIMERI,
1533 MOO_TARGET_TABLE_EXPTIMEYJ,
1534 MOO_TARGET_TABLE_EXPTIMEH };
1535
1536 res = cpl_table_get_double(self->table, exptimecols[j], i, NULL);
1537
1538 return res;
1539}
1540
1541int
1542moo_is_obstype_stare(const char *obstype)
1543{
1544 return (strcmp(obstype, MOO_OBSTYPE_SKYSTARE) == 0 ||
1545 strcmp(obstype, MOO_OBSTYPE_OBSSTARE) == 0 ||
1546 strcmp(obstype, MOO_OBSTYPE_OBSPSTARE) == 0 ||
1547 strcmp(obstype, MOO_OBSTYPE_OBSNODSTARE) == 0 ||
1548 strcmp(obstype, MOO_OBSTYPE_OBSPNODSTARE) == 0 ||
1549 strcmp(obstype, MOO_OBSTYPE_OBSSWITCHSTARE) == 0 ||
1550 strcmp(obstype, MOO_OBSTYPE_SKYRESSTARE) == 0 ||
1551 strcmp(obstype, MOO_OBSTYPE_SKYRESPSTARE) == 0);
1552}
1553
moo_fibres_table_by_index
cpl_error_code moo_fibres_table_by_index(cpl_table *table)
Order fibres table by INDEX (ASC)
Definition: moo_fibres_table.c:1006
moo_fibres_table_get_std_name
const char * moo_fibres_table_get_std_name(cpl_table *table)
get the object name of the STD type in the fibre table
Definition: moo_fibres_table.c:902
moo_fibres_table_by_indexrbn
cpl_error_code moo_fibres_table_by_indexrbn(cpl_table *table)
Order fibres table by INDEXRBN (ASC)
Definition: moo_fibres_table.c:985
moo_rbn_get_fibre_table
cpl_table * moo_rbn_get_fibre_table(moo_rbn *self)
Get the FIBRE TABLE in RBN.
Definition: moo_rbn.c:397
moo_target_table_select_sky_index
cpl_array * moo_target_table_select_sky_index(moo_target_table *self, moo_rbn *sky_rbn)
get the index of the sky in the target table sort by indexspec
Definition: moo_target_table.c:973
moo_target_table_select_pstare
cpl_error_code moo_target_table_select_pstare(moo_target_table *self)
select PSTARE object in trget table
Definition: moo_target_table.c:1056
moo_target_table_delete
void moo_target_table_delete(moo_target_table *self)
Delete a moo_target_table.
Definition: moo_target_table.c:949
moo_target_table_get_exptime
double moo_target_table_get_exptime(moo_target_table *self, int i, int j)
rget the exptime of a target
Definition: moo_target_table.c:1528
moo_target_table_load
moo_target_table * moo_target_table_load(const cpl_frame *frame)
Load a TARGET_TABLE frame and create a moo_target_table.
Definition: moo_target_table.c:1234
moo_target_table_new
moo_target_table * moo_target_table_new(void)
Create a new moo_target_table.
Definition: moo_target_table.c:76
moo_target_table_duplicate
moo_target_table * moo_target_table_duplicate(moo_target_table *self)
Duplicate an existing target_table.
Definition: moo_target_table.c:93
moo_target_table_mode
enum _moo_target_table_mode_ moo_target_table_mode
The type code type.
Definition: moo_target_table.h:156
moo_target_table_merge
cpl_error_code moo_target_table_merge(moo_target_table *self, moo_target_table *tomerge)
Merge two TARGET_TABLE.
Definition: moo_target_table.c:1294
moo_target_table_select_stare
cpl_error_code moo_target_table_select_stare(moo_target_table *self)
select STARE object in trget table
Definition: moo_target_table.c:1027
moo_target_table_find_index
int moo_target_table_find_index(moo_target_table *self, const char *targname)
find target indexspec in TARGET_TABLE
Definition: moo_target_table.c:1443
moo_target_table_find_target
int moo_target_table_find_target(moo_target_table *self, const char *targname)
find target targindex in TARGET_TABLE
Definition: moo_target_table.c:1357
moo_create_target_table
moo_target_table * moo_create_target_table(moo_rbn *rbnA, moo_rbn *rbnB, moo_target_table_mode mode, moo_target_table_params *params)
Prepare target table for SCI frames using their attached fibre.
Definition: moo_target_table.c:901
moo_target_table_select_nod
cpl_error_code moo_target_table_select_nod(moo_target_table *self)
select STARE object in trget table
Definition: moo_target_table.c:1083
moo_target_table_select_pnod
cpl_error_code moo_target_table_select_pnod(moo_target_table *self)
select STARE object in trget table
Definition: moo_target_table.c:1108
moo_target_table_xswitch_paired
int moo_target_table_xswitch_paired(moo_target_table *self)
get the index of the object in the target table sort by indexrbn
Definition: moo_target_table.c:1131
moo_target_table_select_obj_index
cpl_array * moo_target_table_select_obj_index(moo_target_table *self, int ispaired)
get the index of the object in the target table sort by indexrbn
Definition: moo_target_table.c:1184
moo_target_table_mode_get_name
const char * moo_target_table_mode_get_name(moo_target_table_mode m)
Get the name of target mode.
Definition: moo_target_table.c:60
moo_target_table_remove_coadd_cols
cpl_error_code moo_target_table_remove_coadd_cols(moo_target_table *self)
remove columns for coadd in target_table
Definition: moo_target_table.c:1390
moo_table_or_selected_sequal_string
cpl_size moo_table_or_selected_sequal_string(cpl_table *table, const char *name, const char *string)
Select from unselected table rows, by comparing column values with a constant.
Definition: moo_utils.c:2285
moo_target_table
the different type of detectors
Definition: moo_target_table.h:124
Generated on Wed Oct 8 2025 20:38:53 for MOONS Pipeline Reference Manual by doxygen 1.9.6