a2p2 0.2.14__py3-none-any.whl → 0.7.4__py3-none-any.whl

a2p2/vlti/instrument.py

@@ -8,12 +8,16 @@ import json
 import os
 # import ast
 import re
+import logging
 
 import numpy as np
 from astropy.coordinates import SkyCoord
+import astropy.units as u
 
 from a2p2.instrument import Instrument
 
+logger = logging.getLogger(__name__)
+
 
 class VltiInstrument(Instrument):
 
@@ -26,13 +30,41 @@ class VltiInstrument(Instrument):
         self.rangeTable = None
         self.ditTable = None
 
+        # warnings
+        self.warnings = []
+        self.errors = []
+
+    def isScience(self, objtype):
+        return "SCI" in objtype
+
+    def isCalibrator(self, objtype):
+        return "SCI" not in objtype
+
     def get(self, obj, fieldname, defaultvalue):
         if fieldname in obj._fields:
             return getattr(obj, fieldname)
         else:
             return defaultvalue
 
-    # must be defined by each instruments
+    def getSequence(self, ob):
+        # We may look at ob.observationSchedule but at present tuime schedule still is computed on a2p2 side
+        sci = []
+        cal = []
+        for observationConfiguration in ob.observationConfiguration:
+            if 'SCIENCE' in observationConfiguration.type:
+                sci.append(observationConfiguration)
+            else:
+                cal.append(observationConfiguration)
+        if len(sci)+len(cal) <= 2:  # return [CAL] [SCI]
+            return cal+sci
+        # else return CAL1 SCI CAL2 [SCI CAL3] [SCI CAL4]
+        seq = []
+        for c in cal:
+            seq.append(c)
+            seq += sci
+        return seq[0:-1]
+
+    # checkOB() must be defined by each instruments
     # def checkOB(self, ob, p2container=None):
     # consider dryMode if p2container is None else check again and submit on p2 side
 
@@ -42,30 +74,49 @@ class VltiInstrument(Instrument):
 
         # create new container
         obsconflist = ob.observationConfiguration
+
+        # Aspro2 always send SCI at first position (or CAL if no SCI)
         folderName = obsconflist[0].SCTarget.name
         folderName = re.sub('[^A-Za-z0-9]+', '_', folderName.strip())
-
-        # force a top folder in demo.
+        # prefix with username to make test folder clearer
         if p2container.isRoot() and self.facility.isTutorialAccount():
-            ui.addToLog(
-                "create pre folder (required for tutorial account) ", False)
-            folder, _ = api.createFolder(p2container.containerId, folderName)
+            folderName += "_" + self.facility.a2p2client.preferences.getP2UserCommentName()
+
+        # do create a folder or concatenation only for SM or tutorial account
+        # should we create a concatenation only if we have multiple objects
+        if p2container.isRoot():
+            # create a concatenation if service mode (even if we do not have any cal at this stage)
+            if p2container.isServiceModeRun():
+                # TODO fix bug when we keep the last selection that is a Concatenation. Concatenation can't be nested.
+                # use parent container  or ask user to choose another container location ?
+                folder, _ = api.createConcatenation(
+                    p2container.containerId, folderName)
+                ui.addToLog(f"concatenation '{folderName}' created")
+            else:
+                folder, _ = api.createFolder(
+                    p2container.containerId, folderName)
+                ui.addToLog(f"folder '{folderName}' created")
+
+            # update parent tree since we created a new subfolder
+            ui.updateTree(p2container.run, p2container.containerId)
+
             p2container.containerId = folder['containerId']
 
-        # create a concatenation if service mode
-        if p2container.isServiceModeRun():
-            folder, _ = api.createConcatenation(
-                p2container.containerId, folderName)
         else:
-            folder, _ = api.createFolder(p2container.containerId, folderName)
-        p2container.containerId = folder['containerId']
+            ui.addToLog("concatenation or folder not created")
 
         ui.addToLog("OB checked / preparing  submission...")
         self.checkOB(ob, p2container)
 
