Merge pull request #13 from discos/v0.6.3

V0.6.3

README.md

@@ -176,14 +176,3 @@ schedule.
     and modified from user template in step 1.
     if run with -f overrides eventual existing files.
 
-
-## BUILD DOCUMENTATION
-
-You can generate a local copy of the developer documentation using epydoc via
-
-```
-$make doc
-```
-
-You will find the doc under doc/html/ 
-

RELEASENOTES.md

@@ -1,5 +1,32 @@
 # RELEASE NOTES
 
+## v0.6.3
+
+Release notes:
+  - [x] Angles now rounded to the 4th decimal point.
+  - [x] **nop** instruction removed from roach backend configuration.
+  - [x] added explicit **ftrack** parameter in configuration file.
+  - [x] added **offset interleave** parameter in raster map scans.
+  - [x] Fixes algorithm for Raster Maps scans using multifeed receiver.
+
+**Note on ftrack**: in order to use ftrack procedures the user now must specify
+```python
+restFrequency = something_different_from_zero
+ftrack = True
+```
+in the configuration file. Note that this will activate ftrack procedures even
+when  the target velocity is null. On the contrary, setting a *restFrequency*
+value and a target *velocity* will not automatically trigger the *ftrack*
+procedure if not explicitly specified by the *ftrack* parameter in the
+configuration file.
+
+**Note on raster maps**: Raster maps now include a new parameter called
+**offset_interleave**. If **offset_interleave** is differrent from zero this
+will tell basie to add one subscan outside the map after **offset_interleave**
+subscans inside the map. By default the offset position is taken 5 beamsizes
+outside the map perimeter for single feed receivers, while it is take 5 receiver
+extents for multifeed receivers.
+
 ## v0.6.2
 
 Release notes:

requirements.txt

@@ -1,15 +1,15 @@
-BTrees==4.1.4
-argparse==1.2.1
+BTrees>=4.1.4
+argparse>=1.2.1
 numpy>=1.6.1
 astropy>=1.0.1
-configobj==4.7.2
+configobj
 validate
-persistent==4.1.1
-pickleshare==0.5
-transaction==1.4.4
-zc.lockfile==1.1.0
-zdaemon==4.1.0
-ZConfig==3.0.4
-ZODB==4.2.0
-zodbpickle==0.6.0
-zope.interface==4.1.2
+persistent>=4.1.1
+pickleshare>=0.5
+transaction>=1.4.4
+zc.lockfile>=1.1.0
+zdaemon>=4.1.0
+ZConfig>=3.0.4
+ZODB>=4.2.0
+zodbpickle>=0.6.0
+zope.interface>=4.1.2

setup.py

@@ -4,19 +4,16 @@
 
 setup(
       name = "basie",
-      version = "0.6.2",
+      version = "0.7.0-beta",
       description = "schedule creator for italian radiotelescopes",
       author = "Marco Bartolini, Simona Righini",
       author_email = "bartolini@ira.inaf.it",
       maintainer = "Marco Bartolini",
-      mainteiner_email =" bartolini@ira.inaf.it",
       license = "License :: OSI Approved :: BSD License",
       url = "http://github.com/flyingfrog81/basie/",
       packages = ["basie", "basie.scanmode"],
       package_dir = {"basie" : "src", "basie.scanmode" : "src/scanmode"},
       package_data = {"basie" : ["schemas/*.ini",
                                  "user_templates/*.txt"]},
       scripts = ["scripts/basie"],
-      install_requires = ["configobj", "validate", "astropy>=1.0", "zodbpickle",
-                          "ZODB", "BTrees"],
      )

src/__init__.py

@@ -178,7 +178,7 @@
 
 You will find the doc under doc/html/ 
 
-@version: 0.6.2
+@version: 0.6.3
 @status: stable
 @authors: Marco Bartolini, Simona Righini
 @organization: INAF -IRA
