LCB Recipe has been created.

Some bugs have been fixed.

When generating an rss, all headers are copied to the final image

megaradrp/core/recipe.py

@@ -28,13 +28,14 @@
 from numina.core import BaseRecipe
 from numina.core.dataholders import Product
 from numina.core.products import QualityControlProduct
-
 from numina.core.requirements import ObservationResultRequirement
 
 from megaradrp.processing.trimover import OverscanCorrector, TrimImage
 from megaradrp.processing.slitflat import SlitFlatCorrector
 from megaradrp.processing.aperture import ApertureExtractor
 from megaradrp.processing.fiberflat import FiberFlatCorrector
+from megaradrp.processing.twilight import TwilightCorrector
+from megaradrp.processing.weights import WeightsCorrector
 
 _logger = logging.getLogger('numina.recipes.megara')
 
@@ -72,14 +73,18 @@ def __init__(self, version):
                        'TwilightFiberFlatRecipe': [OverscanCorrector,
                                                    TrimImage,
                                                    BiasCorrector,
-                                                   DarkCorrector,
                                                    BadPixelCorrector,
+                                                   DarkCorrector,
                                                    SlitFlatCorrector],
                        'LCBImageRecipe': [OverscanCorrector, TrimImage,
                                           BiasCorrector, BadPixelCorrector,
                                           DarkCorrector, SlitFlatCorrector],
+                                          # WeightsCorrector,
+                                          # FiberFlatCorrector,
+                                          # TwilightCorrector],
                        'PseudoFluxCalibrationRecipe': [OverscanCorrector,
-                                                       TrimImage,BiasCorrector,
+                                                       TrimImage,
+                                                       BiasCorrector,
                                                        BadPixelCorrector,
                                                        DarkCorrector,
                                                        ApertureExtractor,
@@ -126,6 +131,12 @@ def __generate_flow(self, params, confFile):
                     else:
                         del (flow[cont])
                         cont -= 1
+                elif issubclass(TwilightCorrector, flow[cont]):
+                    if 'twilight' in params.keys():
+                        flow[cont] = (flow[cont](params['twilight']))
+                    else:
+                        del (flow[cont])
+                        cont -= 1
                 elif issubclass(TrimImage, flow[cont]) or issubclass(
                         OverscanCorrector, flow[cont]):
                     flow[cont] = (flow[cont](confFile=confFile))
@@ -156,8 +167,9 @@ def bias_process_common(self, obresult, img):
     def hdu_creation(self, obresult, params={}):
 
         basicflow = self.__generate_flow(params, obresult.configuration.values)
-        lista = []
         cdata = []
+        headers = []
+        hdulist = []
         try:
             for frame in obresult.images:
                 hdulist = frame.open()
@@ -168,13 +180,18 @@ def hdu_creation(self, obresult, params={}):
 
             data = combine.median([d[0].data for d in cdata], dtype='float32')
             template_header = cdata[0][0].header
-            hdu = fits.PrimaryHDU(data[0], header=template_header)
-            lista.append(hdu)
+
+            for header in hdulist:
+                if 'PRIMARY' in header.name:
+                    headers.append(fits.PrimaryHDU(data[0], header=template_header))
+                else:
+                    headers.append(header)
+
         finally:
             for hdulist in cdata:
                 hdulist.close()
 
-        return fits.HDUList(lista), data
+        return fits.HDUList(headers), data
 
     def get_parameters(self, rinput):
 
@@ -241,8 +258,14 @@ def get_wlcalib(self, data):
                    data]
         return np.array(wlcalib)
 
-    def resample_rss_flux(self, rss_old, wcalib):
-        """Resample conserving the flux."""
+    def resample_rss_flux(self, rss_old, wcalib, indexes=[]):
+        """
+
+        :param rss_old: rss image
+        :param wcalib: ndarray of the coefficients
+        :param indexes: is an array to take into account that some wlcalib might not be done
+        :return:
+        """
         import math
         from numpy.polynomial.polynomial import polyval
         from numina.array.interpolation import SteffenInterpolator
