Algorithme de création d'un emploi du temps scolaire

Je me demande s'il existe des solutions connues pour l'algorithme de création d'un emploi du temps scolaire. Fondamentalement, il s'agit d'optimiser la «dispersion horaire» (à la fois dans le cas des enseignants et des classes) pour des associations classe-matière-enseignant données. Nous pouvons supposer que nous avons des ensembles de classes, de matières de cours et d'enseignants associés les uns aux autres à l'entrée et que l'emploi du temps devrait être compris entre 8h00 et 16h00.

Je suppose qu'il n'y a probablement pas d'algorithme précis pour cela, mais peut-être que quelqu'un connaît une bonne approximation ou des conseils pour le développer.

Ce problème est NP-Complete !
En un mot, il faut explorer toutes les combinaisons possibles pour trouver la liste des solutions acceptables. En raison des variations dans les circonstances dans lesquelles le problème apparaît dans différentes écoles (par exemple: Y a-t-il des contraintes en ce qui concerne les salles de classe?, Certaines classes sont-elles parfois divisées en sous-groupes?, S'agit-il d'un horaire hebdomadaire? etc.) il n'y a pas de classe de problème bien connue qui correspond à tous les problèmes d'ordonnancement. Peut-être que le problème de Knapsack a de nombreux éléments de similitude avec ces problèmes en général.

Une confirmation qu'il s'agit à la fois d'un problème difficile et pour lequel les gens recherchent constamment une solution est de vérifier cette (longue) liste d'outils de planification de logiciels (principalement commerciaux).

En raison du grand nombre de variables impliquées, dont la plus grande source est, généralement, les désirs du membre du corps professoral; -) ..., il est généralement impossible d'envisager d'énumérer toutes les combinaisons possibles . Au lieu de cela, nous devons choisir une approche qui visite un sous-ensemble des espaces problème / solution.
- Les algorithmes génétiques , cités dans une autre réponse sont (ou, à mon humble avis, semblent ) bien équipés pour effectuer ce genre de recherche semi-guidée (le problème étant de trouver une bonne fonction d'évaluation des candidats à conserver pour la prochaine génération)
- Graphique Les approches de réécriture sont également utiles avec ce type de problèmes d'optimisation combinatoire.

Plutôt que de me concentrer sur des implémentations particulières d'un programme générateur d'horaire automatique, j'aimerais suggérer quelques stratégies qui peuvent être appliquées, au niveau de la définition du problème .
La logique générale est que dans la plupart des problèmes de planification du monde réel, certains compromis seront nécessaires, mais pas toutes les contraintes, exprimées et implicites: seront pleinement satisfaites. Par conséquent, nous nous aidons en:

• Définition et classement de toutes les contraintes connues
• Réduire l'espace du problème, en fournissant manuellement un ensemble de contraintes supplémentaires .
  Cela peut paraître contre-intuitif mais par exemple en fournissant un planning initial partiellement rempli (disons environ 30% des plages horaires), d'une manière qui satisfait pleinement toutes les contraintes, et en considérant cet horaire partiel immuable, nous réduisons significativement le temps / espace nécessaire pour produire des solutions candidates.
  Une autre façon d'aider les contraintes supplémentaires est par exemple l'ajout "artificiellement" d'une contrainte qui empêche l'enseignement de certaines matières certains jours de la semaine (s'il s'agit d'un horaire hebdomadaire ...); ce type de contraintes conduit à réduire les espaces problème / solution, sans exclure typiquement un nombre significatif de bons candidats.
• S'assurer que certaines des contraintes du problème peuvent être rapidement calculées. Ceci est souvent associé au choix du modèle de données utilisé pour représenter le problème; l'idée est de pouvoir opter (ou élaguer) rapidement certaines des options.
• Redéfinir le problème et permettre à certaines des contraintes d'être brisées, à quelques reprises (généralement vers les nœuds d'extrémité du graphe). L'idée ici est soit de supprimer certaines des contraintes pour remplir les derniers créneaux horaires de l'horaire, soit de faire en sorte que le programme du générateur d'horaire automatique cesse de terminer tout l'horaire, au lieu de nous fournir une liste d'une douzaine ou plus plausible. candidats. Un humain est souvent mieux placé pour terminer le casse-tête, comme indiqué, peut-être briser quelques-unes des contraintes, en utilisant des informations qui ne sont généralement pas partagées avec la logique automatisée (par exemple, la règle "Pas de mathématiques dans l'après-midi" peut être violée à l'occasion pour le cours "mathématiques et physique avancées"; ou "Il vaut mieux briser l'une des exigences de M. Jones que celle de Mme Smith ... ;-))

En relisant cette réponse, je me rends compte qu'il est assez timide de fournir une réponse définitive, mais il n'en reste pas moins plein de suggestions pratiques. J'espère que cette aide, avec ce qui est, après tout, un "problème difficile".

C'est le bordel. un désordre royal. Pour ajouter aux réponses, déjà très complètes, je tiens à souligner mon expérience familiale. Ma mère était enseignante et était impliquée dans le processus.

Il s'avère qu'avoir un ordinateur pour le faire n'est pas seulement difficile à coder en soi, c'est aussi difficile parce qu'il y a des conditions qui sont difficiles à spécifier à un programme informatique précuit. Exemples:

• un enseignant enseigne à la fois dans votre école et dans un autre institut. Clairement, s'il y termine le cours à 10h30, il ne peut pas commencer chez vous à 10h30, car il a besoin d'un peu de temps pour se déplacer entre les instituts.
• deux professeurs sont mariés. En général, il est considéré comme une bonne pratique de ne pas avoir deux enseignants mariés dans la même classe. Ces deux professeurs doivent donc avoir deux classes différentes
• deux enseignants sont mariés et leur enfant fréquente la même école. Encore une fois, vous devez empêcher les deux professeurs d'enseigner dans la classe spécifique où se trouve leur enfant.
• l'école a des installations séparées, comme un jour la classe est dans un institut et un autre jour la classe est dans un autre.
• l'école a des laboratoires partagés, mais ces laboratoires ne sont disponibles que certains jours de la semaine (pour des raisons de sécurité, par exemple, lorsqu'un personnel supplémentaire est nécessaire).
• certains enseignants ont des préférences pour la journée libre: certains préfèrent le lundi, certains le vendredi, certains le mercredi. Certains préfèrent venir tôt le matin, certains préfèrent venir plus tard.
• vous ne devriez pas avoir de situations où vous avez une leçon de dire, l'histoire à la première heure, puis trois heures de mathématiques, puis une autre heure d'histoire. Cela n'a aucun sens pour les élèves, ni pour l'enseignant.
• vous devez répartir les arguments uniformément. Cela n'a pas de sens de n'avoir que les premiers jours de la semaine en mathématiques, puis le reste de la semaine uniquement en littérature.
• vous devriez donner à certains enseignants deux heures consécutives pour faire des tests d'évaluation.

