Class scheduler finished <== TO BE TESTED

haribo
1 parent 7a1effdd
Showing 3 changed files with 512 additions and 10 deletions Show diff stats
src/pyros/settings.py
src/pyrosapp/models.py
src/scheduler/models.py
@@ -12,7 +12,7 @@ https://docs.djangoproject.com/en/1.9/ref/settings/
  
 # Set MYSQL to False if you want to use SQLITE
 # This line MUST NOT be changed at all (or install_requirements script will become invalid)
-MYSQL = False
+MYSQL = True
  
  
  
@@ -267,8 +267,8 @@ class Request(models.Model):
  
 class Schedule(models.Model):
     created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
-    day_start = models.DateTimeField(blank=True, null=True)
-    day_stop = models.DateTimeField(blank=True, null=True)
+    plan_start = models.DecimalField(default=0.0, max_digits=15, decimal_places=8)
+    plan_end = models.DecimalField(default=0.0, max_digits=15, decimal_places=8)
     flag = models.CharField(max_length=45, blank=True, null=True)
  
     class Meta:
@@ -282,8 +282,8 @@ class Schedule(models.Model):
 class ScheduleHistory(models.Model):
     sequences = models.ManyToManyField('Sequence', related_name='schedulehistories')
     created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
-    day_start = models.DateTimeField(blank=True, null=True)
-    day_stop = models.DateTimeField(blank=True, null=True)
+    plan_start = models.DecimalField(default=0.0, max_digits=15, decimal_places=8)
+    plan_end = models.DecimalField(default=0.0, max_digits=15, decimal_places=8)
     flag = models.CharField(max_length=45, blank=True, null=True)
  
     class Meta:
@@ -310,6 +310,24 @@ class ScientificProgram(models.Model):
         return (str(self.name))
  
 class Sequence(models.Model):
+    
+    """ Definition of Status enum values """
+    
+    TOBEPLANNED = "TBP"
+    OBSERVABLE = "OBS"
+    UNPLANNABLE = "UNPLN"
+    PLANNED = "PLND"
+    EXECUTED = "EXD"
+    REJECTED = "RJTD"
+    STATUS_CHOICES = (
+        (TOBEPLANNED, "To be planned"),
+        (OBSERVABLE, "Observable"),
+        (UNPLANNABLE, "Unplannable"),
+        (PLANNED, "Planned"),
+        (EXECUTED, "Executed"),
+        (REJECTED, "Rejected")
+    )
+    
     request = models.ForeignKey(Request, models.CASCADE, related_name="sequences")
     sequencetype = models.ForeignKey('SequenceType', models.DO_NOTHING, related_name="sequences")
     schedule = models.ForeignKey(Schedule, models.DO_NOTHING, related_name="sequences")
@@ -318,14 +336,11 @@ class Sequence(models.Model):
     created = models.DateTimeField(blank=True, null=True, auto_now_add=True)
     updated = models.DateTimeField(blank=True, null=True, auto_now=True)
     is_alert = models.BooleanField(default=False)
-    status = models.CharField(max_length=11, blank=True, null=True)
-    duration = models.FloatField(blank=True, null=True)
+    status = models.CharField(max_length=11, blank=True, null=True, choices=STATUS_CHOICES)
     pointing = models.CharField(max_length=45, blank=True, null=True)
     with_drift = models.BooleanField(default=False)
     priority = models.IntegerField(blank=True, null=True)
     analysis_method = models.CharField(max_length=45, blank=True, null=True)
-    exec_start = models.DateTimeField()
-    exec_stop = models.DateTimeField(blank=True, null=True)
     moon_min = models.IntegerField(blank=True, null=True)
     alt_min = models.IntegerField(blank=True, null=True)
     type = models.CharField(max_length=6, blank=True, null=True)
@@ -335,6 +350,14 @@ class Sequence(models.Model):
     obsolete = models.BooleanField(default=False)
     processing = models.BooleanField(default=False)
     flag = models.CharField(max_length=45, blank=True, null=True)
+    tsp = models.DecimalField(default=-1.0, max_digits=15, decimal_places=8)
+    tep = models.DecimalField(default=-1.0, max_digits=15, decimal_places=8)
+    jd1 = models.DecimalField(default=0.0, max_digits=15, decimal_places=8)
+    jd2 = models.DecimalField(default=0.0, max_digits=15, decimal_places=8)
+    deltaTL = models.DecimalField(default=-1.0, max_digits=15, decimal_places=8)
+    deltaTR = models.DecimalField(default=-1.0, max_digits=15, decimal_places=8)
+    t_prefered = models.DecimalField(default=-1.0, max_digits=15, decimal_places=8)
+    duration = models.DecimalField(default=-1.0, max_digits=15, decimal_places=8)
  
  
     class Meta:
 from django.db import models
