Messages

Hi Liviu!

Thanks for your support. It was a layer 8 issue.

Best,
Matthias

Hi Liviu!

"fet-cl --verbose=true" just lists the time and space locks that resulted from locking all activities of the schedule. No further output after that.

I'll send you my config file. Thanks for checking it. I really hope that I'm not wasting your time, but I really have no clue what might be the problem.

@Volker: that was my guess as well. That's why I deleted all time ans space constraints (except the time and space locks that resulted from locking all activities of the last schedule).

Best, Matthias

I have a strange problem with FET 7.2.5. I have successfully calculated a timetable. Part of this timetable was a course consisting of a lecture and two exercises. The lecture was on Thursday 2pm - 4pm, the exercises directly following on 4pm - 6pm and 6pm - 8pm. I locked both space and time for all activities in this timetable.

Now the lecturer of this course has decided that the course should only have one exercise. The lecture should take the place of the first exercise, i.e. from 4pm to 6pm. So I have deleted the activity of the first exercise, deleted the time lock for the lecture and specified that the lecture should start at 4 pm.

I was expecting the lecture to be scheduled at 4pm without a problem, but the scheduling stopped one activity before the end for no apparent reason. There is no reason why the lecture could not be scheduled for 4pm. At least, I don't recognize one. The teacher is available, the students are available, rooms are available.

To be on the safe side, I deleted all restrictions (time and place) except restrictions regarding the time and space locks of the last timetable. Nevertheless, FET only plans up to the last activity.

Unfortunately, I have no idea what could be causing this problem. There are no tasks in conflicts. Also fet-cl with "--verbose=true" does not provide any output. Is there any option for increasing the verbosity of output for getting a clue what might be the problem?

Best,
Matthias

Volker, Liviu, thanks a lot for confirming and fixing the bug. Unfortunately I currently don't have a compiler installed on my machine, so I'm waiting until Darren is providing an updated binary for macOS.

Have yourself a merry christmas and a happy new year!

   

I noticed that FET crashes when performing the following steps:
1) Loading an arbitrary data file
2) Opening the dialog Time -> Teachers -> A teacher (1) -> Max hours daily in an hourly interval for teacher
3) Selecting "add" in the dialog that has opened
4) Selecting some teacher, selecting some start time, selecting some end time, Max daily 1, then pressing "add constraint"
5) Confirming the FET information dialog with pressing "ok"
6) Selecting some other teacher, set Max daily 0, then pressing "add constraint".

After pressing "add constraint" in step 6, FET crashes immediately. I was using an older version of FET, then updating to the most recent version 6.28.3. The problem exists also in this version.

Hi Liviu!

Thanks for your fast response. I have to admit that my example wasn't chosen well, because one of my two problems can be solved the way you described. However, the other problem remains: ensuring consistency in case that constraints are based on the type of an activity.

What I mean are constraints like these:

• regular lectures shall be scheduled between 8:00 and 14:00 (because we made some bad experiences with evening lectures)
• lectures for students in the first and second semester shall be scheduled between 8:00 and 12:00
• activities in our open air lab shall end the students day
• there shall be at least one gap between exercises
• block courses shall be scheduled on Friday afternoon or Saturday

At the moment FET requires adding these constraints to each activity seperately. That means if I'm adding a new activity, I have to identify the required constraints and then adding them in the second step. For instance, if I'm adding a lecture activity of first semester students, I have to add a constraint that the lecture shall be scheduled between 8:00 and 12:00. When adding other activities, it might also be necessary to modify previously defined constraints, e.g. max days between set of activities.

In general, each time I'm adding a new activity, I have to ensure that I'm not only adding all required constraints to this new activity, but also modify existing constraints with the newly created activity. I have to be super attentive to add and modify all constraints correctly, because it is quite easy to miss something.

This situation is due to the fact that constraints are modeled as "properties" of the activity. I know that this description is not overly accurate, but let me just call it this way.

What I'm suggesting is adding some kind of inheriting concept where activities may inherit their time constraints from activity tags. Thus, instead of modeling them as "property" of the activity itself, they might be modeled as "property" of an activity tag. Such a concept already exists for rooms, where I can specify preferred rooms for an activity tag, but not for time.

For instance:

• If there would be a Time -> Tags -> Activities with an activity tag have a set of preferred time slots, I might add such a constraint and define that activity tag LECTURE shall be scheduled Monday to Friday between 8:00 and 14:00.
• When adding a new activity for a lecture, I just add the activity tag LECTURE, not having to define any specific time constraints
• When generating a schedule, FET now has to translate the above time constraint into regular time constraints for the activity. Following the example, FET could create a regular Time -> Activities -> Preferred Times -> An Activity has a set if preferred time slots constraint for each activity with activity tag LECTURE.

From my point of view this modeling concept would have three major advantages:

• The amount of time constraints that need to be defined would reduce significantly (at least in my usage case), since time constraints need to be defined just once for the activity tag and not for each activity seperately.
• The modeling of a new schedule gets less error prone.
• Modifying constraints becomes less time consuming. Let's assume that a schedule cannot be generated with the mentioned time constraint for lectures. So we decide to enhance the duration for lectures until 16:00. Currently I would have to modify all time constraints for all lectures and change 14:00 into 16:00. If there would be a time constraint for an actitiy tag, I would just have to change this single constraint.

And in my naive understanding of FET I assume that implementing these constraints should be pretty simple, because activity tag constraints are just translated into activity constraints, thus the solver does not have to be modified or enhanced in any way.

Besides the mentioned constraint for activity tags, there might be also others:

• Time -> Tags -> Activities with an activity tag have a set of preferred time slots as just described
• Time -> Tags -> Activities with an activity tag have a prefered starting time
• Time -> Tags -> Min days between activities with an activity tag
• Time -> Tags -> Activities with an activity tag begins students day
• Time -> Tags -> Activities with an activity tag ends students day
• Time -> Tags -> Activities with an activity tag ends teachers day
• Time -> Tags -> Activities with an activity tag have same starting time
• Time -> Tags -> Activities with an activity tag occupy min slots
• Time -> Tags -> Activities with an activity tag occupy max slots
• Time -> Tags -> Activities with activity tag A and activity tag B are ordered
• Time -> Tags -> Max hourly span for Activities with an activity tag
• Time -> Tags -> A set of activity tags is not overlapping: this is already existing!
• Time -> Tags -> Min gaps between activities with an activity tag

As a matter of fact there are things that might go wrong or need to be handled. For instance this procedure might generate contradicting time constraints for an activity. This might result in an error during scheduling, so that the user has to modify her configuration. Or the user has already created a constraint for an activity where the same type activity constaint would be generated from actitiy tag. In this case the firstly created constraint could overrule the activity tag based constraint.

Phew, that was a long posting. Thanks for reading it.

Best, Matthias

Hi!

FET allows to assign activity tags to activities, e.g. allowing to add the activity tag "lecture" to all lectures. However, if I want to add a rule that lectures may only be schedules between 8:00-14:00, I have to add the constraint
"Time -> Activities -> Preferred Time -> An activity as a set of preferred time slots" to all activities that are describing lectures.

This approach of modeling contraints for these activities has two downsides. Firstly, it is quite time consuming adding dozents of identical contraints to the various lecture activities. Secondly, it's difficult to remain consistency: it's easy to miss one lecture activity, so that this activity ends up without this constraint. Same if a contraint is modified (e.g. setting the time span for lectures from 8:00 to 16:00) it demands ALL contraints related to lectures to be modified.

It would be highly helpful if FET would support contraints related to activity tags.

Basically I'm thinking of something like a button "Time -> Activity Tags" with nearly identical content as "Time -> Acticities", e.g. "Time -> Activity Tags -> Preferred Times -> An activity tag has a set of preferred time slots".

Internally FET could analyze these constraints and translate them in regular activity constaints: for instance, if there is such a "An activity tag has a set of preferred time slots" contraint for activity tag "lecture", it generates a "An activity has a set of preferred time slots" constraint for each activity that has the activity tag "lecture".

Of course there are special cases that need to be handled, e.g. if an activity has multiple activity tags that would cause the generation of multiple contraints of the same type. However I think that this would be manageable with very little effort, particularly without the need of changing the solver in any way.

FET is already a real power horse. Thanks for all the effort you're putting into it. But being able to define constraints based on activity tags would be a huge leap forward (at least for me  ).

Best, Matthias

Hi!

When generating a new schedule, FET tries to add all activities to the schedule such that all constraints are fulfilled. When adding an activity results in a violation of contraints, a different placement of activities gets evaluated until (hopefully) finally a valid solution is found.

Is it possible to enable some kind of logging of this placement process? Is it perhaps possible to get an information which constraint has been violated during the scheduling process?

Regards, Matthias

Hi!

A colleague would like to use FET for his timetabling problem. He is responsible for generating a schedule in his department. Unfortunately they have some modules that are planned on a bi-weekly basis. In even weeks he has to plan lectures for these modules, in odd weeks he has to plan exercises.

Since I have no experience on modeling bi-weekly activities in FET, I used the search function of this forum. Unfortunately I did not find that much. The postings I found were some years old and recommended to model bi-weekly activities by configuring twice the number of days (5 days for even weeks, 5 days for odd weeks).

Is this way of modeling bi-weekly activities still the current state of art? Or is there a more elegant way of modeling it?

Best, Matthias

MacOS 10.13 is Ventura, right?
Which version is required? I'll gladly try to compile it.

Best, Matthias

