31 #include "muse_postproc.h"
32 #include "muse_instrument.h"
34 #include "muse_astro.h"
36 #include "muse_flux.h"
37 #include "muse_imagelist.h"
38 #include "muse_pfits.h"
39 #include "muse_rvcorrect.h"
40 #include "muse_utils.h"
71 case MUSE_POSTPROC_SCIPOST:
72 case MUSE_POSTPROC_STANDARD:
73 case MUSE_POSTPROC_ASTROMETRY:
77 cpl_msg_error(__func__,
"No such setup known: %d", aType);
78 cpl_error_set(__func__, CPL_ERROR_ILLEGAL_INPUT);
103 cpl_propertylist_delete(aProp->
wcs);
122 cpl_ensure(aSave, CPL_ERROR_NULL_INPUT, CPL_FALSE);
123 if (strlen(aSave) < 4) {
124 cpl_error_set_message(__func__, CPL_ERROR_DATA_NOT_FOUND,
125 "no (valid) save option given!");
129 cpl_boolean allvalid = CPL_TRUE;
133 ns = cpl_array_get_size(asave),
134 nv = cpl_array_get_size(avalid);
135 for (i = 0; i < ns; i++) {
136 cpl_boolean valid = CPL_FALSE;
137 for (j = 0; j < nv; j++) {
138 if (!strcmp(cpl_array_get_string(asave, i),
139 cpl_array_get_string(avalid, j))) {
144 cpl_error_set_message(__func__, CPL_ERROR_ILLEGAL_INPUT,
145 "save option %d (%s) is not valid!", i + 1,
146 cpl_array_get_string(asave, i));
147 allvalid = CPL_FALSE;
150 cpl_array_delete(asave);
151 cpl_array_delete(avalid);
175 if (!strncmp(aResampleString,
"nearest", 8)) {
178 if (!strncmp(aResampleString,
"linear", 7)) {
181 if (!strncmp(aResampleString,
"quadratic", 10)) {
184 if (!strncmp(aResampleString,
"renka", 6)) {
187 if (!strncmp(aResampleString,
"drizzle", 8)) {
190 if (!strncmp(aResampleString,
"lanczos", 8)) {
216 if (!strncmp(aCRTypeString,
"iraf", 5)) {
219 if (!strncmp(aCRTypeString,
"mean", 5)) {
222 if (!strncmp(aCRTypeString,
"median", 7)) {
247 if (!strncmp(aFormatString,
"Cube", 5)) {
250 if (!strncmp(aFormatString,
"Euro3D", 7)) {
253 if (!strncmp(aFormatString,
"xCube", 6)) {
256 if (!strncmp(aFormatString,
"xEuro3D", 8)) {
281 if (!strncmp(aWeightString,
"exptime", 8)) {
284 if (!strncmp(aWeightString,
"fwhm", 5)) {
287 if (!strncmp(aWeightString,
"none", 5)) {
321 const cpl_frame *aFrame,
float aWarnLimit,
322 float aErrLimit,
double *aRA,
double *aDEC)
324 cpl_ensure(aHeader && aFrame, CPL_ERROR_NULL_INPUT, NULL);
325 cpl_errorstate state = cpl_errorstate_get();
328 cpl_ensure(cpl_errorstate_is_equal(state), CPL_ERROR_DATA_NOT_FOUND, NULL);
329 cpl_msg_debug(__func__,
"reference coordinates: RA = %e deg, DEC =%e deg",
338 const char *fn = cpl_frame_get_filename(aFrame);
339 cpl_propertylist *header;
340 double dmin = FLT_MAX;
341 int iext, inearest = -1, next = cpl_fits_count_extensions(fn);
342 for (iext = 1; iext <= next; iext++) {
343 header = cpl_propertylist_load(fn, iext);
344 const char *extname = cpl_propertylist_get_string(header,
"EXTNAME");
348 cpl_msg_debug(__func__,
"extension %d [%s]: RA = %e deg, DEC = %e deg --> "
349 "d = %e deg", iext, extname, ra, dec, d);
354 cpl_propertylist_delete(header);
357 if (dmin * 3600. > aErrLimit) {
358 cpl_error_set_message(__func__, CPL_ERROR_INCOMPATIBLE_INPUT,
"Distance of "
359 "nearest reference table to observed position is %.2f "
360 "arcmin, certainly a wrong reference object!", dmin * 60.);
363 if (dmin * 3600. > aWarnLimit) {
364 cpl_msg_warning(__func__,
"Distance of nearest reference table to observed "
365 "position is %.2f arcmin! (Wrong reference object?)",
368 header = cpl_propertylist_load(fn, inearest);
369 const char *extname = cpl_propertylist_get_string(header,
"EXTNAME");
370 cpl_msg_info(__func__,
"Loading \"%s[%s]\" (distance %.1f arcsec)", fn,
371 extname, dmin * 3600.);
372 cpl_propertylist_delete(header);
373 cpl_table *table = cpl_table_load(fn, inearest, 1);
426 cpl_ensure(aProp && aProp->
exposures, CPL_ERROR_NULL_INPUT, NULL);
427 cpl_ensure((
int)aIndex < cpl_table_get_nrow(aProp->
exposures),
428 CPL_ERROR_ILLEGAL_INPUT, NULL);
429 cpl_msg_info(__func__,
"Starting to process exposure %d (DATE-OBS=%s)",
430 aIndex + 1, cpl_table_get_string(aProp->
exposures,
"DATE-OBS",
432 cpl_ensure(aProp->
exposures, CPL_ERROR_NULL_INPUT, NULL);
434 cpl_table *exposure = cpl_table_extract(aProp->
exposures, aIndex, 1);
438 cpl_table_delete(exposure);
443 cpl_propertylist_erase_regexp(pt->
header,
"ESO QC ", 0);
447 cpl_boolean labdata = CPL_FALSE;
448 cpl_errorstate prestate = cpl_errorstate_get();
452 if (!cpl_errorstate_is_equal(prestate) || airmass < 1.) {
453 cpl_msg_warning(__func__,
"This seems to be lab data (RA=%f DEC=%f, "
454 "airmass=%f), not doing any DAR correction!", ra, dec,
456 cpl_errorstate_dump(prestate, CPL_FALSE, NULL);
457 cpl_errorstate_set(prestate);
460 cpl_error_code rc = CPL_ERROR_NONE;
462 cpl_msg_debug(__func__,
"WFM detected: starting DAR correction");
464 cpl_msg_debug(__func__,
"DAR correction returned rc=%d: %s", rc,
465 rc != CPL_ERROR_NONE ? cpl_error_get_message() :
"");
467 if (aProp->
darcheck != MUSE_POSTPROC_DARCHECK_NONE) {
468 cpl_boolean dorefine = aProp->
darcheck == MUSE_POSTPROC_DARCHECK_CORRECT;
469 cpl_msg_info(__func__,
"Carrying out DAR %s", dorefine ?
"correction" :
"check");
472 if (rc != CPL_ERROR_NONE) {
473 cpl_msg_warning(__func__,
"Maximum detected shift %f\'\' (rc = %d: %s)",
474 maxshift, rc, cpl_error_get_message());
476 cpl_msg_info(__func__,
"Maximum detected shift %f\'\'", maxshift);
482 if (aProp->
type != MUSE_POSTPROC_STANDARD) {
486 cpl_msg_debug(__func__,
"Flux calibration returned rc=%d: %s", rc,
487 rc != CPL_ERROR_NONE ? cpl_error_get_message_default(rc) :
"");
489 cpl_msg_info(__func__,
"Skipping flux calibration (no %s curve)",
490 MUSE_TAG_STD_RESPONSE);
494 cpl_table *sky_cont = NULL,
497 aProp->
skymethod == MUSE_POSTPROC_SKYMETHOD_MODEL &&
502 cpl_table_select_all(sky_pt->
table);
506 cpl_msg_info(__func__,
"Intermediate resampling to produce white-light image"
507 " for sky-spectrum creation:");
508 cpl_msg_indent_more();
514 cpl_msg_error(__func__,
"Could not create cube for whitelight image");
521 cpl_msg_indent_less();
527 cpl_table_select_all(sky_pt->
table);
533 double lambda_low = cpl_array_get_min(lambda);
534 double lambda_high = cpl_array_get_max(lambda);
536 sky_lines = cpl_table_duplicate(aProp->
sky->
lines);
542 prestate = cpl_errorstate_get();
544 if (!cpl_errorstate_is_equal(prestate)) {
545 cpl_errorstate_dump(prestate, CPL_FALSE, NULL);
546 cpl_errorstate_set(prestate);
548 cpl_table_delete(sky_lines);
549 sky_lines = cpl_table_duplicate(master->
lines);
553 cpl_msg_info(__func__,
"No sky continuum given, create it from the data");
560 cpl_table_erase_column(sky_cont,
"stat");
561 cpl_table_erase_column(sky_cont,
"dq");
562 cpl_table_name_column(sky_cont,
"data",
"flux");
564 cpl_msg_info(__func__,
"Using sky continuum given as input");
569 cpl_array_unwrap(lambda);
570 cpl_array_unwrap(data);
571 cpl_array_unwrap(stat);
574 aSkyOut->
mask = sky_mask;
578 cpl_table_delete(spectrum);
581 cpl_table_delete(fwhite);
590 ((aProp->
skymethod == MUSE_POSTPROC_SKYMETHOD_NONE) ||
591 (aProp->
skymethod == MUSE_POSTPROC_SKYMETHOD_MODEL))) {
596 cpl_msg_debug(__func__,
"doing sky continuum subtraction with input "
599 }
else if (sky_cont) {
600 cpl_msg_debug(__func__,
"doing sky continuum subtraction with created "
602 sky->
continuum = cpl_table_duplicate(sky_cont);
605 cpl_msg_debug(__func__,
"doing sky line subtraction with created list");
606 sky->
lines = cpl_table_duplicate(sky_lines);
608 cpl_msg_debug(__func__,
"doing sky line subtraction with input list");
611 cpl_msg_debug(__func__,
"doing sky subtraction by spectrum modeling");
618 aSkyOut->
lines = sky_lines;
621 cpl_table_delete(sky_lines);
622 cpl_table_delete(sky_cont);
624 if (aProp->
skymethod == MUSE_POSTPROC_SKYMETHOD_ROWBYROW) {
626 cpl_msg_debug(__func__,
"doing sky subtraction using row-by-row fitting");
630 #pragma omp parallel for default(none) \
631 shared(aProp, list, n)
632 for (k = 0; k < n; k++) {
645 if (aProp->
type == MUSE_POSTPROC_STANDARD) {
646 double raref, decref;
651 cpl_msg_error(__func__,
"Required input %s could not be loaded!",
652 MUSE_TAG_STD_FLUX_TABLE);
657 cpl_msg_error(__func__,
"%s does not have a recognized format!",
658 MUSE_TAG_STD_FLUX_TABLE);
659 cpl_table_delete(reftable);
664 prestate = cpl_errorstate_get();
668 cpl_msg_debug(__func__,
"Flux integration found %"CPL_SIZE_FORMAT
" stars",
673 cpl_msg_warning(__func__,
"Invalid airmass derived (%.3e), resetting to "
681 cpl_table_delete(reftable);
685 if (!cpl_errorstate_is_equal(prestate)) {
686 cpl_msg_warning(__func__,
"The following errors happened while computing "
687 "the flux calibration (rc = %d/%s):", rc,
688 cpl_error_get_message_default(rc));
695 if (aProp->
type == MUSE_POSTPROC_ASTROMETRY) {
700 cpl_msg_error(__func__,
"Required input %s could not be loaded!",
701 MUSE_TAG_ASTROMETRY_REFERENCE);
705 prestate = cpl_errorstate_get();
708 wcs->crpix1 = aProp->crpix1;
709 wcs->crpix2 = aProp->
crpix2;
713 cpl_table_delete(reftable);
714 cpl_msg_debug(__func__,
"Solving astrometry (initial radius %.1f pix, "
715 "initial relative accuracy %.1f, %d iterations with rejection"
716 " sigma %.2f) returned rc=%d: %s", aProp->
radius,
718 rc, rc != CPL_ERROR_NONE ? cpl_error_get_message() :
"");
721 if (!cpl_errorstate_is_equal(prestate)) {
722 cpl_msg_warning(__func__,
"The following errors happened while computing "
723 "the astrometric solution (rc = %d/%s):", rc,
724 cpl_error_get_message());
731 cpl_msg_debug(__func__,
"Astrometry correction returned rc=%d: %s", rc,
732 rc != CPL_ERROR_NONE ? cpl_error_get_message() :
"");
759 cpl_ensure(aProcessing, CPL_ERROR_NULL_INPUT, NULL);
762 MUSE_TAG_OUTPUT_WCS, 0, CPL_FALSE);
763 if (!fwcs || cpl_frameset_get_size(fwcs) <= 0) {
765 cpl_frameset_delete(fwcs);
768 cpl_frame *frame = cpl_frameset_get_position(fwcs, 0);
769 const char *fn = cpl_frame_get_filename(frame);
770 cpl_propertylist *header = NULL;
771 int iext, next = cpl_fits_count_extensions(fn);
772 for (iext = 0; iext <= next; iext++) {
773 header = cpl_propertylist_load(fn, iext);
774 cpl_errorstate es = cpl_errorstate_get();
775 cpl_wcs *wcs = cpl_wcs_new_from_propertylist(header);
776 if (!cpl_errorstate_is_equal(es)) {
777 cpl_errorstate_set(es);
780 cpl_propertylist_delete(header);
785 int naxis = cpl_wcs_get_image_naxis(wcs);
786 cpl_boolean valid = naxis == 2 || naxis == 3;
788 const cpl_array *ctypes = cpl_wcs_get_ctype(wcs);
789 if (valid && cpl_array_get_string(ctypes, 0)) {
790 valid = valid && !strncmp(cpl_array_get_string(ctypes, 0),
"RA---TAN", 9);
792 if (valid && cpl_array_get_string(ctypes, 1)) {
793 valid = valid && !strncmp(cpl_array_get_string(ctypes, 1),
"DEC--TAN", 9);
796 if (valid && cpl_array_get_string(ctypes, 2)) {
797 const char *ctype3 = cpl_array_get_string(ctypes, 2);
799 && (!strncmp(ctype3,
"AWAV", 5) || !strncmp(ctype3,
"AWAV-LOG", 9));
803 cpl_propertylist *pc = cpl_propertylist_new();
804 cpl_propertylist_copy_property_regexp(pc, header,
"^PC[0-9]+_[0-9]+", 0);
805 valid = cpl_propertylist_get_size(pc) == 0;
806 cpl_propertylist_delete(pc);
810 cpl_msg_debug(__func__,
"Apparently valid header %s found in extension %d"
811 " of \"%s\"", MUSE_TAG_OUTPUT_WCS, iext, fn);
815 cpl_propertylist_delete(header);
819 cpl_msg_warning(__func__,
"No valid headers for %s found in \"%s\"",
820 MUSE_TAG_OUTPUT_WCS, fn);
822 cpl_frameset_delete(fwcs);
852 cpl_ensure_code(aProcessing && aPixtable && aParams, CPL_ERROR_NULL_INPUT);
862 cpl_msg_info(__func__,
"Resampling to final cube follows, output format "
864 cpl_msg_indent_more();
866 cpl_msg_indent_less();
867 cpl_ensure_code(e3d, cpl_error_get_code());
870 cpl_msg_info(__func__,
"Resampling to final cube follows, output format "
872 cpl_msg_indent_more();
874 cpl_msg_indent_less();
875 cpl_ensure_code(fits, cpl_error_get_code());
881 int i, ipos = 0, nfilters = cpl_array_get_size(filters);
882 for (i = 0; i < nfilters; i++) {
885 cpl_array_get_string(filters, i));
895 if (getenv(
"MUSE_COLLAPSE_PIXTABLE") &&
896 atoi(getenv(
"MUSE_COLLAPSE_PIXTABLE")) > 0) {
905 cpl_table_delete(filter);
911 ((
muse_datacube *)cube)->recnames = cpl_array_new(0, CPL_TYPE_STRING);
916 cpl_array_set_size(((
muse_datacube *)cube)->recnames, ipos+1);
917 cpl_array_set_string(((
muse_datacube *)cube)->recnames, ipos,
918 cpl_array_get_string(filters, i));
924 cpl_array_get_string(filters, i));
925 cpl_propertylist_update_string(fov->
header, MUSE_HDR_FILTER,
926 cpl_array_get_string(filters, i));
932 cpl_array_delete(filters);
935 cpl_error_code rc = CPL_ERROR_NONE;
979 cpl_ensure_code(aProcessing && aCube, CPL_ERROR_NULL_INPUT);
982 char prefix[KEYWORD_LENGTH] =
"";
983 if (!strncmp(aProcessing->
name,
"muse_scipost", 13)) {
984 strncpy(prefix, QC_POST_PREFIX_SCIPOST, KEYWORD_LENGTH);
985 }
else if (!strncmp(aProcessing->
name,
"muse_exp_combine", 17)) {
986 strncpy(prefix, QC_POST_PREFIX_EXPCOMBINE, KEYWORD_LENGTH);
987 }
else if (!strncmp(aProcessing->
name,
"muse_standard", 14)) {
988 strncpy(prefix, QC_POST_PREFIX_STANDARD, KEYWORD_LENGTH);
989 }
else if (!strncmp(aProcessing->
name,
"muse_astrometry", 16)) {
990 strncpy(prefix, QC_POST_PREFIX_ASTROMETRY, KEYWORD_LENGTH);
992 cpl_msg_info(__func__,
"Recipe \"%s\" found, not generating QC1 keywords",
994 return CPL_ERROR_NONE;
999 int plane = cpl_imagelist_get_size(aCube->
data) / 2;
1000 cpl_image *cim = cpl_imagelist_get(aCube->
data, plane);
1001 double dsigmas[] = { 5., 4., 3. };
1002 int ndsigmas =
sizeof(dsigmas) /
sizeof(
double);
1003 cpl_vector *vsigmas = cpl_vector_wrap(ndsigmas, dsigmas);
1004 cpl_size isigma = -1;
1005 cpl_errorstate prestate = cpl_errorstate_get();
1006 cpl_apertures *apertures = cpl_apertures_extract(cim, vsigmas, &isigma);
1007 cpl_vector_unwrap(vsigmas);
1008 if (!apertures || !cpl_errorstate_is_equal(prestate)) {
1010 char keyword[KEYWORD_LENGTH];
1011 snprintf(keyword, KEYWORD_LENGTH, QC_POST_POSX, prefix, 0);
1012 cpl_propertylist_update_float(aCube->
header, keyword, -1.);
1013 snprintf(keyword, KEYWORD_LENGTH, QC_POST_POSY, prefix, 0);
1014 cpl_propertylist_update_float(aCube->
header, keyword, -1.);
1015 snprintf(keyword, KEYWORD_LENGTH, QC_POST_FWHMX, prefix, 0);
1016 cpl_propertylist_update_float(aCube->
header, keyword, -1.);
1017 snprintf(keyword, KEYWORD_LENGTH, QC_POST_FWHMY, prefix, 0);
1018 cpl_propertylist_update_float(aCube->
header, keyword, -1.);
1020 cpl_errorstate_set(prestate);
1021 cpl_msg_warning(__func__,
"No sources found for FWHM measurement down to "
1022 "%.1f sigma limit on plane %d, QC parameters will not "
1023 "contain useful information", dsigmas[ndsigmas-1], plane+1);
1024 return CPL_ERROR_DATA_NOT_FOUND;
1026 int ndet = cpl_apertures_get_size(apertures);
1027 cpl_msg_info(__func__,
"Computing FWHM QC parameters for %d source%s found "
1028 "down to the %.1f sigma threshold on plane %d", ndet,
1029 ndet == 1 ?
"" :
"s", dsigmas[isigma], plane + 1);
1033 double cd11 = kMuseSpaxelSizeX_WFM, cd12 = 0., cd21 = 0.,
1034 cd22 = kMuseSpaxelSizeY_WFM;
1035 cpl_errorstate es = cpl_errorstate_get();
1036 cpl_wcs *wcs = cpl_wcs_new_from_propertylist(aCube->
header);
1037 if (!cpl_errorstate_is_equal(es)) {
1038 cpl_errorstate_set(es);
1041 !strncasecmp(cpl_propertylist_get_string(aCube->
header,
"CTYPE1"),
1043 cpl_msg_debug(__func__,
"QC1 FWHM parameter estimation (%d sources): "
1044 "simple conversion to arcsec (CTYPE=%s/%s)!", ndet,
1045 cpl_propertylist_get_string(aCube->
header,
"CTYPE1"),
1046 cpl_propertylist_get_string(aCube->
header,
"CTYPE2"));
1048 cd11 = kMuseSpaxelSizeX_WFM;
1049 cd22 = kMuseSpaxelSizeY_WFM;
1052 const cpl_matrix *cd = cpl_wcs_get_cd(wcs);
1054 cd11 = fabs(cpl_matrix_get(cd, 0, 0)) * 3600.,
1055 cd12 = fabs(cpl_matrix_get(cd, 0, 1)) * 3600.,
1056 cd21 = fabs(cpl_matrix_get(cd, 1, 0)) * 3600.,
1057 cd22 = fabs(cpl_matrix_get(cd, 1, 1)) * 3600.;
1058 cpl_msg_debug(__func__,
"QC1 FWHM parameter estimation (%d sources): "
1059 "full conversion to arcsec (CD=%f,%f,%f,%f)", ndet,
1060 cd11, cd12, cd21, cd22);
1062 cpl_wcs_delete(wcs);
1066 printf(
"index RA_FWHM DEC_FWHM\n");
1069 for (n = 1; n <= ndet; n++) {
1070 cpl_size xcen = lround(cpl_apertures_get_centroid_x(apertures, n)),
1071 ycen = lround(cpl_apertures_get_centroid_y(apertures, n));
1073 cpl_image_get_fwhm(cim, xcen, ycen, &x, &y);
1076 x = cd11 * x + cd12 * y;
1077 y = cd22 * y + cd21 * x;
1079 printf(
"%4d %f %f\n", n, x, y);
1083 char keyword[KEYWORD_LENGTH];
1084 snprintf(keyword, KEYWORD_LENGTH, QC_POST_POSX, prefix, n);
1085 cpl_propertylist_update_float(aCube->
header, keyword, xcen);
1086 snprintf(keyword, KEYWORD_LENGTH, QC_POST_POSY, prefix, n);
1087 cpl_propertylist_update_float(aCube->
header, keyword, ycen);
1088 snprintf(keyword, KEYWORD_LENGTH, QC_POST_FWHMX, prefix, n);
1089 cpl_propertylist_update_float(aCube->
header, keyword, x);
1090 snprintf(keyword, KEYWORD_LENGTH, QC_POST_FWHMY, prefix, n);
1091 cpl_propertylist_update_float(aCube->
header, keyword, y);
1096 cpl_apertures_delete(apertures);
1098 return CPL_ERROR_NONE;
Structure definition of a MUSE datacube.
muse_rvcorrect_type rvtype
cpl_propertylist * muse_postproc_cube_load_output_wcs(muse_processing *aProcessing)
Find a file with a usable output WCS in the input frameset.
Structure definition for a collection of muse_images.
muse_postproc_properties * muse_postproc_properties_new(muse_postproc_type aType)
Create a post-processing properties object.
muse_flux_selection_type select
void muse_image_delete(muse_image *aImage)
Deallocate memory associated to a muse_image object.
muse_pixtable * muse_pixtable_duplicate(muse_pixtable *aPixtable)
Make a copy of the pixtanle.
muse_wcs_centroid_type centroid
double muse_pfits_get_ra(const cpl_propertylist *aHeaders)
find out the right ascension
cpl_image * data
the data extension
cpl_error_code muse_rvcorrect(muse_pixtable *aPixtable, muse_rvcorrect_type aType)
Correct the wavelengths of all pixels of a given pixel table for radial velocity shift.
muse_xcombine_types muse_postproc_get_weight_type(const char *aWeightString)
Select correct weighting type for weight string.
cpl_error_code muse_dar_correct(muse_pixtable *aPixtable, double aLambdaRef)
Correct the pixel coordinates of all pixels of a given pixel table for differential atmospheric refra...
cpl_error_code muse_pixtable_and_selected_mask(muse_pixtable *aPixtable, muse_mask *aMask)
Select all pixels where the (x,y) positions are enabled in the given mask.
Structure to hold the MASTER SKY result.
muse_resampling_crstats_type muse_postproc_get_cr_type(const char *aCRTypeString)
Select correct cosmic ray rejection type for crtype string.
cpl_error_code muse_sky_subtract_rowbyrow(muse_image *, cpl_table *, float, unsigned int)
Subtract the sky row-by-row from a CCD-based image.
void muse_datacube_delete(muse_datacube *aCube)
Deallocate memory associated to a muse_datacube object.
void muse_imagelist_delete(muse_imagelist *aList)
Free the memory of the MUSE image list.
muse_image * muse_datacube_collapse(muse_datacube *aCube, cpl_table *aFilter)
Integrate a FITS NAXIS=3 datacube along the wavelength direction.
cpl_error_code muse_dar_check(muse_pixtable *aPixtable, double *aMaxShift, cpl_boolean aCorrect, muse_datacube **aCube)
check that the continuum of objects in the frame is well-aligned perpendicular to the spatial axis...
cpl_error_code muse_flux_reference_table_check(cpl_table *aTable)
Check and/or adapt the standard flux reference table format.
cpl_error_code muse_postproc_qc_fwhm(muse_processing *aProcessing, muse_datacube *aCube)
Compute QC1 parameters for datacubes and save them in the FITS header.
muse_mask * muse_sky_create_skymask(muse_image *, double, const char *)
Select spaxels to be considered as sky.
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.
WCS object to store data needed while computing the astrometric solution.
Structure definition of MUSE three extension FITS file.
muse_flux_object * muse_flux_object_new(void)
Allocate memory for a new muse_flux_object object.
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_table * table
The pixel table.
muse_flux_profile_type profile
muse_postproc_skymethod skymethod
cpl_propertylist * header
the FITS header
cpl_table * muse_table_load_filter(muse_processing *aProcessing, const char *aFilterName)
Load a table for a given filter name.
unsigned int muse_imagelist_get_size(muse_imagelist *aList)
Return the number of stored images.
muse_imagelist * muse_pixtable_to_imagelist(muse_pixtable *aPixtable)
Project a pixel table with data from one IFU back onto its image.
cpl_error_code muse_wcs_project_tan(muse_pixtable *aPixtable, const cpl_propertylist *aWCS)
Carry out a gnomonic projection of a pixel table into native spherical coordinates.
muse_resampling_crstats_type crtype
cpl_error_code muse_flux_get_telluric_table(muse_flux_object *aFluxObj)
Get the table of the telluric correction.
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.
Flux object to store data needed while computing the flux calibration.
cpl_error_code muse_datacube_convert_dq(muse_datacube *aCube)
Convert the DQ extension of a datacube to NANs in DATA and STAT.
muse_cube_type muse_postproc_get_cube_format(const char *aFormatString)
Select correct cube format for format string.
muse_image * muse_imagelist_get(muse_imagelist *aList, unsigned int aIdx)
Get the muse_image of given list index.
cpl_array * muse_cpltable_extract_column(cpl_table *aTable, const char *aColumn)
Create an array from a section of a column.
cpl_boolean muse_postproc_check_save_param(const char *aSave, const char *aValid)
Check the –save parameter contents against allowed options.
cpl_table * lines
Table of Atmospheric emission lines and their intensities.
cpl_error_code muse_flux_response_compute(muse_flux_object *aFluxObj, muse_flux_selection_type aSelect, double aAirmass, const cpl_table *aReference, const cpl_table *aTellBands, const cpl_table *aExtinct)
Compare measured flux distribution over wavelength with calibrated stellar fluxes and derive instrume...
muse_resampling_crstats_type
Cosmic ray rejection statistics type.
muse_resampling_params * muse_resampling_params_new(muse_resampling_type aMethod)
Create the resampling parameters structure.
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_error_code muse_wcs_solve(muse_wcs_object *aWCSObj, cpl_table *aReference, float aRadius, float aFAccuracy, int aIter, float aThresh)
Find the world coordinate solution for a given field using coordinates of detected sources and coordi...
cpl_boolean muse_pixtable_is_fluxcal(muse_pixtable *aPixtable)
Determine whether the pixel table is flux calibrated.
muse_wcs_object * muse_wcs_object_new(void)
Allocate memory for a new muse_wcs_object object.
muse_flux_smooth_type smooth
Structure definition of the post-processing properties.
void muse_cplerrorstate_dump_some(unsigned aCurrent, unsigned aFirst, unsigned aLast)
Dump some CPL errors.
void muse_euro3dcube_delete(muse_euro3dcube *aEuro3D)
Deallocate memory associated to a muse_euro3dcube object.
void muse_postproc_properties_delete(muse_postproc_properties *aProp)
Free memory taken by a post-processing properties object and all its components.
cpl_error_code muse_flux_calibrate(muse_pixtable *aPixtable, const cpl_table *aResponse, const cpl_table *aExtinction, const cpl_table *aTelluric)
Convert the input pixel table from counts to fluxes.
cpl_imagelist * data
the cube containing the actual data values
cpl_error_code muse_sky_lines_set_range(cpl_table *, double, double)
Limit the lines in the table to a wavelength range.
Structure definition of a Euro3D datacube.
double muse_pfits_get_dec(const cpl_propertylist *aHeaders)
find out the declination
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.
cpl_error_code muse_flux_get_response_table(muse_flux_object *aFluxObj, muse_flux_smooth_type aSmooth)
Get the table of the standard star response function.
void muse_sky_master_delete(muse_sky_master *)
Delete a MASTER SKY structure.
static cpl_table * muse_postproc_load_nearest(const cpl_propertylist *aHeader, const cpl_frame *aFrame, float aWarnLimit, float aErrLimit, double *aRA, double *aDEC)
Load the calibration from a multi-table FITS file that is nearest on the sky.
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.
muse_sky_master * muse_sky_master_fit(const cpl_array *, const cpl_array *, const cpl_array *, const cpl_table *)
Fit all entries of the pixel table to the master sky.
muse_image * muse_resampling_collapse_pixgrid(muse_pixtable *aPixtable, muse_pixgrid *aPixgrid, muse_datacube *aCube, cpl_table *aFilter, muse_resampling_params *aParams)
Integrate a pixel table / pixel grid along the wavelength direction.
void muse_pixgrid_delete(muse_pixgrid *aPixels)
Delete a pixgrid and remove its memory.
muse_postproc_type
Type of per-exposure processing to run.
cpl_error_code muse_flux_integrate_std(muse_pixtable *aPixtable, muse_flux_profile_type aProfile, muse_flux_object *aFluxObj)
Integrate the flux of the standard star(s) in the field over all wavelengths.
cpl_propertylist * header
the 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.
muse_pixtable * muse_pixtable_load_merge_channels(cpl_table *aExposureList, double aLambdaMin, double aLambdaMax)
Load and merge the pixel tables of the 24 MUSE sub-fields.
muse_resampling_type muse_postproc_get_resampling_type(const char *aResampleString)
Select correct resampling type for resample string.
muse_image * muse_euro3dcube_collapse(muse_euro3dcube *aEuro3D, cpl_table *aFilter)
Integrate a Euro3D datacube along the wavelength direction.
cpl_error_code muse_pixtable_from_imagelist(muse_pixtable *aPixtable, muse_imagelist *aList)
Get pixel table values back from a per-IFU imagelist.
Handling of "mask" files.
muse_imagelist * muse_imagelist_new(void)
Create a new (empty) MUSE image list.
muse_resampling_type
Resampling types.
cpl_error_code muse_sky_subtract_rowbyrow_mask(muse_image *, cpl_table *)
Prepare an (object) mask for the sky row-by-row fitting.
muse_euro3dcube * muse_resampling_euro3d(muse_pixtable *aPixtable, muse_resampling_params *aParams)
Resample a pixel table onto a regular grid structure representing a Euro3D format file...
Structure definition of the post-processing output sky data.
void muse_resampling_params_delete(muse_resampling_params *aParams)
Delete a resampling parameters structure.
void muse_mask_delete(muse_mask *aMask)
Deallocate memory associated to a muse_mask object.
cpl_table * continuum
Continuum flux table
cpl_table * muse_resampling_spectrum(muse_pixtable *aPixtable, double aBinwidth)
Resample the selected pixels of a pixel table into a spectrum.
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
muse_sky_params skymodel_params
void muse_pixtable_delete(muse_pixtable *aPixtable)
Deallocate memory associated to a pixel table object.
muse_postproc_darcheck darcheck
muse_xcombine_types
Xposure combination types.
cpl_error_code muse_imagelist_set(muse_imagelist *aList, muse_image *aImage, unsigned int aIdx)
Set the muse_image of given list index.
cpl_error_code muse_sky_subtract_pixtable(muse_pixtable *a, muse_sky_master *, muse_lsf_params **)
Subtract the sky spectrum from the "data" column of a pixel table.
double muse_astro_angular_distance(double aRA1, double aDEC1, double aRA2, double aDEC2)
Compute angular distance in the sky between two positions.
muse_lsf_params ** lsf
LSF parameter for the resampled spectrum.
muse_ins_mode muse_pfits_get_mode(const cpl_propertylist *aHeaders)
find out the observation mode
cpl_error_code muse_utils_copy_modified_header(cpl_propertylist *aH1, cpl_propertylist *aH2, const char *aKeyword, const char *aString)
Copy a modified header keyword from one header to another.
cpl_error_code muse_wcs_locate_sources(muse_pixtable *aPixtable, float aSigma, muse_wcs_centroid_type aCentroid, muse_wcs_object *aWCSObj)
Determine the centers of stars on an astrometric exposure.
cpl_error_code muse_image_dq_to_nan(muse_image *aImage)
Convert pixels flagged in the DQ extension to NANs in DATA (and STAT, if present).
double muse_astro_airmass(cpl_propertylist *aHeader)
Derive the effective airmass of an observation from information in a FITS header. ...
cpl_propertylist * header
The FITS header.
muse_sky_master * muse_sky_master_new(void)
Create a muse_sky_master structure.