+from pyrosapp.models import Schedule, Sequence
+from operator import attrgetter
+from decimal import *
  
-# Create your models here.
+DEFAULT_PLAN_START = 2457485.250000 # April 6th 2016, 18:00:00.0 UT
+DEFAULT_PLAN_END = 2457485.916667 # April 7th 2016, 10:00:00.0 UT
+
+class Interval:
+    """
+    Simple class that represents an interval of time
+    Julian days should be used
+    """
+    
+    def __init__(self, start, end):
+        self._start = Decimal(start)
+        self._end = Decimal(end)
+        self.duration = Decimal(end - start)
+
+        
+    def __str__(self):
+        print("["+str(self.start)+" - "+str(self.end)+"]")
+
+    def _set_start(self, start):
+        if start > self._end:
+            raise ValueError("Cannot set start (%d): must be lower than end (%d)" % (start, self._end))
+        self._start = start
+        self.duration = self._end - self._start
+        
+    def _set_end(self, end):
+        if end < self._start:
+            raise ValueError("Cannot set end (%d): must be bigger than start (%d)" % (end, self._start))
+        self._end = end
+        self.duration = self._end - self._start
+        
+    start = property(_set_start)
+    end = property(_set_end)
+
+class Scheduler():
+    """
+   Role : create a planning for the following/current night
+   
+   Read in DB : Sequence, PyrosUser, ScheduleHistory and parents
+   Create in DB : Schedule, ScheduleHistory ? (not sure)
+   Update in DB : Schedule, Sequence
+   Delete in DB : None
+   
+   Entry point(s) :
+           - make_schedule
+    """
+
+    """
+    TODO:
+        - voir TODOs dans les commentaires
+        - fonction de scheduling ( et descendance)
+        - gestion du re-scheduling (en cas de nouvelle requete)
+        - tests
+        - remplissage des espaces libres
+        - gestion de l'historique (je sais pas si c'est ce module qui va s'en charger au final mais bon ...)
+
+    """
+
+    def __init__(self):
+        self.schedule = Schedule()
+        # TODO: quel est le "flag" dans le schedule ??
+        # il faudrait peut-être appeler ces deux fonctions dans la méthode make_schedule ... ou recevoir plan_start et plan_end en param
+        self.get_night_limits() # TODO
+        self.intervals = [Interval(self.schedule.plan_start, self.schedule.plan_end) ,]
+
+        
+    def get_night_limits(self):
+        '''
+        determines and set plan_start and plan_end (beginning & end of the observation night)        
+        '''
+        
+        # TODO: définir comment on calcule plan_start et plan_end (via quels moyens)
+        self.schedule.plan_start = DEFAULT_PLAN_START # default value
+        self.schedule.plan_end = DEFAULT_PLAN_END # default value
+        
+    
+    def make_schedule(self):
+        '''
+        ENTRY POINT
+
+        Check all 'OBSERVABLE' sequences to create the most optimized planning for the following/current night
+        
+        It is assumed that all sequences that MUST and CAN be analyse have the OBSERVABLE status (e.g. : there must not be any PLANNED sequence at this point)        
+        
+        :side-effect :
+            - modify sequences status and dates in DB
+        '''
+        
+        self.sequences = list(Sequence.objects.filter(status=Sequence.OBSERVABLE))
+        self.determine_priorities()
+        self.remove_not_eligible_sequences()
+        self.sort_by_jd2_and_priorities()
+        self.organize_sequences()
+        self.save_sequences()
+
+        
+    def determine_priorities(self):
+        '''
+        Computes sequences priority according to the user, the scientific program, ...        
+        '''
+        
+        # TODO: définir comment on calcule la priorité
+        pass
+    
+    
+    def remove_not_eligible_sequences(self):
+        '''
+        Computes overlap between [jd1; jd2] and [plan_start; plan_end]
+        Removes from self.sequences all the sequences that cannot be observed between plan_start and plan_end
+        Set UNPLANNABLE sequences if jd2 < plan_start
+        
+        :side-effect :
+            - remove unwanted sequences from self.sequences
+        '''
+        
+        ''' Note (1) '''        
+        for sequence in list(self.sequences):
+            overlap = min(self.schedule.plan_end, sequence.jd2) - max(self.schedule.plan_end, sequence)
+            if overlap < sequence.duration:
+                if sequence.jd2 < self.schedule.plan_start:
+                    """ Note (2) """
+                    sequence.status = Sequence.UNPLANNABLE
+                    sequence.save()
+                self.sequences.remove(sequence)
+
+        
+    def sort_by_jd2_and_priorities(self):
+        '''
+        Sort by priority and jd2, priority being the main sorting parameter        
+        '''
+        
+        self.sequences.sort(key=attrgetter('priority', 'jd2'))
+        
+
+    def organize_sequences(self):
+        '''
+        Main function of the Scheduler
+        Arrange a maximum of observable sequences in the planning
+
+        Algorithm (for each sequence) :
+            - check quota (remove sequence from list if quota is too low)
+            - select matching intervals
+            - IF matching intervals => place sequence according to tPrefered
+            - IF NO matching intervals => try to move other sequences to place this one
+        
+        :side-effect :
+            - remove unwanted sequences from self.sequences
+            - change status and dates of sequences in self.sequences (but not in DB yet)
+        '''
+   
+        ''' Note (1) '''     
+        for sequence in list(self.sequences):
+            quota = self.determine_quota(sequence)
+            if quota < sequence.duration:
+                self.sequences.remove(sequence)
+                continue
+
+            matching_intervals = self.get_matching_intervals(sequence)
+            if len(matching_intervals) > 0:
+                self.place_sequence(sequence, matching_intervals)
+                sequence_placed = True
+            else:
+                sequence_placed = self.try_shifting_sequences(sequence)
+                
+            if sequence_placed == True:
+                sequence.status = Sequence.PLANNED
+                self.update_quota(sequence)
+    
+    def determine_quota(self, sequence:Sequence) -> float:
+        '''
+        Determines the quota (in minutes) according to the current planning duration and the quota of the user and scientific program associated
+
+        :returns : The quota (float)
+        '''
+        # TODO: définir comment on calcule le quota
+        
+        return sequence.request.pyros_user.quota # default value
+        
+    
+    def get_matching_intervals(self, sequence:Sequence):
+        '''
+        Find the intervals where the sequence could be inserted
+        
+        :returns : list of matching Intervals
+        '''
+        
+        matching_intervals = []
+        
+        for interval in self.intervals:
+            overlap = min(sequence.jd2, interval.end) - max(sequence.jd1, interval.start)
+            if overlap >= sequence.duration:
+                matching_intervals.append(interval)
+        
+        return matching_intervals
+        
+        
+    def place_sequence(self, sequence:Sequence, matching_intervals) :
+        '''
+        Place the sequence in the better interval, according to the t_prefered
+        
+        :type matching_intervals: list [Interval]
+        :param matching_intervals: Intervals in which the sequence can be placed
+
+        :side-effect :
+            - changes self.intervals
+            - change the sequence if it it placed
+        '''
+        
+        if len(matching_intervals) == 0:
+            raise ValueError("matching_intervals shall not be empty")
+
+        prefered_interval = self.get_prefered_interval(sequence, matching_intervals)
+        sequence_position_in_interval = self.get_sequence_position_in_interval(sequence, prefered_interval)        
+        self.insert_sequence_in_interval(sequence, prefered_interval, sequence_position_in_interval)
+        self.cut_interval(sequence, prefered_interval)
+        self.update_other_deltas(sequence, prefered_interval)
+
+            
+    def get_prefered_interval(self, sequence:Sequence, matching_intervals) -> Interval:
+        '''
+        Find the better interval, according to the t_prefered
+        
+        :type matching_intervals: list [Interval]
+        :param matching_intervals: Intervals in which the sequence can be placed
+        
+        :returns : An Interval that fits sequence.t_prefered at most
+        '''
+
+        if len(matching_intervals) == 0:
+            raise ValueError("matching_intervals shall not be empty")
+
+        if sequence.t_prefered == 0:
+            prefered_interval = matching_intervals[0]
+        else:
+            for index, interval in enumerate(matching_intervals):
+                if interval.start <= sequence.t_prefered <= interval.end:
+                    prefered_interval = interval
+                    break
+                elif sequence.t_prefered < interval.start:
+                    if index == 0:
+                        prefered_interval = interval
+                    else:
+                        prefered_interval = matching_intervals[index - 1]
+                    break
+        return prefered_interval
+        
+    
+    def get_sequence_position_in_interval(self, sequence:Sequence, interval:Interval) -> str:
+        '''
+        Determines where the sequence will be inserted in the interval, regarding sequence.t_prefered
+
+        :returns : A string in ["START", "END", "PREFERED"] describing where the sequence will be inserted in the interval
+        '''
+
+        if interval.start <= sequence.t_prefered <= interval.end:
+            if (sequence.t_prefered - 0.5 * sequence.duration) <= interval.start:
+                position_in_interval = "START"
+            elif (sequence.t_prefered + 0.5 * sequence.duration) >= interval.end:
+                position_in_interval = "END"
+            else:
+                position_in_interval = "PREFERED"  
+        else:
+            if sequence.t_prefered < interval.start:
+                position_in_interval = "START"
+            else:
+                position_in_interval = "END"
+        return position_in_interval
+    
+
+    def insert_sequence_in_interval(self, sequence:Sequence, interval:Interval, position:str):
+        '''
+        Inserts the sequence in the interval:
+            - sets sequence.tsp and sequence.tep
+            - sets sequence.deltaTL and sequence.deltaTR
+            
+        :param interval: Interval in which the sequence will be inserted
+        :param position: String describing where the sequence will be inserted in the interval
+        
+        :side-effect :
+            - modify sequence attributes (tsp, tep, deltaTL, deltaTR)
+        '''
+        
+        if position not in ["START", "END", "PREFERED"]:
+            raise ValueError("position must be either 'START', 'END' or 'PREFERED'")
+        
+        if position == "START":
+            sequence.tsp = interval.start
+            sequence.tep = interval.start + sequence.duration
+            sequence.deltaTL = 0
+            sequence.deltaTR = interval.end - sequence.tep
+        elif position == "END":
+            sequence.tsp = interval.end
+            sequence.tep = interval.end - sequence.duration
+            sequence.deltaTL = sequence.tsp - interval.start
+            sequence.deltaTR = 0
+        else:
+            sequence.tsp = sequence.t_prefered - 0.5 * sequence.duration
+            sequence.tep = sequence.t_prefered + 0.5 * sequence.duration
+            sequence.deltaTL = sequence.tsp - interval.start
+            sequence.deltaTR = interval.end - sequence.tep
+
+        
+    def cut_interval(self, sequence:Sequence, interval:Interval):
+        '''
+        Separates the interval in two parts regarding to the sequence position
+        Sorts the interval list in time order
+        
+        :param interval : the interval in which the sequence was added
+        
+        :side-effect :
+            - removes interval from self.intervals
+            - add created intervals to self.intervals
+            - sorts self.intervals
+        '''
+        
+        interval_before_sequence = Interval(interval.start, sequence.tsp)
+        interval_after_sequence = Interval(sequence.tep, interval.end)
+        
+        self.intervals.remove(interval)
+        if interval_before_sequence.duration > 0:
+            self.intervals.append(interval_before_sequence)
+        if interval_after_sequence.duration > 0:
+            self.intervals.append(interval_after_sequence)
+        self.intervals.sort(key=lambda interval: interval.start, reverse=False)
+
+
+    def update_other_deltas(self, sequence:Sequence, interval:Interval):
+        '''
+        Update deltaTL and deltaTR of sequences planned near this sequence
+        
+        :param interval: Interval in wich the sequence was added
+        
+        :side-effect :
+            - modify deltaTL and deltaTR of sequences before and after the interval
+        '''
+        
+        for sequence_ in self.sequences:
+            if sequence_.status == Sequence.PLANNED:
+                if sequence_.tep == interval.start:
+                    sequence_before_interval = sequence_
+                elif sequence_.tsp == interval.end:
+                    sequence_after_interval = sequence_
+
+        sequence_before_interval.deltaTR = sequence.tsp - sequence_before_interval.tep                    
+        sequence_after_interval.deltaTL = sequence_after_interval.tsp - sequence.tep
+        
+    
+    def try_shifting_sequences(self, sequence:Sequence) -> bool:
+        '''
+        Tries to find a place in the planning for the sequence, moving the other sequences
+        
+        :returns : A boolean -> True if the sequence was placed, False otherwise
+        
+        :side-effect:
+            - might change some sequences' deltaTL and/or deltaTR
+        '''
+        
+        potential_intervals = self.get_potential_intervals()
+        for interval in potential_intervals:
+            ''' we get the adjacent sequences '''
+            for sequence_ in self.sequences:
+                if sequence_.status == Sequence.PLANNED:
+                    if sequence_.tep == interval.start:
+                        sequence_before_interval = sequence_
+                    elif sequence_.tsp == interval.end:
+                        sequence_after_interval = sequence_
+
+            available_duration = min(interval.end, sequence.jd2) - max(interval.start, sequence.jd1)
+            missing_duration = sequence.duration - available_duration
+            
+            possible_move_to_left = max(sequence_before_interval.deltaTL, interval.start - sequence.jd1)
+            possible_move_to_right =  max(sequence_after_interval.deltaTR, sequence.jd2 - interval.end)
+
+            if possible_move_to_left >= missing_duration:
+                self.move_sequence(sequence_before_interval, missing_duration, "LEFT")
+            elif possible_move_to_right >= missing_duration:
+                self.move_sequence(sequence_after_interval, missing_duration, "RIGHT")
+            elif possible_move_to_left + possible_move_to_right >= missing_duration:
+                self.move_sequence(sequence_before_interval, possible_move_to_left, "LEFT")
+                self.move_sequence(sequence_after_interval, missing_duration - possible_move_to_left, "RIGHT")
+
+            matching_intervals = self.get_matching_intervals(sequence)
+            if len(matching_intervals) != 1:
+                raise ValueError("There should be one and only one matching interval after shifting")
+            self.place_sequence(sequence, matching_intervals)
+            
+        return False
+        
+        
+    def get_potential_intervals(self, sequence:Sequence):
+        '''
+        Find the intervals where a part of the sequence could be inserted
+        
+        :returns : list of partially-matching Intervals
+        '''
+        
+        potential_intervals = []
+        
+        for interval in self.intervals:
+            overlap = min(sequence.jd2, interval.end) - max(sequence.jd1, interval.start)
+            if overlap > 0:
+                potential_intervals.append(interval)
+        
+        return potential_intervals
+
+        
+    def move_sequence(self, sequence:Sequence, time_shift:float, direction:str):
+        '''
+        Moves the sequence in the wanted direction, decreasing its deltaTL or deltaTR.
+        
+        :param sequence: sequence to be moved
+        :param time_shift: amplitude of the shift
+        :param direction: "LEFT" or "RIGHT"
+        
+        :side-effect :
+            - modify the sequence in self.sequences
+            - changes the interval before and the interval after the sequence
+        '''
+        
+        if direction not in ["LEFT", "RIGHT"]:
+            raise ValueError("direction must be 'LEFT' or 'RIGHT'")
+        if time_shift > (sequence.deltaTL if direction == "LEFT" else sequence.deltaTR):
+            raise ValueError("Shift value is bigger than deltaT(R/L)")
+        
+        for interval in self.intervals:
+            if interval.end == sequence.jsp:
+                interval_before = interval
+            elif interval.start == sequence.jep:
+                interval_after = interval
+                
+        if direction == "LEFT":
+            interval_before.end -= time_shift
+            interval_after.start -= time_shift
+            sequence.jsp -= time_shift
+            sequence.jep -= time_shift
+            sequence.deltaTL -= time_shift
+            sequence.deltaTR += time_shift
+        else:
+            interval_before.end += time_shift
+            interval_after.start += time_shift
+            sequence.jsp += time_shift
+            sequence.jep += time_shift
+            sequence.deltaTL += time_shift
+            sequence.deltaTR -= time_shift
+        
+        
+    def update_quota(self, sequence:Sequence):
+        '''
+        Update the quota of the user / scientific program / whatever by substracting the sequence duration to the quotas
+        
+        :side-effect:
+            - Modify User quota in DB
+        '''
+        
+        # TODO: faire les vrais calculs de quota
+        user = sequence.request.pyros_user
+        user.quota -= sequence.duration # action par défaut qui correspond au code de self.determine_quota
+        user.save()
+        
+    def save_sequences(self):
+        '''
+        Final function : save in the db all modifications done to sequences
+        
+        :side-effect :
+            - change sequences status and dates in DB
+        '''
+        
+        for sequence in self.sequences:
+            sequence.save()
+
+
+    
+''' Notes
+
+(1) list(self.sequences) creates a copy in order to modify self.sequences and still iterate on it without unexpected behavior
+(2) UNPLANNABLE is a definitive status meaning that the sequence will never be able to be scheduled
+
+'''
 \ No newline at end of file