def setUp(self):

        self.lst = LstPressureWeather()

        # get the one proposal and it's one session
        proposal = Proposal.objects.all()[0]
        s = proposal.session_set.all()[0]

        # give it some values so it will show up in plot
        s.grade = SessionGrade.objects.get(grade = 'A')
        s.weather_type = WeatherType.objects.get(type = 'Poor')
        s.target.min_lst = 0.0
        s.target.max_lst = hr2rad(12.5)
        s.target.save()
        time = 6.5 # hrs
        s.allotment.allocated_time = time # hrs
        s.allotment.save()
        s.save()
        self.session = s

        ps = [0.0]*6
        ps.extend([1.0]*12)
        ps.extend([0.0]*6)
        self.sessPressure = numpy.array(ps)

        self.wPoor = WeatherType.objects.get(type = 'Poor')
        self.wGood = WeatherType.objects.get(type = 'Good')
        self.wExcellent = WeatherType.objects.get(type = 'Excellent')
    def __init__(self, semester):


        self.sun = Sun()
        self.weather = LstPressureWeather(semester = semester)

        try:
            self.semester = DSSSemester.objects.get(semester = semester)
        except DSSSemester.DoesNotExist:
            self.semester = DSSSemester.objects.create(semester =  semester)

        self.timeRange = (self.semester.start()
                        , self.semester.end())
        self.published = None

        # Galactic Center goes from 15 to 20 hours [,)
        self.gcHrs = (15, 21) 

        # for making sure we don't count a given session > once
        self.preAssignedSessions = []

        # initialize all the buckets we'll be calculating
        self.totalAvailableHrs = SemesterTimes() 
        self.maintHrs = SemesterTimes()
        self.shutdownHrs = SemesterTimes()
        self.testHrs = SemesterTimes()
        self.astronomyAvailableHrs = SemesterTimes()
        self.carryOver = {}
        #self.newAstronomyGradeAHrs = SemesterTimes()
        #self.newAstronomyAllGradeHrs = SemesterTimes()

        self.lowFreqPercent = 0.50
        self.hiFreq1Percent = 0.25
        self.hiFreq2Percent = 0.25

        # how to map from session freq type to time category?
        self.freq2key = {'LF' : 'lowFreq'
                       , 'HF1' : 'hiFreq1'
                       , 'HF2' : 'hiFreq2'
                        }

        self.grades = ['A', 'B', 'C']                
