Example #1
0
    def slew(self, target):
        """Perform the slewing operation for the observatory to the given target.

        Parameters
        ----------
        target : SALPY_scheduler.targetC
            The Scheduler topic instance holding the target information.

        Returns
        -------
        float
            The time to slew the telescope from its current position to the target position.
        """
        self.slew_count += 1
        self.log.log(LoggingLevel.TRACE.value,
                     "Slew count: {}".format(self.slew_count))
        initial_slew_state = copy.deepcopy(self.model.current_state)
        self.log.log(LoggingLevel.TRACE.value,
                     "Initial slew state: {}".format(initial_slew_state))
        self.slew_initial_state = self.get_slew_state(initial_slew_state)

        sched_target = Target.from_topic(target)
        self.model.slew(sched_target)

        final_slew_state = copy.deepcopy(self.model.current_state)
        self.log.log(LoggingLevel.TRACE.value,
                     "Final slew state: {}".format(final_slew_state))
        self.slew_final_state = self.get_slew_state(final_slew_state)

        slew_time = (final_slew_state.time - initial_slew_state.time,
                     "seconds")

        slew_distance = palpy.dsep(final_slew_state.ra_rad,
                                   final_slew_state.dec_rad,
                                   initial_slew_state.ra_rad,
                                   initial_slew_state.dec_rad)

        self.slew_history = SlewHistory(self.slew_count,
                                        initial_slew_state.time,
                                        final_slew_state.time, slew_time[0],
                                        math.degrees(slew_distance),
                                        self.observations_made)

        self.get_slew_activities()

        self.slew_maxspeeds = SlewMaxSpeeds(self.slew_count,
                                            final_slew_state.domalt_peakspeed,
                                            final_slew_state.domaz_peakspeed,
                                            final_slew_state.telalt_peakspeed,
                                            final_slew_state.telaz_peakspeed,
                                            final_slew_state.telrot_peakspeed,
                                            self.slew_count)

        return slew_time
Example #2
0
    def slew(self, target):
        """Perform the slewing operation for the observatory to the given target.

        Parameters
        ----------
        target : SALPY_scheduler.targetC
            The Scheduler topic instance holding the target information.

        Returns
        -------
        float
            The time to slew the telescope from its current position to the target position.
        """
        self.slew_count += 1
        self.log.log(LoggingLevel.TRACE.value, "Slew count: {}".format(self.slew_count))
        initial_slew_state = copy.deepcopy(self.model.currentState)
        self.log.log(LoggingLevel.TRACE.value, "Initial slew state: {}".format(initial_slew_state))
        self.slew_initial_state = self.get_slew_state(initial_slew_state)

        sched_target = Target.from_topic(target)
        self.model.slew(sched_target)

        final_slew_state = copy.deepcopy(self.model.currentState)
        self.log.log(LoggingLevel.TRACE.value, "Final slew state: {}".format(final_slew_state))
        self.slew_final_state = self.get_slew_state(final_slew_state)

        slew_time = (final_slew_state.time - initial_slew_state.time, "seconds")

        slew_distance = palpy.dsep(final_slew_state.ra_rad, final_slew_state.dec_rad,
                                   initial_slew_state.ra_rad, initial_slew_state.dec_rad)

        self.slew_history = SlewHistory(self.slew_count, initial_slew_state.time, final_slew_state.time,
                                        slew_time[0], math.degrees(slew_distance), self.observations_made)

        self.get_slew_activities()

        self.slew_maxspeeds = SlewMaxSpeeds(self.slew_count, final_slew_state.domalt_peakspeed,
                                            final_slew_state.domaz_peakspeed,
                                            final_slew_state.telalt_peakspeed,
                                            final_slew_state.telaz_peakspeed,
                                            final_slew_state.telrot_peakspeed, self.slew_count)

        return slew_time
    def distance(field0, fields):
        """
        Compute the distance (on a sphere) between field0 and each one of fields.

        Input
        field0:   a two dimensional list of floats/doubles (x, y)
        fields:   a list of two dimensional list of floats/doubles ((x, y), ...)

        Output
        A list of N+1 distances, where N=len(fields). Each distance is the angular
        distance between pairs of coordinates.

        Note
        1. x and y are assumed to be in radians.
        2. x and y are assumed to be spherical coordinates.
        3. This is a fallback solution in case an optimized version of this
           routine does not exist.
        """
        #return([slalib.sla_dsep(field0[0], field0[1], field[0], field[1]) for field in fields])
        return ([pal.dsep(field0[0], field0[1], field[0], field[1]) for field in fields])
    def MoonProfile(self):
        (self.moonRA_RAD, self.moonDec_RAD,
         self.moonDiam) = pal.rdplan(self.mjd, 3, self.lon_RAD, self.lat_RAD)
        #print 'hello moon',self.moonRA_RAD, self.moonDec_RAD, self.moonDiam

        #getting the moon phase

        v6moon = pal.dmoon(self.mjd)

        Rmatrix = pal.prenut(2000.0, self.mjd)

        xyzMoon2000 = pal.dmxv(Rmatrix, v6moon)

        (moonra, moondec) = pal.dcc2s(xyzMoon2000)
        moonra = pal.dranrm(2.0 * math.pi + moonra)
        sun12 = pal.evp(self.mjd, 2000.0)
        sun3heliocentric = sun12[3]
        for i in range(3):
            sun3heliocentric[i] *= -1
        (sunra, sundec) = pal.dcc2s(sun3heliocentric)
        sunra = pal.dranrm(2.0 * math.pi + sunra)
        moonsunsep = pal.dsep(sunra, sundec, moonra, moondec)
        self.moonPhase = ((1.0 - math.cos(moonsunsep)) / 2.0) * 100