+        # refresh and select last created element tree
+        ui.updateTree(p2container.run, p2container.containerId)
+        ui.selectTreeItem(p2container.containerId)
+        ui.addToLog(
+            "OB submitted! Please check logs and fix last details on P2 web.")
+
     def getCoords(self, target, requirePrecision=True):
         """
-        Format coordinates from given target to be VLTI compliant.
+        Format HMS DMS coordinates from given target to be VLTI compliant.
         Throws an exception if requirePrecision is true and given inputs have less than 3 (RA) or 2 (DEC) digits.
         """
 
@@ -93,36 +144,63 @@ class VltiInstrument(Instrument):
 
     def getPMCoords(self, target, defaultPMRA=0.0, defaultPMDEC=0.0):
         """
-        Returns PMRA, PMDEC as float values rounded to 4 decimal digits. 0.0 is used as default if not present.
+        Returns PMRA, PMDEC in arcsec/year as float values rounded to 4 decimal digits. 0.0 is used as default if not present.
         """
         PMRA = self.get(target, "PMRA", defaultPMRA)
         PMDEC = self.get(target, "PMDEC", defaultPMDEC)
         return round(float(PMRA) / 1000.0, 4), round(float(PMDEC) / 1000.0, 4)
 
+    def getPARALLAX(self, target, defaultPARALLAX=0.0):
+        """
+        Returns PARALLAX in arcsec as float value rounded to 4 decimal digits. 0.0 is used as default if not present.
+        """
+        PARALLAX = self.get(target, "PARALLAX", defaultPARALLAX)
+        return round(float(PARALLAX) / 1000.0, 4)
+
+
     def getFlux(self, target, flux):
         """
         Returns Flux as float values rounded to 3 decimal digits.
 
         flux in 'V', 'J', 'H'...
         """
-        return round(float(getattr(target, "FLUX_" + flux)), 3)
-
-    def getBaselineCode(self, baseline):
-        # as of P104
-        # take care if you change next branch order
-        if "B2" in baseline:
-            return "small"
-        elif "G2" in baseline:
-            return "medium"
-        elif "J3" in baseline:
-            return "large"
-        elif "K0" in baseline:
-            return "astrometric"
-        elif "U" in baseline:
-            return "UTs"
+        try:
+            return round(float(getattr(target, "FLUX_" + flux)), 3)
+        except:
+            raise ValueError(
+                f"Missing {flux} flux for target { getattr(target,'name') }") from None
+
+    def getBaselineCode(self, ob):
+        confAltName = ob.get(ob.interferometerConfiguration, "confAltName")
+        stations = ob.get(ob.interferometerConfiguration, "stations")
+        if confAltName:
+            return confAltName
         else:
             raise ValueError(
-                "Can't detect Interferometric Array type from given baseline : %s)" % (baseline))
+                "Can't detect alt name of Interferometric Array type from given baseline : %s)" % (stations))
+
+    def getAcquisitionType(self):
+        return self.facility.ui.getAcquisitionType()
+        return "onaxis"
+        return "offaxis"
+        return "wide"
+
+    def checkIssVltiType(self, acqTSF):
+        # TODO improve handling of this keyword using input from Aspro2's OB
+
+        # use GUI live checkboxes instead of preferences
+        vltitypesVars = self.facility.ui.getIssVltitypeVars()
+        vltitypes = [v for v in vltitypesVars
+                     if vltitypesVars[v].get() and self.isInRange(acqTSF.tpl, "ISS.VLTITYPE", v)]
+        if vltitypes:
+            self.ui.addToLog(
+                f"Set template's ISS_VLTITYPE to {vltitypes}")
+            acqTSF.ISS_VLTITYPE = vltitypes
+        else:
+            # TODO throw an warning ?
+            self.ui.addToLog(
+                f"Warning: no compatible ISS_VLTITYPE selected in the GUI")
+            pass
 
     def getA2p2Comments(self):
         return 'Generated by ' + self.facility.a2p2client.preferences.getP2UserCommentName() + \