Comme vous pouvez le voir, le problème n'est pas NP-complet, c'est NP-insensé.

Donc, ce qu'ils font, c'est qu'ils ont une grande table avec de petits inserts en plastique, et ils déplacent les inserts jusqu'à ce qu'un résultat satisfaisant soit obtenu. Ils ne partent jamais de zéro: ils partent normalement du calendrier de l'année précédente et font des ajustements.

Le Concours International de Calendrier 2007 avait une piste de programmation des leçons et une piste de programmation des examens. De nombreux chercheurs ont participé à ce concours. De nombreuses heuristiques et métaheuristiques ont été essayées, mais à la fin, les métaheuristiques de recherche locale (telles que Tabu Search et Simulated Annealing) ont clairement battu d'autres algorithmes (tels que les algorithmes génétiques).

Jetez un œil aux 2 frameworks open source utilisés par certains des finalistes:

• JBoss OptaPlanner (Java, open source)
• Unitime (Java, open source) - plus pour les universités

Une de mes affectations à mi-parcours était une génération de table scolaire à algorithme génétique.

La table entière est un "organisme". Il y avait quelques changements et mises en garde à l'approche des algorithmes génériques génériques:

• Des règles ont été établies pour les «tables illégales»: deux classes dans la même classe, un enseignant enseignant deux groupes en même temps, etc. Ces mutations ont été jugées mortelles immédiatement et un nouvel «organisme» a immédiatement germé à la place du «défunt». Le premier a été généré par une série d'essais aléatoires pour en obtenir un légal (si insensé). La mutation létale n'a pas été comptée dans le nombre de mutations dans l'itération.

• Les mutations "Exchange" étaient beaucoup plus courantes que les mutations "Modify". Les changements étaient seulement entre les parties du gène qui avaient du sens - pas de remplacement d'un enseignant par une classe.