@@ -276,9 +299,10 @@ def resample_rss_flux(self, rss_old, wcalib):
         for idx in range(nfibers):
             # We need a monotonic interpolator
             # linear would work, we use a cubic interpolator
-            interpolator = SteffenInterpolator(old_wl_borders[idx],
-                                               accum_flux[idx],
-                                               extrapolate='border')
+            if len(indexes)==0:
+                interpolator = SteffenInterpolator(old_wl_borders[idx],accum_flux[idx],extrapolate='border')
+            else:
+                interpolator = SteffenInterpolator(old_wl_borders[idx-indexes[idx]],accum_flux[idx],extrapolate='border')
             fl_borders = interpolator(new_borders)
             rss_resampled[idx] = fl_borders[1:] - fl_borders[:-1]
         return rss_resampled, (wl_min, wl_max, delts)

megaradrp/drp.yaml

@@ -13,13 +13,13 @@ configurations:
     box:
       boxcol: 2000
       default: [0,0,0,0,]
-      lr: [130, 260, 398, 534, 710, 887, 1104, 1360, 1825, 2284, 2750, 3006, 3223, 3400, 3577, 3713, 3850, 3985]
       hr: [9,9,9]
       mr: [5,5,5]
       LR-I: [173, 306, 442, 574, 745, 917, 1127, 1379, 1836, 2282, 2738, 2990, 3200, 3371, 3543, 3678, 3811, 3944]
       LR-V: [186, 319, 456, 590, 762, 935, 1150, 1400, 1857, 2310, 2766, 3020, 3232, 3405, 3576, 3714, 3847, 3982]
       LR-Z: [174, 304, 440, 570, 744, 916, 1130, 1380, 1835, 2286, 2743, 2995, 3207, 3377, 3550, 3684, 3818, 3952]
       LR-R: [199, 331, 466, 599, 770, 940, 1153, 1402, 1857, 2306, 2759, 3014, 3225, 3394, 3568, 3703, 3831, 3970]
+      LR-U: [130, 260, 398, 534, 710, 887, 1104, 1360, 1825, 2284, 2750, 3006, 3223, 3400, 3577, 3713, 3850, 3985]
   eng:
     trim1: [[0,2056],[52,4148]]
     trim2: [[2156,4212],[48,4144]]
@@ -33,13 +33,13 @@ configurations:
     box:
       boxcol: 2000
       default: [0,0,0,0,]
-      lr: [130, 260, 398, 534, 710, 887, 1104, 1360, 1825, 2284, 2750, 3006, 3223, 3400, 3577, 3713, 3850, 3985]
       hr: [9,9,9]
       mr: [5,5,5]
       LR-I: [140, 281, 409, 545, 714, 883, 1098, 1349, 1804, 2253, 2709, 2961, 3173, 3346, 3520, 3648, 3776, 3920]
       LR-V: [153, 294, 427, 558, 735, 906, 1120, 1373, 1829, 2287, 2740, 2996, 3209, 3381, 3553, 3687, 3824, 3962]
       LR-Z: [140, 283, 415, 540, 720, 890, 1106, 1357, 1810, 2267, 2720, 2976, 3190, 3360, 3533, 3667, 3794, 3942]
       LR-R: [245, 383, 518, 648, 823, 985, 1206, 1457, 1910, 2365, 2812, 3064, 3274, 3446, 3620, 3754, 3886, 4022]
+      LR-U: [130, 260, 398, 534, 710, 887, 1104, 1360, 1825, 2284, 2750, 3006, 3223, 3400, 3577, 3713, 3850, 3985]
 modes:
 - name: Success
   summary: A mode where the recipe successes

megaradrp/processing/aperture.py

@@ -19,30 +19,25 @@
 
 import logging
 
-from numina.flow.processing import TagOptionalCorrector, TagFits
+from numina.flow.processing import Corrector
 
 from megaradrp.core.processing import apextract, apextract_tracemap
 
-
 _logger = logging.getLogger('numina.processing')
 
 
