MUSE Pipeline Reference Manual  1.0.2
muse_create_sky_z.c
1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim:set sw=2 sts=2 et cin: */
3 /*
4  * This file is part of the MUSE Instrument Pipeline
5  * Copyright (C) 2005-2014 European Southern Observatory
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20  */
21 
22 /* This file was automatically generated */
23 
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27 
28 /*----------------------------------------------------------------------------*
29  * Includes *
30  *----------------------------------------------------------------------------*/
31 #include <string.h> /* strcmp(), strstr() */
32 #include <strings.h> /* strcasecmp() */
33 #include <cpl.h>
34 
35 #include "muse_create_sky_z.h" /* in turn includes muse.h */
36 
37 /*----------------------------------------------------------------------------*/
47 /*----------------------------------------------------------------------------*/
50 /*----------------------------------------------------------------------------*
51  * Static variables *
52  *----------------------------------------------------------------------------*/
53 static const char *muse_create_sky_help =
54  "This recipe creates the continuum and the atmospheric transition line spectra of the night sky from the data in a pixel table(s) belonging to one exposure of (mostly) empty sky.";
55 
56 static const char *muse_create_sky_help_esorex =
57  "\n\nInput frames for raw frame tag \"PIXTABLE_SKY\":\n"
58  "\n Frame tag Type Req #Fr Description"
59  "\n -------------------- ---- --- --- ------------"
60  "\n PIXTABLE_SKY raw Y Input pixel table. If the pixel table is not already flux calibrated, the corresponding flux calibration frames should be given as well."
61  "\n EXTINCT_TABLE calib Y 1 Atmospheric extinction table"
62  "\n STD_RESPONSE calib Y 1 Response curve as derived from standard star(s)"
63  "\n STD_TELLURIC calib . 1 Telluric absorption as derived from standard star(s)"
64  "\n SKY_LINES calib Y 1 List of OH transitions and other sky lines"
65  "\n SKY_CONTINUUM calib . 1 Sky continuum to use"
66  "\n LSF_PROFILE calib . Slice specific LSF parameters"
67  "\n SKY_MASK calib . 1 Sky mask to use"
68  "\n\nProduct frames for raw frame tag \"PIXTABLE_SKY\":\n"
69  "\n Frame tag Level Description"
70  "\n -------------------- -------- ------------"
71  "\n SKY_MASK intermed Created sky mask"
72  "\n IMAGE_FOV intermed Whitelight image used to create the sky mask"
73  "\n SKY_SPECTRUM intermed Sky spectrum within the sky mask"
74  "\n SKY_LINES final Estimated sky line flux table"
75  "\n SKY_CONTINUUM final Estimated continuum flux spectrum";
76 
77 /*----------------------------------------------------------------------------*/
85 /*----------------------------------------------------------------------------*/
86 static cpl_recipeconfig *
87 muse_create_sky_new_recipeconfig(void)
88 {
89  cpl_recipeconfig *recipeconfig = cpl_recipeconfig_new();
90  const char *tag;
91 
92  tag = "PIXTABLE_SKY";
93  cpl_recipeconfig_set_tag(recipeconfig, tag, 1, -1);
94  cpl_recipeconfig_set_input(recipeconfig, tag, "EXTINCT_TABLE", 1, 1);
95  cpl_recipeconfig_set_input(recipeconfig, tag, "STD_RESPONSE", 1, 1);
96  cpl_recipeconfig_set_input(recipeconfig, tag, "STD_TELLURIC", -1, 1);
97  cpl_recipeconfig_set_input(recipeconfig, tag, "SKY_LINES", 1, 1);
98  cpl_recipeconfig_set_input(recipeconfig, tag, "SKY_CONTINUUM", 0, 1);
99  cpl_recipeconfig_set_input(recipeconfig, tag, "LSF_PROFILE", 0, -1);
100  cpl_recipeconfig_set_input(recipeconfig, tag, "SKY_MASK", 0, 1);
101  cpl_recipeconfig_set_output(recipeconfig, tag, "SKY_MASK");
102  cpl_recipeconfig_set_output(recipeconfig, tag, "IMAGE_FOV");
103  cpl_recipeconfig_set_output(recipeconfig, tag, "SKY_SPECTRUM");
104  cpl_recipeconfig_set_output(recipeconfig, tag, "SKY_LINES");
105  cpl_recipeconfig_set_output(recipeconfig, tag, "SKY_CONTINUUM");
106 
107  return recipeconfig;
108 } /* muse_create_sky_new_recipeconfig() */
109 
110 /*----------------------------------------------------------------------------*/
120 /*----------------------------------------------------------------------------*/
121 static cpl_error_code
122 muse_create_sky_prepare_header(const char *aFrametag, cpl_propertylist *aHeader)
123 {
124  cpl_ensure_code(aFrametag, CPL_ERROR_NULL_INPUT);
125  cpl_ensure_code(aHeader, CPL_ERROR_NULL_INPUT);
126  if (!strcmp(aFrametag, "SKY_MASK")) {
127  muse_processing_prepare_property(aHeader, "ESO QC SKY THRESHOLD",
128  CPL_TYPE_DOUBLE,
129  "Threshold in the white light considered as sky, used to create this mask");
130  } else if (!strcmp(aFrametag, "IMAGE_FOV")) {
131  } else if (!strcmp(aFrametag, "SKY_SPECTRUM")) {
132  } else if (!strcmp(aFrametag, "SKY_LINES")) {
133  muse_processing_prepare_property(aHeader, "ESO QC SKY LINE[0-9]+ NAME",
134  CPL_TYPE_STRING,
135  "Name of the strongest line in group k");
136  muse_processing_prepare_property(aHeader, "ESO QC SKY LINE[0-9]+ AWAV",
137  CPL_TYPE_DOUBLE,
138  "[Angstrom] Wavelength (air) of the strongest line of group l");
139  muse_processing_prepare_property(aHeader, "ESO QC SKY LINE[0-9]+ FLUX",
140  CPL_TYPE_DOUBLE,
141  "[erg/(s cm2 arcsec2)] Flux of the strongest line of group l");
142  } else if (!strcmp(aFrametag, "SKY_CONTINUUM")) {
143  muse_processing_prepare_property(aHeader, "ESO QC SKY CONT FLUX",
144  CPL_TYPE_DOUBLE,
145  "[erg/(s cm2 arcsec2)] Total flux of the continuum");
146  muse_processing_prepare_property(aHeader, "ESO QC SKY CONT MAXDEV",
147  CPL_TYPE_DOUBLE,
148  "[erg/(s cm2 arcsec2 Angstrom)] Maximum (absolute value) of the derivative of the continuum spectrum");
149  } else {
150  cpl_msg_warning(__func__, "Frame tag %s is not defined", aFrametag);
151  return CPL_ERROR_ILLEGAL_INPUT;
152  }
153  return CPL_ERROR_NONE;
154 } /* muse_create_sky_prepare_header() */
155 
156 /*----------------------------------------------------------------------------*/
165 /*----------------------------------------------------------------------------*/
166 static cpl_frame_level
167 muse_create_sky_get_frame_level(const char *aFrametag)
168 {
169  if (!aFrametag) {
170  return CPL_FRAME_LEVEL_NONE;
171  }
172  if (!strcmp(aFrametag, "SKY_MASK")) {
173  return CPL_FRAME_LEVEL_INTERMEDIATE;
174  }
175  if (!strcmp(aFrametag, "IMAGE_FOV")) {
176  return CPL_FRAME_LEVEL_INTERMEDIATE;
177  }
178  if (!strcmp(aFrametag, "SKY_SPECTRUM")) {
179  return CPL_FRAME_LEVEL_INTERMEDIATE;
180  }
181  if (!strcmp(aFrametag, "SKY_LINES")) {
182  return CPL_FRAME_LEVEL_FINAL;
183  }
184  if (!strcmp(aFrametag, "SKY_CONTINUUM")) {
185  return CPL_FRAME_LEVEL_FINAL;
186  }
187  return CPL_FRAME_LEVEL_NONE;
188 } /* muse_create_sky_get_frame_level() */
189 
190 /*----------------------------------------------------------------------------*/
199 /*----------------------------------------------------------------------------*/
200 static muse_frame_mode
201 muse_create_sky_get_frame_mode(const char *aFrametag)
202 {
203  if (!aFrametag) {
204  return MUSE_FRAME_MODE_ALL;
205  }
206  if (!strcmp(aFrametag, "SKY_MASK")) {
207  return MUSE_FRAME_MODE_MASTER;
208  }
209  if (!strcmp(aFrametag, "IMAGE_FOV")) {
210  return MUSE_FRAME_MODE_MASTER;
211  }
212  if (!strcmp(aFrametag, "SKY_SPECTRUM")) {
213  return MUSE_FRAME_MODE_MASTER;
214  }
215  if (!strcmp(aFrametag, "SKY_LINES")) {
216  return MUSE_FRAME_MODE_MASTER;
217  }
218  if (!strcmp(aFrametag, "SKY_CONTINUUM")) {
219  return MUSE_FRAME_MODE_MASTER;
220  }
221  return MUSE_FRAME_MODE_ALL;
222 } /* muse_create_sky_get_frame_mode() */
223 
224 /*----------------------------------------------------------------------------*/
234 /*----------------------------------------------------------------------------*/
235 static int
236 muse_create_sky_create(cpl_plugin *aPlugin)
237 {
238  /* Check that the plugin is part of a valid recipe */
239  cpl_recipe *recipe;
240  if (cpl_plugin_get_type(aPlugin) == CPL_PLUGIN_TYPE_RECIPE) {
241  recipe = (cpl_recipe *)aPlugin;
242  } else {
243  return -1;
244  }
245 
246  /* register the extended processing information (new FITS header creation, *
247  * getting of the frame level for a certain tag) */
249  muse_create_sky_new_recipeconfig(),
250  muse_create_sky_prepare_header,
251  muse_create_sky_get_frame_level,
252  muse_create_sky_get_frame_mode);
253 
254  /* XXX initialize timing in messages *
255  * since at least esorex is too stupid to turn it on, we have to do it */
257  cpl_msg_set_time_on();
258  }
259 
260  /* Create the parameter list in the cpl_recipe object */
261  recipe->parameters = cpl_parameterlist_new();
262  /* Fill the parameters list */
263  cpl_parameter *p;
264 
265  /* --fraction: Fraction of the image to be considered as sky. If an input sky mask is provided, the fraction is applied to the regions within the mask. If the whole sky mask should be used, set this parameter to 1. */
266  p = cpl_parameter_new_value("muse.muse_create_sky.fraction",
267  CPL_TYPE_DOUBLE,
268  "Fraction of the image to be considered as sky. If an input sky mask is provided, the fraction is applied to the regions within the mask. If the whole sky mask should be used, set this parameter to 1.",
269  "muse.muse_create_sky",
270  (double)0.75);
271  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "fraction");
272  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "fraction");
273 
274  cpl_parameterlist_append(recipe->parameters, p);
275 
276  /* --sampling: Spectral sampling of the sky spectrum [Angstrom]. */
277  p = cpl_parameter_new_value("muse.muse_create_sky.sampling",
278  CPL_TYPE_DOUBLE,
279  "Spectral sampling of the sky spectrum [Angstrom].",
280  "muse.muse_create_sky",
281  (double)1.25);
282  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "sampling");
283  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "sampling");
284  if (!getenv("MUSE_EXPERT_USER")) {
285  cpl_parameter_disable(p, CPL_PARAMETER_MODE_CLI);
286  }
287 
288  cpl_parameterlist_append(recipe->parameters, p);
289 
290  /* --csampling: Spectral sampling of the continuum spectrum [Angstrom]. */
291  p = cpl_parameter_new_value("muse.muse_create_sky.csampling",
292  CPL_TYPE_DOUBLE,
293  "Spectral sampling of the continuum spectrum [Angstrom].",
294  "muse.muse_create_sky",
295  (double)1.25);
296  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "csampling");
297  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "csampling");
298  if (!getenv("MUSE_EXPERT_USER")) {
299  cpl_parameter_disable(p, CPL_PARAMETER_MODE_CLI);
300  }
301 
302  cpl_parameterlist_append(recipe->parameters, p);
303 
304  /* --cr: Type of cosmic ray cleaning to use. "Cube" is the standard CR cleaning which works on a datacube, "spectrum" uses sigma clipping on the spectrum. */
305  p = cpl_parameter_new_enum("muse.muse_create_sky.cr",
306  CPL_TYPE_STRING,
307  "Type of cosmic ray cleaning to use. \"Cube\" is the standard CR cleaning which works on a datacube, \"spectrum\" uses sigma clipping on the spectrum.",
308  "muse.muse_create_sky",
309  (const char *)"cube",
310  3,
311  (const char *)"none",
312  (const char *)"cube",
313  (const char *)"spectrum");
314  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "cr");
315  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "cr");
316  if (!getenv("MUSE_EXPERT_USER")) {
317  cpl_parameter_disable(p, CPL_PARAMETER_MODE_CLI);
318  }
319 
320  cpl_parameterlist_append(recipe->parameters, p);
321 
322  /* --lambdamin: Cut off the data below this wavelength after loading the pixel table(s). */
323  p = cpl_parameter_new_value("muse.muse_create_sky.lambdamin",
324  CPL_TYPE_DOUBLE,
325  "Cut off the data below this wavelength after loading the pixel table(s).",
326  "muse.muse_create_sky",
327  (double)4000.);
328  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "lambdamin");
329  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "lambdamin");
330 
331  cpl_parameterlist_append(recipe->parameters, p);
332 
333  /* --lambdamax: Cut off the data above this wavelength after loading the pixel table(s). */
334  p = cpl_parameter_new_value("muse.muse_create_sky.lambdamax",
335  CPL_TYPE_DOUBLE,
336  "Cut off the data above this wavelength after loading the pixel table(s).",
337  "muse.muse_create_sky",
338  (double)10000.);
339  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "lambdamax");
340  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "lambdamax");
341 
342  cpl_parameterlist_append(recipe->parameters, p);
343 
344  /* --lambdaref: Reference wavelength used for correction of differential atmospheric refraction. The R-band (peak wavelength ~7000 Angstrom) that is usually used for guiding, is close to the central wavelength of MUSE, so a value of 7000.0 Angstrom should be used if nothing else is known. A value less than zero switches DAR correction off. */
345  p = cpl_parameter_new_value("muse.muse_create_sky.lambdaref",
346  CPL_TYPE_DOUBLE,
347  "Reference wavelength used for correction of differential atmospheric refraction. The R-band (peak wavelength ~7000 Angstrom) that is usually used for guiding, is close to the central wavelength of MUSE, so a value of 7000.0 Angstrom should be used if nothing else is known. A value less than zero switches DAR correction off.",
348  "muse.muse_create_sky",
349  (double)7000.);
350  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "lambdaref");
351  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "lambdaref");
352 
353  cpl_parameterlist_append(recipe->parameters, p);
354 
355  return 0;
356 } /* muse_create_sky_create() */
357 
358 /*----------------------------------------------------------------------------*/
369 /*----------------------------------------------------------------------------*/
370 static int
371 muse_create_sky_params_fill(muse_create_sky_params_t *aParams, cpl_parameterlist *aParameters)
372 {
373  cpl_ensure_code(aParams, CPL_ERROR_NULL_INPUT);
374  cpl_ensure_code(aParameters, CPL_ERROR_NULL_INPUT);
375  cpl_parameter *p;
376 
377  p = cpl_parameterlist_find(aParameters, "muse.muse_create_sky.fraction");
378  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
379  aParams->fraction = cpl_parameter_get_double(p);
380 
381  p = cpl_parameterlist_find(aParameters, "muse.muse_create_sky.sampling");
382  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
383  aParams->sampling = cpl_parameter_get_double(p);
384 
385  p = cpl_parameterlist_find(aParameters, "muse.muse_create_sky.csampling");
386  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
387  aParams->csampling = cpl_parameter_get_double(p);
388 
389  p = cpl_parameterlist_find(aParameters, "muse.muse_create_sky.cr");
390  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
391  aParams->cr_s = cpl_parameter_get_string(p);
392  aParams->cr =
393  (!strcasecmp(aParams->cr_s, "none")) ? MUSE_CREATE_SKY_PARAM_CR_NONE :
394  (!strcasecmp(aParams->cr_s, "cube")) ? MUSE_CREATE_SKY_PARAM_CR_CUBE :
395  (!strcasecmp(aParams->cr_s, "spectrum")) ? MUSE_CREATE_SKY_PARAM_CR_SPECTRUM :
396  MUSE_CREATE_SKY_PARAM_CR_INVALID_VALUE;
397  cpl_ensure_code(aParams->cr != MUSE_CREATE_SKY_PARAM_CR_INVALID_VALUE,
398  CPL_ERROR_ILLEGAL_INPUT);
399 
400  p = cpl_parameterlist_find(aParameters, "muse.muse_create_sky.lambdamin");
401  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
402  aParams->lambdamin = cpl_parameter_get_double(p);
403 
404  p = cpl_parameterlist_find(aParameters, "muse.muse_create_sky.lambdamax");
405  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
406  aParams->lambdamax = cpl_parameter_get_double(p);
407 
408  p = cpl_parameterlist_find(aParameters, "muse.muse_create_sky.lambdaref");
409  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
410  aParams->lambdaref = cpl_parameter_get_double(p);
411 
412  return 0;
413 } /* muse_create_sky_params_fill() */
414 
415 /*----------------------------------------------------------------------------*/
422 /*----------------------------------------------------------------------------*/
423 static int
424 muse_create_sky_exec(cpl_plugin *aPlugin)
425 {
426  if (cpl_plugin_get_type(aPlugin) != CPL_PLUGIN_TYPE_RECIPE) {
427  return -1;
428  }
429  cpl_recipe *recipe = (cpl_recipe *)aPlugin;
430  cpl_msg_set_threadid_on();
431 
432  cpl_frameset *usedframes = cpl_frameset_new(),
433  *outframes = cpl_frameset_new();
435  muse_create_sky_params_fill(&params, recipe->parameters);
436 
437  cpl_errorstate prestate = cpl_errorstate_get();
438 
439  muse_processing *proc = muse_processing_new("muse_create_sky",
440  recipe);
441  int rc = muse_create_sky_compute(proc, &params);
442  cpl_frameset_join(usedframes, proc->usedframes);
443  cpl_frameset_join(outframes, proc->outframes);
445 
446  if (!cpl_errorstate_is_equal(prestate)) {
447  /* dump all errors from this recipe in chronological order */
448  cpl_errorstate_dump(prestate, CPL_FALSE, muse_cplerrorstate_dump_some);
449  /* reset message level to not get the same errors displayed again by esorex */
450  cpl_msg_set_level(CPL_MSG_INFO);
451  }
452  /* clean up duplicates in framesets of used and output frames */
455 
456  /* to get esorex to see our classification (frame groups etc.), *
457  * replace the original frameset with the list of used frames *
458  * before appending product output frames */
459  /* keep the same pointer, so just erase all frames, not delete the frameset */
460  muse_cplframeset_erase_all(recipe->frames);
461  cpl_frameset_join(recipe->frames, usedframes);
462  cpl_frameset_join(recipe->frames, outframes);
463  cpl_frameset_delete(usedframes);
464  cpl_frameset_delete(outframes);
465  return rc;
466 } /* muse_create_sky_exec() */
467 
468 /*----------------------------------------------------------------------------*/
475 /*----------------------------------------------------------------------------*/
476 static int
477 muse_create_sky_destroy(cpl_plugin *aPlugin)
478 {
479  /* Get the recipe from the plugin */
480  cpl_recipe *recipe;
481  if (cpl_plugin_get_type(aPlugin) == CPL_PLUGIN_TYPE_RECIPE) {
482  recipe = (cpl_recipe *)aPlugin;
483  } else {
484  return -1;
485  }
486 
487  /* Clean up */
488  cpl_parameterlist_delete(recipe->parameters);
490  return 0;
491 } /* muse_create_sky_destroy() */
492 
493 /*----------------------------------------------------------------------------*/
503 /*----------------------------------------------------------------------------*/
504 int
505 cpl_plugin_get_info(cpl_pluginlist *aList)
506 {
507  cpl_recipe *recipe = cpl_calloc(1, sizeof *recipe);
508  cpl_plugin *plugin = &recipe->interface;
509 
510  char *helptext;
512  helptext = cpl_sprintf("%s%s", muse_create_sky_help,
513  muse_create_sky_help_esorex);
514  } else {
515  helptext = cpl_sprintf("%s", muse_create_sky_help);
516  }
517 
518  /* Initialize the CPL plugin stuff for this module */
519  cpl_plugin_init(plugin, CPL_PLUGIN_API, MUSE_BINARY_VERSION,
520  CPL_PLUGIN_TYPE_RECIPE,
521  "muse_create_sky",
522  "Create night sky model from selected pixels of an exposure of empty sky.",
523  helptext,
524  "Ole Streicher",
525  "usd-help@eso.org",
527  muse_create_sky_create,
528  muse_create_sky_exec,
529  muse_create_sky_destroy);
530  cpl_pluginlist_append(aList, plugin);
531  cpl_free(helptext);
532 
533  return 0;
534 } /* cpl_plugin_get_info() */
535 
void muse_processing_delete(muse_processing *aProcessing)
Free the muse_processing structure.
muse_cplframework_type muse_cplframework(void)
Return the CPL framework the recipe is run under.
double csampling
Spectral sampling of the continuum spectrum [Angstrom].
int cr
Type of cosmic ray cleaning to use. "Cube" is the standard CR cleaning which works on a datacube...
cpl_frameset * usedframes
muse_processing * muse_processing_new(const char *aName, cpl_recipe *aRecipe)
Create a new processing structure.
const char * muse_get_license(void)
Get the pipeline copyright and license.
Definition: muse_utils.c:84
muse_frame_mode
cpl_frameset * outframes
void muse_cplerrorstate_dump_some(unsigned aCurrent, unsigned aFirst, unsigned aLast)
Dump some CPL errors.
void muse_processinginfo_delete(cpl_recipe *)
Clear all information from the processing info and from the recipe config.
cpl_error_code muse_cplframeset_erase_duplicate(cpl_frameset *aFrames)
Erase all duplicate frames from a frameset.
cpl_error_code muse_cplframeset_erase_all(cpl_frameset *aFrames)
Erase all frames in a frameset.
double lambdamin
Cut off the data below this wavelength after loading the pixel table(s).
double sampling
Spectral sampling of the sky spectrum [Angstrom].
void muse_processinginfo_register(cpl_recipe *, cpl_recipeconfig *, muse_processing_prepare_header_func *, muse_processing_get_frame_level_func *, muse_processing_get_frame_mode_func *)
Register extended functionalities for MUSE recipes.
double fraction
Fraction of the image to be considered as sky. If an input sky mask is provided, the fraction is appl...
double lambdamax
Cut off the data above this wavelength after loading the pixel table(s).
double lambdaref
Reference wavelength used for correction of differential atmospheric refraction. The R-band (peak wav...
const char * cr_s
Type of cosmic ray cleaning to use. "Cube" is the standard CR cleaning which works on a datacube...
Structure to hold the parameters of the muse_create_sky recipe.
cpl_error_code muse_processing_prepare_property(cpl_propertylist *, const char *, cpl_type, const char *)
Prepare and check the specified property.