Hi Liviu!
Thanks for your great support!
Best, Matthias

Hi Liviu!
From my point of view it was a great idea to add the concept of time/space locking. In fact I always lock all activities at the end of the planning process to make the generated schedule reproducable. Again thanks a lot for developing such a planning power pack.

But isn't it fairly easy to dynamically check wether a schedule has been locked? In my naive unterstanding you just have to use the routine that is invoked when "Timetable -> Advanced Lock/Unlock" is selected. There you check all the activities and add/remove locks where required.
If this check indicates that no locks have to be added, this means that all activities are locked in time and space. And in such a situation all weighted contraints may be ignored.

Surely this does not help in the case of partially locked timetables and I have no idea how to solve the problem there. But at least it would help in the case of entirely locked timetables...

Best, Matthias

Hi Liviu!
Thanks for replying to my posting. I just mailed the fet input file to the specified email address. In this file all activities are locked so that the schedule cannot be computed. If you unlock all activities and wait for some minutes, the schedule will be generated successfully.
You guessed correctly: I have some constraints with 99.9999% significance. I will change them to 99.99% and check if the problem still occurs.
Regarding the underlying problem:
If time and space is locked for all activities of a schedule, this means that the user wants to have the schedule in exactly this way. This means that there is nothing to compute for FET, but just to check the schedule against the specified constraints.
But since all activities have been locked for space and time, this is just a validation and not a computation. So can't all constraints with less than 100% significance simply be left out of consideration in this situation?
Best, Matthias

Hi!
I have a weird problem here with FET that is reproducable with the currentmost version (6.7.2) of FET. I configured a relatively small timetable with only 23 activities which succeeds to compute after some minutes of compute time.
Then I selected "Timetable -> Advanced lock/unlock -> Lock all activities of current timetable" for locking all assignments of starting time and rooms to the activities.
Now the weird part is happening. I expected that the schedule now can be recomputed in an instant, since all time/space assignments are locked (at least this is my experience). But instead FET is displaying an error message saying that the current timetable cannot be computed.
If I remove the time/space locks of all activities, the schedule becomes computable again (after some minutes of runtime).

In my eyes this behavior is a little bit surprising. Shouldn't a schedule be computable if all activities are locked directly after a successful generation?

Best, Matthias

I'm currently creating a new schedule for our department and hit one issue that cannot be solved by FET in an ellegant way (at least I don't have an idea how to solve it). Here's the issue:

For each lecture we have a number of exams (e.g. first semester course "Programming 1" has one lecture and ten exercises). Thus I'm creating eleven activities (one for the lecture and one for each exercise). Note that the exercises differ in assigned student groups and room requirements.

For some large courses multiple teachers share the exercises. For the example above, a group of five teachers could share the ten exercises. This means that each teacher would take two exercises. These teachers don't care which group is assigned to them, they only care that it's two exercises in total and that all of her constraints are respected (available times, max hours per day, etc.).

And this makes it difficult for me, because a schedule can only be computed if the constraints of the attached teacher match the general constraints of the activitiy. And there are a number of combinations of assigning teachers to these exercises. If the schedule cannot be computed, I usually try another combination of teachers for these exercises and try again. Until finally I found a combination where the constraints of the assigned teachers match the constraints of the activities and a schedule is generated successfully.

This can be a time consuming process, because we have about a dozen of these courses. So I'm changing combinations again and again, until the schedule generation finally succeeds.

I had the idea of applying the concept of virtual teachers.

A virtual teacher is defined as a list of real teachers, where a real teachers can be added to the list multiple times. When specifying the activities for the ten exercises (in the example above), I could simply assign the virtual teacher to that activity. This virtual teachr is defined as:

Virtual Teacher V = { real teacher A, real teacher A, real teacher B, real teacher B,real teacher C, real teacher C, real teacher D, real teacher D, real teacher E, real teacher E }

Here FET would be allowed to assign each of the real teachers A-E two times in total when virtual teacher V is assigned to an activity. This means that each of the ten exercises would be assigned to one of the teachers A-E, but FET decides which is the best combination.

Obviously the number of real teachers within a virtual teacher cannot be lower than the number of activities that the virtual teacher is assigned to. However, the number can be larger. For instance:

Virtual Teacher V = { real teacher A, real teacher A, real teacher A, real teacher A, real teacher B, real teacher B,real teacher C, real teacher C, real teacher D, real teacher D, real teacher E, real teacher E }

Here, the real teacher A could be assigned up to four times for activities of virtual teacher V. In the case of ten exercises assigned to virtual teacher V this means, that some of the other real teachers would no be assigned two times (because it's only ten activities).

In my (naive) understanding of the schedule generation process, the introduction of virtual teachers would not imply major modifications. It would just need some kind of loop, where all combinations of real teachers to a virtual teacher have to be iterated.