@@ -147,7 +225,7 @@ class VltiInstrument(Instrument):
         self.ditTable = json.load(open(f))
         return self.ditTable
 
-    def getDit(self, tel, spec, pol, K, dualFeed=False, showWarning=False):
+    def getDit(self, tel, spec, pol, K, dualFeed=False, targetName="", showWarning=False):
         """
         finds DIT according to ditTable and K magnitude K
 
@@ -172,7 +250,7 @@ class VltiInstrument(Instrument):
         if tel == "UT":
             dK += ditTable["AT"]['Kut']
         for i, d in enumerate(dits):
-            if mags[i] < (K - dK) and (K - dK) <= mags[i + 1]:
+            if mags[i] <= (K - dK) and (K - dK) <= mags[i + 1]:
                 return d
 
         # handle out of bounds
@@ -181,11 +259,19 @@ class VltiInstrument(Instrument):
         for i, d in enumerate(dits):
             kmin = min(kmin, mags[i] + dK)
             kmax = max(kmax, mags[i + 1] + dK)
-        if kmin == K:
-            return minDIT
-        raise ValueError(
-            "K mag (%f) is out of ranges [%f,%f]\n for this mode (tel=%s, spec=%s, pol=%s, dualFeed=%s)" % (
-                K, kmin, kmax, tel, spec, pol, dualFeed))
+
+        if showWarning:
+            self.warnings.append(
+                f"K mag ({K})  is out of range [{kmin},{kmax}]\n mode ( ∆K={dK} tel={tel}, spec={spec}, pol={pol}, dualFeed={dualFeed}) \n  for target '{targetName}'")
+
+        # always return a value to avoid unsupported operations
+        if K < kmin:
+            return min(dits)
+        return max(dits)
+
+#        raise ValueError(
+#            "K mag (%f) of '%s' is out of ranges [%f,%f]\n for this mode (tel=%s, spec=%s, pol=%s, dualFeed=%s)" % (
+#                K, targetName, kmin, kmax, tel, spec, pol, dualFeed))
 
     def getRangeTable(self):
         if self.rangeTable:
@@ -220,6 +306,14 @@ class VltiInstrument(Instrument):
             return value >= rangeTable[_tpl][key]['min'] and \
                 value <= rangeTable[_tpl][key]['max']
         if 'list' in rangeTable[_tpl][key].keys():
+            #
+            # hack set to check for coordinates convention define by p2
+            # vlue will be checked by p2 later...
+            if "ra" in rangeTable[_tpl][key]['list']:
+                return True
+            if "dec" in rangeTable[_tpl][key]['list']:
+                return True
+
             #            return value in rangeTable[_tpl][key]['list']
             if type(value) is list:
                 for v in value:
@@ -280,7 +374,7 @@ class VltiInstrument(Instrument):
         if not key in rangeTable[_tpl].keys():
             raise ValueError(
                 "unknown keyword '%s' in template '%s'" % (key, tpl))
-        if 'default' in rangeTable[_tpl][key].keys() :
+        if 'default' in rangeTable[_tpl][key].keys():
             return rangeTable[_tpl][key]['default']
         return None
 
@@ -304,13 +398,15 @@ class VltiInstrument(Instrument):
                 res[key] = rangeTable[_tpl][key]["default"]
         return res
 
+    def getSkySeparation(self, ra1, dec1, ra2, dec2):
+        target1 = SkyCoord(ra1, dec1, frame='icrs', unit=(u.hourangle, u.deg))
+        target2 = SkyCoord(ra2, dec2, frame='icrs', unit=(u.hourangle, u.deg))
+        return target1.separation(target2)
 
-    def getSkyDiff(self, ra, dec, ftra, ftdec):
-        science = SkyCoord(ra, dec, frame='icrs', unit='deg')
-        ft = SkyCoord(ftra, ftdec, frame='icrs', unit='deg')
-        ra_offset = (science.ra - ft.ra) * np.cos(ft.dec.to('radian'))
-        dec_offset = (science.dec - ft.dec)
-        return [ra_offset.deg * 3600 * 1000, dec_offset.deg * 3600 * 1000]  # in mas
+    def getSkyOffset(self, ra, dec, originRa, originDec):
+        science = SkyCoord(ra, dec, frame='icrs', unit=(u.hourangle, u.deg))
+        origin = SkyCoord(originRa, originDec, frame='icrs', unit=(u.hourangle, u.deg))
+        return origin.spherical_offsets_to(science)
 
     def getSiderealTimeConstraints(self, LSTINTERVAL):
         # by default, above 40 degree. Will generate a WAIVERABLE ERROR if not.
@@ -330,9 +426,10 @@ class VltiInstrument(Instrument):
                 intervals.append({'from': lstStartSex, 'to': lstEndSex})
         return intervals
 
-    def saveSiderealTimeConstraints(self, api, obId, LSTINTERVAL):
+    def saveSiderealTimeConstraints(self, api, ob, LSTINTERVAL):
         # wait for next Aspro release to only send constraints set by user
         return
+        obId = ob['obId']
         intervals = self.getSiderealTimeConstraints(LSTINTERVAL)
         if intervals:
             sidTCs, stcVersion = api.getSiderealTimeConstraints(obId)
@@ -362,7 +459,35 @@ class VltiInstrument(Instrument):
 
         return s
 
-    def showP2Response(self, response, ob, obId):
+    def formatRangeTable(self):
+        rangeTable = self.getRangeTable()
+        buffer = ""
+        for l in rangeTable.keys():
+            buffer += l + "\n"
+            for k in rangeTable[l].keys():
+                constraint = rangeTable[l][k]
+                keys = constraint.keys()
+                buffer += ' %30s :' % (k)
+                if 'min' in keys and 'max' in keys:
+                    buffer += ' %f ... %f ' % (
+                        constraint['min'], constraint['max'])
+                elif 'list' in keys:
+                    buffer += str(constraint['list'])
+                elif "spaceseparatedlist" in keys:
+                    buffer += ' ' + " ".join(constraint['spaceseparatedlist'])
+                if 'default' in keys:
+                    buffer += ' (' + str(constraint['default']) + ')'
+                else:
+                    buffer += ' -no default-'
+                buffer += "\n"
+        return buffer
+
+    def showP2Response(self, response, ob,):
+        if not ob:
+            return
+
+        obId = ob['obId']
+
         if response['observable']:
             msg = 'OB ' + \
                   str(obId) + ' submitted successfully on P2\n' + \
@@ -371,9 +496,93 @@ class VltiInstrument(Instrument):
             msg = 'OB ' + str(obId) + ' submitted successfully on P2\n' + ob[
                 'name'] + ' has WARNING.\n see LOG for details.'
         self.ui.addToLog('\n')
-        self.ui.ShowInfoMessage(msg)
+        # self.ui.ShowInfoMessage(msg)
+        self.ui.addToLog(msg)
         self.ui.addToLog('\n'.join(response['messages']) + '\n\n')
 
+    def createOB(self, p2container, obTarget, obConstraints, OBJTYPE, instrumentMode, LSTINTERVAL, tsfs):
+        """ Creates an OB on P2 and attach a template for every given tsf."""
+
+        ui = self.ui
+        ui.setProgress(0.1)
+
+        goodName = re.sub('[^A-Za-z0-9]+', '_', obTarget.name)
+        OBS_DESCR = '_'.join(
+            (OBJTYPE[0:3], goodName, self.getName(), instrumentMode))
+        # removed from template name acqTSF.ISS_BASELINE[0]
+
+        # dev code to debug without interracting with P2
+        if False:
+            self.ui.addToLog(f"Skip ob creation : {OBS_DESCR}")
+            for tsf in tsfs:
+                self.ui.addToLog(f"Skip {tsf.getP2Name()} template creation")
+            ui.setProgress(1.0)
+            return None
+        else:
+            self.ui.addToLog(f"Creating new ob from p2 : {OBS_DESCR}")
+
+        api = self.facility.getAPI()
+
+        ob, obVersion = api.createOB(p2container.containerId, OBS_DESCR)
+
+        # we use obId to populate OB
+        ob['obsDescription']['name'] = OBS_DESCR[0:min(len(OBS_DESCR), 31)]
+        ob['obsDescription']['userComments'] = self.getA2p2Comments()
+
+        # copy target info
+        targetInfo = obTarget.getDict()
+        for key in targetInfo:
+            ob['target'][key] = targetInfo[key]
+
+        # copy constraints info
+        constraints = obConstraints.getDict()
+        for k in constraints:
+            ob['constraints'][k] = constraints[k]
+
+        self.ui.addToLog("New OB saved to p2\n%s" % ob, False)
+        ob, obVersion = api.saveOB(ob, obVersion)
+
+        # set time constraints if present
+        self.saveSiderealTimeConstraints(api, ob, LSTINTERVAL)
+        ui.addProgress()
+
+        for tsf in tsfs:
+            ui.addProgress()
+            self.createTemplate(ob,tsf)
+
+        # verify OB online
+        response = self.verifyOB(ob)
+        ui.setProgress(1.0)
+
+        self.showP2Response(response, ob)
+
+        return ob
+
+    def createTemplate(self, ob, tsf, templateName=None):
+        if not templateName:
+            templateName = tsf.getP2Name()
+
+        if not ob:
+            self.ui.addToLog(f"Request for new template ignored '{templateName}'")
+            return
+        self.ui.addToLog(f"Creating new template '{templateName}'")
+        obId = ob['obId']
+        api = self.facility.getAPI()
+        tpl, tplVersion = api.createTemplate(obId, templateName)
+        values = tsf.getDict()
+        tpl, tplVersion = api.setTemplateParams(
+            obId, tpl, values, tplVersion)
+
+    def verifyOB(self, ob):
+        if not ob:
+            self.ui.addToLog(f"Request to verify OB ignored")
+            return
+
+        api = self.facility.getAPI()
+        response, _=api.verifyOB(ob['obId'], True)
+        return response
+
+
 
 # TemplateSignatureFile
 # use new style class to get __getattr__ advantage
@@ -410,6 +619,9 @@ class TSF(object):
     def getDict(self):
         return self.tsfParams
 
+    def getName(self):
+        return self.tpl
+
     def getP2Name(self):
         return self.tpl[0:-4]
 
@@ -488,9 +700,14 @@ class FixedDict(object):
 
 class OBTarget(FixedDict):
 
-    def __init__(self):
+    def __init__(self, instrument, scienceTarget):
         FixedDict.__init__(
             self, ('name', 'ra', 'dec', 'properMotionRa', 'properMotionDec'))
+        # Target name can include any alphanumeric character, and space, dot, plus or minus signs [a-z][A-Z][0-9][.+- ]
+        # ( https://www.eso.org/sci/observing/phase2/p2intro/p2-tutorials/p2-ImportTargetList.html )
+        self.name = re.sub(r'[^a-zA-Z0-9.\+\- ]+','',scienceTarget.name.strip())
+        self.ra, self.dec = instrument.getCoords(scienceTarget)
+        self.properMotionRa, self.properMotionDec = instrument.getPMCoords(scienceTarget)
 
 
 class OBConstraints(TSF):
@@ -498,4 +715,4 @@ class OBConstraints(TSF):
     def __init__(self, instrument):
         TSF.__init__(self, instrument, "instrumentConstraints.tsf")
         # WORKARROUND missing param in p2 json but valid and used in our code
-        instrument.getRangeTable()[self.tpl]["name"]={}
+        instrument.getRangeTable()[self.tpl]["name"] = {}