Example #5
0
    def distance(field0, fields):
        """
        Compute the distance (on a sphere) between field0 and each one of fields.

        Input
        field0:   a two dimensional list of floats/doubles (x, y)
        fields:   a list of two dimensional list of floats/doubles ((x, y), ...)

        Output
        A list of N+1 distances, where N=len(fields). Each distance is the angular
        distance between pairs of coordinates.

        Note
        1. x and y are assumed to be in radians.
        2. x and y are assumed to be spherical coordinates.
        3. This is a fallback solution in case an optimized version of this
           routine does not exist.
        """
        #return([slalib.sla_dsep(field0[0], field0[1], field[0], field[1]) for field in fields])
        return ([
            pal.dsep(field0[0], field0[1], field[0], field[1])
            for field in fields
        ])
    def __init__(self,
                 ra,
                 dec,
                 mjd,
                 date,
                 filtre,
                 airmass_opsim,
                 extinction=0.172,
                 skyBrightness=21.587):

        self.ra_RAD = ra
        self.dec_RAD = dec
        self.mjd = mjd
        self.k = extinction
        self.skyBrightness = skyBrightness
        self.date = date
        self.simEpoch = 59580
        #self.simEpoch=53371
        #if date<0.:
        ddate = self.date
        mjd_new = float(ddate) / float(DAY) + float(self.simEpoch)
        self.date = int((self.mjd - self.simEpoch) * float(DAY))
        self.filter = filtre
        self.airmass_opsim = airmass_opsim
        self.lon_RAD = -70.7494 * DEG2RAD  #obs site long (from sims_operations/conf/system/SiteCP.conf)
        self.lat_RAD = -30.2444 * DEG2RAD  #obs site lat (from sims_operations/conf/system/SiteCP.conf)
        self.lst_RAD = self.Get_Sidereal_Time_at_Site(
        )  #local sidereal time at site (radians)
        # TWILIGHT LIMITS
        # Altitude of the Sun in degrees that define the twilight.
        # When the sun is above this limit and below the night limit, a special
        # twilight factor is included in the sky brightness model
        self.SunAltitudeTwilightLimit = -18.0
        self.SunAltitudeNightLimit = -12.0
        self.n1dp92104 = (1. / 0.92104)
        self.log34p08 = math.log(34.08)

        self.twilightBrightness = 17.3
        self.fluxTwilight = 10.**((-self.twilightBrightness) / 2.5)

        self.MoonProfile()
        self.Moon_Distance()
        alpha = self.Get_alpha()
        self.distance2moon_RAD = pal.dsep(self.moonRA_RAD, self.moonDec_RAD,
                                          self.ra_RAD, self.dec_RAD)
        self.distance2moon_DEG = self.distance2moon_RAD * RAD2DEG
        lha_RAD = self.lst_RAD - self.ra_RAD
        (az_RAD, d1, d2, alt_RAD, d4, d5, pa_RAD, d7,
         d8) = pal.altaz(lha_RAD, self.dec_RAD, self.lat_RAD)
        # Altitude -> Zenith distance (degrees)
        targetZD_DEG = 90. - (alt_RAD * RAD2DEG)
        # Altitude -> Zenith distance (radian)
        zd_RAD = 1.5707963 - alt_RAD
        # Airmass
        #am = slalib.sla_airmas (zd_RAD)
        am = pal.airmas(zd_RAD)
        self.airmass_pal = am

        # Compute Raileigh scattering
        rs = (10.**5.36) * (1.06 + (math.cos(self.distance2moon_RAD))**2.)
        #rs = 2.27E5 * (1.06 + (math.cos(self.distance2moon_RAD)) ** 2.)

        # Compute Mie scattering
        #print 'distance',self.distance2moon_DEG
        if self.distance2moon_DEG > 10.:
            ms = 10.**(6.15 - (self.distance2moon_DEG / 40.))
        else:
            ms = 6.2E7 / (self.distance2moon_DEG**2.)

        # Compute illumninace of the Moon
        i = 10.**(-0.4 * (3.84 + 0.026 * abs(alpha) + 4.E-9 * (alpha)**4.))

        # Compute optical pathlength (in units of airmass) as a
        # function of the Zenith Distance (ZD)
        x = lambda z: (1. - 0.96 * (math.sin(z * DEG2RAD))**2.)**-0.5
        #xa = lambda z: pal.airmas(z* DEG2RAD)

        #print 'airmass here',x(self.moonZD_DEG),xa(self.moonZD_DEG),x(targetZD_DEG),xa(targetZD_DEG),self.distance2moon_RAD,self.moonRA_RAD, self.moonDec_RAD,lha_RAD,zd_RAD,alt_RAD,self.lst_RAD,targetZD_DEG,self.mjd

        # Put all together (nanoLamberts)!

        moonBr = (rs + ms) * i * 10.**(-0.4 * self.k * x(self.moonZD_DEG))
        moonBr *= (1. - 10.**(-0.4 * self.k * x(targetZD_DEG)))

        self.moon_airmass = x(self.moonZD_DEG)
        self.targetZD_DEG = targetZD_DEG
        self.target_airmass = x(targetZD_DEG)
        #print 'airmasses',self.target_airmass,self.airmass_opsim,pal.airmas(zd_RAD)

        #  Taper brightness to 0, at moon altitude = self.sunAltitudeNightLimit
        if self.moonAlt_DEG < self.SunAltitudeNightLimit:
            moonBr = 0.
        elif self.moonAlt_DEG < 0. and self.moonAlt_DEG >= self.SunAltitudeNightLimit:
            moonBr *= (1 - self.moonAlt_DEG / self.SunAltitudeNightLimit)

        # Now, compute the dark sky brightness (in nanoLamberts) at
        # the Zenith from the same value in mag/arcsec^s
        skyBrightness = 34.08 * math.exp(20.7233 - 0.92104 * skyBrightness)

        # ... and at our position in the sky (targetZD_DEG)
        skyBr = skyBrightness * x(targetZD_DEG) * 10.**(-0.4 * self.k *
                                                        (x(targetZD_DEG) - 1.))

        # Add the brightness of the moon to that of the dark sky (nanoLamberts)
        self.moonBr = moonBr
        totBr = moonBr + skyBr

        # Transform it into mag/arcsec^2
        #totBr = (1. / 0.92104) * math.log (34.08 * math.exp (20.7233) / totBr)
        totBr = self.n1dp92104 * (self.log34p08 + 20.7233 - math.log(totBr))

        #print 'totbr',totBr

        #Get the Twilight profile

        self.TwilightProfile()

        #if self.date < self.sunSetTwil or self.date > self.sunRiseTwil:
        self.twilight = 0
        (yy, mm, dd, hh, min, sec) = self.mjd2gre(mjd)[:6]
        if (hh < 20 and self.date > self.sunRiseTwil) or (
                hh > 20 and self.date < self.sunSetTwil):
            totBr = -2.5 * math.log10(10.**(
                (-totBr) / 2.5) + self.fluxTwilight)
            self.twilight = 1
        #print 'after twilight',totBr,self.date,self.sunSetTwil,self.sunRiseTwil

        #print 'filterskybrightness',self.FilterSkyBrightness(totBr)
        self.totBr = totBr
        self.skybrightness_moon = self.FilterSkyBrightness(totBr)