@@ -187,7 +187,7 @@
 @contact: bartolini@ira.inaf.it
 """
 
-VERSION = "0.6.2"
+VERSION = "0.6.3"
 NURAGHE_TAG = "nuraghe-0.6"
 ESCS_TAG = "escs-0.6"
 
@@ -234,6 +234,7 @@ def cmd_line():
 
     #imports are here as logging has already been configured
     import schedule, rich_validator, utils, target_parser, receiver
+    from radiotelescopes import radiotelescopes
 
     try:
         if ns.get_templates:
@@ -255,10 +256,24 @@ def cmd_line():
             dst_directory = os.path.abspath(ns.directory)
             conf = rich_validator.validate_configuration(configuration_file)
             #setting target file in the same directory as schedule file
-            conf['targetsFile'] = os.path.join(src_directory, conf['targetsFile'])
-            parsed_targets = target_parser.parse_file(conf['targetsFile'])
+            targetsFile = os.path.join(src_directory, conf.pop('targetsFile'))
+            parsed_targets = target_parser.parse_file(targetsFile)
             logger.debug("parsed targets: %s" % (parsed_targets,))
-            _schedule = schedule.Schedule(**conf)
+            #prepare Schedule contructor arguments
+            schedule_params = conf
+            radiotelescope = radiotelescopes[conf["radiotelescope"]]
+            try:
+                receiver = radiotelescope.receivers[conf["receiver"]]
+            except:
+                raise ScheduleError("radiotelescope does not have specified receiver")
+            schedule_params.radiotelescope = radiotelescope
+            schedule_params.receiver = receiver
+            backends = schedule_params.pop("backends")
+            scantypes = schedule_params.pop("scantypes")
+            logger.debug(schedule_params)
+            _schedule = schedule.Schedule(**schedule_params)
+            _schedule.backends = backends
+            _schedule.scantypes = scantypes
             for _target, _scanmode, _backend, _  in parsed_targets:
                 _schedule.add_scan(_target, _scanmode, _backend)
             _schedule.set_base_dir(dst_directory)

src/receiver.py

@@ -110,8 +110,8 @@ def get_beamsize(self, freq=None):
         if not freq:
             logger.warning("RECEIVER %s using default beamsize at min frequency" %
                            (self.name,))
-            freq = self.fmin.value
-        if((not self.fmin <= freq <= self.fmax) and (freq > 0)):
+            freq = self.fmin
+        if((not self.fmin <= freq <= self.fmax) and (freq > 0 * u.MHz)):
             logger.warning("RECEIVER %s beamsize at frequency %f out of range" %
                            (self.name, freq.value,))
         logger.debug("Getting beamsize\nfreq: %s\nt0: %s\nt1: %s" % \

src/rich_validator.py

@@ -158,8 +158,9 @@ def check_raster_map(value):
     except:
         logger.debug("RASTER map specify scans per beam")
         spacing = v.is_float(value[6], min=1)
+    offset = v.is_integer(value[7], min=0)
     return RasterMapScan(_frame, start_point, scan_axis, length_x, length_y,
-                       spacing, duration)
+                       spacing, duration, offset)
 
 def check_nodding_sequence(value):
     if not isinstance(value, list):

src/scan.py

@@ -19,16 +19,16 @@ def __init__(self,
                  receiver, 
                  frequency,
                  backend,
-                 repetitions,
-                 tsys,
+                 schedule_repetitions = 1,
+                 schedule_tsys = 0,
                 ):
         self.target = target
         self.scanmode = scanmode
         self.receiver = receiver
         self.backend = backend
         self.frequency = frequency
-        self.repetitions = repetitions
-        self.tsys = tsys
+        self.repetitions = target.repetitions or schedule_repetitions
+        self.tsys = target.tsys or schedule_tsys
         if self.target.offset_coord.is_null():
             try:
                 self.target.offset_coord.frame = scanmode.frame
@@ -47,19 +47,20 @@ def subscans(self):
         base_subscans = self.scanmode._do_scan(self.target, 
                                                self.receiver, 
                                                self.frequency)
+        counter = 0
         for rep in xrange(self.repetitions):
             for sn, ss in enumerate(base_subscans):
-                logger.debug("REP: %d SUBSCAN: %d" % (rep, sn))
-                subscan_number = rep * self.scanmode.unit_subscans + sn
-                logger.debug("subscan_number %d" % (subscan_number,))
+                #logger.debug("REP: %d SUBSCAN: %d" % (rep, sn))
+                #subscan_number = rep * self.scanmode.unit_subscans + sn
                 yield_tsys = False
                 #should we add a TSYS subscan?
-                if subscan_number == 0 and self.tsys >= 0:
+                if rep == 0 and sn == 0 and self.tsys >= 0:
                     yield_tsys = True
-                elif self.tsys > 0 and not(subscan_number % self.tsys):
+                elif self.tsys > 0 and not(counter % self.tsys):
                     yield_tsys = True
                 if yield_tsys:
                     subscans.append(copy.deepcopy(ss[1]))
                 subscans.append(copy.deepcopy(ss[0]))
+                counter += 1
         return subscans
 

src/scanmode/maps.py

@@ -5,6 +5,7 @@
 
 from basie import utils, frame
 from basie.valid_angles import VAngle
+from basie.errors import *
 
 from scanmode import ScanMode
 from ..frame import Coord
@@ -175,10 +176,69 @@ def _do_scan(self, _target, _receiver, _frequency):
 
 class RasterMapScan(MapScan):
     def __init__(self, frame, start_point, scan_axis, 
-                 length_x, length_y, spacing, duration):
+                 length_x, length_y, spacing, duration, offset=0):
         MapScan.__init__(self, frame, start_point, scan_axis,
                   length_x, length_y, spacing)
         self.duration = duration
+        self.offset_interleave = offset
+
+    def _get_spacing(self, receiver, frequency):
+        self.beamsize = VAngle(receiver.get_beamsize(max(frequency)))
+        if receiver.is_multifeed() and receiver.has_derotator:
+            #we can exploit multifeed derotator optimization 
+            logger.info("applying multifeed derotator optimization for map generation")
+            if not isinstance(self.spacing, VAngle):
+                approx_spacing = self.beamsize / self.spacing
+                scans_per_interleave = ceil(receiver.interleave / approx_spacing)
+                if not scans_per_interleave == self.spacing:
+                    #logger.warning("Rounding to {0} scans per interleave".format(scans_per_interleave))
+                    pass
+                self.spacing = receiver.interleave / scans_per_interleave
+                logger.info("Spacing subscans by {0}".format(self.spacing))
+            else:
+                if (self.spacing > (receiver.interleave / 2)):
+                    logger.warning("Spacing is too high, map will be undersampled")
+                scans_per_interleave = floor(receiver.interleave / self.spacing)
+            #this is necessary for tsys and offsets
+            self.beamsize = receiver.feed_extent * 2
+            if scans_per_interleave == 0:
+                #logger.warning("Spacing is too high for this receiver")
+                raise ScanError("Spacing is too high for this receiver")
+                #scans_per_interleave = 1
+                #self.spacing = 0
+            major_spacing = receiver.feed_extent * 2
+            self.dimension_x = 0
+            self.offset_x = []
+            self.dimension_y = 0
+            self.offset_y = []
+            if self.scan_axis == "LON":
+                _offset_x = (-1 * (self.length_x / 2)) - receiver.feed_extent
+                while _offset_x <= (self.length_x / 2 + receiver.feed_extent):
+                    self.offset_x.append(_offset_x)
+                    _offset_x = _offset_x + self.spacing
+                _offset_y = (-1 * (self.length_y / 2)) + receiver.feed_extent
+                while _offset_y <= (self.length_y / 2 + receiver.feed_extent):
+                    for i in range(scans_per_interleave):
+                        self.offset_y.append(_offset_y)
+                        _offset_y = _offset_y + self.spacing
+                        #self.offset_y.append(_offset_y + i * self.spacing)
+                    _offset_y = _offset_y + major_spacing
+            else: #self.scan_axis == "LAT"
+                _offset_x = (-1 * (self.length_x / 2)) + receiver.feed_extent
+                while _offset_x <= (self.length_x / 2 + receiver.feed_extent):
+                    for i in range(scans_per_interleave):
+                        self.offset_x.append(_offset_x)
+                        _offset_x = _offset_x + self.spacing
+                        #self.offset_x.append(_offset_x + i * self.spacing)
+                    _offset_x = _offset_x + major_spacing
+                _offset_y = (-1 * (self.length_y / 2)) - receiver.feed_extent
+                while _offset_y <= (self.length_y / 2 + receiver.feed_extent):
+                    self.offset_y.append(_offset_y)
+                    _offset_y = _offset_y + self.spacing
+            self.dimension_x = len(self.offset_x)
+            self.dimension_y = len(self.offset_y)
+        else:
+            super(RasterMapScan, self)._get_spacing()
 
     def _get_offsets(self):
         """
