MUSE Pipeline Reference Manual  2.1.1
muse_scipost.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 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25 
26 /*---------------------------------------------------------------------------*
27  * Includes *
28  *---------------------------------------------------------------------------*/
29 #include <string.h>
30 
31 #include <muse.h>
32 #include "muse_scipost_z.h"
33 
34 /*---------------------------------------------------------------------------*
35  * Functions code *
36  *---------------------------------------------------------------------------*/
37 
38 /*----------------------------------------------------------------------------*/
50 /*----------------------------------------------------------------------------*/
51 static void
52 muse_scipost_offsets_scale(muse_pixtable *aPT, const cpl_table *aOffsets,
53  const char *aPurpose)
54 {
55  if (!aPT || !aOffsets) {
56  return;
57  }
58  if (!aPT->header) {
59  return;
60  }
61  cpl_msg_info(__func__, "Applying offsets to %s...", aPurpose);
62  cpl_msg_indent_more();
63  double ra = muse_pfits_get_ra(aPT->header),
64  dec = muse_pfits_get_dec(aPT->header),
65  *offsets = muse_xcombine_find_offsets(aOffsets,
67  char keyword[KEYWORD_LENGTH], comment[KEYWORD_LENGTH];
68  if (offsets) {
69  if (isfinite(offsets[0]) && isfinite(offsets[1])) {
70  ra -= offsets[0];
71  dec -= offsets[1];
72  cpl_msg_debug(__func__, "Applying coordinate offsets to exposure: %e/%e"
73  " deg", offsets[0], offsets[1]);
74  /* update RA/DEC in the header of the pixel table */
75  cpl_errorstate state = cpl_errorstate_get();
76  cpl_propertylist_update_double(aPT->header, "RA", ra);
77  if (!cpl_errorstate_is_equal(state)) {
78  cpl_errorstate_set(state);
79  cpl_propertylist_update_float(aPT->header, "RA", ra);
80  }
81  cpl_propertylist_set_comment(aPT->header, "RA", "offset applied!");
82  state = cpl_errorstate_get();
83  cpl_propertylist_update_double(aPT->header, "DEC", dec);
84  if (!cpl_errorstate_is_equal(state)) {
85  cpl_errorstate_set(state);
86  cpl_propertylist_update_float(aPT->header, "DEC", dec);
87  }
88  cpl_propertylist_set_comment(aPT->header, "DEC", "offset applied!");
89  /* store in the header of the pixel table */
90  snprintf(keyword, KEYWORD_LENGTH, MUSE_HDR_OFFSETi_DRA, 1);
91  snprintf(comment, KEYWORD_LENGTH, MUSE_HDR_OFFSETi_DRA_C, offsets[0] * 3600.);
92  cpl_propertylist_append_double(aPT->header, keyword, offsets[0]);
93  cpl_propertylist_set_comment(aPT->header, keyword, comment);
94  snprintf(keyword, KEYWORD_LENGTH, MUSE_HDR_OFFSETi_DDEC, 1);
95  snprintf(comment, KEYWORD_LENGTH, MUSE_HDR_OFFSETi_DDEC_C, offsets[1] * 3600.);
96  cpl_propertylist_append_double(aPT->header, keyword, offsets[1]);
97  cpl_propertylist_set_comment(aPT->header, keyword, comment);
98  } /* if spatial offsets */
99  if (isnormal(offsets[2])) { /* valid flux scale */
100  /* get and apply the scale */
101  cpl_msg_debug(__func__, "Scaling flux of exposure by %g.", offsets[2]);
102  muse_pixtable_flux_multiply(aPT, offsets[2]);
103  /* store in the header of the pixel table */
104  snprintf(keyword, KEYWORD_LENGTH, MUSE_HDR_FLUX_SCALEi, 1);
105  cpl_propertylist_append_double(aPT->header, keyword, offsets[2]);
106  cpl_propertylist_set_comment(aPT->header, keyword, MUSE_HDR_FLUX_SCALEi_C);
107  } /* if scale */
108  /* store date of changed exposure in the header of the output pixel table */
109  snprintf(keyword, KEYWORD_LENGTH, MUSE_HDR_OFFSETi_DATEOBS, 1);
110  snprintf(comment, KEYWORD_LENGTH, MUSE_HDR_OFFSETi_DATEOBS_C, 1);
111  cpl_propertylist_append_string(aPT->header, keyword,
113  cpl_propertylist_set_comment(aPT->header, keyword, comment);
114  } /* if offsets */
115  cpl_free(offsets);
116  cpl_msg_indent_less();
117 } /* muse_scipost_offsets_scale() */
118 
119 /*----------------------------------------------------------------------------*/
135 /*----------------------------------------------------------------------------*/
136 int
137 muse_scipost_compute(muse_processing *aProcessing,
138  muse_scipost_params_t *aParams)
139 {
140  const char *savevalid = "cube,skymodel,individual,positioned,combined,stacked";
141  if (!muse_postproc_check_save_param(aParams->save, savevalid)) {
142  return -1;
143  }
144  muse_postproc_properties *prop = muse_postproc_properties_new(MUSE_POSTPROC_SCIPOST);
145  /* per-exposure parameters */
146  prop->lambdamin = aParams->lambdamin;
147  prop->lambdamax = aParams->lambdamax;
148  prop->lambdaref = aParams->lambdaref;
149  prop->darcheck = MUSE_POSTPROC_DARCHECK_NONE;
150  if (aParams->darcheck == MUSE_SCIPOST_PARAM_DARCHECK_CHECK) {
151  prop->darcheck = MUSE_POSTPROC_DARCHECK_CHECK;
152  } else if (aParams->darcheck == MUSE_SCIPOST_PARAM_DARCHECK_CORRECT) {
153  prop->darcheck = MUSE_POSTPROC_DARCHECK_CORRECT;
154  }
155  prop->rvtype = muse_rvcorrect_select_type(aParams->rvcorr_s);
156  /* flux calibration */
157  prop->response = muse_processing_load_table(aProcessing,
158  MUSE_TAG_STD_RESPONSE, 0);
159  prop->telluric = muse_processing_load_table(aProcessing,
160  MUSE_TAG_STD_TELLURIC, 0);
161  prop->extinction = muse_processing_load_ctable(aProcessing,
162  MUSE_TAG_EXTINCT_TABLE, 0);
163  /* astrometric correction */
164  if (aParams->astrometry) {
165  prop->wcs = muse_processing_load_header(aProcessing, MUSE_TAG_ASTROMETRY_WCS);
166  if (!prop->wcs) {
167  /* if it was not in the input, create a default WFM astrometry */
168  cpl_msg_warning(__func__, "Using default MUSE WFM astrometry, output "
169  "world coordinates will be inaccurate!");
170  prop->wcs = muse_wcs_create_default();
171  }
172  }
173 
174  const struct {
175  int par;
176  muse_postproc_skymethod postproc;
177  } skymethod[] = {
178  { MUSE_SCIPOST_PARAM_SKYMETHOD_NONE, MUSE_POSTPROC_SKYMETHOD_NONE },
179  { MUSE_SCIPOST_PARAM_SKYMETHOD_SUBTRACT_MODEL, MUSE_POSTPROC_SKYMETHOD_NONE }, /* sic! */
180  { MUSE_SCIPOST_PARAM_SKYMETHOD_MODEL, MUSE_POSTPROC_SKYMETHOD_MODEL },
181  { MUSE_SCIPOST_PARAM_SKYMETHOD_SIMPLE, MUSE_POSTPROC_SKYMETHOD_SIMPLE },
182  { MUSE_SCIPOST_PARAM_SKYMETHOD_INVALID_VALUE, MUSE_POSTPROC_SKYMETHOD_MODEL },
183  };
184  prop->skymethod = MUSE_POSTPROC_SKYMETHOD_MODEL;
185  int i_method;
186  for (i_method = 0;
187  skymethod[i_method].par != MUSE_SCIPOST_PARAM_SKYMETHOD_INVALID_VALUE;
188  i_method++) {
189  if (skymethod[i_method].par == aParams->skymethod) {
190  prop->skymethod = skymethod[i_method].postproc;
191  break;
192  }
193  }
194  prop->skymodel_params.fraction = aParams->skymodel_fraction;
195  prop->skymodel_params.ignore = aParams->skymodel_ignore;
196  prop->skymodel_params.sampling = aParams->skymodel_sampling;
197  prop->skymodel_params.csampling = aParams->skymodel_csampling;
198  /* CR rejection sigmas */
199  cpl_array *crarray = muse_cplarray_new_from_delimited_string(aParams->sky_crsigma, ",");
200  if (cpl_array_get_size(crarray) < 2) {
201  prop->skymodel_params.crsigmac = 15.;
202  prop->skymodel_params.crsigmas = 0.;
203  cpl_msg_warning(__func__, "Less than two values given by sky_crsigma "
204  "parameter, using defaults (%.3f.,%.3f)!",
205  prop->skymodel_params.crsigmac, prop->skymodel_params.crsigmas);
206  } else {
207  prop->skymodel_params.crsigmac = cpl_array_get_string(crarray, 0)
208  ? atof(cpl_array_get_string(crarray, 0)) : 15.;
209  prop->skymodel_params.crsigmas = cpl_array_get_string(crarray, 1)
210  ? atof(cpl_array_get_string(crarray, 1)) : 0.;
211  }
212  cpl_array_delete(crarray);
213 
214 #ifdef USE_LSF_PARAMS
215  cpl_errorstate prestate = cpl_errorstate_get();
216 #endif
217  if (aParams->skymethod == MUSE_SCIPOST_PARAM_SKYMETHOD_SUBTRACT_MODEL) {
218  prop->lsf_cube = muse_lsf_cube_load_all(aProcessing);
219  if (prop->lsf_cube != NULL) {
220  prop->sky_lines = muse_sky_lines_load(aProcessing);
221 #ifdef USE_LSF_PARAMS
222  } else {
223  prop-> lsf_params = muse_processing_lsf_params_load(aProcessing, 0);
224  if (prop->lsf_params != NULL) { // Old LSF params code
225  cpl_errorstate_set(prestate);
226  prop->sky_lines = muse_sky_lines_load(aProcessing);
227  }
228 #endif
229  }
230  prop->sky_continuum = muse_sky_continuum_load(aProcessing);
231  } else if (aParams->skymethod == MUSE_SCIPOST_PARAM_SKYMETHOD_MODEL) {
232  prop->lsf_cube = muse_lsf_cube_load_all(aProcessing);
233  if (prop->lsf_cube == NULL) {
234 #ifdef USE_LSF_PARAMS
235  prop->lsf_params = muse_processing_lsf_params_load(aProcessing, 0);
236  if (prop->lsf_params != NULL) { // Old LSF params code
237  cpl_errorstate_set(prestate);
238  } else {
239 #endif
240  cpl_msg_error(__func__, "Missing required LSF frames for sky model");
241 #ifdef USE_LSF_PARAMS
242  }
243 #endif
244  }
245  prop->sky_lines = muse_sky_lines_load(aProcessing);
246  if (prop->sky_lines == NULL) {
247  cpl_msg_error(__func__, "Missing required sky lines frame for sky model");
248  }
249  if (((prop->lsf_cube == NULL)
250 #ifdef USE_LSF_PARAMS
251  && (prop->lsf_params == NULL)
252 #endif
253  )
254  || (prop->sky_lines == NULL)) {
256  return -1;
257  }
258  prop->sky_continuum = muse_sky_continuum_load(aProcessing);
259  prop->sky_mask = muse_processing_load_mask(aProcessing, MUSE_TAG_SKY_MASK);
260  } else if (aParams->skymethod == MUSE_SCIPOST_PARAM_SKYMETHOD_SIMPLE) {
261  /* a mask could help for the simple sky subtraction */
262  prop->sky_mask = muse_processing_load_mask(aProcessing, MUSE_TAG_SKY_MASK);
263  }
264 
265  /* sort input pixel tables into different exposures */
266  prop->exposures = muse_processing_sort_exposures(aProcessing);
267  if (!prop->exposures) {
268  cpl_msg_error(__func__, "no science exposures found in input");
270  return -1;
271  }
272  int nexposures = cpl_table_get_nrow(prop->exposures);
273 
274  /* load optional offsets */
275  cpl_table *offsets = muse_processing_load_ctable(aProcessing, MUSE_TAG_OFFSET_LIST, 0);
276  if (offsets && muse_cpltable_check(offsets, muse_offset_list_def) != CPL_ERROR_NONE) {
277  cpl_msg_warning(__func__, "Input %s has unexpected format, proceeding "
278  "without offset and flux scales!", MUSE_TAG_OFFSET_LIST);
279  cpl_table_delete(offsets);
280  offsets = NULL;
281  } /* if offsets have wrong format */
282 
283  /* now process all the pixel tables, do it separately for each exposure */
284  /* allocate one additional element for NULL termination */
285  muse_pixtable **pixtables = cpl_calloc(nexposures + 1, sizeof(muse_pixtable *));
286  int i;
287  for (i = 0; i < nexposures; i++) {
288  muse_postproc_sky_outputs *skyout = cpl_calloc(1, sizeof(muse_postproc_sky_outputs));
289  pixtables[i] = muse_postproc_process_exposure(prop, i, skyout);
290  if (!pixtables[i]) {
291  int i2;
292  for (i2 = 0; i2 <= i; i2++) {
293  muse_pixtable_delete(pixtables[i2]);
294  } /* for i2 */
295  cpl_free(pixtables);
297  cpl_table_delete(offsets);
298  return -1; /* enough error messages, just return */
299  }
300  /* save the effectively used sky products, if requested */
301  if (strstr(aParams->save, "skymodel")) {
302  if (skyout->mask) {
303  muse_processing_save_mask(aProcessing, -1, skyout->mask, MUSE_TAG_SKY_MASK);
304  }
305  if (skyout->spectrum) {
306  cpl_propertylist *header = cpl_propertylist_duplicate(pixtables[i]->header);
307  cpl_propertylist_erase_regexp(header, MUSE_HDR_PT_REGEXP, 0);
308  muse_processing_save_table(aProcessing, -1, skyout->spectrum, header,
309  MUSE_TAG_SKY_SPECTRUM, MUSE_TABLE_TYPE_CPL);
310  cpl_propertylist_delete(header);
311  }
312  if (skyout->lines) {
313  cpl_propertylist *header = cpl_propertylist_duplicate(pixtables[i]->header);
314  cpl_propertylist_erase_regexp(header, MUSE_HDR_PT_REGEXP, 0);
315  muse_sky_qc_lines(header, skyout->lines, "ESO QC SCIPOST");
316  muse_sky_lines_save(aProcessing, skyout->lines, header);
317  cpl_propertylist_delete(header);
318  }
319  if (skyout->continuum) {
320  cpl_propertylist *header = cpl_propertylist_duplicate(pixtables[i]->header);
321  cpl_propertylist_erase_regexp(header, MUSE_HDR_PT_REGEXP, 0);
322  muse_sky_qc_continuum(header, skyout->continuum, "ESO QC SCIPOST");
323  muse_sky_save_continuum(aProcessing, skyout->continuum, header);
324  cpl_propertylist_delete(header);
325  }
326  }
327  muse_mask_delete(skyout->mask);
328  cpl_table_delete(skyout->spectrum);
329  cpl_table_delete(skyout->lines);
330  cpl_table_delete(skyout->continuum);
331  cpl_free(skyout);
332 
333  if (strstr(aParams->save, "individual")) {
334  muse_processing_save_table(aProcessing, -1, pixtables[i], NULL,
335  MUSE_TAG_PIXTABLE_REDUCED,
337  }
338  if (strstr(aParams->save, "positioned")) {
339  /* duplicate table to not mess with the coordinates in the individual *
340  * pixel tables, which are still needed when combining the exposures */
341  muse_pixtable *pt = muse_pixtable_duplicate(pixtables[i]);
342  /* since after positioning it is too late to *
343  * adapt the reference position, do it now */
344  muse_scipost_offsets_scale(pt, offsets,
345  "positioned pixel table for saving");
348  muse_processing_save_table(aProcessing, -1, pt, NULL,
349  MUSE_TAG_PIXTABLE_POSITIONED,
352  }
353  } /* for i (exposures) */
355 
356  /* now combine the possibly more than one exposures */
357  muse_pixtable *bigpixtable = NULL;
358  if (nexposures > 1) {
360  cpl_error_code rc = muse_xcombine_weights(pixtables, weight);
361  if (rc != CPL_ERROR_NONE) {
362  cpl_msg_error(__func__, "weighting the pixel tables didn't work: %s",
363  cpl_error_get_message());
364  for (i = 0; i < nexposures; i++) {
365  muse_pixtable_delete(pixtables[i]);
366  } /* for i (exposures) */
367  cpl_free(pixtables);
368  cpl_table_delete(offsets);
369  return -1;
370  }
371  /* combine individual pixel tables and delete them */
372  bigpixtable = muse_xcombine_tables(pixtables, offsets);
373  if (!bigpixtable) {
374  cpl_msg_error(__func__, "combining the pixel tables didn't work: %s",
375  cpl_error_get_message());
376  for (i = 0; i < nexposures; i++) {
377  muse_pixtable_delete(pixtables[i]);
378  } /* for i (exposures) */
379  cpl_free(pixtables);
380  cpl_table_delete(offsets);
381  return -1;
382  }
383  } else {
384  bigpixtable = pixtables[0];
385  /* if there is only one pixel table, apply the offset for that */
386  cpl_msg_indent_more();
387  muse_scipost_offsets_scale(bigpixtable, offsets,
388  "single pixel table for resampling");
389  cpl_msg_indent_less();
390  muse_wcs_position_celestial(bigpixtable,
391  muse_pfits_get_ra(bigpixtable->header),
392  muse_pfits_get_dec(bigpixtable->header));
393  }
394  cpl_free(pixtables);
395  cpl_table_delete(offsets);
396 
397  cpl_error_code rc = CPL_ERROR_NONE;
398  if (strstr(aParams->save, "cube")) {
399  muse_resampling_type resample
402  rp->dx = aParams->dx;
403  rp->dy = aParams->dy;
404  rp->dlambda = aParams->dlambda;
405  rp->crtype = muse_postproc_get_cr_type(aParams->crtype_s);
406  rp->crsigma = aParams->crsigma;
407  rp->ld = aParams->ld;
408  rp->rc = aParams->rc;
410  cpl_propertylist *outwcs = muse_postproc_cube_load_output_wcs(aProcessing);
411  muse_resampling_params_set_wcs(rp, outwcs);
412  cpl_propertylist_delete(outwcs);
414  rc = muse_postproc_cube_resample_and_collapse(aProcessing, bigpixtable,
415  format, rp, aParams->filter);
417  } /* if save contains cube */
418  if (strstr(aParams->save, "combined")) {
419  muse_processing_save_table(aProcessing, -1, bigpixtable, NULL,
420  MUSE_TAG_PIXTABLE_COMBINED,
422  }
423  if (strstr(aParams->save, "stacked")) {
424  cpl_msg_debug(__func__, "additional output as column-stacked image");
425  muse_image *img = muse_resampling_image(bigpixtable,
427  aParams->dx, aParams->dlambda);
428  muse_processing_save_image(aProcessing, -1, img, MUSE_TAG_OBJECT_RESAMPLED);
429  muse_image_delete(img);
430  }
431 
432  muse_pixtable_delete(bigpixtable);
433 
434  /* the cube is normally the main output, check only its return code */
435  return rc == CPL_ERROR_NONE ? 0 : -1;
436 } /* muse_scipost_compute() */
muse_rvcorrect_type rvtype
Definition: muse_postproc.h:98
muse_image * muse_resampling_image(muse_pixtable *aPixtable, muse_resampling_type aMethod, double aDX, double aDLambda)
Resample a pixel table onto a two-dimensional regular grid.
cpl_propertylist * muse_postproc_cube_load_output_wcs(muse_processing *aProcessing)
Find a file with a usable output WCS in the input frameset.
muse_postproc_properties * muse_postproc_properties_new(muse_postproc_type aType)
Create a post-processing properties object.
Definition: muse_postproc.c:77
muse_postproc_skymethod
Method of sky subtraction to apply.
Definition: muse_postproc.h:69
void muse_image_delete(muse_image *aImage)
Deallocate memory associated to a muse_image object.
Definition: muse_image.c:85
double lambdamin
Cut off the data below this wavelength after loading the pixel table(s).
muse_pixtable * muse_pixtable_duplicate(muse_pixtable *aPixtable)
Make a copy of the pixtanle.
int muse_processing_save_mask(muse_processing *aProcessing, int aIFU, muse_mask *aMask, const char *aTag)
Save a computed MUSE mask to disk.
double muse_pfits_get_ra(const cpl_propertylist *aHeaders)
find out the right ascension
Definition: muse_pfits.c:267
cpl_error_code muse_resampling_params_set_wcs(muse_resampling_params *aParams, const cpl_propertylist *aWCS)
Set an output WCS (and wavelength scale) in the resampling parameters.
cpl_error_code muse_sky_lines_save(muse_processing *, const cpl_table *, cpl_propertylist *)
Save sky lines table to file.
void muse_mask_delete(muse_mask *aMask)
Deallocate memory associated to a muse_mask object.
Definition: muse_mask.c:78
muse_xcombine_types muse_postproc_get_weight_type(const char *aWeightString)
Select correct weighting type for weight string.
double skymodel_ignore
Fraction of the image to be ignored. If an input sky mask is provided, the fraction is applied to the...
cpl_table * muse_sky_lines_load(muse_processing *)
Load the sky data files.
muse_resampling_crstats_type muse_postproc_get_cr_type(const char *aCRTypeString)
Select correct cosmic ray rejection type for crtype string.
int ld
Number of adjacent pixels to take into account during resampling in all three directions (loop distan...
const char * muse_pfits_get_dateobs(const cpl_propertylist *aHeaders)
find out the date of observations
Definition: muse_pfits.c:364
const muse_cpltable_def muse_offset_list_def[]
const char * rvcorr_s
Correct the radial velocity of the telescope with reference to either the barycenter of the Solar Sys...
muse_rvcorrect_type muse_rvcorrect_select_type(const char *aTypeString)
Select type of radial velocity correction to be done from type string.
void muse_sky_qc_lines(cpl_propertylist *, cpl_table *, const char *)
Fill a header with the QC parameters for the sky lines.
Definition: muse_sky_qc.c:46
void * muse_postproc_process_exposure(muse_postproc_properties *aProp, unsigned int aIndex, muse_postproc_sky_outputs *aSkyOut)
Merge and process pixel tables from one exposure.
Structure definition of MUSE three extension FITS file.
Definition: muse_image.h:40
const char * pixfrac
Pixel down-scaling factor for the "drizzle" resampling method. Up to three, comma-separated, floating-point values can be given. If only one value is given, it applies to all dimensions, two values are interpreted as spatial and spectral direction, respectively, while three are taken as horizontal, vertical, and spectral.
cpl_error_code muse_postproc_cube_resample_and_collapse(muse_processing *aProcessing, muse_pixtable *aPixtable, muse_cube_type aFormat, muse_resampling_params *aParams, const char *aFilter)
High level function to resample to a datacube and collapse that to an image of the field of view and ...
cpl_error_code muse_xcombine_weights(muse_pixtable **aPixtables, muse_xcombine_types aWeighting)
compute the weights for combination of two or more exposures
muse_postproc_skymethod skymethod
muse_lsf_params ** lsf_params
cpl_error_code muse_cpltable_check(const cpl_table *aTable, const muse_cpltable_def *aDef)
Check whether the table contains the fields of the definition.
const char * sky_crsigma
Sigma level clipping for cube-based and spectrum-based CR rejection when creating the sky spectrum...
const char * filter
The filter name(s) to be used for the output field-of-view image. Each name has to correspond to an E...
muse_resampling_crstats_type crtype
void muse_sky_qc_continuum(cpl_propertylist *, cpl_table *, const char *)
Fill a header with the QC parameters for the sky continuum.
Definition: muse_sky_qc.c:102
const char * weight_s
Type of weighting scheme to use when combining multiple exposures. "exptime" just uses the exposure t...
cpl_table * muse_sky_continuum_load(muse_processing *)
Load the sky continuum.
cpl_array * muse_cplarray_new_from_delimited_string(const char *aString, const char *aDelim)
Convert a delimited string into an array of strings.
Structure definition of MUSE pixel table.
muse_cube_type muse_postproc_get_cube_format(const char *aFormatString)
Select correct cube format for format string.
double * muse_xcombine_find_offsets(const cpl_table *aOffsets, const char *aDateObs)
Get offsets and scale from table row with matching DATE-OBS entry.
double dy
Vertical step size for resampling (in arcsec or pixel). The following defaults are taken when this va...
cpl_boolean muse_postproc_check_save_param(const char *aSave, const char *aValid)
Check the –save parameter contents against allowed options.
muse_resampling_params * muse_resampling_params_new(muse_resampling_type aMethod)
Create the resampling parameters structure.
double lambdaref
Reference wavelength used for correction of differential atmospheric refraction. The R-band (peak wav...
double rc
Critical radius for the "renka" resampling method.
muse_lsf_cube ** muse_lsf_cube_load_all(muse_processing *aProcessing)
Load all LSF cubes for all IFUs into an array.
muse_pixtable * muse_xcombine_tables(muse_pixtable **aPixtables, const cpl_table *aOffsets)
combine the pixel tables of several exposures into one
muse_table * muse_processing_load_table(muse_processing *aProcessing, const char *aTag, unsigned char aIFU)
Load a MUSE table according to its tag and IFU/channel number.
muse_cube_type
cpl_propertylist * wcs
Structure definition of the post-processing properties.
Definition: muse_postproc.h:91
double skymodel_fraction
Fraction of the image (without the ignored part) to be considered as sky. If an input sky mask is pro...
void muse_postproc_properties_delete(muse_postproc_properties *aProp)
Free memory taken by a post-processing properties object and all its components.
const char * crtype_s
Type of statistics used for detection of cosmic rays during final resampling. "iraf" uses the varianc...
int darcheck
Carry out a check of the theoretical DAR correction using source centroiding. If "correct" it will al...
double skymodel_sampling
Spectral sampling of the sky spectrum [Angstrom].
double muse_pfits_get_dec(const cpl_propertylist *aHeaders)
find out the declination
Definition: muse_pfits.c:285
int astrometry
If false, skip any astrometric calibration, even if one was passed in the input set of files...
muse_mask * muse_processing_load_mask(muse_processing *aProcessing, const char *aTag)
Load a mask file and its FITS header.
double skymodel_csampling
Spectral sampling of the continuum spectrum [Angstrom].
muse_lsf_cube ** lsf_cube
cpl_error_code muse_resampling_params_set_pixfrac(muse_resampling_params *aParams, const char *aString)
Set resampling pixfrac given a string that can contain up to three floating-point values...
const char * format_s
Type of output file format, "Cube" is a standard FITS cube with NAXIS=3 and multiple extensions (for ...
double lambdamax
Cut off the data above this wavelength after loading the pixel table(s).
int muse_processing_save_image(muse_processing *aProcessing, int aIFU, muse_image *aImage, const char *aTag)
Save a computed MUSE image to disk.
cpl_table * muse_processing_load_ctable(muse_processing *aProcessing, const char *aTag, unsigned char aIFU)
Load a CPL table according to its tag and IFU/channel number.
muse_resampling_type muse_postproc_get_resampling_type(const char *aResampleString)
Select correct resampling type for resample string.
double dx
Horizontal step size for resampling (in arcsec or pixel). The following defaults are taken when this ...
int skymethod
The method used to subtract the sky background (spectrum). Option "model" should work in all kinds of...
Structure to hold the parameters of the muse_scipost recipe.
double crsigma
Sigma rejection factor to use for cosmic ray rejection during final resampling. A zero or negative va...
cpl_error_code muse_processing_save_table(muse_processing *aProcessing, int aIFU, void *aTable, cpl_propertylist *aHeader, const char *aTag, muse_table_type aType)
Save a computed table to disk.
muse_resampling_type
Resampling types.
Resampling parameters.
Structure definition of the post-processing output sky data.
void muse_resampling_params_delete(muse_resampling_params *aParams)
Delete a resampling parameters structure.
muse_lsf_params ** muse_processing_lsf_params_load(muse_processing *aProcessing, int aIFU)
Load slice LSF parameters.
cpl_error_code muse_wcs_position_celestial(muse_pixtable *aPixtable, double aRA, double aDEC)
Convert native to celestial spherical coordinates in a pixel table.
Definition: muse_wcs.c:1466
muse_sky_params skymodel_params
cpl_table * muse_processing_sort_exposures(muse_processing *aProcessing)
Sort input frames (containing lists of pixel table filenames) into different exposures.
void muse_pixtable_delete(muse_pixtable *aPixtable)
Deallocate memory associated to a pixel table object.
cpl_propertylist * muse_processing_load_header(muse_processing *aProcessing, const char *aTag)
load a header according to its tag
muse_postproc_darcheck darcheck
Definition: muse_postproc.h:97
muse_xcombine_types
Xposure combination types.
Definition: muse_xcombine.h:44
double dlambda
Wavelength step size (in Angstrom). Natural instrument sampling is used, if this is 0...
const char * resample_s
The resampling technique to use for the final output cube. (as string)
cpl_propertylist * header
The FITS header.
const char * save
Select output product(s) to save. Can contain one or more of "cube", "skymodel", "individual", "positioned", "combined", and "stacked". If several options are given, they have to be comma-separated. ("cube": output cube and associated images, if this is not given, no final resampling is done at all – "skymodel": up to four additional output products about the effectively used sky that was subtracted with the "model" method – "individual": fully reduced pixel table for each individual exposure – "positioned": fully reduced and positioned pixel table for each individual exposure, the difference to "individual" is that here, the output pixel tables have coordinates in RA and DEC; this is only useful, if both the relative exposure weighting and the final resampling are to be done externally – "combined": fully reduced and combined pixel table for the full set of exposures, the difference to "positioned" is that all pixel tables are combined into one, with an added weight column; this is useful, if only the final resampling step is to be done separately – "stacked": an additional output file in form of a 2D column-stacked image, i.e. x direction is pseudo-spatial, y direction is wavelength.)
cpl_error_code muse_pixtable_flux_multiply(muse_pixtable *aPixtable, double aScale)
Scale the flux of a pixel table with correct treatment of variance.
cpl_propertylist * muse_wcs_create_default(void)
Create FITS headers containing a default (relative) WCS.
Definition: muse_wcs.c:1174
cpl_error_code muse_sky_save_continuum(muse_processing *, const cpl_table *, cpl_propertylist *)
Save sky continuum table to file.