class SemesterTimeAccounting(object):

    """
    This class is responsible for determining many complicated
    time accounting quantities.
    For each quantity, there are two types: total, and those covered
    by the Galactic Center.
    Here are the rules:
    totalAv = total available time for the semester; simply the days in the semester * 24 hours.
    preAssigned = pre assigned time for the semester; sum of the hours for Maintenance, Shutdown, and testing
    astroAv = totalAv - preAssigned
    carryover = hours from carryover - that is proposals from previous semesters *not* included in preAssigned. carryover = coA + coB + coC
    coA, coB, coC = the carryover broken down by grade; 
    newAstroAv = available for NEW astronomy in the semester.  newAstroAv = totalAv - preAssigned - carryover
    newAstroAvCoA = available for NEW astronomy in the semester only taking grade A carryover into account.  newAstroAvCoA = totalAv - preAssigned - coA

    Here's a summary of the rules:
    astroAv = totalAv - preAssigned
    newAstroAv = totalAv - preAssigned - carryover
    """

    def __init__(self, semester):


        self.sun = Sun()
        self.weather = LstPressureWeather(semester = semester)

        try:
            self.semester = DSSSemester.objects.get(semester = semester)
        except DSSSemester.DoesNotExist:
            self.semester = DSSSemester.objects.create(semester =  semester)

        self.timeRange = (self.semester.start()
                        , self.semester.end())
        self.published = None

        # Galactic Center goes from 15 to 20 hours [,)
        self.gcHrs = (15, 21) 

        # for making sure we don't count a given session > once
        self.preAssignedSessions = []

        # initialize all the buckets we'll be calculating
        self.totalAvailableHrs = SemesterTimes() 
        self.maintHrs = SemesterTimes()
        self.shutdownHrs = SemesterTimes()
        self.testHrs = SemesterTimes()
        self.astronomyAvailableHrs = SemesterTimes()
        self.carryOver = {}
        #self.newAstronomyGradeAHrs = SemesterTimes()
        #self.newAstronomyAllGradeHrs = SemesterTimes()

        self.lowFreqPercent = 0.50
        self.hiFreq1Percent = 0.25
        self.hiFreq2Percent = 0.25

        # how to map from session freq type to time category?
        self.freq2key = {'LF' : 'lowFreq'
                       , 'HF1' : 'hiFreq1'
                       , 'HF2' : 'hiFreq2'
                        }

        self.grades = ['A', 'B', 'C']                

    def checkTimes(self):
        "Basic check that everything adds up"

        self.totalAvailableHrs.check() 
        self.maintHrs.check() 
        self.shutdownHrs.check() 
        self.testHrs.check() 
        self.astronomyAvailableHrs.check() 
        
        preAssigned = self.maintHrs + self.shutdownHrs + self.testHrs
        avail = preAssigned  + self.astronomyAvailableHrs


        assert avail.total == self.totalAvailableHrs.total

        gradeACarryOver = self.carryOver['A']['times'].total.total + self.carryOver['A']['fixed'].total.total
        assert self.newAstroAvailGradeAHrs.total.total == avail.total.total - preAssigned.total.total - gradeACarryOver   

        totalCarryOver = sum([(self.carryOver[g]['times'].total.total + self.carryOver[g]['fixed'].total.total) for g in self.grades])
        assert self.newAstroAvailAllGradeHrs.total.total == avail.total.total - preAssigned.total.total - totalCarryOver   

    def calcTotalAvailableHours(self):

        # how many hours in this semester?
        days = self.getSemesterDays(self.semester)
        totalHrs = days * 24
        totalGCHrs = self.getGCHrs(totalHrs)
        total = Times(type = 'Total'
                    , total = totalHrs
                    , lowFreq = totalHrs*self.lowFreqPercent
                    , hiFreq1 = totalHrs*self.hiFreq1Percent
                    , hiFreq2 = totalHrs*self.hiFreq2Percent
                     )
        gc = Times(type = 'GC'
                 , total = self.getGCHrs(totalHrs)
                 , lowFreq = self.getGCHrs(total.lowFreq)
                 , hiFreq1 = self.getGCHrs(total.hiFreq1)
                 , hiFreq2 = self.getGCHrs(total.hiFreq2)
                     )         
        return  SemesterTimes(total = total, gc = gc)  

    def calculateTimeAccounting(self):

        self.published = datetime.now()

        self.totalAvailableHrs =  self.calcTotalAvailableHours()  

        # how much has been pre-assigned for this semester?
        # first, find the periods
        self.maintPeriods = self.getMaintenancePeriods()
        self.shutdownPeriods = self.getShutdownPeriods()
        self.testSessions = self.getTestSessions()

        # now calculate their hours
        self.maintHrs = self.getHours(self.maintPeriods)
        self.shutdownHrs = self.getHours(self.shutdownPeriods)
        self.testHrs = self.getSessionsHours(self.testSessions)

        # so, how much does that leave left for real astronomy?
        self.astronomyAvailableHrs = None
        # add up maintHrs, shutdownHrs, testHrs, total and GC, 
        # then subtract those from the totalAvailableHrs
        preAssigned = self.maintHrs + self.shutdownHrs + self.testHrs
        self.astronomyAvailableHrs = self.totalAvailableHrs - preAssigned             
        # now, what's the carry over?
        self.carryOverSessions = self.getCarryOverSessions()
        self.carryOver = self.getCarryOver(self.carryOverSessions)

        # and how does THAT affect time available?
        self.newAstroAvailGradeAHrs = \
            self.getNewAstroAvailableTime(self.carryOver
                                         , self.astronomyAvailableHrs
                                         , ['A']
                                          )

        self.newAstroAvailAllGradeHrs = \
            self.getNewAstroAvailableTime(self.carryOver
                                         , self.astronomyAvailableHrs
                                         , self.grades
                                          )

    def getNewAstroAvailableTime(self, carryover, available, grades):

        carryOverTotals = SemesterTimes()
        for g in grades:
            times = carryover[g]['times']
            fixed = carryover[g]['fixed']
            carryOverTotals += times + fixed

        return available - carryOverTotals

    def report(self):
        "Prints out simple version of the results."

        print "Summary of Semester %s" % self.semester.semester
        print "As of %s" % datetime.now()
        print ""
        print "Time Analysis for Semester %s" % self.semester.semester
        print "%s to %s" % (self.semester.start(), self.semester.end())
        print ""

        print "Hours available in the Semester: "
        print "%s" % self.totalAvailableHrs.total
        print "%s" % self.totalAvailableHrs.gc

        print ""
        print "Maint: %s" % self.maintHrs.total
        print "       %s" % self.maintHrs.gc
        print "Shutd: %s" % self.shutdownHrs.total
        print "       %s" % self.shutdownHrs.gc
        print "Tests: %s" % self.testHrs.total
        print "       %s" % self.testHrs.gc
        print ""

        print "Available for Astronomy = %5.2f, GC[%5.2f]" % \
            (self.astronomyAvailableHrs.total.total
           , self.astronomyAvailableHrs.gc.total)

        print ""
        print "Available for ALL Astronomy during %s" % \
            self.semester.semester    
        print "%s" % self.astronomyAvailableHrs.total
        print "%s" % self.astronomyAvailableHrs.gc

        print ""
        print "Backlog committments for %s" % self.semester.semester
        for g in self.grades:
            tt = self.carryOver[g]['fixed'].total.total + \
                 self.carryOver[g]['times'].total.total
            gt = self.carryOver[g]['fixed'].gc.total + \
                 self.carryOver[g]['times'].gc.total
            print "Group %s Time:" % g
            print "    Fixed: %s" % self.carryOver[g]['fixed'].total
            print "           %s" % self.carryOver[g]['fixed'].gc
            print "    Rest:  %s" % self.carryOver[g]['times'].total
            print "           %s" % self.carryOver[g]['times'].gc
            print "Group %s total Hours = %5.2f GC[%5.2f]" % (g, tt, gt)
            print ""
            
        print "Available for NEW Astronomy during %s" % self.semester.semester
        print "Includes only Group A carry over time:"
        print "    %s" % self.newAstroAvailGradeAHrs.total
        print "    %s" % self.newAstroAvailGradeAHrs.gc
        print ""
        print "Includes Groups A, B and C carry over time:"
        print "    %s" % self.newAstroAvailAllGradeHrs.total
        print "    %s" % self.newAstroAvailAllGradeHrs.gc
        print ""

        #self.debugReport()

    def debugReport(self):
        "For debugging"

        print "DETAILS: "
        print "Maint. Periods: "
        total = 0
        for p in self.maintPeriods:
            print p 
            total += p.duration
        print "Total maint periods: ", total    

        print "Shutdown Periods: "
        total = 0
        for p in self.shutdownPeriods:
            print p 
            total += p.duration
        print "Total shutdown periods: ", total    

        print "Test Sessions: "
        for s in self.testSessions:
            print s

        print "Carryover Sessions:"
        total = 0
        totals = {'A' : 0.0, 'B' : 0.0, 'C' : 0.0, 'None' : 0.0}
        for s in self.carryOverSessions:
            print s, s.session_type, s.grade, s.next_semester.time, self.getTimeType(s) 
            if s.grade is not None:
                totals[s.grade.grade] += s.next_semester.time
            else:
                totals['None'] += s.next_semester.time
            total = s.next_semester.time
        print "Total Carryover Time: ", total, totals    

    def getSemesterDays(self, semester = None):    
        "How many days in the given semester?"
        if semester is None:
            s = self.semester
        else:    
            s = DSSSemester.objects.get(semester = semester)
        return s.numDays() #(s.end() - s.start()).days

    def getGCHrs(self, hrs):
        """
        Given a uniformly distributed number of hours, how many would
        fall within the Galactic Center range?
        """
        gcHrs = (self.gcHrs[1] - self.gcHrs[0]) 
        return hrs * (gcHrs/24.)

    def getMaintenancePeriods(self):
        "What maintenance periods have been scheduled for this semester?"
        allPs = self.getProjectPeriods('Maintenance')
        # this list of periods includes all periods from elective
        # sessions; in this case, we only want one period per elective
        ps = []
        electives = []
        for p in allPs:
            if p.session.session_type.type == 'elective':
                if p.elective is not None and p.elective not in electives:
                    # use this period
                    ps.append(p)
                    # don't use periods from other electives
                    electives.append(p.elective)
            else:
                ps.append(p)
        return ps

    def getShutdownPeriods(self):
        "What shutdown periods have been scheduled for this semester?"
        return self.getProjectPeriods('Shutdown')

    def getProjectPeriods(self, pcode):    
        ss = DSSSession.objects.filter(project__pcode = pcode)
        self.preAssignedSessions.extend(ss)
        
        ps = DSSPeriod.objects.filter( \
            session__project__pcode = pcode
          , start__gt = self.semester.start()
          , start__lt = self.semester.end()).exclude( \
              state__name = 'Deleted').order_by('start')    
        return ps 

    def getTestSessions(self):
        "What are the testing sessions for this semester?"
        sem = self.semester.semester
        testing = Observing_Type.objects.get(type='testing')
        commissioning = Observing_Type.objects.get(type='commissioning')
        calibration = Observing_Type.objects.get(type = 'calibration')
        ss = Session.objects.filter(Q(semester__semester = sem) 
                                    , Q(observing_type = testing) \
                                    | Q(observing_type = commissioning)\
                                    | Q(observing_type = calibration))
        self.preAssignedSessions.extend(ss)
        return ss

    def getHours(self, periods):

        allHrs = SemesterTimes()            
        for p in periods:
            hrs = self.getPeriodHours(p)
            # update the totals
            allHrs += hrs

        return allHrs        
            
    def getPeriodHours(self, period):
        """
        Determines how much of ther various types of time these periods 
        add up.  These types include:
           * how much lies in the galactic center?
           * how much gets billed to each frequency bin?
        Uses their duration, since we'll be looking at mostly pending
        periods, who won't have any time billed yet.
        """

        dur = period.duration
        start = period.start
        end = period.end()

        # Turns out that we FOR NOW, we don't care about day/night
        #dayHrs, nightHrs = self.getHrsInDayTime(start, end)
        gcHrs, nonGCHrs  = self.getHrsInGC(start, end)
        gcFrac = gcHrs / dur

        lowFreqHrs = self.lowFreqPercent * dur
        hiFreq1Hrs = self.hiFreq1Percent * dur
        hiFreq2Hrs = self.hiFreq2Percent * dur

        total= Times(type = 'total'
                  , total = dur
                  , lowFreq= lowFreqHrs
                  , hiFreq1= hiFreq1Hrs
                  , hiFreq2= hiFreq2Hrs
                  )       

        gc = total.factor(gcFrac)
        gc.type = 'gc'
        
        return SemesterTimes(total = total, gc = gc)

    def getHrsInDayTime(self, start, end):
        "Split up given time range by PTCS day and night time hours."
        dur = TimeAgent.dtDiffHrs(start, end)
        startDate = date(start.year, start.month, start.day)
        #rise, set = self.sun.getRiseSet(date1)
        # cast a wide net: compute the rise and set times for any days
        # that might be covered by the given time range
        days = (end - start).days + 2
        dayTimes = []
        for day in range(days):
            dt = startDate + timedelta(days = day)
            dayTimes.append(self.sun.getPTCSRiseSet(dt))
        # where does our given time range intersect with day time?    
        ints = AnalogSet.intersects([dayTimes, [(start, end)]])
        if len(ints) > 0:
            # some day time
            day = 0.0
            for intersection in ints:
                td = intersection[1] - intersection[0]
                day += TimeAgent.timedelta2frachours(td)
            # the rest must be night time    
            night = abs(dur - day) 
        else:
            # our range is all night time.
            day = 0.0
            night = dur 
        return (day, night)

    def fltEqual(self, flt1, flt2):
        eps = 1e-3
        return abs(flt1 - flt2) < eps

    def getHrsInGC(self, start, end):
        "Split up given time range by Galactic Center overlap."
        dur = TimeAgent.dtDiffHrs(start, end)
        # convert local time range to LST range
        lstStart = sla.Absolute2RelativeLST(start)
        lstEnd = sla.Absolute2RelativeLST(end)
        # be simplistic about the overalp
        if lstEnd < lstStart:
            lstEnd += 24.0
        
        gcHrs, nonGcHrs = self.findOverlap((lstStart, lstEnd), self.gcHrs, dur)
        return (gcHrs, nonGcHrs)

    def findOverlap(self, a, b, dur):
        """Utility for returning the fraction of given duration that
        is spent in the overlap of the two given tuples.
        """
        a1, a2 = a
        b1, b2 = b
        # what's the overlap between them (like the Galactice Center)?
        if AnalogSet.overlaps(a, b):
            ints = AnalogSet.intersect(a, b)
            # if our range is entirely in overlap, avoid calculations
            if self.fltEqual(ints[0], a1) \
                and self.fltEqual(ints[1], a2):
                overlap = dur
                nonOverlap = 0
            else:    
               # otherwise we need to convert back to duration - 
               # one way to do this is via fractions
               frac = (ints[1] - ints[0]) / (a2 - a1)
               overlap = dur * frac
               nonOverlap = (1.0 - frac) * dur
        else:
            overlap = 0
            nonOverlap = dur
            
        return (overlap, nonOverlap)

    def getSessionsHours(self, ss):

        all = SemesterTimes()
        for s in ss:
            if s.allotment is not None and \
              s.allotment.allocated_time is not None:
                t = self.getSessionHours(s)
                all += t
        return all

    def getTimeType(self, session):
        "Which of the three types for this session?"
        # if there is no freq. category, use low freq.
        freqCat = session.determineFreqCategory()
        return self.freq2key[freqCat] if freqCat is not None else 'lowFreq'

    def getSessionHours(self, s):
        "PHT Sessions simply bill to the freq they are at."

        t = Times()          

        # do this right with the LstPressureWeather class; 
        # but we don't care about the LST distruibution
        ps = [s.allotment.allocated_time]
        ps.extend([0.0]*23)
        ps = numpy.array(ps)
        wps = self.weather.binSession(s, ps)
        t.fromWeather(wps)

        gcHrs, nonGCHrs = self.getGCHoursFromSession(s)
        if gcHrs + nonGCHrs != 0.0:
            gcFrac = gcHrs / (gcHrs + nonGCHrs) 
        else:
            gcFrac = 0.0
        gc       = t.factor(gcFrac)

        return SemesterTimes(total = t, gc = gc)

            
            
    def getGCHoursFromSession(self, session):
        if session.allotment is None \
          or session.allotment.allocated_time is None \
          or session.target is None \
          or session.target.min_lst is None \
          or session.target.max_lst is None:
            return 0.0, 0.0
        # use max/min LST as compared to the Galctic Center
        min_lst = rad2hr(session.target.min_lst)
        max_lst = rad2hr(session.target.max_lst)
        # check for overlap
        if min_lst > max_lst:
            ss = [(0.0, max_lst), (min_lst, 24.0)]
        else:
            ss = [(min_lst, max_lst)]
        dur = session.allotment.allocated_time
        # now find overlaps for each range w/ the Gal. Center
        gcHrs = 0.0
        nonGCHrs = 0.0
        for s in ss:
            gc, nonGC = self.findOverlap(s, self.gcHrs, dur)
            gcHrs += gc
            nonGCHrs += nonGC
        return gcHrs, nonGCHrs                                 

    def getCarryOverSessions(self):
        """
        Returns any sessions that have a corresponding
        DSS Session and won't be complete next semester.
        In other words, they contribute to carry over.
        """

        preAssigned = [s.name for s in self.preAssignedSessions]

        # TBF: how to do the not None query?
        ss = Session.objects.filter(next_semester__complete = False).order_by('name')
        ss2 = [s for s in ss if s.dss_session is not None and s.name not in preAssigned]
        return ss2
            
    def getCarryOver(self, sessions):
        """
        How much do these sessions contribute to the 
        carryover, divided by Grade and Frequency,
        among other things.
        """

        carryOver = {}
        for g in ['A', 'B', 'C']:
            grade = SessionGrade.objects.get(grade = g)
            ss = [s for s in sessions if s.grade == grade]
            carryOver[g] = self.getCarryOverForGrade(ss)
        return carryOver    

    def getCarryOverForGrade(self, sessions):
        "Carry over is divided between fixed and everything else"

        fixed = SessionType.objects.get(type = 'Fixed')
        fixedSess = [s for s in sessions if s.session_type == fixed]
        otherSess = [s for s in sessions if s.session_type != fixed]

        fixed = self.getCarryOverTimes(fixedSess) 
        st = self.getCarryOverTimes(otherSess)

        return dict(fixed = fixed
                  , times = st)

    def getCarryOverTimes(self, ss):

       sts = SemesterTimes()
       for s in ss:
          st = self.getCarryOverForSession(s)
          sts += st 
       return sts    

    def getCarryOverForSession(self, s):
        """
        How much will the given session contribute to this
        semester's carryover?
        """

        t = Times(type = 'Total')          

        # add next semester's time to this time type 
        time = s.next_semester.time if s.next_semester.time is not None else 0.0
        ps = [time]      
        ps.extend([0.0]*23) 
        ps = numpy.array(ps)
        wps = self.weather.binSession(s, ps)  
        t.fromWeather(wps)  

        # how much of this time is Galactic Center time?
        gcHrs, nonGcHrs = self.getGCHoursFromSession(s)
        if (gcHrs + nonGcHrs) > 0.0:
            gcFrac = gcHrs / (gcHrs + nonGcHrs)
        else:
            gcFrac = 0.0
        gc = t.factor(gcFrac)
        gc.type = 'GC'

        return SemesterTimes(total = t, gc = gc) 
