32 #include "muse_geometry_z.h"
49 muse_geometry_qc_spots(cpl_table *aSpots, cpl_propertylist *aHeader)
51 cpl_msg_debug(__func__,
"Adding QC keywords to %s", MUSE_TAG_SPOTS_TABLE);
54 nexp1 = cpl_table_get_column_min(aSpots,
"image"),
55 nexp2 = cpl_table_get_column_max(aSpots,
"image");
56 for (nexp = nexp1; nexp <= nexp2; nexp++) {
57 cpl_table_unselect_all(aSpots);
58 cpl_table_or_selected_int(aSpots,
"image", CPL_EQUAL_TO, nexp);
59 cpl_table_and_selected_double(aSpots,
"xfwhm", CPL_GREATER_THAN, 0.);
60 cpl_table_and_selected_double(aSpots,
"yfwhm", CPL_GREATER_THAN, 0.);
61 cpl_table_and_selected_double(aSpots,
"flux", CPL_GREATER_THAN, 1000.);
62 cpl_table *table = cpl_table_extract_selected(aSpots);
64 cpl_table_duplicate_column(table,
"fwhm", table,
"xfwhm");
65 cpl_table_add_columns(table,
"fwhm",
"yfwhm");
66 cpl_table_multiply_scalar(table,
"fwhm", 0.5);
67 double mean = cpl_table_get_column_mean(table,
"fwhm"),
68 median = cpl_table_get_column_median(table,
"fwhm"),
69 stdev = cpl_table_get_column_stdev(table,
"fwhm");
70 cpl_table_delete(table);
72 char keyword[KEYWORD_LENGTH];
73 snprintf(keyword, KEYWORD_LENGTH, QC_GEO_EXPk_MEAN, nexp);
74 cpl_propertylist_update_float(aHeader, keyword, mean);
75 snprintf(keyword, KEYWORD_LENGTH, QC_GEO_EXPk_MEDIAN, nexp);
76 cpl_propertylist_update_float(aHeader, keyword, median);
77 snprintf(keyword, KEYWORD_LENGTH, QC_GEO_EXPk_STDEV, nexp);
78 cpl_propertylist_update_float(aHeader, keyword, stdev);
91 muse_geometry_qc_ifu(
muse_geo_table *aGeoInit, cpl_propertylist *aHeader,
92 const cpl_vector *aLambdas)
94 cpl_table *gtinit = aGeoInit->
table;
95 const unsigned char ifu = cpl_table_get_int(gtinit, MUSE_GEOTABLE_FIELD, 0, NULL);
96 double angle = cpl_table_get_column_mean(gtinit, MUSE_GEOTABLE_ANGLE),
97 astdev = cpl_table_get_column_stdev(gtinit, MUSE_GEOTABLE_ANGLE),
98 amedian = cpl_table_get_column_median(gtinit, MUSE_GEOTABLE_ANGLE);
99 cpl_msg_debug(__func__,
"Adding QC keywords for IFU %hhu: angle = %.3f +/- %.3f "
100 "(%.3f) deg", ifu, angle, astdev, amedian);
101 char *keyword = cpl_sprintf(QC_GEO_IFUi_ANGLE, ifu);
102 cpl_propertylist_update_float(aHeader, keyword, amedian);
105 int i, n = cpl_vector_get_size(aLambdas);
106 for (i = 1; i <= n; i++) {
107 double lambda = cpl_vector_get(aLambdas, i - 1);
108 char *kw = cpl_sprintf(QC_GEO_IFUi_WLENj, ifu, i),
109 *kwmean = cpl_sprintf(QC_GEO_IFUi_MEANj, ifu, i),
110 *kwmedi = cpl_sprintf(QC_GEO_IFUi_MEDIANj, ifu, i),
111 *kwstdv = cpl_sprintf(QC_GEO_IFUi_STDEVj, ifu, i);
112 cpl_propertylist_update_float(aHeader, kw, lambda);
114 cpl_table_unselect_all(gtinit);
115 cpl_table_or_selected_double(gtinit,
"lambda", CPL_EQUAL_TO, lambda);
116 if (cpl_table_count_selected(gtinit) < 1) {
117 cpl_propertylist_update_float(aHeader, kwmean, i);
118 cpl_propertylist_update_float(aHeader, kwmedi, i);
119 cpl_propertylist_update_float(aHeader, kwstdv, i);
121 cpl_table *t = cpl_table_extract_selected(gtinit);
122 cpl_propertylist_update_float(aHeader, kwmean,
123 cpl_table_get_column_mean(t,
"flux"));
124 cpl_propertylist_update_float(aHeader, kwmedi,
125 cpl_table_get_column_median(t,
"flux"));
126 cpl_propertylist_update_float(aHeader, kwstdv,
127 cpl_table_get_column_stdev(t,
"flux"));
146 cpl_propertylist *aHeader)
148 double angle = cpl_table_get_column_mean(aGeoTable->
table, MUSE_GEOTABLE_ANGLE),
149 astdev = cpl_table_get_column_stdev(aGeoTable->
table, MUSE_GEOTABLE_ANGLE),
150 amedian = cpl_table_get_column_median(aGeoTable->
table, MUSE_GEOTABLE_ANGLE);
151 cpl_msg_debug(__func__,
"Adding global QC keywords: angle = %.3f +/- %.3f "
152 "(%.3f) deg", angle, astdev, amedian);
153 cpl_propertylist_update_float(aHeader, QC_GEO_MASK_ANGLE, amedian);
165 muse_geometry_load_images(
muse_processing *aProcessing,
unsigned short aIFU)
167 unsigned int skip = 0;
168 if (getenv(
"MUSE_GEOMETRY_SKIP") && atoi(getenv(
"MUSE_GEOMETRY_SKIP")) > 0) {
169 skip = atoi(getenv(
"MUSE_GEOMETRY_SKIP"));
178 unsigned int ifile, nfiles = 99;
180 cpl_msg_warning(__func__,
"Skipping spot measurements, only loading first"
181 " (reduced) file for IFU %02hu", aIFU);
184 cpl_msg_warning(__func__,
"Skipping raw image processing, loading all "
185 "reduced images directly");
187 for (ifile = 0; ifile < nfiles; ifile++) {
188 char *fn = cpl_sprintf(
"MASK_REDUCED_00%02u-%02hu.fits", ifile + 1, aIFU);
189 cpl_errorstate es = cpl_errorstate_get();
192 cpl_errorstate_set(es);
196 cpl_frame *frame = cpl_frame_new();
197 cpl_frame_set_filename(frame, fn);
198 cpl_frame_set_tag(frame,
"MASK");
200 cpl_msg_debug(__func__,
"file = %s", fn);
204 cpl_msg_debug(__func__,
"Read %u file%s", ifile, ifile == 1 ?
"" :
"s");
233 static cpl_error_code
237 double aLMin,
double aLMax)
239 cpl_ensure_code(aProcessing && aParams && aGeo && aGeo->
table,
240 CPL_ERROR_NULL_INPUT);
241 if (aLMin >= aLMax) {
242 cpl_msg_warning(__func__,
"Invalid wavelength range for reconstruction "
243 "(%.2f..%.2f), using 6800..7200 instead!", aLMin, aLMax);
247 unsigned int skip = 0;
248 if (getenv(
"MUSE_GEOMETRY_SKIP") && atoi(getenv(
"MUSE_GEOMETRY_SKIP")) > 0) {
249 skip = atoi(getenv(
"MUSE_GEOMETRY_SKIP"));
251 cpl_table *gt = aGeo->
table;
255 #pragma omp parallel for default(none) \
256 shared(gt, aParams, aProcessing, pts, skip)
257 for (nifu = (
unsigned)aParams->
ifu1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
258 cpl_table *trace =
muse_table_load(aProcessing, MUSE_TAG_TRACE_TABLE, nifu),
260 if (!trace || !wavecal) {
261 cpl_table_delete(trace);
262 cpl_table_delete(wavecal);
266 cpl_frame *cframe = NULL;
269 cframe = cpl_frame_new();
270 char *fn = cpl_sprintf(
"MASK_COMBINED-%02hhu.fits", nifu);
271 cpl_frame_set_filename(cframe, fn);
274 MUSE_TAG_MASK_COMBINED, nifu);
277 cpl_table_delete(trace);
278 cpl_table_delete(wavecal);
281 cpl_msg_debug(__func__,
"reconstructing IFU %2hhu using \"%s\"", nifu,
282 cpl_frame_get_filename(cframe));
284 cpl_frame_delete(cframe);
286 cpl_table_delete(trace);
287 cpl_table_delete(wavecal);
293 for (nifu = (
unsigned)aParams->
ifu1 + 1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
304 return cpl_error_set_message(__func__, CPL_ERROR_ILLEGAL_OUTPUT,
305 "After cutting to %.2f..%.2f in wavelength no "
306 "pixels for image reconstruction are left!",
319 cube->
recnames = cpl_array_new(1, CPL_TYPE_STRING);
321 cpl_array_set_string(cube->
recnames, 0,
"white");
326 return CPL_ERROR_NONE;
356 static cpl_error_code
361 cpl_ensure_code(aProcessing && aParams && aGeo && aGeo->
table,
362 CPL_ERROR_NULL_INPUT);
363 if (aLMin >= aLMax) {
364 cpl_msg_warning(__func__,
"Invalid wavelength range for reconstruction "
365 "(%.2f..%.2f), using 6800..7200 instead!", aLMin, aLMax);
373 cpl_frameset *usedoriginal = cpl_frameset_duplicate(aProcessing->
usedFrames);
374 int iframe, nframes = cpl_frameset_get_size(aProcessing->
usedFrames);
375 for (iframe = 0; iframe < nframes; iframe++) {
376 cpl_frame *frame = cpl_frameset_get_position(aProcessing->
usedFrames, iframe);
377 if (cpl_frame_get_group(frame) == CPL_FRAME_GROUP_RAW) {
378 cpl_frame_set_group(frame, CPL_FRAME_GROUP_CALIB);
382 cpl_table *gt = aGeo->
table;
384 "MASK_CHECK", 0, CPL_FALSE);
385 nframes = cpl_frameset_get_size(frames);
386 cpl_msg_info(__func__,
"Found %d datasets to reconstruct", nframes);
387 for (iframe = 0; iframe < nframes; iframe++) {
388 cpl_frame *frame = cpl_frameset_get_position(frames, iframe);
389 const char *fn = cpl_frame_get_filename(frame);
390 cpl_msg_info(__func__,
"Reconstructing image %d (from \"%s\"), using "
391 "wavelength range %.2f..%.2f", iframe + 1, fn, aLMin, aLMax);
394 #pragma omp parallel for default(none) \
395 shared(aParams, aProcessing, fn, frames, gt, pts)
396 for (nifu = (
unsigned)aParams->
ifu1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
397 cpl_table *trace =
muse_table_load(aProcessing, MUSE_TAG_TRACE_TABLE, nifu),
399 if (!trace || !wavecal) {
400 cpl_table_delete(trace);
401 cpl_table_delete(wavecal);
405 MUSE_TAG_MASTER_BIAS, nifu);
407 cpl_table_delete(trace);
408 cpl_table_delete(wavecal);
411 const char *bname = cpl_frame_get_filename(bframe);
412 cpl_errorstate es = cpl_errorstate_get();
415 cpl_errorstate_set(es);
418 cpl_frame_delete(bframe);
424 cpl_table_delete(trace);
425 cpl_table_delete(wavecal);
438 cpl_table_delete(trace);
439 cpl_table_delete(wavecal);
445 for (nifu = (
unsigned)aParams->
ifu1 + 1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
455 cpl_error_set_message(__func__, CPL_ERROR_ILLEGAL_OUTPUT,
456 "After cutting to %.2f..%.2f in wavelength no "
457 "pixels for image reconstruction of \"%s\" are "
458 "left!", aLMin, aLMax, fn);
468 rp->dlambda = 10000.;
476 cpl_frameset_insert(usedoriginal, cpl_frame_duplicate(frame));
477 cpl_propertylist *header = cpl_propertylist_load(fn, 0);
479 header,
"GEOMETRY_CHECK");
480 cpl_propertylist_delete(header);
483 cpl_frameset_delete(frames);
487 return CPL_ERROR_NONE;
504 if (aParams->
centroid == MUSE_GEOMETRY_PARAM_CENTROID_GAUSSIAN) {
506 }
else if (aParams->
centroid != MUSE_GEOMETRY_PARAM_CENTROID_BARYCENTER) {
507 cpl_msg_error(__func__,
"unknown centroiding method \"%s\"", aParams->
centroid_s);
512 cpl_table *linelist =
muse_table_load(aProcessing, MUSE_TAG_LINE_CATALOG, 0);
514 MUSE_TAG_LINE_CATALOG);
516 cpl_propertylist_delete(linehead);
518 cpl_table_delete(linelist);
519 if (!listvalid || !vlines) {
520 cpl_msg_error(__func__,
"%s could not be loaded/verified or enough suitable"
521 "lines are missing", MUSE_TAG_LINE_CATALOG);
522 cpl_vector_delete(vlines);
526 cpl_msg_info(__func__,
"Analyzing IFUs %d to %d", aParams->
ifu1, aParams->
ifu2);
527 cpl_error_code rc[kMuseNumIFUs];
528 cpl_table *mspots[kMuseNumIFUs],
529 *trace[kMuseNumIFUs],
530 *wavecal[kMuseNumIFUs];
531 cpl_propertylist *headfinal = NULL;
532 cpl_array *dy = cpl_array_new(0, CPL_TYPE_DOUBLE);
534 #pragma omp parallel for default(none) \
535 shared(aParams, aProcessing, centroid, dy, headfinal, mspots, rc, \
536 trace, vlines, wavecal)
537 for (nifu = (
unsigned)aParams->
ifu1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
538 rc[nifu - 1] = CPL_ERROR_NONE;
539 mspots[nifu - 1] = NULL;
543 trace[nifu - 1] =
muse_table_load(aProcessing, MUSE_TAG_TRACE_TABLE, nifu);
544 wavecal[nifu - 1] =
muse_table_load(aProcessing, MUSE_TAG_WAVECAL_TABLE, nifu);
545 if (!trace[nifu - 1] || !wavecal[nifu - 1]) {
546 cpl_msg_error(__func__,
"Calibration could not be loaded for IFU %hu: %s%s",
547 nifu, !trace[nifu - 1] ?
" "MUSE_TAG_TRACE_TABLE :
"",
548 !wavecal[nifu - 1] ?
" "MUSE_TAG_WAVECAL_TABLE :
"");
549 cpl_table_delete(trace[nifu - 1]);
550 cpl_table_delete(wavecal[nifu - 1]);
551 trace[nifu - 1] = NULL;
552 wavecal[nifu - 1] = NULL;
553 rc[nifu - 1] = CPL_ERROR_NULL_INPUT;
559 muse_imagelist *images = muse_geometry_load_images(aProcessing, nifu);
561 cpl_msg_error(__func__,
"Loading and basic processing of the raw input "
562 "images failed for IFU %hu!", nifu);
563 cpl_table_delete(trace[nifu - 1]);
564 cpl_table_delete(wavecal[nifu - 1]);
565 trace[nifu - 1] = NULL;
566 wavecal[nifu - 1] = NULL;
567 rc[nifu - 1] = cpl_error_get_code();
571 unsigned int skip = 0;
572 if (getenv(
"MUSE_GEOMETRY_SKIP") && atoi(getenv(
"MUSE_GEOMETRY_SKIP")) > 0) {
573 skip = atoi(getenv(
"MUSE_GEOMETRY_SKIP"));
575 cpl_propertylist *header;
577 char *fn = cpl_sprintf(
"SPOTS_TABLE-%02hu.fits", nifu);
578 cpl_msg_warning(__func__,
"Reading spot measurements from \"%s\"", fn);
579 mspots[nifu - 1] = cpl_table_load(fn, 1, 1);
587 wavecal[nifu - 1], vlines,
588 aParams->
sigma, centroid);
594 muse_geometry_qc_spots(mspots[nifu - 1], header);
597 cpl_propertylist_delete(header);
599 cpl_msg_info(__func__,
"measured %"CPL_SIZE_FORMAT
" spots in %u images",
601 cpl_table_delete(wavecal[nifu - 1]);
610 MUSE_TAG_MASK_REDUCED);
613 #pragma omp critical (muse_geo_header_construct)
622 cpl_propertylist_erase_regexp(headfinal,
623 "EXTNAME|ESO DET (CHIP|OUT)|ESO DET2", 0);
634 UNUSED_ARGUMENT(pinholedy);
635 cpl_array_delete(dy);
638 cpl_table *spots = NULL;
640 #pragma omp parallel for default(none) \
641 shared(aParams, geotable, headfinal, mspots, spots, trace, vlines)
642 for (nifu = (
unsigned)aParams->
ifu1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
646 cpl_table_delete(trace[nifu - 1]);
648 #pragma omp critical (muse_geo_header_construct)
649 muse_geometry_qc_ifu(geoinit, headfinal, vlines);
653 #pragma omp critical (muse_geo_table_insert)
658 if (fabs(geotable->
scale - geohori->
scale) > DBL_EPSILON) {
659 cpl_msg_warning(__func__,
"Combined and single geometry tables have "
660 "different scales (%f / %f)!", geotable->
scale,
663 cpl_table_insert(geotable->
table, geohori->
table,
664 cpl_table_get_nrow(geotable->
table));
668 #pragma omp critical (muse_spots_table_insert)
671 spots = mspots[nifu - 1];
673 cpl_table_insert(spots, mspots[nifu - 1], cpl_table_get_nrow(spots));
674 cpl_table_delete(mspots[nifu - 1]);
678 cpl_vector_delete(vlines);
679 cpl_error_code result = CPL_ERROR_NONE;
681 for (nifu = (
unsigned)aParams->
ifu1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
682 if (result < rc[nifu - 1]) {
683 result = rc[nifu - 1];
687 cpl_table_save(geotable, NULL, NULL,
"geocombined.fits", CPL_IO_CREATE);
688 cpl_table_save(spots, NULL, NULL,
"spotscombined.fits", CPL_IO_CREATE);
691 cpl_table_delete(spots);
696 if (result < rcfinal) {
699 muse_geometry_qc_global(geofinal, headfinal);
703 muse_geometry_reconstruct_combined(aProcessing, aParams, geofinal,
707 muse_geometry_reconstruct(aProcessing, aParams, geofinal,
710 cpl_propertylist_delete(headfinal);
712 return result != CPL_ERROR_NONE ? -1 : 0;
cpl_error_code muse_quadrants_overscan_correct(muse_image *aImage, muse_image *aRefImage)
Adapt bias level to reference image using overscan statistics.
int muse_processing_save_cimage(muse_processing *aProcessing, int aIFU, cpl_image *aImage, cpl_propertylist *aHeader, const char *aTag)
Save a computed FITS image to disk.
muse_imagelist * muse_basicproc_load(muse_processing *aProcessing, unsigned char aIFU, muse_basicproc_params *aBPars)
Load the raw input files from disk and do basic processing.
Structure definition of a MUSE datacube.
Structure definition for a collection of muse_images.
const char * centroid_s
Type of centroiding and FWHM determination to use for all spot measurements: simple barycenter method...
cpl_error_code muse_geo_refine_horizontal(muse_geo_table *aGeo, cpl_table *aSpots)
Refine relative horizontal positions of adjacent IFUs.
void muse_image_delete(muse_image *aImage)
Deallocate memory associated to a muse_image object.
int muse_utils_get_extension_for_ifu(const char *aFilename, unsigned char aIFU)
Return extension number that corresponds to this IFU/channel number.
cpl_size muse_pixtable_get_nrow(muse_pixtable *aPixtable)
get the number of rows within the pixel table
muse_image * muse_image_load_from_raw(const char *aFilename, int aExtension)
Load raw image into the data extension of a MUSE image.
double sigma
Sigma detection level for spot detection, in terms of median deviation above the median.
double lambdamax
When passing any MASK_CHECK frames in the input, use this upper wavelength cut before reconstructing ...
int muse_image_subtract(muse_image *aImage, muse_image *aSubtract)
Subtract a muse_image from another with correct treatment of bad pixels and variance.
void muse_datacube_delete(muse_datacube *aCube)
Deallocate memory associated to a muse_datacube object.
double muse_geo_compute_pinhole_global_distance(cpl_array *aDY, double aWidth, double aMin, double aMax)
Use vertical pinhole distance measurements of all IFUs to compute the effective global value...
void muse_imagelist_delete(muse_imagelist *aList)
Free the memory of the MUSE image list.
double scale
The VLT focal plane scale factor of the data. output file.
muse_geo_table * muse_geo_determine_vertical(const muse_geo_table *aGeo)
Use all properties of the central spot and the horizontal properties in each slice to compute the ver...
muse_image * muse_datacube_collapse(muse_datacube *aCube, cpl_table *aFilter)
Integrate a FITS NAXIS=3 datacube along the wavelength direction.
Structure definition of MUSE three extension FITS file.
cpl_array * recnames
the reconstructed image filter names
cpl_table * table
The pixel table.
cpl_propertylist * header
the FITS header
muse_image * muse_combine_average_create(muse_imagelist *aImages)
Average a list of input images.
int muse_image_variance_create(muse_image *aImage, muse_image *aBias)
Create the photon noise-based variance in the stat extension.
unsigned int muse_imagelist_get_size(muse_imagelist *aList)
Return the number of stored images.
muse_geo_table * muse_geo_determine_horizontal(const muse_geo_table *aGeo)
Use per-spot and per-wavelength partial geometry to determine the horizontal geometrical properties f...
cpl_error_code muse_geo_compute_pinhole_local_distance(cpl_array *aDY, cpl_table *aSpots)
Use spot measurements of one IFU to compute vertical pinhole distance.
cpl_error_code muse_pixtable_restrict_wavelength(muse_pixtable *aPixtable, double aLow, double aHigh)
Restrict a pixel table to a certain wavelength range.
cpl_table * muse_geo_measure_spots(muse_image *aImage, muse_imagelist *aList, const cpl_table *aTrace, const cpl_table *aWave, const cpl_vector *aLines, double aSigma, muse_geo_centroid_type aCentroid)
Detect spots on a combined image and measure them on the corresponding series of images.
Structure definition of MUSE pixel table.
muse_image * muse_imagelist_get(muse_imagelist *aList, unsigned int aIdx)
Get the muse_image of given list index.
cpl_table * table
The geometry table.
Structure definition of MUSE geometry table.
cpl_error_code muse_geo_finalize(muse_geo_table *aGeo)
Create a final version of a geometry table.
muse_resampling_params * muse_resampling_params_new(muse_resampling_type aMethod)
Create the resampling parameters structure.
muse_geo_centroid_type
Type of centroiding algorithm to use.
cpl_error_code muse_processing_save_cube(muse_processing *aProcessing, int aIFU, void *aCube, const char *aTag, muse_cube_type aType)
Save a MUSE datacube to disk.
cpl_frameset * outputFrames
cpl_imagelist * data
the cube containing the actual data values
void muse_processing_append_used(muse_processing *aProcessing, cpl_frame *aFrame, cpl_frame_group aGroup, int aDuplicate)
Add a frame to the set of used frames.
muse_pixtable * muse_pixtable_create(muse_image *aImage, cpl_table *aTrace, cpl_table *aWave, cpl_table *aGeoTable)
Create the pixel table for one CCD.
void muse_geo_table_delete(muse_geo_table *aGeo)
Deallocate memory associated to a geometry table object.
muse_datacube * muse_resampling_cube(muse_pixtable *aPixtable, muse_resampling_params *aParams, muse_pixgrid **aPixgrid)
Resample a pixel table onto a regular grid structure representing a FITS NAXIS=3 datacube.
int centroid
Type of centroiding and FWHM determination to use for all spot measurements: simple barycenter method...
cpl_error_code muse_quadrants_overscan_stats(muse_image *aImage, const char *aRejection, unsigned int aIgnore)
Compute overscan statistics of all quadrants and save in FITS header.
int muse_processing_save_image(muse_processing *aProcessing, int aIFU, muse_image *aImage, const char *aTag)
Save a computed MUSE image to disk.
int ifu2
Last IFU to analyze.
muse_image * muse_image_load(const char *aFilename)
Load the three extensions and the FITS headers of a MUSE image from a file.
cpl_error_code muse_image_reject_from_dq(muse_image *aImage)
Reject pixels of a muse_image depending on its DQ data.
muse_imagelist * muse_imagelist_new(void)
Create a new (empty) MUSE image list.
int ifu1
First IFU to analyze.
cpl_table * muse_table_load(muse_processing *aProcessing, const char *aTag, unsigned char aIFU)
load a table according to its tag and IFU/channel number
double lambdamin
When passing any MASK_CHECK frames in the input, use this lower wavelength cut before reconstructing ...
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.
void muse_resampling_params_delete(muse_resampling_params *aParams)
Delete a resampling parameters structure.
cpl_propertylist * muse_propertylist_load(muse_processing *aProcessing, const char *aTag)
load a propertylist according to its tag
cpl_boolean muse_wave_lines_check(cpl_table *aTable, cpl_propertylist *aHeader)
Check that a LINE_CATALOG has the expected format.
cpl_error_code muse_image_adu_to_count(muse_image *aImage)
Convert the data units from raw adu to count (= electron) units.
cpl_frameset * muse_frameset_find(const cpl_frameset *aFrames, const char *aTag, unsigned char aIFU, cpl_boolean aInvert)
return frameset containing data from an IFU/channel with a certain tag
cpl_vector * muse_geo_lines_get(const cpl_table *aLines)
Select lines suitable for geometrical calibration from a line list.
muse_image * muse_image_load_from_extensions(const char *aFilename, unsigned char aIFU)
Load the three extensions and the FITS headers of a MUSE image from extensions of a merged file...
cpl_frameset * inputFrames
cpl_frameset * usedFrames
void muse_pixtable_delete(muse_pixtable *aPixtable)
Deallocate memory associated to a pixel table object.
cpl_error_code muse_imagelist_set(muse_imagelist *aList, muse_image *aImage, unsigned int aIdx)
Set the muse_image of given list index.
muse_geo_table * muse_geo_determine_initial(cpl_table *aSpots, const cpl_table *aTrace)
Use spot measurements to compute initial geometrical properties.
cpl_frame * muse_frameset_find_master(const cpl_frameset *aFrames, const char *aTag, unsigned char aIFU)
find the master frame according to its CCD number and tag
muse_imagelist * recimages
the reconstructed image data
muse_image * muse_quadrants_trim_image(muse_image *aImage)
Trim the input image of pre- and over-scan regions of all quadrants.
Structure to hold the parameters of the muse_geometry recipe.