MUSE Pipeline Reference Manual  1.0.2
muse_scipost_calibrate_flux_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_scipost_calibrate_flux_z.h" /* in turn includes muse.h */
36 
37 /*----------------------------------------------------------------------------*/
43 /*----------------------------------------------------------------------------*/
46 /*----------------------------------------------------------------------------*
47  * Static variables *
48  *----------------------------------------------------------------------------*/
49 static const char *muse_scipost_calibrate_flux_help =
50  "Replace the intensity in the MUSE pixel tables by the absolute flux. This is a task separated from muse_scipost.";
51 
52 static const char *muse_scipost_calibrate_flux_help_esorex =
53  "\n\nInput frames for raw frame tag \"PIXTABLE_OBJECT\":\n"
54  "\n Frame tag Type Req #Fr Description"
55  "\n -------------------- ---- --- --- ------------"
56  "\n PIXTABLE_OBJECT raw Y Pixel table without flux calibration"
57  "\n EXTINCT_TABLE calib Y 1 Atmospheric extinction table"
58  "\n STD_RESPONSE calib Y 1 Response curve as derived from standard star(s)"
59  "\n STD_TELLURIC calib . 1 Telluric absorption correction as derived from standard star(s)"
60  "\n\nProduct frames for raw frame tag \"PIXTABLE_OBJECT\":\n"
61  "\n Frame tag Level Description"
62  "\n -------------------- -------- ------------"
63  "\n PIXTABLE_OBJECT final Flux calibrated pixel table";
64 
65 /*----------------------------------------------------------------------------*/
73 /*----------------------------------------------------------------------------*/
74 static cpl_recipeconfig *
75 muse_scipost_calibrate_flux_new_recipeconfig(void)
76 {
77  cpl_recipeconfig *recipeconfig = cpl_recipeconfig_new();
78  const char *tag;
79 
80  tag = "PIXTABLE_OBJECT";
81  cpl_recipeconfig_set_tag(recipeconfig, tag, 1, -1);
82  cpl_recipeconfig_set_input(recipeconfig, tag, "EXTINCT_TABLE", 1, 1);
83  cpl_recipeconfig_set_input(recipeconfig, tag, "STD_RESPONSE", 1, 1);
84  cpl_recipeconfig_set_input(recipeconfig, tag, "STD_TELLURIC", -1, 1);
85  cpl_recipeconfig_set_output(recipeconfig, tag, "PIXTABLE_OBJECT");
86 
87  return recipeconfig;
88 } /* muse_scipost_calibrate_flux_new_recipeconfig() */
89 
90 /*----------------------------------------------------------------------------*/
100 /*----------------------------------------------------------------------------*/
101 static cpl_error_code
102 muse_scipost_calibrate_flux_prepare_header(const char *aFrametag, cpl_propertylist *aHeader)
103 {
104  cpl_ensure_code(aFrametag, CPL_ERROR_NULL_INPUT);
105  cpl_ensure_code(aHeader, CPL_ERROR_NULL_INPUT);
106  if (!strcmp(aFrametag, "PIXTABLE_OBJECT")) {
107  } else {
108  cpl_msg_warning(__func__, "Frame tag %s is not defined", aFrametag);
109  return CPL_ERROR_ILLEGAL_INPUT;
110  }
111  return CPL_ERROR_NONE;
112 } /* muse_scipost_calibrate_flux_prepare_header() */
113 
114 /*----------------------------------------------------------------------------*/
123 /*----------------------------------------------------------------------------*/
124 static cpl_frame_level
125 muse_scipost_calibrate_flux_get_frame_level(const char *aFrametag)
126 {
127  if (!aFrametag) {
128  return CPL_FRAME_LEVEL_NONE;
129  }
130  if (!strcmp(aFrametag, "PIXTABLE_OBJECT")) {
131  return CPL_FRAME_LEVEL_FINAL;
132  }
133  return CPL_FRAME_LEVEL_NONE;
134 } /* muse_scipost_calibrate_flux_get_frame_level() */
135 
136 /*----------------------------------------------------------------------------*/
145 /*----------------------------------------------------------------------------*/
146 static muse_frame_mode
147 muse_scipost_calibrate_flux_get_frame_mode(const char *aFrametag)
148 {
149  if (!aFrametag) {
150  return MUSE_FRAME_MODE_ALL;
151  }
152  if (!strcmp(aFrametag, "PIXTABLE_OBJECT")) {
153  return MUSE_FRAME_MODE_ALL;
154  }
155  return MUSE_FRAME_MODE_ALL;
156 } /* muse_scipost_calibrate_flux_get_frame_mode() */
157 
158 /*----------------------------------------------------------------------------*/
168 /*----------------------------------------------------------------------------*/
169 static int
170 muse_scipost_calibrate_flux_create(cpl_plugin *aPlugin)
171 {
172  /* Check that the plugin is part of a valid recipe */
173  cpl_recipe *recipe;
174  if (cpl_plugin_get_type(aPlugin) == CPL_PLUGIN_TYPE_RECIPE) {
175  recipe = (cpl_recipe *)aPlugin;
176  } else {
177  return -1;
178  }
179 
180  /* register the extended processing information (new FITS header creation, *
181  * getting of the frame level for a certain tag) */
183  muse_scipost_calibrate_flux_new_recipeconfig(),
184  muse_scipost_calibrate_flux_prepare_header,
185  muse_scipost_calibrate_flux_get_frame_level,
186  muse_scipost_calibrate_flux_get_frame_mode);
187 
188  /* XXX initialize timing in messages *
189  * since at least esorex is too stupid to turn it on, we have to do it */
191  cpl_msg_set_time_on();
192  }
193 
194  /* Create the parameter list in the cpl_recipe object */
195  recipe->parameters = cpl_parameterlist_new();
196  /* Fill the parameters list */
197  cpl_parameter *p;
198 
199  /* --lambdamin: Cut off the data below this wavelength after loading the pixel table(s). */
200  p = cpl_parameter_new_value("muse.muse_scipost_calibrate_flux.lambdamin",
201  CPL_TYPE_DOUBLE,
202  "Cut off the data below this wavelength after loading the pixel table(s).",
203  "muse.muse_scipost_calibrate_flux",
204  (double)4000.);
205  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "lambdamin");
206  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "lambdamin");
207 
208  cpl_parameterlist_append(recipe->parameters, p);
209 
210  /* --lambdamax: Cut off the data above this wavelength after loading the pixel table(s). */
211  p = cpl_parameter_new_value("muse.muse_scipost_calibrate_flux.lambdamax",
212  CPL_TYPE_DOUBLE,
213  "Cut off the data above this wavelength after loading the pixel table(s).",
214  "muse.muse_scipost_calibrate_flux",
215  (double)10000.);
216  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CFG, "lambdamax");
217  cpl_parameter_set_alias(p, CPL_PARAMETER_MODE_CLI, "lambdamax");
218 
219  cpl_parameterlist_append(recipe->parameters, p);
220 
221  return 0;
222 } /* muse_scipost_calibrate_flux_create() */
223 
224 /*----------------------------------------------------------------------------*/
235 /*----------------------------------------------------------------------------*/
236 static int
237 muse_scipost_calibrate_flux_params_fill(muse_scipost_calibrate_flux_params_t *aParams, cpl_parameterlist *aParameters)
238 {
239  cpl_ensure_code(aParams, CPL_ERROR_NULL_INPUT);
240  cpl_ensure_code(aParameters, CPL_ERROR_NULL_INPUT);
241  cpl_parameter *p;
242 
243  p = cpl_parameterlist_find(aParameters, "muse.muse_scipost_calibrate_flux.lambdamin");
244  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
245  aParams->lambdamin = cpl_parameter_get_double(p);
246 
247  p = cpl_parameterlist_find(aParameters, "muse.muse_scipost_calibrate_flux.lambdamax");
248  cpl_ensure_code(p, CPL_ERROR_DATA_NOT_FOUND);
249  aParams->lambdamax = cpl_parameter_get_double(p);
250 
251  return 0;
252 } /* muse_scipost_calibrate_flux_params_fill() */
253 
254 /*----------------------------------------------------------------------------*/
261 /*----------------------------------------------------------------------------*/
262 static int
263 muse_scipost_calibrate_flux_exec(cpl_plugin *aPlugin)
264 {
265  if (cpl_plugin_get_type(aPlugin) != CPL_PLUGIN_TYPE_RECIPE) {
266  return -1;
267  }
268  cpl_recipe *recipe = (cpl_recipe *)aPlugin;
269  cpl_msg_set_threadid_on();
270 
271  cpl_frameset *usedframes = cpl_frameset_new(),
272  *outframes = cpl_frameset_new();
274  muse_scipost_calibrate_flux_params_fill(&params, recipe->parameters);
275 
276  cpl_errorstate prestate = cpl_errorstate_get();
277 
278  muse_processing *proc = muse_processing_new("muse_scipost_calibrate_flux",
279  recipe);
280  int rc = muse_scipost_calibrate_flux_compute(proc, &params);
281  cpl_frameset_join(usedframes, proc->usedframes);
282  cpl_frameset_join(outframes, proc->outframes);
284 
285  if (!cpl_errorstate_is_equal(prestate)) {
286  /* dump all errors from this recipe in chronological order */
287  cpl_errorstate_dump(prestate, CPL_FALSE, muse_cplerrorstate_dump_some);
288  /* reset message level to not get the same errors displayed again by esorex */
289  cpl_msg_set_level(CPL_MSG_INFO);
290  }
291  /* clean up duplicates in framesets of used and output frames */
294 
295  /* to get esorex to see our classification (frame groups etc.), *
296  * replace the original frameset with the list of used frames *
297  * before appending product output frames */
298  /* keep the same pointer, so just erase all frames, not delete the frameset */
299  muse_cplframeset_erase_all(recipe->frames);
300  cpl_frameset_join(recipe->frames, usedframes);
301  cpl_frameset_join(recipe->frames, outframes);
302  cpl_frameset_delete(usedframes);
303  cpl_frameset_delete(outframes);
304  return rc;
305 } /* muse_scipost_calibrate_flux_exec() */
306 
307 /*----------------------------------------------------------------------------*/
314 /*----------------------------------------------------------------------------*/
315 static int
316 muse_scipost_calibrate_flux_destroy(cpl_plugin *aPlugin)
317 {
318  /* Get the recipe from the plugin */
319  cpl_recipe *recipe;
320  if (cpl_plugin_get_type(aPlugin) == CPL_PLUGIN_TYPE_RECIPE) {
321  recipe = (cpl_recipe *)aPlugin;
322  } else {
323  return -1;
324  }
325 
326  /* Clean up */
327  cpl_parameterlist_delete(recipe->parameters);
329  return 0;
330 } /* muse_scipost_calibrate_flux_destroy() */
331 
332 /*----------------------------------------------------------------------------*/
342 /*----------------------------------------------------------------------------*/
343 int
344 cpl_plugin_get_info(cpl_pluginlist *aList)
345 {
346  cpl_recipe *recipe = cpl_calloc(1, sizeof *recipe);
347  cpl_plugin *plugin = &recipe->interface;
348 
349  char *helptext;
351  helptext = cpl_sprintf("%s%s", muse_scipost_calibrate_flux_help,
352  muse_scipost_calibrate_flux_help_esorex);
353  } else {
354  helptext = cpl_sprintf("%s", muse_scipost_calibrate_flux_help);
355  }
356 
357  /* Initialize the CPL plugin stuff for this module */
358  cpl_plugin_init(plugin, CPL_PLUGIN_API, MUSE_BINARY_VERSION,
359  CPL_PLUGIN_TYPE_RECIPE,
360  "muse_scipost_calibrate_flux",
361  "Calibrate flux for MUSE pixel tables.",
362  helptext,
363  "Ole Streicher",
364  "usd-help@eso.org",
366  muse_scipost_calibrate_flux_create,
367  muse_scipost_calibrate_flux_exec,
368  muse_scipost_calibrate_flux_destroy);
369  cpl_pluginlist_append(aList, plugin);
370  cpl_free(helptext);
371 
372  return 0;
373 } /* cpl_plugin_get_info() */
374 
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 lambdamax
Cut off the data above this wavelength after loading the pixel table(s).
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.
Structure to hold the parameters of the muse_scipost_calibrate_flux recipe.
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 lambdamin
Cut off the data below this wavelength after loading the pixel table(s).