-class ApertureExtractor(TagOptionalCorrector):
+class ApertureExtractor(Corrector):
     """A Node that extracts apertures."""
 
-    def __init__(self, trace, datamodel=None, mark=True,
-                 tagger=None, dtype='float32'):
-
-        if tagger is None:
-            tagger = TagFits('NUM-MAE', 'MEGARA Aperture extractor')
+    def __init__(self, trace, datamodel=None, dtype='float32'):
+        # if tagger is None:
+        #     tagger = TagFits_('NUM-MAE', 'MEGARA Aperture extractor')
 
         super(ApertureExtractor, self).__init__(datamodel=datamodel,
-                                                tagger=tagger,
-                                                mark=mark,
                                                 dtype=dtype)
         self.trace = trace
 
-    def _run(self, img):
+    def run(self, img):
         imgid = self.get_imgid(img)
         _logger.debug('extracting apertures in image %s', imgid)
         rss = apextract(img[0].data, self.trace)
@@ -51,27 +46,22 @@ def _run(self, img):
         return img
 
 
-class ApertureExtractor2(TagOptionalCorrector):
+class ApertureExtractor2(Corrector):
     """A Node that extracts apertures."""
 
     def __init__(self, trace, datamodel=None, mark=True,
                  tagger=None, dtype='float32'):
+        # if tagger is None:
+        #     tagger = TagFits_('NUM-MAE', 'MEGARA Aperture extractor')
 
-        if tagger is None:
-            tagger = TagFits('NUM-MAE', 'MEGARA Aperture extractor')
-
         self.trace = trace
 
         super(ApertureExtractor2, self).__init__(datamodel=datamodel,
-                                                tagger=tagger,
-                                                mark=mark,
-                                                dtype=dtype)
-
+                                                 dtype=dtype)
 
-    def _run(self, img):
+    def run(self, img):
         imgid = self.get_imgid(img)
         _logger.debug('extracting (apextract_tracemap) in image %s', imgid)
         rss = apextract_tracemap(img[0].data, self.trace)
         img[0].data = rss
         return img
-

megaradrp/processing/fiberflat.py

@@ -21,26 +21,18 @@
 
 from astropy.io import fits
 import numpy as np
-
-from numina.flow.processing import TagOptionalCorrector, TagFits
-
+from numina.flow.processing import Corrector
 
 _logger = logging.getLogger('numina.processing')
 
 
-class FiberFlatCorrector(TagOptionalCorrector):
-
+class FiberFlatCorrector(Corrector):
     '''A Node that corrects from fiber flat.'''
 
     def __init__(self, fiberflat, datamodel=None, mark=True,
                  tagger=None, dtype='float32'):
 
-        if tagger is None:
-            tagger = TagFits('NUM-MFF', 'MEGARA Fiber flat correction')
-
         super(FiberFlatCorrector, self).__init__(datamodel=datamodel,
-                                                 tagger=tagger,
-                                                 mark=mark,
                                                  dtype=dtype)
 
         if isinstance(fiberflat, fits.HDUList):