• De petites primes ont été attribuées pour regrouper certaines 2 heures ensemble, pour attribuer la même classe générique en séquence pour le même groupe, pour maintenir les heures de travail des enseignants et la charge de la classe en continu. Des primes modérées ont été attribuées pour donner des salles de classe correctes pour une matière donnée, maintenir les heures de classe dans les obligations (matin ou après-midi), etc. Les gros bonus concernaient l'attribution du nombre correct de matières données, la charge de travail donnée à un enseignant, etc.

• Les enseignants peuvent créer leurs horaires de charge de travail comme suit: «veux travailler alors», «d'accord pour travailler alors», «n'aime pas travailler alors», «ne peut pas travailler alors», avec des pondérations appropriées. Toutes les 24 heures étaient des heures de travail légales, sauf que la nuit était très indésirable.

• La fonction de poids ... oh ouais. La fonction de poids était un produit énorme et monstrueux (comme dans la multiplication) des poids attribués aux caractéristiques et propriétés sélectionnées. C'était extrêmement raide, une propriété facilement capable de la changer d'un ordre de grandeur vers le haut ou vers le bas - et il y avait des centaines ou des milliers de propriétés dans un organisme. Cela a abouti à des nombres absolument ÉNORMES en tant que poids, et en conséquence directe, il faut utiliser une bibliothèque bignum (gmp) pour effectuer les calculs. Pour un petit testcase d'environ 10 groupes, 10 enseignants et 10 salles de classe, la série initiale a commencé avec une note de 10 ^ -200 quelque chose et s'est terminée avec 10 ^ + 300 quelque chose. C'était totalement inefficace quand c'était plus plat. En outre, les valeurs ont augmenté beaucoup plus loin avec de plus grandes «écoles».

• En termes de temps de calcul, il y avait peu de différence entre une petite population (100) sur une longue période et une grande population (10k +) sur moins de générations. Le calcul sur le même temps a produit à peu près la même qualité.

• Le calcul (sur un processeur à 1 GHz) prendrait environ 1h pour se stabiliser près de 10 ^ + 300, générant des calendriers qui semblaient assez beaux, pour ledit cas de test 10x10x10.

• Le problème est facilement paralellisable en fournissant une installation de mise en réseau qui permettrait d'échanger les meilleurs spécimens entre les ordinateurs exécutant le calcul.

Le programme qui en a résulté n'a jamais vu la lumière du jour à l'extérieur me donner une bonne note pour le semestre. Cela a montré des promesses mais je n'ai jamais eu assez de motivation pour ajouter une interface graphique et la rendre utilisable au grand public.

Ce problème est plus difficile qu'il n'y paraît.

Comme d'autres l'ont fait allusion, il s'agit d'un problème NP-complet, mais analysons ce que cela signifie.

Fondamentalement, cela signifie que vous devez examiner toutes les combinaisons possibles.

Mais «regarder» ne vous dit pas grand-chose de ce que vous devez faire.

Générer toutes les combinaisons possibles est facile. Cela peut produire une énorme quantité de données, mais vous ne devriez pas avoir beaucoup de problèmes pour comprendre les concepts de cette partie du problème.

Le deuxième problème est celui de juger si une combinaison possible donnée est bonne, mauvaise ou meilleure que la «bonne» solution précédente.

Pour cela, vous avez besoin de plus que "est-ce une solution possible".

Par exemple, le même enseignant travaille-t-il 5 jours par semaine pendant X semaines consécutives? Même si c'est une solution de travail, ce n'est peut-être pas une meilleure solution que d'alterner entre deux personnes pour que chaque enseignant fasse une semaine chacun. Oh, tu n'y as pas pensé? N'oubliez pas que vous avez affaire à des personnes, pas seulement à un problème d'allocation de ressources.

Même si un enseignant pouvait travailler à temps plein pendant 16 semaines consécutives, cela pourrait être une solution sous-optimale par rapport à une solution où vous essayez d'alterner entre les enseignants, et ce type d'équilibrage est très difficile à intégrer dans le logiciel.

Pour résumer, produire une bonne solution à ce problème vaudra beaucoup, pour beaucoup de gens. Par conséquent, ce n'est pas un problème facile à décomposer et à résoudre. Soyez prêt à définir des objectifs qui ne sont pas à 100% et à les qualifier de «assez bons».