@@ -231,13 +291,21 @@ def _do_scan(self, _target, _receiver, _frequency):
                                               ))
         self._offsets = self._get_offsets()
         _subscans = []
-        for offset_lon, offset_lat in self._offsets:
+        for i, (offset_lon, offset_lat) in enumerate(self._offsets):
             logger.debug("OFFSETS: %f %f" % (offset_lon.deg, offset_lat.deg))
             _offset = Coord(self.frame, offset_lon, offset_lat)
             _subscans.append(subscan.get_sid_tsys(_target, 
                                                   _offset,
                                                   self.extremes,
                                                   self.duration,
                                                   self.beamsize))
+            if not self.offset_interleave == 0:
+                if i % self.offset_interleave == 0:
+                    _subscans.append(subscan.get_off_tsys(_target,
+                                                          _offset,
+                                                          self.extremes,
+                                                          self.duration,
+                                                          self.beamsize))
         return _subscans
 
+

src/scanmode/nodding.py

@@ -24,16 +24,16 @@ def _do_scan(self, _target, _receiver, _frequency):
         offset_b = _receiver.feed_offsets[self.feed_b]
         _subscans = []
         for element in self.sequence:
+            if element[1] == "a":
+                offset = offset_a
+            else:
+                offset = offset_b
+            ss = subscan.get_sidereal(_target,
+                                      offset,
+                                      self.duration,
+                                      is_cal=element[2])
+            st = subscan.get_tsys(_target,
+                                  offset)
             for repetitions in range(element[0]):
-                if element[1] == "a":
-                    offset = offset_a
-                else:
-                    offset = offset_b
-                ss = subscan.get_sidereal(_target,
-                                          offset,
-                                          self.duration,
-                                          is_cal=element[2])
-                st = subscan.get_tsys(_target,
-                                      offset)
                 _subscans.append((ss, st))
         return _subscans