class TestLstPressureWeather(TestCase):

    fixtures = ['proposal_GBT12A-002.json', 'scheduler.json']

    def setUp(self):

        self.lst = LstPressureWeather()

        # get the one proposal and it's one session
        proposal = Proposal.objects.all()[0]
        s = proposal.session_set.all()[0]

        # give it some values so it will show up in plot
        s.grade = SessionGrade.objects.get(grade = 'A')
        s.weather_type = WeatherType.objects.get(type = 'Poor')
        s.target.min_lst = 0.0
        s.target.max_lst = hr2rad(12.5)
        s.target.save()
        time = 6.5 # hrs
        s.allotment.allocated_time = time # hrs
        s.allotment.save()
        s.save()
        self.session = s

        ps = [0.0]*6
        ps.extend([1.0]*12)
        ps.extend([0.0]*6)
        self.sessPressure = numpy.array(ps)

        self.wPoor = WeatherType.objects.get(type = 'Poor')
        self.wGood = WeatherType.objects.get(type = 'Good')
        self.wExcellent = WeatherType.objects.get(type = 'Excellent')
   
    def createSession(self):
        "Create a new session for the tests"
        p = Proposal.objects.all()[0]
        return createSession(p)
    
    def test_binOpenSession(self):

        # make sure it shows up in poor
        ps = self.lst.binOpenSession(self.session, self.sessPressure)
        exp = Pressures(poor = self.sessPressure)
        self.assertEqual(exp, ps)

        # now make sure it shows up in good
        self.session.weather_type = self.wGood 
        ps = self.lst.binOpenSession(self.session, self.sessPressure)
        exp = Pressures(good = self.sessPressure)
        self.assertEqual(exp, ps)

    def test_binFixedSession(self):

        # make sure it shows up spread around 
        ps = self.lst.binFixedSession(self.session, self.sessPressure)
        exp = Pressures(poor = self.sessPressure*0.5
                      , good = self.sessPressure*0.25
                      , excellent = self.sessPressure*0.25
                        )
        self.assertEqual(exp, ps)

        # distribution is different for good weather
        self.session.weather_type = self.wGood
        ps = self.lst.binFixedSession(self.session, self.sessPressure)
        exp = Pressures(excellent = self.sessPressure*0.5
                      , good = self.sessPressure*0.5)
        self.assertEqual(exp, ps)

        # and pretty simple for excellent weather 
        self.session.weather_type = self.wExcellent
        ps = self.lst.binFixedSession(self.session, self.sessPressure)
        exp = Pressures(excellent = self.sessPressure)
        self.assertEqual(exp, ps)

    def test_binWindowedSession(self):

        self.session.monitoring.window_size = 2
        ps = self.lst.binWindowedSession(self.session, self.sessPressure)
        exp = Pressures(poor = self.sessPressure*0.5
                      , good = self.sessPressure*0.25
                      , excellent = self.sessPressure*0.25
                        )
        self.assertEqual(exp, ps)

        # now change the window size
        self.session.monitoring.window_size = 20
        ps = self.lst.binWindowedSession(self.session, self.sessPressure)
        self.assertEqual(ps.good.tolist(), ps.excellent.tolist())
        exp = Pressures(poor = self.sessPressure*0.75
                      , good = self.sessPressure*0.125
                      , excellent = self.sessPressure*0.125
                        )
        self.assertEqual(exp, ps)

    def test_binSession(self):

        # make sure it shows up in poor
        ps = self.lst.binSession(self.session, self.sessPressure)
        exp = Pressures(poor = self.sessPressure)
        self.assertEqual(exp, ps)