Mon algorithme de programmation, implémenté dans FET (Free Timetabling Software, http://lalescu.ro/liviu/fet/ , une application réussie):

L'algorithme est heuristique. Je l'ai nommé "échange récursif".

Entrée: un ensemble d'activités A_1 ... A_n et les contraintes.

Sortie: un ensemble de temps TA_1 ... TA_n (le créneau horaire de chaque activité. Les pièces sont ici exclues, par souci de simplicité). L'algorithme doit placer chaque activité sur un créneau horaire, en respectant les contraintes. Chaque TA_i est compris entre 0 (T_1) et max_time_slots-1 (T_m).

Contraintes:

C1) Basique: une liste de paires d'activités qui ne peuvent pas être simultanées (par exemple, A_1 et A_2, car ils ont le même enseignant ou les mêmes élèves);

C2) Beaucoup d'autres contraintes (exclues ici, par souci de simplicité).

L'algorithme de planification (que j'ai appelé "échange récursif"):

1. Trier les activités, les plus difficiles en premier. Pas d'étape critique, mais accélère l'algorithme peut-être 10 fois ou plus.

2. Essayez de placer chaque activité (A_i) dans un créneau horaire autorisé, en suivant l'ordre ci-dessus, une à la fois. Recherchez un emplacement disponible (T_j) pour A_i, dans lequel cette activité peut être placée en respectant les contraintes. Si plusieurs emplacements sont disponibles, choisissez-en un au hasard. Si aucun n'est disponible, effectuez un échange récursif:

   a . Pour chaque intervalle de temps T_j, considérez ce qui se passe si vous mettez A_i dans T_j. Il y aura une liste d'autres activités qui ne sont pas d'accord avec ce mouvement (par exemple, l'activité A_k est sur le même emplacement T_j et a le même professeur ou les mêmes élèves que A_i). Gardez une liste des activités conflictuelles pour chaque tranche horaire T_j.

   b . Choisissez un emplacement (T_j) avec le plus petit nombre d'activités en conflit. Supposons que la liste des activités de cet emplacement contient 3 activités: A_p, A_q, A_r.

   c . Placez A_i à T_j et rendez A_p, A_q, A_r non alloués.

   d . Essayez récursivement de placer A_p, A_q, A_r (si le niveau de récursivité n'est pas trop grand, disons 14, et si le nombre total d'appels récursifs comptés depuis l'étape 2) sur A_i commencé n'est pas trop grand, disons 2 * n), comme à l'étape 2).

   e . Si placé avec succès A_p, A_q, A_r, retournez avec succès, sinon essayez d'autres créneaux horaires (passez à l'étape 2 b) et choisissez le meilleur créneau horaire suivant).

   f . Si tous les créneaux horaires (ou un nombre raisonnable) ont été essayés sans succès, retournez sans succès.

   g . Si nous sommes au niveau 0, et que nous n'avons pas réussi à placer A_i, placez-le comme dans les étapes 2 b) et 2 c), mais sans récursivité. Nous avons maintenant 3 - 1 = 2 autres activités à organiser. Passez à l'étape 2) (certaines méthodes pour éviter le cyclisme sont utilisées ici).

MISE À JOUR: à partir des commentaires ... devrait aussi avoir des heuristiques!

J'irais avec Prolog ... puis utiliser Ruby ou Perl ou quelque chose pour nettoyer votre solution sous une forme plus jolie.

teaches(Jill,math).
teaches(Joe,history).

involves(MA101,math).
involves(SS104,history).

myHeuristic(D,A,B) :- [test_case]->D='<';D='>'.
createSchedule :- findall(Class,involves(Class,Subject),Classes),
                  predsort(myHeuristic,Classes,ClassesNew),
                  createSchedule(ClassesNew,[]).
createSchedule(Classes,Scheduled) :- [the actual recursive algorithm].

Je suis (toujours) en train de faire quelque chose de similaire à ce problème mais en utilisant le même chemin que je viens de mentionner. Prolog (en tant que langage fonctionnel) facilite vraiment la résolution des problèmes NP-Hard.

Des algorithmes génétiques sont souvent utilisés pour une telle planification.

J'ai trouvé cet exemple (Making Class Schedule Using Genetic Algorithm) qui correspond assez bien à vos besoins.

Voici quelques liens que j'ai trouvés:

Emploi du temps scolaire - Répertorie certains problèmes impliqués

