32 #include "muse_geometry_z.h" 50 muse_geometry_qc_spots(cpl_table *aSpots, cpl_propertylist *aHeader)
52 if (!aSpots || !aHeader) {
57 nexp1 = cpl_table_get_column_min(aSpots,
"image"),
58 nexp2 = cpl_table_get_column_max(aSpots,
"image");
59 cpl_msg_debug(__func__,
"Adding QC keywords for %u exposures to %s",
60 nexp2 - nexp1 + 1, MUSE_TAG_SPOTS_TABLE);
62 cpl_array *amean = cpl_array_new(nexp2 - nexp1 + 1, CPL_TYPE_DOUBLE);
63 for (nexp = nexp1; nexp <= nexp2; nexp++) {
64 cpl_table_unselect_all(aSpots);
65 cpl_table_or_selected_int(aSpots,
"image", CPL_EQUAL_TO, nexp);
66 cpl_table_and_selected_double(aSpots,
"xfwhm", CPL_GREATER_THAN, 0.);
67 cpl_table_and_selected_double(aSpots,
"yfwhm", CPL_GREATER_THAN, 0.);
68 cpl_table_and_selected_double(aSpots,
"flux", CPL_GREATER_THAN, 1000.);
69 cpl_table *table = cpl_table_extract_selected(aSpots);
71 cpl_table_duplicate_column(table,
"fwhm", table,
"xfwhm");
72 cpl_table_add_columns(table,
"fwhm",
"yfwhm");
73 cpl_table_multiply_scalar(table,
"fwhm", 0.5);
74 double mean = cpl_table_get_column_mean(table,
"fwhm"),
75 median = cpl_table_get_column_median(table,
"fwhm"),
76 stdev = cpl_table_get_column_stdev(table,
"fwhm");
77 cpl_table_delete(table);
79 char keyword[KEYWORD_LENGTH];
80 snprintf(keyword, KEYWORD_LENGTH, QC_GEO_EXPk_MEAN, nexp);
81 cpl_propertylist_update_float(aHeader, keyword, mean);
82 snprintf(keyword, KEYWORD_LENGTH, QC_GEO_EXPk_MEDIAN, nexp);
83 cpl_propertylist_update_float(aHeader, keyword, median);
84 snprintf(keyword, KEYWORD_LENGTH, QC_GEO_EXPk_STDEV, nexp);
85 cpl_propertylist_update_float(aHeader, keyword, stdev);
87 cpl_array_set_double(amean, nexp - nexp1, mean);
89 cpl_propertylist_update_float(aHeader, QC_GEO_FWHM_MEAN,
90 cpl_array_get_mean(amean));
91 cpl_propertylist_update_float(aHeader, QC_GEO_FWHM_STDEV,
92 cpl_array_get_stdev(amean));
93 cpl_array_delete(amean);
109 muse_geometry_qc_ifu(
muse_geo_table *aGeoInit, cpl_propertylist *aHeader,
110 const cpl_vector *aLambdas)
112 if (!aGeoInit || !aHeader || !aLambdas) {
115 cpl_table *gtinit = aGeoInit->
table;
116 const unsigned char ifu = cpl_table_get_int(gtinit, MUSE_GEOTABLE_FIELD, 0, NULL);
118 double angle = -cpl_table_get_column_mean(gtinit, MUSE_GEOTABLE_ANGLE),
119 astdev = cpl_table_get_column_stdev(gtinit, MUSE_GEOTABLE_ANGLE),
120 amedian = -cpl_table_get_column_median(gtinit, MUSE_GEOTABLE_ANGLE);
122 if (getenv(
"MUSE_GEOMETRY_NO_INVERSION")
123 && atoi(getenv(
"MUSE_GEOMETRY_NO_INVERSION")) > 0) {
127 cpl_msg_debug(__func__,
"Adding QC keywords for IFU %hhu: angle = %.3f +/- %.3f " 128 "(%.3f) deg", ifu, angle, astdev, amedian);
129 char *keyword = cpl_sprintf(QC_GEO_IFUi_ANGLE, ifu);
130 cpl_propertylist_update_float(aHeader, keyword, amedian);
133 int i, n = cpl_vector_get_size(aLambdas);
134 for (i = 1; i <= n; i++) {
135 double lambda = cpl_vector_get(aLambdas, i - 1);
136 char *kw = cpl_sprintf(QC_GEO_IFUi_WLENj, ifu, i),
137 *kwmean = cpl_sprintf(QC_GEO_IFUi_MEANj, ifu, i),
138 *kwmedi = cpl_sprintf(QC_GEO_IFUi_MEDIANj, ifu, i),
139 *kwstdv = cpl_sprintf(QC_GEO_IFUi_STDEVj, ifu, i);
140 cpl_propertylist_update_float(aHeader, kw, lambda);
142 cpl_table_unselect_all(gtinit);
143 cpl_table_or_selected_double(gtinit,
"lambda", CPL_EQUAL_TO, lambda);
144 if (cpl_table_count_selected(gtinit) < 1) {
145 cpl_propertylist_update_float(aHeader, kwmean, i);
146 cpl_propertylist_update_float(aHeader, kwmedi, i);
147 cpl_propertylist_update_float(aHeader, kwstdv, i);
149 cpl_table *t = cpl_table_extract_selected(gtinit);
150 cpl_propertylist_update_float(aHeader, kwmean,
151 cpl_table_get_column_mean(t,
"flux"));
152 cpl_propertylist_update_float(aHeader, kwmedi,
153 cpl_table_get_column_median(t,
"flux"));
154 cpl_propertylist_update_float(aHeader, kwstdv,
155 cpl_table_get_column_stdev(t,
"flux"));
174 muse_geometry_load_images(
muse_processing *aProcessing,
unsigned short aIFU)
176 unsigned int skip = 0;
177 if (getenv(
"MUSE_GEOMETRY_SKIP") && atoi(getenv(
"MUSE_GEOMETRY_SKIP")) > 0) {
178 skip = atoi(getenv(
"MUSE_GEOMETRY_SKIP"));
186 MUSE_TAG_MASTER_BIAS, aIFU);
188 cpl_propertylist *hbias = cpl_propertylist_load(cpl_frame_get_filename(fbias), 0);
189 cpl_frame_delete(fbias);
191 cpl_propertylist_delete(hbias);
197 unsigned int ifile, nfiles = 99;
199 cpl_msg_warning(__func__,
"Skipping spot measurements, only loading first" 200 " (reduced) file for IFU %02hu", aIFU);
203 cpl_msg_warning(__func__,
"Skipping raw image processing, loading all " 204 "reduced images directly");
206 for (ifile = 0; ifile < nfiles; ifile++) {
207 char *fn = cpl_sprintf(
"MASK_REDUCED_00%02u-%02hu.fits", ifile + 1, aIFU);
208 cpl_errorstate es = cpl_errorstate_get();
211 cpl_errorstate_set(es);
215 cpl_frame *frame = cpl_frame_new();
216 cpl_frame_set_filename(frame, fn);
217 cpl_frame_set_tag(frame,
"MASK");
219 cpl_msg_debug(__func__,
"file = %s", fn);
223 cpl_msg_debug(__func__,
"Read %u file%s", ifile, ifile == 1 ?
"" :
"s");
252 static cpl_error_code
256 double aLMin,
double aLMax)
258 cpl_ensure_code(aProcessing && aParams && aGeo && aGeo->
table,
259 CPL_ERROR_NULL_INPUT);
260 if (aLMin >= aLMax) {
261 cpl_msg_warning(__func__,
"Invalid wavelength range for reconstruction " 262 "(%.2f..%.2f), skipping combined reconstruction!", aLMin, aLMax);
263 return CPL_ERROR_ILLEGAL_INPUT;
265 cpl_msg_info(__func__,
"Reconstructing combined input as cube in the " 266 "wavelength range %.2f..%.2f.", aLMin, aLMax);
267 unsigned int skip = 0;
268 if (getenv(
"MUSE_GEOMETRY_SKIP") && atoi(getenv(
"MUSE_GEOMETRY_SKIP")) > 0) {
269 skip = atoi(getenv(
"MUSE_GEOMETRY_SKIP"));
271 cpl_table *gt = aGeo->
table;
275 #pragma omp parallel for default(none) \ 276 shared(gt, aParams, aProcessing, pts, skip) 277 for (nifu = (
unsigned)aParams->
ifu1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
280 if (!trace || !wavecal) {
281 cpl_table_delete(trace);
282 cpl_table_delete(wavecal);
286 cpl_frame *cframe = NULL;
289 cframe = cpl_frame_new();
290 char *fn = cpl_sprintf(
"MASK_COMBINED-%02hhu.fits", nifu);
291 cpl_frame_set_filename(cframe, fn);
295 MUSE_TAG_MASK_COMBINED, nifu);
298 cpl_table_delete(trace);
299 cpl_table_delete(wavecal);
302 cpl_msg_debug(__func__,
"reconstructing IFU %2hhu using \"%s\"", nifu,
303 cpl_frame_get_filename(cframe));
305 cpl_frame_delete(cframe);
307 cpl_table_delete(trace);
308 cpl_table_delete(wavecal);
310 if (!pts[nifu - 1]) {
311 cpl_msg_warning(__func__,
"Could not create a pixel table for reconstruction" 312 " for IFU %2hhu!", nifu++);
318 nifu = aParams->
ifu1;
320 pts[nifu - 1] = NULL;
321 while (!pt && nifu <= aParams->ifu2) {
324 pts[nifu - 1] = NULL;
327 for ( ; nifu <= (unsigned)aParams->
ifu2; nifu++) {
340 return cpl_error_set_message(__func__, CPL_ERROR_ILLEGAL_OUTPUT,
341 "After cutting to %.2f..%.2f in wavelength no " 342 "pixels for image reconstruction are left!",
355 cube->
recnames = cpl_array_new(1, CPL_TYPE_STRING);
357 cpl_array_set_string(cube->
recnames, 0,
"white");
362 return CPL_ERROR_NONE;
392 static cpl_error_code
397 cpl_ensure_code(aProcessing && aParams && aGeo && aGeo->
table,
398 CPL_ERROR_NULL_INPUT);
399 if (aLMin >= aLMax) {
400 cpl_msg_warning(__func__,
"Invalid wavelength range for reconstruction " 401 "(%.2f..%.2f), skipping reconstruction!", aLMin, aLMax);
402 return CPL_ERROR_ILLEGAL_INPUT;
408 cpl_frameset *usedoriginal = cpl_frameset_duplicate(aProcessing->
usedframes);
409 int iframe, nframes = cpl_frameset_get_size(aProcessing->
usedframes);
410 for (iframe = 0; iframe < nframes; iframe++) {
411 cpl_frame *frame = cpl_frameset_get_position(aProcessing->
usedframes, iframe);
412 if (cpl_frame_get_group(frame) == CPL_FRAME_GROUP_RAW) {
413 cpl_frame_set_group(frame, CPL_FRAME_GROUP_CALIB);
417 cpl_table *gt = aGeo->
table;
419 "MASK_CHECK", 0, CPL_FALSE);
420 nframes = cpl_frameset_get_size(frames);
421 cpl_msg_info(__func__,
"Found %d datasets to reconstruct", nframes);
422 for (iframe = 0; iframe < nframes; iframe++) {
423 cpl_frame *frame = cpl_frameset_get_position(frames, iframe);
424 const char *fn = cpl_frame_get_filename(frame);
425 cpl_msg_info(__func__,
"Reconstructing image %d (from \"%s\"), using " 426 "wavelength range %.2f..%.2f", iframe + 1, fn, aLMin, aLMax);
429 #pragma omp parallel for default(none) \ 430 shared(aParams, aProcessing, fn, frames, gt, pts) 431 for (nifu = (
unsigned)aParams->
ifu1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
434 if (!trace || !wavecal) {
435 cpl_table_delete(trace);
436 cpl_table_delete(wavecal);
440 MUSE_TAG_MASTER_BIAS, nifu);
442 cpl_table_delete(trace);
443 cpl_table_delete(wavecal);
446 const char *bname = cpl_frame_get_filename(bframe);
447 cpl_errorstate es = cpl_errorstate_get();
450 cpl_errorstate_set(es);
453 cpl_frame_delete(bframe);
459 cpl_table_delete(trace);
460 cpl_table_delete(wavecal);
466 if (bpars && !strncmp(bpars->
overscan,
"vpoly", 5)) {
468 unsigned char ovscvorder = 3;
471 char *rest = strchr(bpars->
overscan,
':');
472 if (strlen(bpars->
overscan) > 6 && rest++) {
473 ovscvorder = strtol(rest, &rest, 10);
474 if (strlen(rest++) > 0) {
475 frms = strtod(rest, &rest);
476 if (strlen(rest++) > 0) {
477 fchisq = strtod(rest, &rest);
488 if (bpars && !strncmp(bpars->
overscan,
"offset", 6)) {
496 cpl_table_delete(trace);
497 cpl_table_delete(wavecal);
499 if (!pts[nifu - 1]) {
500 cpl_msg_warning(__func__,
"Could not create a pixel table for " 501 "reconstruction for IFU %2hhu!", nifu++);
507 nifu = aParams->
ifu1;
509 pts[nifu - 1] = NULL;
510 while (!pt && nifu <= aParams->ifu2) {
513 pts[nifu - 1] = NULL;
516 for ( ; nifu <= (unsigned)aParams->
ifu2; nifu++) {
528 cpl_error_set_message(__func__, CPL_ERROR_ILLEGAL_OUTPUT,
529 "After cutting to %.2f..%.2f in wavelength no " 530 "pixels for image reconstruction of \"%s\" are " 531 "left!", aLMin, aLMax, fn);
541 rp->dlambda = 10000.;
550 #pragma omp critical(muse_processing_used_frames) 551 cpl_frameset_insert(usedoriginal, cpl_frame_duplicate(frame));
552 cpl_propertylist *header = cpl_propertylist_load(fn, 0);
554 header,
"GEOMETRY_CHECK");
555 cpl_propertylist_delete(header);
558 cpl_frameset_delete(frames);
562 return CPL_ERROR_NONE;
579 if (aParams->
centroid == MUSE_GEOMETRY_PARAM_CENTROID_GAUSSIAN) {
581 }
else if (aParams->
centroid != MUSE_GEOMETRY_PARAM_CENTROID_BARYCENTER) {
582 cpl_msg_error(__func__,
"unknown centroiding method \"%s\"", aParams->
centroid_s);
588 MUSE_TAG_LINE_CATALOG, 0);
592 if (!listvalid || !vlines) {
593 cpl_msg_error(__func__,
"%s could not be loaded/verified or enough suitable" 594 " lines are missing", MUSE_TAG_LINE_CATALOG);
595 cpl_vector_delete(vlines);
599 cpl_msg_info(__func__,
"Analyzing IFUs %d to %d", aParams->
ifu1, aParams->
ifu2);
600 cpl_error_code rc[kMuseNumIFUs];
601 cpl_table *mspots[kMuseNumIFUs],
602 *trace[kMuseNumIFUs],
603 *wavecal[kMuseNumIFUs];
604 cpl_propertylist *headfinal = NULL;
605 cpl_array *dy = cpl_array_new(0, CPL_TYPE_DOUBLE);
607 #pragma omp parallel for default(none) \ 608 shared(aParams, aProcessing, centroid, dy, headfinal, mspots, rc, \ 609 trace, vlines, wavecal) 610 for (nifu = (
unsigned)aParams->
ifu1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
611 rc[nifu - 1] = CPL_ERROR_NONE;
612 mspots[nifu - 1] = NULL;
618 if (!trace[nifu - 1] || !wavecal[nifu - 1]) {
619 cpl_msg_error(__func__,
"Calibration could not be loaded for IFU %u: %s%s",
620 nifu, !trace[nifu - 1] ?
" "MUSE_TAG_TRACE_TABLE :
"",
621 !wavecal[nifu - 1] ?
" "MUSE_TAG_WAVECAL_TABLE :
"");
622 cpl_table_delete(trace[nifu - 1]);
623 cpl_table_delete(wavecal[nifu - 1]);
624 trace[nifu - 1] = NULL;
625 wavecal[nifu - 1] = NULL;
626 rc[nifu - 1] = CPL_ERROR_NULL_INPUT;
632 muse_imagelist *images = muse_geometry_load_images(aProcessing, nifu);
634 cpl_msg_error(__func__,
"Loading and basic processing of the raw input " 635 "images failed for IFU %u!", nifu);
636 cpl_table_delete(trace[nifu - 1]);
637 cpl_table_delete(wavecal[nifu - 1]);
638 trace[nifu - 1] = NULL;
639 wavecal[nifu - 1] = NULL;
640 rc[nifu - 1] = cpl_error_get_code();
644 unsigned int skip = 0;
645 if (getenv(
"MUSE_GEOMETRY_SKIP") && atoi(getenv(
"MUSE_GEOMETRY_SKIP")) > 0) {
646 skip = atoi(getenv(
"MUSE_GEOMETRY_SKIP"));
648 cpl_propertylist *header;
650 char *fn = cpl_sprintf(
"SPOTS_TABLE-%02u.fits", nifu);
651 cpl_msg_warning(__func__,
"Reading spot measurements from \"%s\"", fn);
652 mspots[nifu - 1] = cpl_table_load(fn, 1, 1);
660 wavecal[nifu - 1], vlines,
661 aParams->
sigma, centroid);
667 muse_geometry_qc_spots(mspots[nifu - 1], header);
670 cpl_propertylist_delete(header);
672 cpl_msg_info(__func__,
"measured %"CPL_SIZE_FORMAT
" spots in %u images",
674 cpl_table_delete(wavecal[nifu - 1]);
683 MUSE_TAG_MASK_REDUCED);
686 #pragma omp critical (muse_geo_header_construct) 695 cpl_propertylist_erase_regexp(headfinal,
696 "EXTNAME|ESO DET (CHIP|OUT)|ESO DET2", 0);
707 UNUSED_ARGUMENT(pinholedy);
708 cpl_array_delete(dy);
711 cpl_table *spots = NULL;
713 #pragma omp parallel for default(none) \ 714 shared(aParams, geotable, headfinal, mspots, spots, trace, vlines) 715 for (nifu = (
unsigned)aParams->
ifu1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
719 cpl_table_delete(trace[nifu - 1]);
721 #pragma omp critical (muse_geo_header_construct) 722 muse_geometry_qc_ifu(geoinit, headfinal, vlines);
726 #pragma omp critical (muse_geo_table_insert) 731 if (fabs(geotable->
scale - geohori->
scale) > 1e-10) {
735 cpl_msg_warning(__func__,
"Combined and single geometry tables have " 736 "different scales (%.15f / %.15f)!", geotable->
scale,
739 cpl_table_insert(geotable->
table, geohori->
table,
740 cpl_table_get_nrow(geotable->
table));
744 #pragma omp critical (muse_spots_table_insert) 747 spots = mspots[nifu - 1];
749 cpl_table_insert(spots, mspots[nifu - 1], cpl_table_get_nrow(spots));
750 cpl_table_delete(mspots[nifu - 1]);
754 cpl_vector_delete(vlines);
755 cpl_error_code result = CPL_ERROR_NONE;
757 for (nifu = (
unsigned)aParams->
ifu1; nifu <= (
unsigned)aParams->
ifu2; nifu++) {
758 if (result < rc[nifu - 1]) {
759 result = rc[nifu - 1];
763 cpl_table_save(geotable, NULL, NULL,
"geocombined.fits", CPL_IO_CREATE);
764 cpl_table_save(spots, NULL, NULL,
"spotscombined.fits", CPL_IO_CREATE);
767 cpl_table_delete(spots);
772 if (result < rcfinal) {
776 if (aParams->
smooth > 0.) {
784 if (result < rcfinal) {
789 cpl_propertylist_update_int(headfinal, QC_GEO_SMOOTH_NX, -1);
790 cpl_propertylist_update_int(headfinal, QC_GEO_SMOOTH_NY, -1);
791 cpl_propertylist_update_int(headfinal, QC_GEO_SMOOTH_NA, -1);
792 cpl_propertylist_update_int(headfinal, QC_GEO_SMOOTH_NW, -1);
802 muse_geometry_reconstruct_combined(aProcessing, aParams, geofinal,
806 muse_geometry_reconstruct(aProcessing, aParams, geofinal,
809 cpl_propertylist_delete(headfinal);
811 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.
muse_image * muse_image_load_from_raw(const char *aFilename, int aExtension)
Load raw image into the data extension of a MUSE image.
cpl_size muse_pixtable_get_nrow(const muse_pixtable *aPixtable)
get the number of rows within the pixel table
double sigma
Sigma detection level for spot detection, in terms of median deviation above the median.
cpl_error_code muse_geo_correct_slices(muse_geo_table *aGeo, cpl_propertylist *aHeader, double aSigma)
Correct deviant slices in an existing MUSE geometry table.
double lambdamax
When passing any MASK_CHECK frames in the input, use this upper wavelength cut before reconstructing ...
muse_datacube * muse_resampling_cube(muse_pixtable *aPixtable, muse_resampling_params *aParams, muse_pixgrid **aGrid)
Resample a pixel table onto a regular grid structure representing a FITS NAXIS=3 datacube.
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...
cpl_boolean muse_wave_lines_check(muse_table *aTable)
Check that a LINE_CATALOG has the expected format.
Structure definition of MUSE three extension FITS file.
cpl_array * recnames
the reconstructed image filter names
cpl_error_code muse_quadrants_overscan_polyfit_vertical(muse_image *aImage, unsigned aIgnore, unsigned char aOrder, double aSigma, const double aFRMS, double aFChiSq)
Correct quadrants by polynomial representation of vertical overscan.
cpl_table * table
The pixel table.
void muse_basicproc_params_delete(muse_basicproc_params *aBPars)
Free a structure of basic processing parameters.
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.
cpl_frameset * usedframes
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.
cpl_error_code muse_geo_qc_global(const muse_geo_table *aGeoTable, cpl_propertylist *aHeader)
Add the global QC parameters to the geometry 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_table * table
The table.
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.
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.
Structure to store a table together with a property list.
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_table_delete(muse_table *aTable)
Deallocate memory associated to a muse_table object.
void muse_geo_table_delete(muse_geo_table *aGeo)
Deallocate memory associated to a geometry table object.
int centroid
Type of centroiding and FWHM determination to use for all spot measurements: simple barycenter method...
double smooth
Use this sigma-level cut for smoothing of the output table within each slicer stack. Set to non-positive value to deactivate smoothing.
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.
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.
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.
muse_basicproc_params * muse_basicproc_params_new_from_propertylist(const cpl_propertylist *aHeader)
Create a structure of basic processing parameters from a FITS header.
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.
Structure of basic processing parameters.
void muse_resampling_params_delete(muse_resampling_params *aParams)
Delete a resampling parameters structure.
muse_image * muse_datacube_collapse(muse_datacube *aCube, const muse_table *aFilter)
Integrate a FITS NAXIS=3 datacube along the wavelength direction.
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...
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.