MOONS Pipeline Reference Manual 0.13.2
moons_science_xswitch2.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
28#include "moo_utils.h"
29#include "moo_pfits.h"
30#include "moo_dfs.h"
31#include "moo_params.h"
32#include "moo_drl.h"
33#include "moo_badpix.h"
34#include "moo_extlist.h"
35#include "moo_rbnlist.h"
36#include "moo_correct_tell.h"
37#include "moo_subtract_nod.h"
38#include "moo_combine_sky.h"
39#include "moo_combine_pair.h"
40#include "moo_products.h"
41#include <cpl.h>
42
43#include <string.h>
44
45/*-----------------------------------------------------------------------------
46 Plugin registration
47 -----------------------------------------------------------------------------*/
48
49int cpl_plugin_get_info(cpl_pluginlist *list);
50
51/*-----------------------------------------------------------------------------
52 Private function prototypes
53 -----------------------------------------------------------------------------*/
54
55static int _moons_science_xswitch2_create(cpl_plugin *plugin);
56static int _moons_science_xswitch2_exec(cpl_plugin *plugin);
57static int _moons_science_xswitch2_destroy(cpl_plugin *plugin);
58static int _moons_science_xswitch2(cpl_frameset *frameset,
59 const cpl_parameterlist *parlist);
60
61/*-----------------------------------------------------------------------------
62 Static variables
63 -----------------------------------------------------------------------------*/
64static const char *const _moons_science_xswitch2_description =
65 "From an observation sequence in XSwitch mode, this recipe removes "
66 "the instrumental signature and provides calibrated science products. "
67 "During the sequence, the telescope nods from one position on the sky "
68 "(labeled as A in Fig. 5-11) to another (B). In the sequence, different "
69 "slit"
70 " offset positions can be used: as represented in Fig. 5-11, the "
71 "combination "
72 "is done with 1D wavelength calibrated sky subtracted spectra. Using "
73 "different"
74 " slit offset positions implies that different sets of calibration "
75 "(FF, wave maps) are given as inputs.\n"
76 "INPUT FRAMES\n"
77 " * science exposure frames n>=1 file(s) (RAW) with tag "
78 "OBJECT_XSWITCH : "
79 "science frame in xswitch mode file\n"
80 " * [OPTIONAL] ReferenceBadPixMask 1 file (QUA) with tag "
81 "BP_MAP_RP : "
82 "cosmetic bad pixel map\n"
83 " * [OPTIONAL] NonLinearityBadPixMask 1 file (QUA) with tag "
84 "BP_MAP_NL : "
85 "cosmetic bad pixel map coming from linearity recipe\n"
86 " * MasterBias 1 file (DET) with tag "
87 "MASTER_BIAS : "
88 "master bias file\n"
89 " * MasterDarkNir 1 file (DET) with tag "
90 "MASTER_DARK_NIR : "
91 "master dark nir for object\n"
92 " * [OPTIONAL] MasterDarkNir 1 file (DET) with tag "
93 "MASTER_DARK_NIR : "
94 "master dark nir file for sky (if exposure time is different from object)\n"
95 " * [OPTIONAL] MasterDarkVis 1 file (DET) with tag "
96 "MASTER_DARK_VIS : "
97 "master dark vis file\n"
98 " * [OPTIONAL] CoeffsCube 1 or 2 file(s) one by offset (3D) with tag "
99 "LINEARITY_COEFF_CUBE : "
100 "coefficients to correct pixels detector linearity\n"
101 " * [OPTIONAL] P2pMap 1 file (DET) with tag "
102 "P2P_MAP : "
103 "pixel to pixel map\n"
104 " * Fftrace 1 or 2 file(s) one by offset (LOC) with tag "
105 "FF_TRACE :"
106 "the localisation table\n"
107 " * [OPTIONAL] MasterFlat 1 or 2 file(s) one by offset (PSF) with tag "
108 "MASTER_FLAT : "
109 "the master flat used for optimal extraction\n"
110 " * Ffext 1 or 2 file(s) one by offset (EXT) with tag "
111 "FF_EXTSPECTRA : "
112 "the extracted flat field\n"
113 " * F2f [OPTIONAL] 1 or 2 file(s) one by offset (F2F) with tag "
114 "F2F_TABLE :"
115 "the fibre-to-fibre relative response\n"
116 " * SFormat 1 file (FMT) with tag "
117 "SPECTRAL_FORMAT : "
118 "the spectral format table\n"
119 " * WaveMap 1 or 2 file(s) one by offset (WMAP) with tag "
120 "WAVE_MAP : "
121 "the wavelength map\n"
122 " * SkyLines 1 file (CAT) with tag "
123 "SKY_LINE_LIST : "
124 "the sky lines list table\n"
125 " * [OPTIONAL] response 1 file (RESPONSE) with "
126 "tag RESPONSE : "
127 "the response spectra in the extracted pixel space\n"
128 " * [OPTIONAL] atmosExt 1 file (ATMO) with tag "
129 "ATMOS_EXT : "
130 "the atmospheric extinction table\n"
131 "PRODUCTS\n"
132 " * SCIENCE_XSWITCHRBNSPECTRA_OFFSET[offset]_[insmode]_i.fits (RBN) with "
133 "tag "
134 "xswitch_RBNSPECTRA : "
135 "Science product individual calibrated frames\n"
136 " * SCIENCE_XSWITCHSKSSPECTRA_OFFSET[offset]_[insmode]_i.fits (SCI) with "
137 "tag "
138 "xswitch_SKSSPECTRA : "
139 "Science product individual sky subtracted frames\n"
140 " * SCIENCE_XSWITCHSKSSPECTRA_[insmode].fits (SCI) with "
141 "tag "
142 "xswitch_SKSSPECTRA : "
143 "Science product coadd calibrated frame\n"
144 " * [OPTIONAL] SCIENCE_XSWITCHFLXSPECTRA_[insmode].fits (SCI) with "
145 "tag "
146 "xswitch_FLXSPECTRA : "
147 "Science product flux calibrated frame\n"
148 "\n";
149
150/*-----------------------------------------------------------------------------
151 Function code
152 -----------------------------------------------------------------------------*/
153
154/*----------------------------------------------------------------------------*/
164/*----------------------------------------------------------------------------*/
165
166int
167cpl_plugin_get_info(cpl_pluginlist *list)
168{
169 cpl_recipe *recipe = cpl_calloc(1, sizeof *recipe);
170 cpl_plugin *plugin = &recipe->interface;
171
172 if (cpl_plugin_init(plugin, CPL_PLUGIN_API, MOONS_BINARY_VERSION,
173 CPL_PLUGIN_TYPE_RECIPE, "moons_science_xswitch2",
174 "Reduces science exposure in xswitch mode",
175 _moons_science_xswitch2_description, "Regis Haigron",
176 PACKAGE_BUGREPORT, moo_get_license(),
177 _moons_science_xswitch2_create,
178 _moons_science_xswitch2_exec,
179 _moons_science_xswitch2_destroy)) {
180 cpl_msg_error(cpl_func, "Plugin initialization failed");
181 (void)cpl_error_set_where(cpl_func);
182 return 1;
183 }
184
185 if (cpl_pluginlist_append(list, plugin)) {
186 cpl_msg_error(cpl_func, "Error adding plugin to list");
187 (void)cpl_error_set_where(cpl_func);
188 return 1;
189 }
190
191 return 0;
192}
193
194/*----------------------------------------------------------------------------*/
202/*----------------------------------------------------------------------------*/
203
204static int
205_moons_science_xswitch2_create(cpl_plugin *plugin)
206{
207 cpl_recipe *recipe;
208
209 /* Do not create the recipe if an error code is already set */
210 if (cpl_error_get_code() != CPL_ERROR_NONE) {
211 cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
212 cpl_func, __LINE__, cpl_error_get_where());
213 return (int)cpl_error_get_code();
214 }
215
216 if (plugin == NULL) {
217 cpl_msg_error(cpl_func, "Null plugin");
218 cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
219 }
220
221 /* Verify plugin type */
222 if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
223 cpl_msg_error(cpl_func, "Plugin is not a recipe");
224 cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
225 }
226
227 /* Get the recipe */
228 recipe = (cpl_recipe *)plugin;
229
230 /* Create the parameters list in the cpl_recipe object */
231 recipe->parameters = cpl_parameterlist_new();
232 if (recipe->parameters == NULL) {
233 cpl_msg_error(cpl_func, "Parameter list allocation failed");
234 cpl_ensure_code(0, (int)CPL_ERROR_ILLEGAL_OUTPUT);
235 }
236
237 moo_params *params = moo_params_new("moons", "moons_science_xswitch2");
238
239 /* Fill the parameters list */
240 moo_params_add_keep_temp(params, recipe->parameters);
241 moo_params_add_prepare(params, recipe->parameters);
242 moo_params_add_correct_bias(params, recipe->parameters,
243 MOO_CORRECT_BIAS_METHOD_MASTER);
244 moo_params_add_extract(params, recipe->parameters);
245 moo_params_add_science_wavesol(params, recipe->parameters);
246 moo_params_add_rebin(params, recipe->parameters);
247 moo_params_add_target_table(params, recipe->parameters, CPL_FALSE);
248 moo_params_add_combine_pair(params, recipe->parameters, CPL_TRUE);
249 moo_params_add_sub_sky_stare(params, recipe->parameters);
250 moo_params_add_coadd(params, recipe->parameters);
251 moo_params_add_create_s1d(params, recipe->parameters);
252 moo_params_delete(params);
253
254 return 0;
255}
256
257/*----------------------------------------------------------------------------*/
263/*----------------------------------------------------------------------------*/
264
265static int
266_moons_science_xswitch2_exec(cpl_plugin *plugin)
267{
268 cpl_recipe *recipe;
269 int recipe_status;
270 cpl_errorstate initial_errorstate = cpl_errorstate_get();
271
272 /* Return immediately if an error code is already set */
273 if (cpl_error_get_code() != CPL_ERROR_NONE) {
274 cpl_msg_error(cpl_func, "%s():%d: An error is already set: %s",
275 cpl_func, __LINE__, cpl_error_get_where());
276 return (int)cpl_error_get_code();
277 }
278
279 if (plugin == NULL) {
280 cpl_msg_error(cpl_func, "Null plugin");
281 cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
282 }
283
284 /* Verify plugin type */
285 if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
286 cpl_msg_error(cpl_func, "Plugin is not a recipe");
287 cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
288 }
289
290 /* Get the recipe */
291 recipe = (cpl_recipe *)plugin;
292
293 /* Verify parameter and frame lists */
294 if (recipe->parameters == NULL) {
295 cpl_msg_error(cpl_func, "Recipe invoked with NULL parameter list");
296 cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
297 }
298 if (recipe->frames == NULL) {
299 cpl_msg_error(cpl_func, "Recipe invoked with NULL frame set");
300 cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
301 }
302
303 /* Invoke the recipe */
304 recipe_status = _moons_science_xswitch2(recipe->frames, recipe->parameters);
305
306 /* Ensure DFS-compliance of the products */
307 if (cpl_dfs_update_product_header(recipe->frames)) {
308 if (!recipe_status)
309 recipe_status = (int)cpl_error_get_code();
310 }
311
312 if (!cpl_errorstate_is_equal(initial_errorstate)) {
313 /* Dump the error history since recipe execution start.
314 At this point the recipe cannot recover from the error */
315 cpl_errorstate_dump(initial_errorstate, CPL_FALSE, NULL);
316 }
317
318 return recipe_status;
319}
320
321/*----------------------------------------------------------------------------*/
327/*----------------------------------------------------------------------------*/
328
329static int
330_moons_science_xswitch2_destroy(cpl_plugin *plugin)
331{
332 cpl_recipe *recipe;
333
334 if (plugin == NULL) {
335 cpl_msg_error(cpl_func, "Null plugin");
336 cpl_ensure_code(0, (int)CPL_ERROR_NULL_INPUT);
337 }
338
339 /* Verify plugin type */
340 if (cpl_plugin_get_type(plugin) != CPL_PLUGIN_TYPE_RECIPE) {
341 cpl_msg_error(cpl_func, "Plugin is not a recipe");
342 cpl_ensure_code(0, (int)CPL_ERROR_TYPE_MISMATCH);
343 }
344
345 /* Get the recipe */
346 recipe = (cpl_recipe *)plugin;
347
348 cpl_parameterlist_delete(recipe->parameters);
349
350 return 0;
351}
352
353static cpl_error_code
354_moons_p2pmap(moo_det *arc, const cpl_frame *p2pmap)
355{
356 cpl_error_code status = CPL_ERROR_NONE;
357 moo_det *p2p = NULL;
358 if (p2pmap != NULL) {
359 moo_try_check(p2p = moo_det_create(p2pmap), " ");
360 moo_try_check(moo_apply_p2p(arc, p2p), " ");
361 }
362moo_try_cleanup:
363 moo_det_delete(p2p);
364 return status;
365}
366
367static const cpl_frame *
368find_masterdark_nir(moo_det *det, cpl_frameset *set)
369{
370 const cpl_frame *result = NULL;
371 double dit = 0.0;
372 int ndit = 0;
373 double exptime = 0.0;
374 int num;
375 int type;
376 int find = 0;
377 moo_det *current_det = NULL;
378
379 cpl_ensure(det != NULL, CPL_ERROR_NULL_INPUT, NULL);
380
381 for (num = 1; num <= 2; num++) {
382 for (type = 1; type <= 2; type++) {
383 moo_single *single = moo_det_get_single(det, type, num);
384 if (single != NULL) {
385 moo_try_check(ndit = moo_pfits_get_ndit(single->header), " ");
386 moo_try_check(dit = moo_pfits_get_dit(single->header), " ");
387 exptime = dit * ndit;
388 find = 1;
389 break;
390 }
391 }
392 if (find) {
393 break;
394 }
395 }
396
397 if (find && set != NULL) {
398 int size = cpl_frameset_get_size(set);
399 for (int i = 0; i < size; i++) {
400 const cpl_frame *current = cpl_frameset_get_position_const(set, i);
401 current_det = moo_det_create(current);
402 moo_single *current_single =
403 moo_det_get_single(current_det, type, num);
404 moo_try_check(ndit = moo_pfits_get_ndit(current_single->header),
405 " ");
406 moo_try_check(dit = moo_pfits_get_dit(current_single->header), " ");
407 double current_exptime = dit * ndit;
408 if (fabs(exptime - current_exptime) <= 1E-9) {
409 result = current;
410 break;
411 }
412 moo_det_delete(current_det);
413 current_det = NULL;
414 }
415 }
416moo_try_cleanup:
417 moo_det_delete(current_det);
418 return result;
419}
420
421static cpl_frame *
422_moons_xswitch_subtractnod(int inum,
423 const char *mode,
424 int offset,
425 const cpl_frame *obj_frame,
426 const cpl_frame *obj_det_frame,
427 const cpl_frame *sky_det_frame,
428 moo_products *products)
429{
430 cpl_frame *result = NULL;
431 char *nod_det_filename = NULL;
432 moo_det *nod_det = NULL;
433 unsigned int badpix_level = MOO_BADPIX_GOOD;
434
435 moo_det *obj_det = moo_det_create(obj_det_frame);
436 moo_det *sky_det = moo_det_create(sky_det_frame);
437 moo_try_check(moo_det_load(obj_det, badpix_level), " ");
438 moo_try_check(moo_det_load(sky_det, badpix_level), " ");
439
440 nod_det_filename =
441 cpl_sprintf("%s_OFFSET%d_%s_%d.fits", MOONS_TAG_XSWITCH_SUBTRACTNOD,
442 offset, mode, inum);
443
444 moo_try_check(nod_det =
445 moo_subtract_nod(obj_det, sky_det, nod_det_filename),
446 " ");
447 moo_try_check(result = moo_products_add(products, nod_det,
448 CPL_FRAME_LEVEL_INTERMEDIATE,
449 MOONS_TAG_XSWITCH_SUBTRACTNOD,
450 nod_det_filename, obj_frame),
451 " ");
452
453moo_try_cleanup:
454 cpl_free(nod_det_filename);
455 moo_det_delete(obj_det);
456 moo_det_delete(sky_det);
457 moo_det_delete(nod_det);
458
459 return result;
460}
461
462static cpl_frame *
463_moons_xswitch_prepare(int inum,
464 const char *mode,
465 int offset,
466 const cpl_frame *frame,
467 const char *bpmap_rp_name,
468 const char *bpmap_nl_name,
469 const cpl_frame *masterbias,
470 const cpl_frame *masterdark_vis,
471 cpl_frameset *masterdark_nir_frameset,
472 const cpl_frame *p2pmap,
473 const cpl_frame *coeffs_cube,
474 moo_prepare_params *prepare_params,
475 moo_correct_bias_params *cbias_params,
476 moo_products *products,
477 const char *prefix)
478{
479 cpl_frame *result = NULL;
480 const cpl_frame *masterdark_nir = NULL;
481 moo_det *det = NULL;
482 char *det_filename = NULL;
483 char *det_p2p_filename = NULL;
484
485 cpl_ensure(frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
486
487 moo_try_check(det = moo_prepare(frame, bpmap_rp_name, bpmap_nl_name,
488 masterbias, coeffs_cube, prepare_params),
489 " ");
490 moo_try_check(moo_correct_bias(det, masterbias, cbias_params), " ");
491
492 masterdark_nir = find_masterdark_nir(det, masterdark_nir_frameset);
493
494 moo_try_check(moo_correct_dark(det, NULL, masterdark_vis, masterdark_nir),
495 " ");
496 det_filename =
497 cpl_sprintf("%s_%s_OFFSET%d_%s_%d.fits", MOONS_TAG_XSWITCH_CORRECTDARK,
498 prefix, offset, mode, inum);
499 moo_try_check(moo_products_add(products, det, CPL_FRAME_LEVEL_INTERMEDIATE,
500 MOONS_TAG_XSWITCH_CORRECTDARK, det_filename,
501 frame),
502 " ");
503 moo_try_check(_moons_p2pmap(det, p2pmap), " ");
504 det_p2p_filename =
505 cpl_sprintf("%s_%s_OFFSET%d_%s_%d.fits", MOONS_TAG_XSWITCH_APPLYP2P,
506 prefix, offset, mode, inum);
507 moo_try_check(result = moo_products_add(products, det,
508 CPL_FRAME_LEVEL_INTERMEDIATE,
509 MOONS_TAG_XSWITCH_APPLYP2P,
510 det_p2p_filename, frame),
511 " ");
512
513moo_try_cleanup:
514 cpl_free(det_filename);
515 cpl_free(det_p2p_filename);
516 moo_det_delete(det);
517 return result;
518}
519
520static cpl_error_code
521_moons_science_xswitch2_check_sof(cpl_frameset *frameset,
522 cpl_frameset *offset_frameset,
523 const char **bpmap_rp_name,
524 const char **bpmap_nl_name,
525 const cpl_frame **masterbias,
526 const cpl_frame **masterdark_vis,
527 cpl_frameset *masterdark_nir,
528 const cpl_frame **p2pmap,
529 const cpl_frame **sformat,
530 const cpl_frame **sky_lines,
531 const cpl_frame **atmo,
532 const cpl_frame **resp,
533 const cpl_frame **tell,
534 const cpl_frame **airglow_group,
535 const cpl_frame **airglow_var,
536 const cpl_frame **solflux,
537 const moo_sub_sky_stare_params *subsky_params)
538{
539 cpl_ensure_code(moo_dfs_set_groups(frameset) == CPL_ERROR_NONE,
540 cpl_error_get_code());
541 int i;
542
543 for (i = 0; i < cpl_frameset_get_size(frameset); ++i) {
544 cpl_frame *current_frame = cpl_frameset_get_position(frameset, i);
545 if (!strcmp(cpl_frame_get_tag(current_frame),
546 MOONS_TAG_OBJECT_XSWITCH)) {
547 cpl_frameset_insert(offset_frameset,
548 cpl_frame_duplicate(current_frame));
549 }
550 else if (!strcmp(cpl_frame_get_tag(current_frame),
551 MOONS_TAG_BP_MAP_RP)) {
552 *bpmap_rp_name = cpl_frame_get_filename(current_frame);
553 }
554 else if (!strcmp(cpl_frame_get_tag(current_frame),
555 MOONS_TAG_BP_MAP_NL)) {
556 *bpmap_nl_name = cpl_frame_get_filename(current_frame);
557 }
558 else if (!strcmp(cpl_frame_get_tag(current_frame),
559 MOONS_TAG_MASTER_BIAS)) {
560 *masterbias = current_frame;
561 }
562 else if (!strcmp(cpl_frame_get_tag(current_frame),
563 MOONS_TAG_MASTER_DARK_VIS)) {
564 *masterdark_vis = current_frame;
565 }
566 else if (!strcmp(cpl_frame_get_tag(current_frame),
567 MOONS_TAG_MASTER_DARK_NIR)) {
568 cpl_frameset_insert(masterdark_nir,
569 cpl_frame_duplicate(current_frame));
570 }
571 else if (!strcmp(cpl_frame_get_tag(current_frame),
572 MOONS_TAG_MASTER_FLAT)) {
573 cpl_frameset_insert(offset_frameset,
574 cpl_frame_duplicate(current_frame));
575 }
576 else if (!strcmp(cpl_frame_get_tag(current_frame), MOONS_TAG_P2P_MAP)) {
577 *p2pmap = current_frame;
578 }
579 else if (!strcmp(cpl_frame_get_tag(current_frame),
580 MOONS_TAG_FF_TRACE)) {
581 cpl_frameset_insert(offset_frameset,
582 cpl_frame_duplicate(current_frame));
583 }
584 else if (!strcmp(cpl_frame_get_tag(current_frame),
585 MOONS_TAG_LINEARITY_COEFF_CUBE)) {
586 cpl_frameset_insert(offset_frameset,
587 cpl_frame_duplicate(current_frame));
588 }
589 else if (!strcmp(cpl_frame_get_tag(current_frame),
590 MOONS_TAG_SPECTRAL_FORMAT)) {
591 *sformat = current_frame;
592 }
593 else if (!strcmp(cpl_frame_get_tag(current_frame), MOONS_TAG_WAVEMAP)) {
594 cpl_frameset_insert(offset_frameset,
595 cpl_frame_duplicate(current_frame));
596 }
597 else if (!strcmp(cpl_frame_get_tag(current_frame),
598 MOONS_TAG_SKY_LINE_LIST)) {
599 *sky_lines = current_frame;
600 }
601 else if (!strcmp(cpl_frame_get_tag(current_frame),
602 MOONS_TAG_FF_EXTSPECTRA)) {
603 cpl_frameset_insert(offset_frameset,
604 cpl_frame_duplicate(current_frame));
605 }
606 else if (!strcmp(cpl_frame_get_tag(current_frame),
607 MOONS_TAG_F2F_TABLE)) {
608 cpl_frameset_insert(offset_frameset,
609 cpl_frame_duplicate(current_frame));
610 }
611 else if (!strcmp(cpl_frame_get_tag(current_frame),
612 MOONS_TAG_ATMOS_EXT)) {
613 *atmo = current_frame;
614 }
615 else if (!strcmp(cpl_frame_get_tag(current_frame),
616 MOONS_TAG_RESPONSE)) {
617 *resp = current_frame;
618 }
619 else if (!strcmp(cpl_frame_get_tag(current_frame),
620 MOONS_TAG_TELLURIC_CORR)) {
621 *tell = current_frame;
622 }
623 else if (!strcmp(cpl_frame_get_tag(current_frame),
624 MOONS_TAG_AIRGLOW_GROUP)) {
625 *airglow_group = current_frame;
626 }
627 else if (!strcmp(cpl_frame_get_tag(current_frame),
628 MOONS_TAG_AIRGLOW_VAR)) {
629 *airglow_var = current_frame;
630 }
631 else if (!strcmp(cpl_frame_get_tag(current_frame), MOONS_TAG_SOLFLUX)) {
632 *solflux = current_frame;
633 }
634 }
635
636 if (*sformat == NULL) {
637 return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
638 "SOF does not have any file tagged "
639 "with %s",
640 MOONS_TAG_SPECTRAL_FORMAT);
641 }
642
643 if (*sky_lines == NULL) {
644 return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
645 "SOF does not have any file tagged "
646 "with %s",
647 MOONS_TAG_SKY_LINE_LIST);
648 }
649
650 if (*airglow_group == NULL &&
651 strcmp(subsky_params->method, MOO_SUB_SKY_STARE_METHOD_SKYCORR) == 0) {
652 return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
653 "SOF does not have any file tagged "
654 "with %s",
655 MOONS_TAG_AIRGLOW_GROUP);
656 }
657 if (*airglow_var == NULL &&
658 strcmp(subsky_params->method, MOO_SUB_SKY_STARE_METHOD_SKYCORR) == 0) {
659 return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
660 "SOF does not have any file tagged "
661 "with %s",
662 MOONS_TAG_AIRGLOW_VAR);
663 }
664 if (*solflux == NULL &&
665 strcmp(subsky_params->method, MOO_SUB_SKY_STARE_METHOD_SKYCORR) == 0) {
666 return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
667 "SOF does not have any file tagged "
668 "with %s",
669 MOONS_TAG_SOLFLUX);
670 }
671 return CPL_ERROR_NONE;
672}
673
674static cpl_error_code
675_moons_science_xswitch2_check_sof_byoffset(cpl_frameset *frameset,
676 cpl_frameset *objA_frameset,
677 cpl_frameset *objB_frameset,
678 const cpl_frame **master_flat,
679 const cpl_frame **fftrace,
680 const cpl_frame **coeffs_cube,
681 const cpl_frame **wmap,
682 const cpl_frame **flat,
683 const cpl_frame **f2f,
684 moo_extract_params *ext_params)
685{
686 cpl_ensure_code(moo_dfs_set_groups(frameset) == CPL_ERROR_NONE,
687 cpl_error_get_code());
688 int nb_object = 0;
689 int i;
690 for (i = 0; i < cpl_frameset_get_size(frameset); ++i) {
691 cpl_frame *current_frame = cpl_frameset_get_position(frameset, i);
692 if (!strcmp(cpl_frame_get_tag(current_frame),
693 MOONS_TAG_OBJECT_XSWITCH)) {
694 if (nb_object % 2 == 0) {
695 cpl_frameset_insert(objA_frameset,
696 cpl_frame_duplicate(current_frame));
697 }
698 else {
699 cpl_frameset_insert(objB_frameset,
700 cpl_frame_duplicate(current_frame));
701 }
702 nb_object++;
703 }
704 else if (!strcmp(cpl_frame_get_tag(current_frame),
705 MOONS_TAG_MASTER_FLAT)) {
706 *master_flat = current_frame;
707 }
708
709 else if (!strcmp(cpl_frame_get_tag(current_frame),
710 MOONS_TAG_FF_TRACE)) {
711 *fftrace = current_frame;
712 }
713 else if (!strcmp(cpl_frame_get_tag(current_frame),
714 MOONS_TAG_LINEARITY_COEFF_CUBE)) {
715 *coeffs_cube = current_frame;
716 }
717 else if (!strcmp(cpl_frame_get_tag(current_frame), MOONS_TAG_WAVEMAP)) {
718 *wmap = current_frame;
719 }
720 else if (!strcmp(cpl_frame_get_tag(current_frame),
721 MOONS_TAG_FF_EXTSPECTRA)) {
722 *flat = current_frame;
723 }
724 else if (!strcmp(cpl_frame_get_tag(current_frame),
725 MOONS_TAG_F2F_TABLE)) {
726 *f2f = current_frame;
727 }
728 }
729
730 if (nb_object <= 0) {
731 return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
732 "SOF does not have any file tagged "
733 "with %s",
734 MOONS_TAG_OBJECT_XSWITCH);
735 }
736
737 if (*fftrace == NULL) {
738 return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
739 "SOF does not have any file tagged "
740 "with %s",
741 MOONS_TAG_FF_TRACE);
742 }
743
744 if (*wmap == NULL) {
745 return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
746 "SOF does not have any file tagged "
747 "with %s",
748 MOONS_TAG_WAVEMAP);
749 }
750 if (*flat == NULL) {
751 return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
752 "SOF does not have any file tagged "
753 "with %s",
754 MOONS_TAG_FF_EXTSPECTRA);
755 }
756 if (*master_flat == NULL &&
757 strcmp(ext_params->method, MOO_EXTRACT_METHOD_OPTIMAL) == 0) {
758 return (int)cpl_error_set_message(cpl_func, CPL_ERROR_DATA_NOT_FOUND,
759 "SOF does not have any file tagged "
760 "with %s",
761 MOONS_TAG_MASTER_FLAT);
762 }
763 return CPL_ERROR_NONE;
764}
765
766static cpl_error_code
767_moons_apply_flat(moo_ext *ext,
768 const cpl_frame *flat_frame,
769 const cpl_frame *f2f_frame)
770{
771 cpl_error_code status = CPL_ERROR_NONE;
772 moo_ext *flat = NULL;
773 moo_f2f *f2f = NULL;
774
775 moo_try_check(flat = moo_ext_create(flat_frame), " ");
776 if (f2f_frame != NULL) {
777 f2f = moo_f2f_load(f2f_frame);
778 }
779 moo_try_check(moo_apply_flat(ext, flat, f2f), " ");
780
781moo_try_cleanup:
782 moo_ext_delete(flat);
783 moo_f2f_delete(f2f);
784 return status;
785}
786
787static cpl_frame *
788_moons_xswitch_rebin(int inum,
789 const char *mode,
790 int offset,
791 moo_ext *ext,
792 const cpl_frame *ref_frame,
793 moo_spectral_format *sformat,
794 moo_sky_lines_list *sky_lines,
795 moo_map *wmap,
796 const cpl_frame *atmo_frame,
797 const cpl_frame *resp_frame,
798 const cpl_frame *tell_frame,
799 moo_rebin_params *rbn_params,
800 moo_products *products,
801 const char *prefix)
802{
803 cpl_frame *rbn_frame = NULL;
804 moo_atm *atm = NULL;
805 moo_resp *resp = NULL;
806 moo_telluric *telluric = NULL;
807 moo_rbn *rbn = NULL;
808
809 char *rbn_filename = NULL;
810 char *calibflux_filename = NULL;
811 char *tellcorr_filename = NULL;
812
813 cpl_ensure(ext != NULL, CPL_ERROR_NULL_INPUT, NULL);
814 cpl_ensure(ref_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
815
816 rbn_filename = cpl_sprintf("%s_RBNSPECTRA_OFFSET%d_%s_%d.fits", prefix,
817 offset, mode, inum);
818 moo_try_check(rbn = moo_rebin(ext, wmap, sformat, rbn_params, rbn_filename),
819 " ");
820 moo_try_check(moo_rbn_compute_snr(rbn, sky_lines), " ");
821 moo_try_check(rbn_frame =
822 moo_products_add_rbn(products, rbn, CPL_FRAME_LEVEL_FINAL,
823 MOONS_TAG_SCIENCE_XSWITCH_RBNSPECTRA,
824 rbn_filename, ref_frame),
825 " ");
826
827 if (atmo_frame != NULL && resp_frame != NULL) {
828 moo_try_check(atm = moo_atm_load(atmo_frame), " ");
829 moo_try_check(resp = moo_resp_load(resp_frame), " ");
830
831 calibflux_filename = cpl_sprintf("%s_RBNFLXSPECTRA_OFFSET%d_%s_%d.fits",
832 prefix, offset, mode, inum);
833 moo_try_check(moo_calib_flux(rbn, atm, resp), " ");
834 moo_try_check(rbn_frame = moo_products_add_rbn(
835 products, rbn, CPL_FRAME_LEVEL_FINAL,
836 MOONS_TAG_SCIENCE_XSWITCH_RBNFLXSPECTRA,
837 calibflux_filename, ref_frame),
838 " ");
839 }
840 else {
841 cpl_msg_info(__func__, "No flux calibration");
842 }
843
844 if (tell_frame != NULL) {
845 moo_try_check(telluric = moo_telluric_load(tell_frame), " ");
846
847 tellcorr_filename =
848 cpl_sprintf("%s_RBNTELLCORRSPECTRA_OFFSET%d_%s_%d.fits", prefix,
849 offset, mode, inum);
850 moo_try_check(moo_correct_tell(rbn, telluric), " ");
851 moo_try_check(rbn_frame = moo_products_add_rbn(
852 products, rbn, CPL_FRAME_LEVEL_FINAL,
853 MOONS_TAG_SCIENCE_XSWITCH_RBNTELLCORRSPECTRA,
854 tellcorr_filename, ref_frame),
855 " ");
856 }
857 else {
858 cpl_msg_info(__func__, "No telluric correction");
859 }
860
861moo_try_cleanup:
862 cpl_free(tellcorr_filename);
863 cpl_free(calibflux_filename);
864 cpl_free(rbn_filename);
865 moo_atm_delete(atm);
866 moo_resp_delete(resp);
867 moo_telluric_delete(telluric);
868 moo_rbn_delete(rbn);
869 return rbn_frame;
870}
871
872static cpl_frame *
873_moons_xswitch_extract(int inum,
874 const char *mode,
875 int offset,
876 const cpl_frame *ref_frame,
877 const cpl_frame *det_frame,
878 moo_loc *loc,
879 moo_map *wmap,
880 moo_spectral_format *sformat,
881 moo_sky_lines_list *skylines,
882 const cpl_frame *masterflat_frame,
883 const cpl_frame *flat_frame,
884 const cpl_frame *f2f_frame,
885 moo_extract_params *extract_params,
886 moo_products *products,
887 const char *prefix)
888{
889 cpl_frame *ext_frame = NULL;
890 moo_det *det = NULL;
891 moo_psf *psf = NULL;
892 moo_ext *ext = NULL;
893
894 char *ext_filename = NULL;
895 char *extff_filename = NULL;
896
897 cpl_ensure(det_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
898 det = moo_det_create(det_frame);
899 ext_filename = cpl_sprintf("%s_EXTSPECTRA_OFFSET%d_%s_%d.fits", prefix,
900 offset, mode, inum);
901 if (masterflat_frame != NULL) {
902 psf = moo_psf_load(masterflat_frame);
903 }
904
905 moo_try_check(ext =
906 moo_extract(det, loc, psf, extract_params, ext_filename),
907 " ");
908 moo_try_check(ext_frame =
909 moo_products_add_ext(products, ext,
910 CPL_FRAME_LEVEL_INTERMEDIATE,
911 MOONS_TAG_SCIENCE_XSWITCH_EXTSPECTRA,
912 ext_filename, ref_frame),
913 " ");
914
915 moo_try_check(_moons_apply_flat(ext, flat_frame, f2f_frame), " ");
916 moo_try_check(moo_ext_compute_snr(ext, wmap, sformat, skylines), " ");
917 extff_filename = cpl_sprintf("%s_EXTFFSPECTRA_OFFSET%d_%s_%d.fits", prefix,
918 offset, mode, inum);
919
920 moo_try_check(ext_frame =
921 moo_products_add_ext(products, ext,
922 CPL_FRAME_LEVEL_INTERMEDIATE,
923 MOONS_TAG_SCIENCE_XSWITCH_EXTSPECTRA,
924 extff_filename, ref_frame),
925 " ");
926
927moo_try_cleanup:
928 cpl_free(ext_filename);
929 cpl_free(extff_filename);
930 moo_det_delete(det);
931 moo_ext_delete(ext);
932 moo_psf_delete(psf);
933 return ext_frame;
934}
935
936static int
937_moons_sort_mjdobs(const cpl_frame *a, const cpl_frame *b)
938{
939 int res = 0;
940
941 const char *filenameA = cpl_frame_get_filename(a);
942 const char *filenameB = cpl_frame_get_filename(b);
943
944 cpl_propertylist *lista = cpl_propertylist_load(filenameA, 0);
945 cpl_propertylist *listb = cpl_propertylist_load(filenameB, 0);
946
947 if (cpl_propertylist_has(lista, MOO_PFITS_MJDOBS) &&
948 cpl_propertylist_has(listb, MOO_PFITS_MJDOBS)) {
949 double mjdA = moo_pfits_get_mjdobs(lista);
950 double mjdB = moo_pfits_get_mjdobs(listb);
951 if (mjdA < mjdB) {
952 res = -1;
953 }
954 else if (mjdA > mjdB) {
955 res = 1;
956 }
957 else {
958 res = 0;
959 }
960 }
961 cpl_propertylist_delete(listb);
962 cpl_propertylist_delete(lista);
963 return res;
964}
965
966static int
967_moons_compare_offset(const cpl_frame *a, const cpl_frame *b)
968{
969 int res = 0;
970 const char *filenameA = cpl_frame_get_filename(a);
971 cpl_propertylist *lista = cpl_propertylist_load(filenameA, 0);
972
973 double oA = moo_pfits_get_slit_offset(lista);
974 const char *filenameB = cpl_frame_get_filename(b);
975 cpl_propertylist *listb = cpl_propertylist_load(filenameB, 0);
976
977 double oB = moo_pfits_get_slit_offset(listb);
978 if (fabs(oA - oB) < 1E-12) {
979 res = 1;
980 }
981
982 cpl_propertylist_delete(lista);
983 cpl_propertylist_delete(listb);
984 return res;
985}
986
987static moo_target_table *
988_xswitch_target_table(cpl_frame *frameA,
989 cpl_frame *frameB,
990 moo_target_table_mode mode,
991 moo_target_table_params *params)
992{
993 moo_target_table *result = NULL;
994
995 moo_rbn *objA_rbn = NULL;
996 moo_rbn *objB_rbn = NULL;
997
998 moo_try_check(objA_rbn = moo_rbn_create(frameA), " ");
999 moo_try_check(objB_rbn = moo_rbn_create(frameB), " ");
1000
1001 moo_try_check(result =
1002 moo_create_target_table(objA_rbn, objB_rbn, mode, params),
1003 " ");
1004moo_try_cleanup:
1005 moo_rbn_delete(objA_rbn);
1006 moo_rbn_delete(objB_rbn);
1007
1008 return result;
1009}
1010static cpl_frame *
1011_xswitch_nod_rebin(cpl_frameset *det_frameset,
1012 const char *mode,
1013 int offset,
1014 const cpl_frame *ref_frame,
1015 moo_loc *loc,
1016 moo_map *wmap,
1017 moo_spectral_format *sformat,
1018 moo_sky_lines_list *skylines,
1019 const cpl_frame *masterflat_frame,
1020 const cpl_frame *flat_frame,
1021 const cpl_frame *f2f_frame,
1022 const cpl_frame *atmo_frame,
1023 const cpl_frame *resp_frame,
1024 const cpl_frame *tell_frame,
1025 moo_extract_params *extract_params,
1026 moo_rebin_params *rbn_params,
1027 moo_products *products,
1028 const char *prefix)
1029{
1030 cpl_frame *result = NULL;
1031 moo_detlist *detlist = NULL;
1032 moo_det *combined = NULL;
1033
1034 moo_psf *psf = NULL;
1035 moo_ext *ext = NULL;
1036 moo_crh_params *crh_params = NULL;
1037 moo_atm *atm = NULL;
1038 moo_resp *resp = NULL;
1039 moo_telluric *telluric = NULL;
1040 moo_rbn *rbn = NULL;
1041
1042 char *comb_filename = NULL;
1043 char *ext_filename = NULL;
1044 char *extff_filename = NULL;
1045
1046 char *rbn_filename = NULL;
1047 char *calibflux_filename = NULL;
1048 char *tellcorr_filename = NULL;
1049
1050 cpl_ensure(det_frameset != NULL, CPL_ERROR_NULL_INPUT, NULL);
1051
1052 cpl_errorstate prestate = cpl_errorstate_get();
1053 crh_params = moo_crh_params_new();
1054 crh_params->method = MOO_CRH_METHOD_MEDIAN;
1055 moo_try_check(detlist = moo_detlist_create(det_frameset), " ");
1056 moo_try_check(combined = moo_remove_CRH(detlist, NULL, crh_params), " ");
1057 comb_filename =
1058 cpl_sprintf("%s_COMB2D_OFFSET%d_%s.fits", prefix, offset, mode);
1059
1060 moo_try_check(moo_products_add(products, combined,
1061 CPL_FRAME_LEVEL_INTERMEDIATE,
1062 MOONS_TAG_XSWITCH_REMOVECRH, comb_filename,
1063 ref_frame),
1064 " ");
1065
1066 ext_filename =
1067 cpl_sprintf("%s_EXTSPECTRA_OFFSET%d_%s.fits", prefix, offset, mode);
1068 if (masterflat_frame != NULL) {
1069 psf = moo_psf_load(masterflat_frame);
1070 }
1071
1072 moo_try_check(ext = moo_extract(combined, loc, psf, extract_params,
1073 ext_filename),
1074 " ");
1075 moo_try_check(moo_products_add_ext(products, ext,
1076 CPL_FRAME_LEVEL_INTERMEDIATE,
1077 MOONS_TAG_SCIENCE_XSWITCH_EXTSPECTRA,
1078 ext_filename, ref_frame),
1079 " ");
1080
1081 moo_try_check(_moons_apply_flat(ext, flat_frame, f2f_frame), " ");
1082 moo_try_check(moo_ext_compute_snr(ext, wmap, sformat, skylines), " ");
1083 extff_filename =
1084 cpl_sprintf("%s_EXTFFSPECTRA_OFFSET%d_%s.fits", prefix, offset, mode);
1085
1086 moo_try_check(moo_products_add_ext(products, ext,
1087 CPL_FRAME_LEVEL_INTERMEDIATE,
1088 MOONS_TAG_SCIENCE_XSWITCH_EXTSPECTRA,
1089 extff_filename, ref_frame),
1090 " ");
1091
1092 rbn_filename =
1093 cpl_sprintf("%s_RBNSPECTRA_OFFSET%d_%s.fits", prefix, offset, mode);
1094 moo_try_check(rbn = moo_rebin(ext, wmap, sformat, rbn_params, rbn_filename),
1095 " ");
1096 moo_try_check(moo_rbn_compute_snr(rbn, skylines), " ");
1097 moo_try_check(result =
1098 moo_products_add_rbn(products, rbn, CPL_FRAME_LEVEL_FINAL,
1099 MOONS_TAG_SCIENCE_XSWITCH_RBNSPECTRA,
1100 rbn_filename, ref_frame),
1101 " ");
1102
1103 if (atmo_frame != NULL && resp_frame != NULL) {
1104 moo_try_check(atm = moo_atm_load(atmo_frame), " ");
1105 moo_try_check(resp = moo_resp_load(resp_frame), " ");
1106
1107 calibflux_filename = cpl_sprintf("%s_RBNFLXSPECTRA_OFFSET%d_%s.fits",
1108 prefix, offset, mode);
1109 moo_try_check(moo_calib_flux(rbn, atm, resp), " ");
1110 moo_try_check(result = moo_products_add_rbn(
1111 products, rbn, CPL_FRAME_LEVEL_FINAL,
1112 MOONS_TAG_SCIENCE_XSWITCH_RBNFLXSPECTRA,
1113 calibflux_filename, ref_frame),
1114 " ");
1115 }
1116 else {
1117 cpl_msg_info(__func__, "No flux calibration");
1118 }
1119
1120 if (tell_frame != NULL) {
1121 moo_try_check(telluric = moo_telluric_load(tell_frame), " ");
1122
1123 tellcorr_filename =
1124 cpl_sprintf("%s_RBNTELLCORRSPECTRA_OFFSET%d_%s.fits", prefix,
1125 offset, mode);
1126 moo_try_check(moo_correct_tell(rbn, telluric), " ");
1127 moo_try_check(result = moo_products_add_rbn(
1128 products, rbn, CPL_FRAME_LEVEL_FINAL,
1129 MOONS_TAG_SCIENCE_XSWITCH_RBNTELLCORRSPECTRA,
1130 tellcorr_filename, ref_frame),
1131 " ");
1132 }
1133 else {
1134 cpl_msg_info(__func__, "No telluric correction");
1135 }
1136 result = cpl_frame_duplicate(result);
1137
1138moo_try_cleanup:
1139 if (!cpl_errorstate_is_equal(prestate)) {
1140 cpl_frame_delete(result);
1141 result = NULL;
1142 }
1143 moo_detlist_delete(detlist);
1144 moo_crh_params_delete(crh_params);
1145 moo_det_delete(combined);
1146 cpl_free(comb_filename);
1147
1148 moo_ext_delete(ext);
1149 moo_psf_delete(psf);
1150 cpl_free(ext_filename);
1151 cpl_free(extff_filename);
1152 cpl_free(rbn_filename);
1153 moo_rbn_delete(rbn);
1154
1155 cpl_free(tellcorr_filename);
1156 cpl_free(calibflux_filename);
1157
1158 moo_atm_delete(atm);
1159 moo_resp_delete(resp);
1160 moo_telluric_delete(telluric);
1161
1162 return result;
1163}
1164
1165static cpl_frame *
1166_moons_xswitch_sci1d(int inum,
1167 const char *mode,
1168 int offset,
1169 const cpl_frame *obja_frame,
1170 const cpl_frame *obja_rbn_frame,
1171 const cpl_frame *objb_frame,
1172 const cpl_frame *objb_rbn_frame,
1173 moo_sky_lines_list *sky_lines,
1174 const cpl_frame *f2f_frame,
1175 const cpl_frame *airglow_group_frame,
1176 const cpl_frame *airglow_var_frame,
1177 const cpl_frame *solflux_frame,
1178 moo_target_table *target_table,
1179 moo_sub_sky_stare_params *sky_params,
1180 moo_products *products,
1181 const char *prefix,
1182 cpl_frame **result_psci1d)
1183{
1184 cpl_frame *result_sci1d = NULL;
1185 moo_rbn *objb_rbn = NULL;
1186 moo_rbn *obja_rbn = NULL;
1187 moo_sci *sci1d = NULL;
1188 moo_sci *psci1d = NULL;
1189 moo_f2f *f2f = NULL;
1190
1191 char *sci1d_filename = NULL;
1192 char *psci1d_filename = NULL;
1193
1194 cpl_ensure(obja_rbn_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
1195 cpl_ensure(objb_rbn_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
1196
1197 cpl_errorstate prestate = cpl_errorstate_get();
1198
1199 moo_try_check(obja_rbn = moo_rbn_create(obja_rbn_frame), " ");
1200 moo_try_check(objb_rbn = moo_rbn_create(objb_rbn_frame), " ");
1201
1202 sci1d_filename =
1203 cpl_sprintf("%s_SCI1D_OFFSET%d_%s_%d.fits", prefix, offset, mode, inum);
1204
1205 if (f2f_frame != NULL) {
1206 f2f = moo_f2f_load(f2f_frame);
1207 }
1208 moo_try_check(sci1d =
1209 moo_sub_sky_stare(obja_rbn, target_table, objb_rbn, f2f,
1210 solflux_frame, airglow_group_frame,
1211 airglow_var_frame, sky_params,
1212 sci1d_filename, MOO_SCI1D_NOT_PAIRED),
1213 " ");
1214
1215 moo_try_check(moo_sci_compute_snr(sci1d, sky_lines), " ");
1216
1217 moo_try_check(result_sci1d =
1218 moo_products_add_sci(products, sci1d,
1219 CPL_FRAME_LEVEL_FINAL,
1220 MOONS_TAG_SCIENCE_XSWITCH_SKSSPECTRA,
1221 sci1d_filename, obja_frame),
1222 " ");
1223 psci1d_filename = cpl_sprintf("%s_SCI1D_PAIRED_OFFSET%d_%s_%d.fits", prefix,
1224 offset, mode, inum);
1225 moo_try_check(psci1d =
1226 moo_sub_sky_stare(obja_rbn, target_table, objb_rbn, f2f,
1227 solflux_frame, airglow_group_frame,
1228 airglow_var_frame, sky_params,
1229 psci1d_filename, MOO_SCI1D_PAIRED),
1230 " ");
1231
1232 moo_try_check(moo_sci_compute_snr(psci1d, sky_lines), " ");
1233
1234 moo_try_check(*result_psci1d =
1235 moo_products_add_sci(products, psci1d,
1236 CPL_FRAME_LEVEL_FINAL,
1237 MOONS_TAG_SCIENCE_XSWITCH_SKSSPECTRA,
1238 psci1d_filename, objb_frame),
1239 " ");
1240
1241moo_try_cleanup:
1242 if (!cpl_errorstate_is_equal(prestate)) {
1243 cpl_frame_delete(result_sci1d);
1244 result_sci1d = NULL;
1245 *result_psci1d = NULL;
1246 }
1247 cpl_free(sci1d_filename);
1248 cpl_free(psci1d_filename);
1249 moo_sci_delete(sci1d);
1250 moo_sci_delete(psci1d);
1251 moo_rbn_delete(objb_rbn);
1252 moo_rbn_delete(obja_rbn);
1253 moo_f2f_delete(f2f);
1254 return result_sci1d;
1255}
1256
1257static cpl_frame *
1258_moons_xswitch_sci2d(const char *mode,
1259 int offset,
1260 const cpl_frame *ref_frame,
1261 const cpl_frame *nod_rbn_frame,
1262 const cpl_frameset *objB_rbn_frameset,
1263 const cpl_frameset *objA_rbn_frameset,
1264 moo_sky_lines_list *sky_lines,
1265 moo_target_table *target_table,
1266 int ispaired,
1267 moo_products *products,
1268 const char *prefix)
1269{
1270 cpl_frame *result = NULL;
1271 moo_rbnlist *objA_rbnlist = NULL;
1272 moo_rbnlist *objB_rbnlist = NULL;
1273 moo_rbn *nod_rbn = NULL;
1274 moo_rbn *objB_rbn = NULL;
1275 moo_rbn *objA_rbn = NULL;
1276
1277 moo_sci *sci2d = NULL;
1278 char *sci2d_filename = NULL;
1279
1280 cpl_ensure(nod_rbn_frame != NULL, CPL_ERROR_NULL_INPUT, NULL);
1281 cpl_ensure(objA_rbn_frameset != NULL, CPL_ERROR_NULL_INPUT, NULL);
1282 cpl_ensure(objB_rbn_frameset != NULL, CPL_ERROR_NULL_INPUT, NULL);
1283
1284 cpl_errorstate prestate = cpl_errorstate_get();
1285
1286 moo_try_check(nod_rbn = moo_rbn_create(nod_rbn_frame), " ");
1287 moo_try_check(objA_rbnlist = moo_rbnlist_create(objA_rbn_frameset), " ");
1288 moo_try_check(objB_rbnlist = moo_rbnlist_create(objB_rbn_frameset), " ");
1289 moo_try_check(objA_rbn = moo_combine_sky(objA_rbnlist), " ");
1290 moo_try_check(objB_rbn = moo_combine_sky(objB_rbnlist), " ");
1291
1292 sci2d_filename =
1293 cpl_sprintf("%s_SCI2D_OFFSET%d_%s.fits", prefix, offset, mode);
1294
1295 moo_try_check(sci2d =
1296 moo_create_sci2d(nod_rbn, objB_rbn, objA_rbn,
1297 target_table, ispaired, sci2d_filename),
1298 " ");
1299
1300 moo_try_check(moo_sci_compute_snr(sci2d, sky_lines), " ");
1301
1302 moo_try_check(result =
1303 moo_products_add_sci(products, sci2d,
1304 CPL_FRAME_LEVEL_FINAL,
1305 MOONS_TAG_SCIENCE_XSWITCH_SKSSPECTRA,
1306 sci2d_filename, ref_frame),
1307 " ");
1308
1309moo_try_cleanup:
1310 if (!cpl_errorstate_is_equal(prestate)) {
1311 cpl_frame_delete(result);
1312 result = NULL;
1313 }
1314 cpl_free(sci2d_filename);
1315 moo_sci_delete(sci2d);
1316 moo_rbn_delete(nod_rbn);
1317 moo_rbn_delete(objA_rbn);
1318 moo_rbn_delete(objB_rbn);
1319 moo_rbnlist_delete(objA_rbnlist);
1320 moo_rbnlist_delete(objB_rbnlist);
1321 return result;
1322}
1323
1324static cpl_frame *
1325_moons_science_xswitch2_byoffset(cpl_frameset *frameset,
1326 cpl_frameset *ref_frameset,
1327 const char *bpmap_rp_name,
1328 const char *bpmap_nl_name,
1329 const cpl_frame *masterbias,
1330 const cpl_frame *masterdark_vis,
1331 cpl_frameset *masterdark_nir,
1332 const cpl_frame *p2pmap,
1333 const cpl_frame *sformat_frame,
1334 moo_sky_lines_list *sky_lines,
1335 const cpl_frame *airglow_group_frame,
1336 const cpl_frame *solflux_frame,
1337 const cpl_frame *airglow_var_frame,
1338 const cpl_frame *atmo_frame,
1339 const cpl_frame *resp_frame,
1340 const cpl_frame *tell_frame,
1341 moo_prepare_params *prepare_params,
1342 moo_correct_bias_params *correct_bias_params,
1343 moo_extract_params *extract_params,
1344 moo_wavesol_params *wavesol_params,
1345 moo_rebin_params *rbn_params,
1346 moo_target_table_params *target_table_params,
1347 moo_sub_sky_stare_params *sky_params,
1348 moo_coadd_params *coadd_params,
1349 moo_products *products)
1350{
1351 /* parameters */
1352 cpl_frame *result = NULL;
1353 moo_loc *loc = NULL;
1354 moo_spectral_format *sformat = NULL;
1355 moo_map *wmap = NULL;
1356 moo_map *wmap_tuned = NULL;
1357 moo_extlist *objA_extlist = NULL;
1358 moo_extlist *objB_extlist = NULL;
1359 moo_extlist *wavemap_extlist = NULL;
1360 moo_ext *sum_ext = NULL;
1361
1362 cpl_frameset *objA_frameset = NULL;
1363 cpl_frameset *objB_frameset = NULL;
1364
1365 cpl_frameset *objA_det_frameset = NULL;
1366 cpl_frameset *objB_det_frameset = NULL;
1367 cpl_frameset *nod_det_frameset = NULL;
1368
1369 cpl_frameset *objB_ext_frameset = NULL;
1370 cpl_frameset *objA_ext_frameset = NULL;
1371
1372 cpl_frameset *objB_rbn_frameset = NULL;
1373 cpl_frameset *objA_rbn_frameset = NULL;
1374 cpl_frame *nod_rbn_frame = NULL;
1375
1376 cpl_frameset *objB_ref_frameset = NULL;
1377 cpl_frameset *objA_sci1d_frameset = NULL;
1378 cpl_frameset *objB_sci1d_frameset = NULL;
1379
1380 const cpl_frame *master_flat = NULL;
1381 const cpl_frame *fftrace = NULL;
1382 const cpl_frame *coeffs_cube = NULL;
1383 const cpl_frame *wmap_frame = NULL;
1384 const cpl_frame *flat_frame = NULL;
1385 const cpl_frame *f2f_frame = NULL;
1386
1387 char *sum_ext_filename = NULL;
1388 const char *refA_filename = NULL;
1389 cpl_propertylist *refA_header = NULL;
1390
1391 moo_mode_type mode;
1392 const char *mode_name = NULL;
1393 int offset;
1394 char *wmap_tuned_filename = NULL;
1395 int wavemap_extlist_size = 0;
1396
1397 moo_target_table *xswitch_target_table = NULL;
1398 char *xswitch_ttable_filename = NULL;
1399
1400 moo_scilist *sci1d_list = NULL;
1401 moo_sci *sci1d_coadd = NULL;
1402 char *coadd1d_filename = NULL;
1403
1404 moo_scilist *psci1d_list = NULL;
1405 moo_sci *psci1d_coadd = NULL;
1406 char *pcoadd1d_filename = NULL;
1407
1408 cpl_errorstate prestate = cpl_errorstate_get();
1409 objA_frameset = cpl_frameset_new();
1410 objB_frameset = cpl_frameset_new();
1411
1412 objA_det_frameset = cpl_frameset_new();
1413 objB_det_frameset = cpl_frameset_new();
1414 nod_det_frameset = cpl_frameset_new();
1415
1416 objA_ext_frameset = cpl_frameset_new();
1417 objB_ext_frameset = cpl_frameset_new();
1418
1419 objA_rbn_frameset = cpl_frameset_new();
1420 objB_rbn_frameset = cpl_frameset_new();
1421
1422 objA_sci1d_frameset = cpl_frameset_new();
1423 objB_sci1d_frameset = cpl_frameset_new();
1424
1425 objB_ref_frameset = cpl_frameset_new();
1426
1427 moo_try_check(_moons_science_xswitch2_check_sof_byoffset(
1428 frameset, objA_frameset, objB_frameset, &master_flat,
1429 &fftrace, &coeffs_cube, &wmap_frame, &flat_frame,
1430 &f2f_frame, extract_params),
1431 " ");
1432
1433 int nb_objA = cpl_frameset_get_size(objA_frameset);
1434 int nb_objB = cpl_frameset_get_size(objB_frameset);
1435 cpl_frame *ref_frameA = cpl_frameset_get_position(objA_frameset, 0);
1436 cpl_frameset_insert(ref_frameset, cpl_frame_duplicate(ref_frameA));
1437
1438 cpl_frame *ref_frameB = cpl_frameset_get_position(objB_frameset, 0);
1439 refA_filename = cpl_frame_get_filename(ref_frameA);
1440
1441 moo_try_check(mode = moo_mode_get(ref_frameA), " ");
1442 mode_name = moo_mode_get_name(mode);
1443
1444 moo_try_check(refA_header = cpl_propertylist_load(refA_filename, 0), " ");
1445 moo_try_check(offset = moo_pfits_get_slit_offset(refA_header), " ");
1446 cpl_propertylist_delete(refA_header);
1447 refA_header = NULL;
1448
1449 cpl_msg_info(__func__, "Do offset %d use mode %s", offset, mode_name);
1450
1451 for (int i = 0; i < nb_objA; i++) {
1452 cpl_msg_info(__func__, "---Prepare object A: %d/%d", i + 1, nb_objA);
1453 cpl_frame *objA_frame = NULL;
1454 moo_try_check(objA_frame = cpl_frameset_get_position(objA_frameset, i),
1455 " ");
1456 cpl_frame *frame =
1457 _moons_xswitch_prepare(i, mode_name, offset, objA_frame,
1458 bpmap_rp_name, bpmap_nl_name, masterbias,
1459 masterdark_vis, masterdark_nir, p2pmap,
1460 coeffs_cube, prepare_params,
1461 correct_bias_params, products, "A");
1462 cpl_frameset_insert(objA_det_frameset, cpl_frame_duplicate(frame));
1463 }
1464
1465 for (int i = 0; i < nb_objB; i++) {
1466 cpl_msg_info(__func__, "---Prepare object B: %d/%d", i + 1, nb_objA);
1467 cpl_frame *objB_frame = NULL;
1468 moo_try_check(objB_frame = cpl_frameset_get_position(objB_frameset, i),
1469 " ");
1470 cpl_frame *frame =
1471 _moons_xswitch_prepare(i, mode_name, offset, objB_frame,
1472 bpmap_rp_name, bpmap_nl_name, masterbias,
1473 masterdark_vis, masterdark_nir, p2pmap,
1474 coeffs_cube, prepare_params,
1475 correct_bias_params, products, "B");
1476 cpl_frameset_insert(objB_det_frameset, cpl_frame_duplicate(frame));
1477 }
1478 moo_try_check(sformat = moo_spectral_format_load(sformat_frame, mode), " ");
1479 moo_try_check(wmap = moo_map_load(wmap_frame), " ");
1480 moo_try_check(loc = moo_loc_load(fftrace), " ");
1481
1482 for (int i = 0; i < nb_objA; i++) {
1483 cpl_frame *objA_frame = NULL;
1484 cpl_frame *objA_det_frame = NULL;
1485 cpl_frame *objB_det_frame = NULL;
1486 moo_try_check(objA_frame = cpl_frameset_get_position(objA_frameset, i),
1487 " ");
1488 moo_try_check(objA_det_frame =
1489 cpl_frameset_get_position(objA_det_frameset, i),
1490 " ");
1491 moo_try_check(objB_det_frame =
1492 cpl_frameset_get_position(objB_det_frameset, i),
1493 " ");
1494 cpl_msg_info(__func__, "---Prepare nod %d/%d using object A:%s B:%s",
1495 i + 1, nb_objA, cpl_frame_get_filename(objA_det_frame),
1496 cpl_frame_get_filename(objB_det_frame));
1497 cpl_frame *frame =
1498 _moons_xswitch_subtractnod(i, mode_name, offset, objA_frame,
1499 objA_det_frame, objB_det_frame,
1500 products);
1501 cpl_frameset_insert(nod_det_frameset, cpl_frame_duplicate(frame));
1502 }
1503 int nb_nod = cpl_frameset_get_size(nod_det_frameset);
1504
1505 for (int i = 0; i < nb_objA; i++) {
1506 cpl_frame *objA_frame = NULL;
1507 cpl_frame *objA_det_frame = NULL;
1508 cpl_msg_info(__func__, "---Extract object A: %d/%d", i + 1, nb_objA);
1509 moo_try_check(objA_frame = cpl_frameset_get_position(objA_frameset, i),
1510 " ");
1511 moo_try_check(objA_det_frame =
1512 cpl_frameset_get_position(objA_det_frameset, i),
1513 " ");
1514 cpl_frame *frame =
1515 _moons_xswitch_extract(i, mode_name, offset, objA_frame,
1516 objA_det_frame, loc, wmap, sformat,
1517 sky_lines, master_flat, flat_frame,
1518 f2f_frame, extract_params, products,
1519 "XSWITCH_OBJECTA");
1520 cpl_frameset_insert(objA_ext_frameset, cpl_frame_duplicate(frame));
1521 }
1522
1523 for (int i = 0; i < nb_objB; i++) {
1524 cpl_frame *objB_frame = NULL;
1525 cpl_frame *objB_det_frame = NULL;
1526 cpl_msg_info(__func__, "---Extract object B: %d/%d", i + 1, nb_objB);
1527 moo_try_check(objB_frame = cpl_frameset_get_position(objB_frameset, i),
1528 " ");
1529 moo_try_check(objB_det_frame =
1530 cpl_frameset_get_position(objB_det_frameset, i),
1531 " ");
1532 cpl_frame *frame =
1533 _moons_xswitch_extract(i, mode_name, offset, objB_frame,
1534 objB_det_frame, loc, wmap, sformat,
1535 sky_lines, master_flat, flat_frame,
1536 f2f_frame, extract_params, products,
1537 "XSWITCH_OBJECTB");
1538 cpl_frameset_insert(objB_ext_frameset, cpl_frame_duplicate(frame));
1539 }
1540
1541 objA_extlist = moo_extlist_create(objA_ext_frameset);
1542 objB_extlist = moo_extlist_create(objB_ext_frameset);
1543 wavemap_extlist = moo_extlist_new();
1544
1545 for (int i = 0; i < nb_objA; i++) {
1546 moo_ext *ext = moo_extlist_get(objA_extlist, i);
1547 moo_extlist_set(wavemap_extlist, ext, wavemap_extlist_size);
1548 wavemap_extlist_size++;
1549 }
1550 for (int i = 0; i < nb_objB; i++) {
1551 moo_ext *ext = moo_extlist_get(objB_extlist, i);
1552 moo_extlist_set(wavemap_extlist, ext, wavemap_extlist_size);
1553 wavemap_extlist_size++;
1554 }
1555
1556 sum_ext_filename =
1557 cpl_sprintf("XSWITCH_EXT_SUM_OFFSET%d_%s.fits", offset, mode_name);
1558 sum_ext = moo_extlist_sum(wavemap_extlist, sum_ext_filename);
1559 moo_try_check(moo_products_add_ext(products, sum_ext,
1560 CPL_FRAME_LEVEL_TEMPORARY,
1561 MOONS_TAG_SCIENCE_XSWITCH_EXTSPECTRA,
1562 sum_ext_filename, ref_frameA),
1563 " ");
1564 moo_map *used_wmap = NULL;
1565 const char *wavesol_control = wavesol_params->control;
1566 if ((strcmp(wavesol_control, MOO_WAVESOL_CONTROL_CHECK) == 0) ||
1567 (strcmp(wavesol_control, MOO_WAVESOL_CONTROL_UPDATE) == 0)) {
1568 const char *sky_lines_name = sky_lines->filename;
1569 moo_try_check(wmap_tuned = moo_wavesol(sum_ext, sky_lines_name, sformat,
1570 loc, wmap, wavesol_params),
1571 " ");
1572 if (strcmp(wavesol_control, MOO_WAVESOL_CONTROL_UPDATE) == 0) {
1573 used_wmap = wmap_tuned;
1574 wmap_tuned_filename =
1575 cpl_sprintf("XSWICTH_WMAP_TUNED_OFFSET%d_%s.fits", offset,
1576 mode_name);
1577 moo_map_save(wmap_tuned, wmap_tuned_filename);
1578 }
1579 }
1580 else {
1581 used_wmap = wmap;
1582 }
1583
1584 for (int i = 0; i < nb_objA; i++) {
1585 cpl_frame *objA_frame = NULL;
1586 moo_ext *objA_ext = moo_extlist_get(objA_extlist, i);
1587 cpl_msg_info(__func__, "---Rebin object A: %d/%d", i + 1, nb_objA);
1588 moo_try_check(objA_frame = cpl_frameset_get_position(objA_frameset, i),
1589 " ");
1590 cpl_frame *frame =
1591 _moons_xswitch_rebin(i, mode_name, offset, objA_ext, objA_frame,
1592 sformat, sky_lines, used_wmap, atmo_frame,
1593 resp_frame, tell_frame, rbn_params, products,
1594 "XSWITCH_OBJECTA");
1595 cpl_frameset_insert(objA_rbn_frameset, cpl_frame_duplicate(frame));
1596 }
1597
1598 for (int i = 0; i < nb_objB; i++) {
1599 cpl_frame *objB_frame = NULL;
1600 moo_ext *objB_ext = moo_extlist_get(objB_extlist, i);
1601 cpl_msg_info(__func__, "---Rebin object B: %d/%d", i + 1, nb_objB);
1602 moo_try_check(objB_frame = cpl_frameset_get_position(objB_frameset, i),
1603 " ");
1604 cpl_frame *frame =
1605 _moons_xswitch_rebin(i, mode_name, offset, objB_ext, objB_frame,
1606 sformat, sky_lines, used_wmap, atmo_frame,
1607 resp_frame, tell_frame, rbn_params, products,
1608 "XSWITCH_OBJECTB");
1609 cpl_frameset_insert(objB_rbn_frameset, cpl_frame_duplicate(frame));
1610 }
1611
1612 if (nb_nod > 0) {
1613 moo_try_check(nod_rbn_frame =
1614 _xswitch_nod_rebin(nod_det_frameset, mode_name,
1615 offset, ref_frameA, loc, used_wmap,
1616 sformat, sky_lines, master_flat,
1617 flat_frame, f2f_frame, atmo_frame,
1618 resp_frame, tell_frame,
1619 extract_params, rbn_params,
1620 products, "XSWITCH_NOD"),
1621 " ");
1622
1623 cpl_frame *objA_rbn_frame = NULL;
1624 cpl_frame *objB_rbn_frame = NULL;
1625 cpl_frame *sci_frameA = NULL;
1626 cpl_frame *sci_frameB = NULL;
1627
1628 moo_try_check(objA_rbn_frame =
1629 cpl_frameset_get_position(objA_rbn_frameset, 0),
1630 " ");
1631 moo_try_check(objB_rbn_frame =
1632 cpl_frameset_get_position(objB_rbn_frameset, 0),
1633 " ");
1634
1635 moo_try_check(xswitch_target_table =
1636 _xswitch_target_table(objA_rbn_frame, objB_rbn_frame,
1637 MOO_MODE_XSWITCH,
1638 target_table_params),
1639 " ");
1640 xswitch_ttable_filename =
1641 cpl_sprintf("%s_OFFSET%d_%s.fits", MOONS_TAG_XSWITCH_TARGET_TABLE,
1642 offset, mode_name);
1643
1644 moo_try_check(
1645 moo_products_add_target_table(products, xswitch_target_table,
1646 CPL_FRAME_LEVEL_INTERMEDIATE,
1647 MOONS_TAG_XSWITCH_TARGET_TABLE,
1648 xswitch_ttable_filename, ref_frameA),
1649 " ");
1650
1651 moo_try_check(sci_frameA =
1652 _moons_xswitch_sci2d(mode_name, offset, ref_frameA,
1653 nod_rbn_frame, objB_rbn_frameset,
1654 objA_rbn_frameset, sky_lines,
1655 xswitch_target_table,
1656 MOO_SCI2D_NOT_PAIRED, products,
1657 "XSWITCH_NOD"),
1658 " ");
1659 moo_try_check(sci_frameB =
1660 _moons_xswitch_sci2d(mode_name, offset, ref_frameB,
1661 nod_rbn_frame, objB_rbn_frameset,
1662 objA_rbn_frameset, sky_lines,
1663 xswitch_target_table,
1664 MOO_SCI2D_PAIRED, products,
1665 "XSWITCH_NOD_PAIRED"),
1666 " ");
1667 for (int i = 0; i < nb_objA; i++) {
1668 cpl_frame *objA_frame = NULL;
1669 cpl_frame *objA_rbn_framel = NULL;
1670 cpl_frame *objB_frame = NULL;
1671 cpl_frame *objB_rbn_framel = NULL;
1672 cpl_frame *sci_frame = NULL;
1673 cpl_frame *psci_frame = NULL;
1674 moo_try_check(objA_frame =
1675 cpl_frameset_get_position(objA_frameset, i),
1676 " ");
1677 moo_try_check(objA_rbn_framel =
1678 cpl_frameset_get_position(objA_rbn_frameset, i),
1679 " ");
1680 moo_try_check(objB_frame =
1681 cpl_frameset_get_position(objB_frameset, i),
1682 " ");
1683 moo_try_check(objB_rbn_framel =
1684 cpl_frameset_get_position(objB_rbn_frameset, i),
1685 " ");
1686
1687 cpl_msg_info(__func__,
1688 "---Create sci1d: %d/%d use objectA:%s objectB: %s",
1689 i + 1, nb_objA,
1690 cpl_frame_get_filename(objA_rbn_framel),
1691 cpl_frame_get_filename(objB_rbn_framel));
1692
1693 moo_try_check(sci_frame = _moons_xswitch_sci1d(
1694 i, mode_name, offset, objA_frame, objA_rbn_framel,
1695 objB_frame, objB_rbn_framel, sky_lines, f2f_frame,
1696 airglow_group_frame, airglow_var_frame,
1697 solflux_frame, xswitch_target_table, sky_params,
1698 products, "XSWITCH_OBJECTA", &psci_frame),
1699 " ");
1700 cpl_frameset_insert(objA_sci1d_frameset,
1701 cpl_frame_duplicate(sci_frame));
1702 cpl_frameset_insert(objB_sci1d_frameset,
1703 cpl_frame_duplicate(psci_frame));
1704 }
1705 int sci1d_size = cpl_frameset_get_size(objA_sci1d_frameset);
1706 if (sci1d_size > 0) {
1707 sci1d_list = moo_scilist_create(objA_sci1d_frameset);
1708 coadd1d_filename = cpl_sprintf("XSWITCH_SCI1D_OFFSET%d_%s.fits",
1709 offset, moo_mode_get_name(mode));
1710
1711 sci1d_coadd = moo_coadd(sci1d_list, coadd_params, coadd1d_filename);
1712
1713 moo_try_check(moo_sci_compute_snr(sci1d_coadd, sky_lines), " ");
1714
1715 moo_try_check(moo_products_add_sci(products, sci1d_coadd,
1716 CPL_FRAME_LEVEL_FINAL,
1717 MOONS_TAG_XSWITCH_SKSSPECTRA,
1718 coadd1d_filename, ref_frameA),
1719 " ");
1720 }
1721 int psci1d_size = cpl_frameset_get_size(objA_sci1d_frameset);
1722 if (psci1d_size > 0) {
1723 psci1d_list = moo_scilist_create(objB_sci1d_frameset);
1724 pcoadd1d_filename =
1725 cpl_sprintf("XSWITCH_SCI1D_PAIRED_OFFSET%d_%s.fits", offset,
1726 moo_mode_get_name(mode));
1727
1728 psci1d_coadd =
1729 moo_coadd(psci1d_list, coadd_params, pcoadd1d_filename);
1730
1731 moo_try_check(moo_sci_compute_snr(psci1d_coadd, sky_lines), " ");
1732
1733 moo_try_check(moo_products_add_sci(products, psci1d_coadd,
1734 CPL_FRAME_LEVEL_FINAL,
1735 MOONS_TAG_XSWITCH_SKSSPECTRA,
1736 pcoadd1d_filename, ref_frameB),
1737 " ");
1738 }
1739 {
1740 moo_sci *sci2d = NULL;
1741 moo_sci *psci2d = NULL;
1742 moo_sci *scicomb = NULL;
1743 char *result_filename = NULL;
1744
1745 sci2d = moo_sci_create(sci_frameA);
1746 psci2d = moo_sci_create(sci_frameB);
1747 result_filename = cpl_sprintf("XSWITCH_SCI_OFFSET%d_%s.fits",
1748 offset, moo_mode_get_name(mode));
1749
1750 scicomb = moo_combine_pair_sci(xswitch_target_table, sci1d_coadd,
1751 psci1d_coadd, sci2d, psci2d,
1752 result_filename);
1753
1754 moo_try_check(moo_sci_compute_snr(scicomb, sky_lines), " ");
1755
1756 moo_try_check(result = cpl_frame_duplicate(moo_products_add_sci(
1757 products, scicomb, CPL_FRAME_LEVEL_FINAL,
1758 MOONS_TAG_XSWITCH_SKSSPECTRA, result_filename,
1759 ref_frameA)),
1760 " ");
1761
1762 cpl_free(result_filename);
1763 moo_sci_delete(scicomb);
1764 moo_sci_delete(sci2d);
1765 moo_sci_delete(psci2d);
1766 }
1767 }
1768
1769moo_try_cleanup:
1770 if (!cpl_errorstate_is_equal(prestate)) {
1771 cpl_propertylist_delete(refA_header);
1772 }
1773 moo_extlist_delete(objA_extlist);
1774 moo_extlist_delete(objB_extlist);
1775
1776 if (wavemap_extlist != NULL) {
1777 for (int i = 0; i < nb_objA * 2; i++) {
1778 moo_extlist_unset(wavemap_extlist, 0);
1779 }
1780 }
1781 moo_extlist_delete(wavemap_extlist);
1782 moo_ext_delete(sum_ext);
1783 moo_loc_delete(loc);
1784 moo_map_delete(wmap);
1785 moo_map_delete(wmap_tuned);
1786 moo_target_table_delete(xswitch_target_table);
1787 cpl_free(xswitch_ttable_filename);
1788
1789 cpl_free(sum_ext_filename);
1790 cpl_free(wmap_tuned_filename);
1791 moo_spectral_format_delete(sformat);
1792
1793 cpl_frameset_delete(objA_frameset);
1794 cpl_frameset_delete(objB_frameset);
1795
1796 cpl_frameset_delete(nod_det_frameset);
1797 cpl_frameset_delete(objA_det_frameset);
1798 cpl_frameset_delete(objB_det_frameset);
1799
1800 cpl_frameset_delete(objB_ext_frameset);
1801 cpl_frameset_delete(objA_ext_frameset);
1802
1803 cpl_frameset_delete(objB_rbn_frameset);
1804 cpl_frameset_delete(objA_rbn_frameset);
1805
1806 cpl_frameset_delete(objA_sci1d_frameset);
1807 cpl_frameset_delete(objB_sci1d_frameset);
1808 cpl_frame_delete(nod_rbn_frame);
1809
1810 cpl_frameset_delete(objB_ref_frameset);
1811
1812 cpl_free(coadd1d_filename);
1813 moo_sci_delete(sci1d_coadd);
1814 moo_scilist_delete(sci1d_list);
1815
1816 cpl_free(pcoadd1d_filename);
1817 moo_sci_delete(psci1d_coadd);
1818 moo_scilist_delete(psci1d_list);
1819
1820 return result;
1821}
1822
1823static int
1824_moons_science_xswitch2(cpl_frameset *frameset,
1825 const cpl_parameterlist *parlist)
1826{
1827 /* parameters */
1828 moo_prepare_params *prepare_params = NULL;
1829 moo_correct_bias_params *correct_bias_params = NULL;
1830 moo_extract_params *extract_params = NULL;
1831 moo_wavesol_params *wavesol_params = NULL;
1832 moo_rebin_params *rbn_params = NULL;
1833 moo_target_table_params *target_table_params = NULL;
1834 moo_combine_pair_params *combine_pair_params = NULL;
1835 moo_sub_sky_stare_params *sky_params = NULL;
1836 moo_coadd_params *coadd_params = NULL;
1837 moo_create_s1d_params *s1d_params = NULL;
1838
1839 moo_scilist *sci_list = NULL;
1840 moo_sci *sci_coadd = NULL;
1841
1842 cpl_frameset *offset_frameset = NULL;
1843 cpl_frameset *set = NULL;
1844 cpl_frameset *sci_set = NULL;
1845 cpl_frameset *ref_frameset = NULL;
1846
1847 const char *bpmap_rp_name = NULL;
1848 const char *bpmap_nl_name = NULL;
1849 const cpl_frame *masterbias = NULL;
1850 const cpl_frame *masterdark_vis = NULL;
1851 cpl_frameset *masterdark_nir = NULL;
1852 const cpl_frame *p2pmap = NULL;
1853 const cpl_frame *sformat_frame = NULL;
1854 const cpl_frame *sky_lines_frame = NULL;
1855 const cpl_frame *atmo_frame = NULL;
1856 const cpl_frame *resp_frame = NULL;
1857 const cpl_frame *tell_frame = NULL;
1858
1859 const cpl_frame *airglow_group_frame = NULL;
1860 const cpl_frame *solflux_frame = NULL;
1861 const cpl_frame *airglow_var_frame = NULL;
1862 const cpl_frame *ref_frame = NULL;
1863 cpl_size nsel = 0;
1864 cpl_size *selection = NULL;
1865 moo_sky_lines_list *skylines = NULL;
1866 char *coadd_filename = NULL;
1867 char *calibflux_filename = NULL;
1868
1869 cpl_errorstate prestate = cpl_errorstate_get();
1870
1871 moo_products *products =
1872 moo_products_new(frameset, parlist, "moons_science_xswitch2",
1873 PACKAGE "/" PACKAGE_VERSION);
1874
1875 const moo_params *params = moo_products_get_params(products);
1876 moo_try_check(prepare_params = moo_params_get_prepare(params, parlist),
1877 " ");
1878 moo_try_check(correct_bias_params =
1879 moo_params_get_correct_bias(params, parlist),
1880 " ");
1881 moo_try_check(extract_params = moo_params_get_extract(params, parlist),
1882 " ");
1883 moo_try_check(rbn_params = moo_params_get_rebin(params, parlist), " ");
1884 moo_try_check(target_table_params =
1885 moo_params_get_target_table(params, parlist),
1886 " ");
1887 moo_try_check(combine_pair_params =
1888 moo_params_get_combine_pair(params, parlist),
1889 " ");
1890 moo_try_check(sky_params = moo_params_get_sub_sky_stare(params, parlist),
1891 " ");
1892 moo_try_check(coadd_params = moo_params_get_coadd(params, parlist), " ");
1893 moo_try_check(wavesol_params =
1894 moo_params_get_science_wavesol(params, parlist),
1895 " ");
1896 moo_try_check(s1d_params = moo_params_get_create_s1d(params, parlist), " ");
1897 /* SOF file */
1898 offset_frameset = cpl_frameset_new();
1899 sci_set = cpl_frameset_new();
1900
1901 ref_frameset = cpl_frameset_new();
1902 masterdark_nir = cpl_frameset_new();
1903
1904 moo_try_check(_moons_science_xswitch2_check_sof(
1905 frameset, offset_frameset, &bpmap_rp_name, &bpmap_nl_name,
1906 &masterbias, &masterdark_vis, masterdark_nir, &p2pmap,
1907 &sformat_frame, &sky_lines_frame, &atmo_frame,
1908 &resp_frame, &tell_frame, &airglow_group_frame,
1909 &airglow_var_frame, &solflux_frame, sky_params),
1910 " ");
1911
1912 // cpl_frameset_sort(offset_frameset, _moons_sort_mjdobs);
1913 moo_try_check(selection =
1914 cpl_frameset_labelise(offset_frameset,
1915 &_moons_compare_offset, &nsel),
1916 " ");
1917
1918 moo_try_check(skylines = moo_sky_lines_list_load(sky_lines_frame), " ");
1919
1920 for (int i = 0; i < nsel; i++) {
1921 cpl_frame *result = NULL;
1922 moo_try_check(set = cpl_frameset_extract(offset_frameset, selection, i),
1923 " ");
1924 moo_try_check(result = _moons_science_xswitch2_byoffset(
1925 set, ref_frameset, bpmap_rp_name, bpmap_nl_name,
1926 masterbias, masterdark_vis, masterdark_nir, p2pmap,
1927 sformat_frame, skylines, airglow_group_frame,
1928 solflux_frame, airglow_var_frame, atmo_frame,
1929 resp_frame, tell_frame, prepare_params,
1930 correct_bias_params, extract_params, wavesol_params,
1931 rbn_params, target_table_params, sky_params,
1932 coadd_params, products),
1933 " ");
1934 cpl_frameset_insert(sci_set, result);
1935 cpl_frameset_delete(set);
1936 set = NULL;
1937 }
1938
1939 moo_try_check(ref_frame = cpl_frameset_get_position_const(ref_frameset, 0),
1940 " ");
1941 moo_mode_type mode = moo_mode_get(ref_frame);
1942
1943 sci_list = moo_scilist_create(sci_set);
1944 coadd_filename =
1945 cpl_sprintf("%s_%s.fits", MOONS_TAG_XSWITCH2_COMBINED_SPECTRA,
1946 moo_mode_get_name(mode));
1947
1948 sci_coadd = moo_coadd(sci_list, coadd_params, coadd_filename);
1949
1950 moo_try_check(moo_sci_compute_snr(sci_coadd, skylines), " ");
1951 cpl_frame *sci_final = NULL;
1952
1953 moo_try_check(sci_final =
1954 moo_products_add_sci(products, sci_coadd,
1955 CPL_FRAME_LEVEL_FINAL,
1956 MOONS_TAG_XSWITCH2_COMBINED_SPECTRA,
1957 coadd_filename, ref_frame),
1958 " ");
1959 moo_create_s1d(sci_final, s1d_params, MOONS_TAG_SCIENCE_XSWITCH2_1DSPECTRUM,
1960 products);
1961
1962
1963moo_try_cleanup:
1964 if (!cpl_errorstate_is_equal(prestate)) {
1965 cpl_frameset_delete(set);
1966 }
1967 cpl_free(coadd_filename);
1968 cpl_free(calibflux_filename);
1969 cpl_free(selection);
1970 moo_sci_delete(sci_coadd);
1971 moo_scilist_delete(sci_list);
1972 moo_sky_lines_list_delete(skylines);
1973
1974 cpl_frameset_delete(sci_set);
1975
1976 cpl_frameset_delete(ref_frameset);
1977 cpl_frameset_delete(offset_frameset);
1978 cpl_frameset_delete(masterdark_nir);
1979
1980 moo_extract_params_delete(extract_params);
1981 moo_wavesol_params_delete(wavesol_params);
1982 moo_rebin_params_delete(rbn_params);
1983 moo_target_table_params_delete(target_table_params);
1984
1985 moo_combine_pair_params_delete(combine_pair_params);
1986 moo_sub_sky_stare_params_delete(sky_params);
1987 moo_coadd_params_delete(coadd_params);
1988 moo_correct_bias_params_delete(correct_bias_params);
1989 moo_prepare_params_delete(prepare_params);
1990 moo_create_s1d_params_delete(s1d_params);
1991 moo_products_delete(products);
1992 return (int)cpl_error_get_code();
1993}
moo_atm_load
moo_atm * moo_atm_load(const cpl_frame *frame)
Load a ATM frame and create a moo_atm.
Definition: moo_atm.c:83
moo_atm_delete
void moo_atm_delete(moo_atm *self)
Delete a moo_atm.
Definition: moo_atm.c:154
MOO_BADPIX_GOOD
#define MOO_BADPIX_GOOD
Definition: moo_badpix.h:36
moo_det_create
moo_det * moo_det_create(const cpl_frame *frame)
Create a new moo_det from the given DET frame.
Definition: moo_det.c:91
moo_det_load
cpl_error_code moo_det_load(moo_det *self, unsigned int level)
Load all parts in DET.
Definition: moo_det.c:135
moo_det_delete
void moo_det_delete(moo_det *self)
Delete a moo_det.
Definition: moo_det.c:472
moo_det_get_single
moo_single * moo_det_get_single(moo_det *self, moo_detector_type type, int num)
Get the type part in DET and return it.
Definition: moo_det.c:359
moo_mode_get
moo_mode_type moo_mode_get(const cpl_frame *frame)
Get the name of a mode from a frame.
Definition: moo_detector.c:224
moo_mode_get_name
const char * moo_mode_get_name(moo_mode_type type)
Get the name of a mode.
Definition: moo_detector.c:204
moo_detlist_create
moo_detlist * moo_detlist_create(cpl_frameset *frameset)
Create a new moo_detlist from the given DET frameset.
Definition: moo_detlist.c:71
moo_detlist_delete
void moo_detlist_delete(moo_detlist *self)
Free all memory used by a moo_detlist object including the DET.
Definition: moo_detlist.c:559
moo_ext_create
moo_ext * moo_ext_create(const cpl_frame *frame)
Create a new empty EXT filename.
Definition: moo_ext.c:86
moo_ext_delete
void moo_ext_delete(moo_ext *self)
Delete a moo_ext.
Definition: moo_ext.c:370
moo_ext_compute_snr
cpl_error_code moo_ext_compute_snr(moo_ext *self, moo_map *wmap, moo_spectral_format *sformat, moo_sky_lines_list *skylines)
Compute SNR for all fibres EXT.
Definition: moo_ext.c:553
moo_extlist_get
moo_ext * moo_extlist_get(moo_extlist *self, int i)
Get the DET at the position i in the list.
Definition: moo_extlist.c:197
moo_extlist_set
cpl_error_code moo_extlist_set(moo_extlist *self, moo_ext *ext, cpl_size pos)
Insert a DET into an moo_extlist.
Definition: moo_extlist.c:376
moo_extlist_unset
moo_ext * moo_extlist_unset(moo_extlist *self, cpl_size pos)
Remove a DET from a DET list.
Definition: moo_extlist.c:467
moo_extlist_sum
moo_ext * moo_extlist_sum(moo_extlist *self, const char *filename)
Sum EXT element from the list and save result in filename.
Definition: moo_extlist.c:581
moo_extlist_delete
void moo_extlist_delete(moo_extlist *self)
Free all memory used by a moo_extlist object including the DET.
Definition: moo_extlist.c:561
moo_extlist_create
moo_extlist * moo_extlist_create(cpl_frameset *frameset)
Create a new moo_extlist from the given DET frameset.
Definition: moo_extlist.c:72
moo_extlist_new
moo_extlist * moo_extlist_new(void)
Create a new moo_extlist.
Definition: moo_extlist.c:57
moo_f2f_delete
void moo_f2f_delete(moo_f2f *self)
Delete a moo_f2f.
Definition: moo_f2f.c:413
moo_f2f_load
moo_f2f * moo_f2f_load(const cpl_frame *f2f_frame)
Load a F2F table from a fits file.
Definition: moo_f2f.c:139
moo_loc_load
moo_loc * moo_loc_load(const cpl_frame *locframe)
Load a LOC frame and create a moo_loc.
Definition: moo_loc.c:109
moo_loc_delete
void moo_loc_delete(moo_loc *self)
Delete a moo_loc.
Definition: moo_loc.c:332
moo_map_save
void moo_map_save(moo_map *self, const char *filename)
Save a moo_map to a FITS file.
Definition: moo_map.c:275
moo_map_delete
void moo_map_delete(moo_map *self)
Delete a moo_map.
Definition: moo_map.c:236
moo_params_get_coadd
moo_coadd_params * moo_params_get_coadd(const moo_params *self, const cpl_parameterlist *list)
Get coadd parameters from moons parameters list.
Definition: moo_params.c:3147
moo_params_add_create_s1d
cpl_error_code moo_params_add_create_s1d(moo_params *self, cpl_parameterlist *list)
Add default parameters for create_s1d.
Definition: moo_params.c:2437
moo_create_s1d_params_delete
void moo_create_s1d_params_delete(moo_create_s1d_params *self)
Delete a moo_create_s1d_params.
Definition: moo_params.c:2353
moo_params_add_extract
cpl_error_code moo_params_add_extract(moo_params *self, cpl_parameterlist *list)
Add default parameters for extraction.
Definition: moo_params.c:902
moo_params_add_sub_sky_stare
cpl_error_code moo_params_add_sub_sky_stare(moo_params *self, cpl_parameterlist *list)
Add default parameters for moo_sub_sky_stare.
Definition: moo_params.c:2179
moo_params_get_create_s1d
moo_create_s1d_params * moo_params_get_create_s1d(const moo_params *self, const cpl_parameterlist *list)
Get create s1d parameters from moons parameters list.
Definition: moo_params.c:1614
moo_params_get_prepare
moo_prepare_params * moo_params_get_prepare(const moo_params *self, const cpl_parameterlist *list)
Get remove prepare parameters from moons parameters list.
Definition: moo_params.c:1073
moo_params_get_sub_sky_stare
moo_sub_sky_stare_params * moo_params_get_sub_sky_stare(const moo_params *self, const cpl_parameterlist *list)
Get sub sky stare parameters from moons parameters list.
Definition: moo_params.c:2909
moo_params_get_combine_pair
moo_combine_pair_params * moo_params_get_combine_pair(const moo_params *self, const cpl_parameterlist *list)
Get combine_pair parameters from moons parameters list.
Definition: moo_params.c:3035
moo_params_add_target_table
cpl_error_code moo_params_add_target_table(moo_params *self, cpl_parameterlist *list, int value)
Add default parameters for moo_create_target_table.
Definition: moo_params.c:2616
moo_params_add_combine_pair
cpl_error_code moo_params_add_combine_pair(moo_params *self, cpl_parameterlist *list, int value)
Add default parameters for moo_combine_pair.
Definition: moo_params.c:2591
moo_params_get_target_table
moo_target_table_params * moo_params_get_target_table(const moo_params *self, const cpl_parameterlist *list)
Get target_table parameters from moons parameters list.
Definition: moo_params.c:3063
moo_params_add_science_wavesol
cpl_error_code moo_params_add_science_wavesol(moo_params *self, cpl_parameterlist *list)
Add default science parameters for moo_wavesol.
Definition: moo_params.c:2091
moo_params_get_correct_bias
moo_correct_bias_params * moo_params_get_correct_bias(const moo_params *self, const cpl_parameterlist *list)
Get correct_bias parameters from moons parameters list.
Definition: moo_params.c:1167
moo_params_get_extract
moo_extract_params * moo_params_get_extract(const moo_params *self, const cpl_parameterlist *list)
Get extraction parameters from moons parameters list.
Definition: moo_params.c:1197
moo_params_get_science_wavesol
moo_wavesol_params * moo_params_get_science_wavesol(const moo_params *self, const cpl_parameterlist *list)
Get science_wavesol parameters from moons parameters list.
Definition: moo_params.c:2790
moo_params_delete
void moo_params_delete(moo_params *self)
Delete a moo_params.
Definition: moo_params.c:85
moo_params_add_correct_bias
cpl_error_code moo_params_add_correct_bias(moo_params *self, cpl_parameterlist *list, const char *method)
Add default parameters for correct_bias.
Definition: moo_params.c:860
moo_params_add_keep_temp
cpl_error_code moo_params_add_keep_temp(moo_params *self, cpl_parameterlist *list)
Add default parameters for keep-temp.
Definition: moo_params.c:932
moo_params_add_prepare
cpl_error_code moo_params_add_prepare(moo_params *self, cpl_parameterlist *list)
Add default parameters for prepare.
Definition: moo_params.c:667
moo_params_get_rebin
moo_rebin_params * moo_params_get_rebin(const moo_params *self, const cpl_parameterlist *list)
Get rebin parameters from moons parameters list.
Definition: moo_params.c:2866
moo_params_add_coadd
cpl_error_code moo_params_add_coadd(moo_params *self, cpl_parameterlist *list)
Add default parameters for moo_coadd.
Definition: moo_params.c:2687
moo_params_new
moo_params * moo_params_new(const char *pid, const char *recipe_id)
Create a new moo_params.
Definition: moo_params.c:62
moo_params_add_rebin
cpl_error_code moo_params_add_rebin(moo_params *self, cpl_parameterlist *list)
Add default parameters for moo_rebin.
Definition: moo_params.c:2152
moo_psf_delete
void moo_psf_delete(moo_psf *self)
Delete a moo_psf.
Definition: moo_psf.c:264
moo_psf_load
moo_psf * moo_psf_load(const cpl_frame *psfframe)
Load a PSF frame and create a moo_psf.
Definition: moo_psf.c:109
moo_rbn_delete
void moo_rbn_delete(moo_rbn *self)
Delete a moo_rbn.
Definition: moo_rbn.c:120
moo_rbn_create
moo_rbn * moo_rbn_create(const cpl_frame *frame)
Create a new empty RBN filename.
Definition: moo_rbn.c:85
moo_rbn_compute_snr
cpl_error_code moo_rbn_compute_snr(moo_rbn *self, moo_sky_lines_list *skylines)
Compute SNR for targets in RBN.
Definition: moo_rbn.c:421
moo_rbnlist_delete
void moo_rbnlist_delete(moo_rbnlist *self)
Free all memory used by a moo_rbnlist object including the RBN.
Definition: moo_rbnlist.c:529
moo_rbnlist_create
moo_rbnlist * moo_rbnlist_create(const cpl_frameset *frameset)
Create a new moo_rbnlist from the given RBN frameset.
Definition: moo_rbnlist.c:71
moo_resp_delete
void moo_resp_delete(moo_resp *self)
Delete a moo_resp.
Definition: moo_resp.c:320
moo_resp_load
moo_resp * moo_resp_load(const cpl_frame *frame)
Load a RESP frame and create a moo_resp.
Definition: moo_resp.c:401
moo_sci_delete
void moo_sci_delete(moo_sci *self)
Delete a moo_sci.
Definition: moo_sci.c:84
moo_sci_create
moo_sci * moo_sci_create(const cpl_frame *frame)
Create a new empty SCI filename.
Definition: moo_sci.c:249
moo_sci_compute_snr
cpl_error_code moo_sci_compute_snr(moo_sci *self, moo_sky_lines_list *skylines)
Compute SNR for all targets in SCI.
Definition: moo_sci.c:415
moo_scilist_delete
void moo_scilist_delete(moo_scilist *self)
Free all memory used by a moo_scilist object including the SCI.
Definition: moo_scilist.c:176
moo_scilist_create
moo_scilist * moo_scilist_create(cpl_frameset *frameset)
Create a new moo_scilist from the given SCI frameset.
Definition: moo_scilist.c:321
moo_sky_lines_list_load
moo_sky_lines_list * moo_sky_lines_list_load(const cpl_frame *frame)
Load a SKY_LINES_LIST frame and create a moo_sky_lines_list.
Definition: moo_sky_lines_list.c:81
moo_sky_lines_list_delete
void moo_sky_lines_list_delete(moo_sky_lines_list *self)
Delete a moo_sky_lines_list.
Definition: moo_sky_lines_list.c:107
moo_spectral_format_delete
void moo_spectral_format_delete(moo_spectral_format *self)
Delete a moo_spectral_format.
Definition: moo_spectral_format.c:224
moo_spectral_format_load
moo_spectral_format * moo_spectral_format_load(const cpl_frame *frame, moo_mode_type m)
Load a SPECTRAL FORMAT frame and create a moo_spectral_format.
Definition: moo_spectral_format.c:99
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_mode
enum _moo_target_table_mode_ moo_target_table_mode
The type code type.
Definition: moo_target_table.h:156
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_telluric_load
moo_telluric * moo_telluric_load(const cpl_frame *frame)
Load a TELLURIC frame and create a moo_telluric.
Definition: moo_telluric.c:405
moo_telluric_delete
void moo_telluric_delete(moo_telluric *self)
Delete a moo_telluric.
Definition: moo_telluric.c:334
moo_dfs_set_groups
cpl_error_code moo_dfs_set_groups(cpl_frameset *set)
Set the group as RAW or CALIB in a frameset.
Definition: moo_dfs.c:206
moo_remove_CRH
moo_det * moo_remove_CRH(moo_detlist *detlist, moo_masklist *cosmiclist, moo_crh_params *params)
Remove CRH in single frames or in a combination of multiple frames.
Definition: moo_remove_crh.c:427
moo_extract
moo_ext * moo_extract(moo_det *det, moo_loc *loc, moo_psf *master_flat, moo_extract_params *params, const char *filename)
extract the 1D spectrum of fibres
Definition: moo_extract.c:523
moo_combine_sky
moo_rbn * moo_combine_sky(moo_rbnlist *rbnlist)
Combine RBN sky frames.
Definition: moo_combine_sky.c:208
moo_correct_tell
cpl_error_code moo_correct_tell(moo_rbn *rbn, moo_telluric *tell)
Apply the telluric correction to 1D rebinned spectra.
Definition: moo_correct_tell.c:124
moo_coadd
moo_sci * moo_coadd(moo_scilist *scilist, moo_coadd_params *params, const char *filename)
Co-add reduced science frames in SCI format.
Definition: moo_coadd.c:134
moo_wavesol
moo_map * moo_wavesol(moo_ext *arc_ext, const char *lineCatname, moo_spectral_format *sformat, moo_loc *loc, moo_map *wmap, moo_wavesol_params *params)
Computes the wavelength solution from 1D extracted arc spectra.
Definition: moo_wavesol.c:2728
moo_apply_p2p
cpl_error_code moo_apply_p2p(moo_det *flat, moo_det *p2pmap)
Divide DET by the pixel-to-pixel variation map.
Definition: moo_apply_p2p.c:122
moo_create_s1d
cpl_error_code moo_create_s1d(cpl_frame *sci_frame, moo_create_s1d_params *params, const char *tag, moo_products *products)
Apply the telluric correction to SCI.
Definition: moo_create_s1d.c:177
moo_rebin
moo_rbn * moo_rebin(moo_ext *ext, moo_map *wmap, moo_spectral_format *sformat, moo_rebin_params *params, const char *filename)
Rebin an EXT spectra in RBN format.
Definition: moo_rebin.c:783
moo_prepare
moo_det * moo_prepare(const cpl_frame *rawframe, const char *const badpixmask_rp, const char *const badpixmask_nl, const cpl_frame *masterbias, const cpl_frame *cube_frame, moo_prepare_params *params)
This function transforms RAW frames in DET frames attaching the default bad pixel map and an error im...
Definition: moo_prepare.c:324
moo_calib_flux
cpl_error_code moo_calib_flux(moo_rbn *rbn, moo_atm *atm, moo_resp *resp)
Apply the relative flux calibration to 1D rebinned spectra.
Definition: moo_calib_flux.c:143
moo_apply_flat
cpl_error_code moo_apply_flat(moo_ext *ext, moo_ext *flat, moo_f2f *f2f)
Divide spectra by 1D flat-field.
Definition: moo_apply_flat.c:182
moo_correct_bias
cpl_error_code moo_correct_bias(moo_det *det, const cpl_frame *masterbias_frame, moo_correct_bias_params *params)
Subtracts the Master Bias frame from a DET frame.
Definition: moo_drl.c:86
moo_subtract_nod
moo_det * moo_subtract_nod(moo_det *object, moo_det *sky, const char *filename)
Sky from object subtraction.
Definition: moo_subtract_nod.c:70
moo_sub_sky_stare
moo_sci * moo_sub_sky_stare(moo_rbn *obja_rbn, moo_target_table *target_table, moo_rbn *objb_rbn, moo_f2f *f2f, const cpl_frame *solflux_frame, const cpl_frame *airglow_group_frame, const cpl_frame *airglow_var_frame, moo_sub_sky_stare_params *params, const char *filename, int ispaired)
This function subtracts the sky in wavelength calibrated and extracted science frames obtain in Stare...
Definition: moo_sub_sky_stare.c:810
moo_correct_dark
cpl_error_code moo_correct_dark(moo_det *det, moo_det *detoff, const cpl_frame *masterDarkVis, const cpl_frame *masterDarkNir)
Subtracts the master dark frame from a frame after scaling for exposure time (RI)....
Definition: moo_drl.c:250
moo_pfits_get_ndit
int moo_pfits_get_ndit(const cpl_propertylist *plist)
find out the ESO DET NDIT value
Definition: moo_pfits.c:382
moo_pfits_get_dit
double moo_pfits_get_dit(const cpl_propertylist *plist)
find out the DIT value
Definition: moo_pfits.c:362
moo_pfits_get_mjdobs
double moo_pfits_get_mjdobs(const cpl_propertylist *plist)
find out the MJD-OBS
Definition: moo_pfits.c:328
moo_pfits_get_slit_offset
int moo_pfits_get_slit_offset(const cpl_propertylist *plist)
find out the INS SLIT OFFSET value
Definition: moo_pfits.c:1110
moo_products_new
moo_products * moo_products_new(cpl_frameset *framelist, const cpl_parameterlist *parlist, const char *recid, const char *pipeline_id)
create a moo_product object for a recipe
Definition: moo_products.c:53
moo_products_add_sci
cpl_frame * moo_products_add_sci(moo_products *self, moo_sci *sci, cpl_frame_level level, const char *tag, const char *filename, const cpl_frame *inherit_frame)
create a product from a SCI object
Definition: moo_products.c:420
moo_products_add_rbn
cpl_frame * moo_products_add_rbn(moo_products *self, moo_rbn *rbn, cpl_frame_level level, const char *tag, const char *filename, const cpl_frame *inherit_frame)
create a product from a RBN object
Definition: moo_products.c:376
moo_products_add_ext
cpl_frame * moo_products_add_ext(moo_products *self, moo_ext *ext, cpl_frame_level level, const char *tag, const char *filename, const cpl_frame *inherit_frame)
create a product from a EXT object
Definition: moo_products.c:333
moo_products_add_target_table
cpl_frame * moo_products_add_target_table(moo_products *self, moo_target_table *ttable, cpl_frame_level level, const char *tag, const char *filename, const cpl_frame *inherit_frame)
create a product from a TARGET_TABLE object
Definition: moo_products.c:774
moo_products_add
cpl_frame * moo_products_add(moo_products *self, moo_det *det, cpl_frame_level level, const char *tag, const char *filename, const cpl_frame *inherit_frame)
create a product from a DET object
Definition: moo_products.c:203
moo_products_get_params
const moo_params * moo_products_get_params(const moo_products *self)
get the moo_params object
Definition: moo_products.c:87
moo_get_license
const char * moo_get_license(void)
Get the pipeline copyright and license.
Definition: moo_utils.c:81
moo_target_table
the different type of detectors
Definition: moo_target_table.h:124
Generated on Wed Oct 8 2025 20:38:51 for MOONS Pipeline Reference Manual by doxygen 1.9.6