Un algorithme génétique hybride pour l'horaire scolaire

Utilitaires et outils de planification

Cet article décrit assez bien le problème de l'emploi du temps scolaire et leur approche de l'algorithme: « Le développement de SYLLABUS — Un planificateur interactif basé sur des contraintes pour les écoles et les collèges. » [PDF]

L'auteur m'informe que le logiciel SYLLABUS est toujours utilisé / développé ici: http://www.scientia.com/uk/

Je travaille sur un moteur de planification largement utilisé qui fait exactement cela. Oui, c'est NP-Complete; les meilleures approches cherchent à approcher une solution optimale. Et, bien sûr, il existe de nombreuses façons différentes de dire quelle est la «meilleure» solution - est-il plus important que vos enseignants soient satisfaits de leur emploi du temps, ou que les élèves entrent dans toutes leurs classes, par exemple?

La question la plus importante que vous devez résoudre dès le début est de savoir ce qui rend une façon de planifier ce système meilleure qu'une autre ? Autrement dit, si j'ai un emploi du temps avec Mme Jones enseignant les mathématiques à 8 ans et M. Smith enseignant les mathématiques à 9 ans, est-ce meilleur ou pire que celui où les deux enseignent les mathématiques à 10 ans? Est-ce mieux ou pire qu'un avec Mme Jones enseignant à 8 ans et M. Jones enseignant à 2 ans? Pourquoi?

Le principal conseil que je donnerais ici est de diviser le problème autant que possible - peut-être cours par cours, peut-être enseignant par enseignant, peut-être salle par salle - et de travailler d'abord sur la résolution du sous-problème. Là, vous devriez vous retrouver avec plusieurs solutions parmi lesquelles choisir et en choisir une comme la plus optimale. Ensuite, travaillez à faire en sorte que les sous-problèmes «antérieurs» prennent en compte les besoins des sous-problèmes ultérieurs en notant leurs solutions potentielles. Ensuite, travaillez peut-être sur la façon de vous sortir de situations dépeints dans le coin (en supposant que vous ne pouvez pas anticiper ces situations dans les sous-problèmes précédents) lorsque vous arrivez à un état «aucune solution valide».

Une passe d'optimisation de recherche locale est souvent utilisée pour «peaufiner» la réponse finale afin d'obtenir de meilleurs résultats.

Notez que généralement, nous avons affaire à des systèmes à ressources très limitées dans la planification des écoles. Les écoles ne passent pas l'année avec beaucoup de salles vides ou des enseignants assis dans le salon 75% de la journée. Les approches qui fonctionnent le mieux dans des environnements riches en solutions ne sont pas nécessairement applicables dans la planification scolaire.

J'ai conçu des algorithmes commerciaux pour la planification des horaires des cours et des examens. Pour le premier, j'ai utilisé la programmation en nombres entiers; pour la seconde, une heuristique basée sur la maximisation d'une fonction objective en choisissant des permutations de slots, très similaire au processus manuel d'origine qui avait été développé. Les éléments principaux pour faire accepter de telles solutions sont la capacité de représenter toutes les contraintes du monde réel; et pour les programmeurs humains de ne pas être en mesure de voir les moyens d'améliorer la solution. En fin de compte, la partie algorithmique était assez simple et facile à mettre en œuvre par rapport à la préparation des bases de données, à l'interface utilisateur, à la capacité de rendre compte de statistiques telles que l'utilisation des salles, l'éducation des utilisateurs, etc.

En général, la programmation par contraintes est une bonne approche pour ce type de problème d'ordonnancement. Une recherche sur «programmation par contraintes» et ordonnancement ou «ordonnancement basé sur les contraintes» à la fois dans le débordement de pile et sur Google va générer de bonnes références. Ce n'est pas impossible - c'est juste un peu difficile à penser lors de l'utilisation de méthodes d'optimisation traditionnelles comme l'optimisation linéaire ou entière. Un résultat serait - existe-t-il un calendrier qui satisfait à toutes les exigences? Cela, en soi, est évidemment utile.

Bonne chance !

Vous pouvez le prendre avec des algorithmes génétiques, oui. Mais vous ne devriez pas :). Cela peut être trop lent et le réglage des paramètres peut prendre trop de temps, etc.

Il existe d'autres approches fructueuses. Tous mis en œuvre dans des projets open source:

• Approche basée sur les contraintes
  • Mis en œuvre dans UniTime (pas vraiment pour les écoles)
  • Vous pouvez également aller plus loin et utiliser la programmation Integer. Réalisé avec succès à l' université d'Udine et également à l'université de Bayreuth (j'y étais impliqué) en utilisant le logiciel commercial (ILOG CPLEX)
  • Approche basée sur des règles avec heuristisc - Voir le planificateur Drools
• Différentes heuristiques - FET et la mienne

Voir ici pour une liste des logiciels de planification

Je pense que vous devriez utiliser un algorithme génétique parce que:

• Il est le mieux adapté aux grandes instances de problèmes.
• Cela réduit la complexité du temps sur le prix d'une réponse inexacte (pas le meilleur ultime)
• Vous pouvez spécifier facilement les contraintes et préférences en ajustant les punitions de remise en forme pour celles qui ne sont pas respectées.
• Vous pouvez spécifier une limite de temps pour l'exécution du programme.

• La qualité de la solution dépend du temps que vous comptez consacrer à la résolution du programme.

  Définition des algorithmes génétiques

  Tutoriel sur les algorithmes génétiques

  Projet de planification de cours avec GA

Jetez également un œil à: une question similaire et une autre

Je ne sais pas que personne sera d'accord avec ce code mais j'ai développé ce code avec l'aide de mon propre algorithme et travaille pour moi en ruby.J'espère que cela aidera ceux qui le recherchent dans le code suivant le periodflag, dayflag subjectflag et teacherflag sont le hachage avec l'ID correspondant et la valeur de l'indicateur qui est booléenne. Tout problème contactez-moi ....... (-_-)

periodflag.each do | k2, v2 |

            if(TimetableDefinition.find(k2).period.to_i != 0)
                subjectflag.each do |k3,v3|
                    if (v3 == 0)
                        if(getflag_period(periodflag,k2))
                            @teachers=EmployeesSubject.where(subject_name: @subjects.find(k3).name, division_id: division.id).pluck(:employee_id)
                            @teacherlists=Employee.find(@teachers)
                            teacherflag=Hash[teacher_flag(@teacherlists,teacherflag,flag).to_a.shuffle] 
                            teacherflag.each do |k4,v4|
                                if(v4 == 0)
                                    if(getflag_subject(subjectflag,k3))
                                        subjectperiod=TimetableAssign.where("timetable_definition_id = ? AND subject_id = ?",k2,k3)
                                        if subjectperiod.blank?
                                            issubjectpresent=TimetableAssign.where("section_id = ? AND subject_id = ?",section.id,k3)
                                            if issubjectpresent.blank?
                                                isteacherpresent=TimetableAssign.where("section_id = ? AND employee_id = ?",section.id,k4)
                                                if isteacherpresent.blank?
                                                    @finaltt=TimetableAssign.new
                                                    @finaltt.timetable_struct_id=@timetable_struct.id
                                                    @finaltt.employee_id=k4
                                                    @finaltt.section_id=section.id
                                                    @finaltt.standard_id=standard.id
                                                    @finaltt.division_id=division.id
                                                    @finaltt.subject_id=k3
                                                    @finaltt.timetable_definition_id=k2
                                                    @finaltt.timetable_day_id=k1
                                                    set_school_id(@finaltt,current_user)
                                                    if(@finaltt.save)

                                                        setflag_sub(subjectflag,k3,1)
                                                        setflag_period(periodflag,k2,1)
                                                        setflag_teacher(teacherflag,k4,1)
                                                    end
                                                end
                                            else
                                                @subjectdetail=TimetableAssign.find_by_section_id_and_subject_id(@section.id,k3)
                                                @finaltt=TimetableAssign.new
                                                @finaltt.timetable_struct_id=@subjectdetail.timetable_struct_id
                                                @finaltt.employee_id=@subjectdetail.employee_id
                                                @finaltt.section_id=section.id
                                                @finaltt.standard_id=standard.id
                                                @finaltt.division_id=division.id
                                                @finaltt.subject_id=@subjectdetail.subject_id
                                                @finaltt.timetable_definition_id=k2
                                                @finaltt.timetable_day_id=k1
                                                set_school_id(@finaltt,current_user)
                                                if(@finaltt.save)

                                                    setflag_sub(subjectflag,k3,1)
                                                    setflag_period(periodflag,k2,1)
                                                    setflag_teacher(teacherflag,k4,1)
                                                end
                                            end
                                        end
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end