@@ -50,15 +42,14 @@ def __init__(self, fiberflat, datamodel=None, mark=True,
         self.corrmean = self.corr.mean()
         # self.corrid = self.get_imgid(fiberflat)
 
-    def _run(self, img):
+    def run(self, img):
         imgid = self.get_imgid(img)
         _logger.debug('correct from fiber flat in image %s', imgid)
 
         # Avoid nan values when divide
         my_mask = self.corr == 0.0
         self.corr[my_mask] = 1.0
 
-        img[0].data /= self.corr
+        # img[0].data /= self.corr
 
         return img
-

megaradrp/processing/twilight.py

@@ -22,25 +22,20 @@
 from astropy.io import fits
 import numpy as np
 
-from numina.flow.processing import TagOptionalCorrector, TagFits
+from numina.flow.processing import Corrector
 
 
 _logger = logging.getLogger('numina.processing')
 
 
-class TwilightCorrector(TagOptionalCorrector):
+class TwilightCorrector(Corrector):
 
     '''A Node that corrects from twilight.'''
 
     def __init__(self, twilight, datamodel=None, mark=True,
                  tagger=None, dtype='float32'):
 
-        if tagger is None:
-            tagger = TagFits('NUM-MFF', 'MEGARA twilight correction')
-
         super(TwilightCorrector, self).__init__(datamodel=datamodel,
-                                                 tagger=tagger,
-                                                 mark=mark,
                                                  dtype=dtype)
 
         if isinstance(twilight, fits.HDUList):
@@ -50,7 +45,7 @@ def __init__(self, twilight, datamodel=None, mark=True,
         self.corrmean = self.corr.mean()
         # self.corrid = self.get_imgid(fiberflat)
 
-    def _run(self, img):
+    def run(self, img):
         imgid = self.get_imgid(img)
         _logger.debug('correct from twilight in image %s', imgid)
 

megaradrp/processing/weights.py

@@ -22,23 +22,19 @@
 from astropy.io import fits
 
 import numpy as np
-from numina.flow.processing import TagOptionalCorrector, TagFits
+from numina.flow.processing import Corrector
 
 _logger = logging.getLogger('numina.processing')
 
 
-class WeightsCorrector(TagOptionalCorrector):
+class WeightsCorrector(Corrector):
     '''A Node that corrects from twilight.'''
 
     def __init__(self, master_weights, datamodel=None, mark=True,
                  tagger=None, dtype='float32'):
-        if tagger is None:
-            tagger = TagFits('NUM-MFF', 'MEGARA master_weights correction')
+        #tagger = TagFits('NUM-MFF', 'MEGARA master_weights correction')
 
-        super(WeightsCorrector, self).__init__(datamodel=datamodel,
-                                               tagger=tagger,
-                                               mark=mark,
-                                               dtype=dtype)
+        super(WeightsCorrector, self).__init__(datamodel=datamodel, dtype=dtype)
 
         self.master_weights = master_weights
         self.processes = mp.cpu_count() - 2

megaradrp/products.py

@@ -150,3 +150,7 @@ def _datatype_load(self, obj):
 
 class WavelengthCalibration(JSONstorage):
     pass
+
+
+class LCBCalibration(JSONstorage):
+    pass

megaradrp/recipes/calibration/arc.py

@@ -54,6 +54,8 @@
                                'threshold':0.19},
                       'LR-Z': {'min_distance':60,
                                'threshold':0.02},
+                      'LR-U':{'min_distance':10,
+                              'threshold': 0.02,}
                       },
            'eng':{'LR-I':{'min_distance':30,
                           'threshold':0.09},
@@ -63,6 +65,9 @@
                            'threshold':0.02},
                   'LR-Z': {'min_distance':60,
                            'threshold':0.03},
+                  'LR-U':{
+                      'min_distance':10,
+                      'threshold': 0.02,}
                   },
 }
 
@@ -99,7 +104,7 @@ def run(self, rinput):
 
         # rssdata = apextract_tracemap(reduced[0].data, rinput.tracemap)
         rssdata = apextract_tracemap_2(reduced[0].data, rinput.tracemap)
-        rssdata = numpy.fliplr(rssdata)
+        # rssdata = numpy.fliplr(rssdata)
 
         rsshdu = fits.PrimaryHDU(rssdata, header=reduced[0].header)
         header_list = self.getHeaderList(
@@ -330,7 +335,7 @@ def calibrate_wl2(self, rss, lines_catalog, poldeg, tracemap,
 
                 except (ValueError, TypeError, IndexError) as error:
                     _logger.error("%s", error)
-                    _logger.info('error in row %d, fibid %d', idx, fibid)
+                    _logger.error('error in row %d, fibid %d', idx, fibid)
                     if False:
                         plt.title('fibid %d' % fibid)
                         rrow = row[::-1]

megaradrp/recipes/calibration/trace.py

@@ -44,6 +44,7 @@
            'LR-R': 0.37,
            'LR-V': 0.27,
            'LR-Z': 0.27,
+           'LR-U': 0.02,
            }
 
 class TraceMapRecipe(MegaraBaseRecipe):