Basics

Let's look at the basic obligations:

• the entire group is here and on time.
• the repo is complete.
• it includes 3 elements: the krpsim program, the krpsim_verif program, at least one of your own process files (several is better).

If one of the conditions has not been met, evaluation stops.

The swiss army lib

Make sure no module/library has been set to make the optimization job
for you. You will be graded in regards of the time you've spent thinking
about the subject, find answers by yourself and impplement your own
solutions. This is not an integration project. If an external element is
responsible for solving the problem, evaluation stops. The group goes
back to work and tries harder this time.

Simple

We use simple tests, ideally provided with resources. But other
kinds of tests are also fine. It's a simple chain, with a starting
stock that is consumed and triggers processes one after the other.
Does the krpsim reach the end of the process? Everytime? When you run
the tests, keep in mind a short timeframe will give less opportunities to
optimize or reach the objective. In contrast, a longer timeframe will
make the objective more reachable (whether it's an accurate result or
a better optimization) more often.
You can run a test with the krpsim_verif, but this should
not be necessary for these simple tests. Your own process description
files must, depending on their natures and difficulties, be used for the
sections/questions that suit them best.

Simple returns

Using the same process file, do you always reach the end in the minimum
time? Everytime? Minimum time must logically be the simple addition of
each process duration (since it's a simple process chain).

Ikea

Now, let's try an Ikea type configuration. Once again, it's better
if there's a little more than an Ikea file. The goal, here, is to repeat
and/or parallelize some actions to reach the objective. The stock should
be used wisely to get all the necessary elements. There are only two
stairs of process (all the stocks' possible paths from beginning to end
include no more than 2 processes). Do we get the result each time (even
if it's not completely accurate, once again)?

Ikea also returns

Is the time taken to reach the goal of Ikea (or any other similar file)
otipimized? => ikea is achieved in 50 cycles for instance.

More complicated

This time, test a simple configuration containing at least one dead
branch that consumes one resource (and cripples or stops the goal's
achievement). Does it work? Do we reach the goal each time or so?

Fancy steak?

Test the steak file. If your krpsim is right, it should cook the whole
thing in 30 sec every time.

syntax error

A file with misformed process/stock/optim: an error is displayed every
time.

Missing parts

Are there any missing parts in te process description file ?

krpsim_verif

Make sure the krpsim_verif program displays an error message when the
tranmitted file is not right. Also make sure the krpsim_verif displays
an error message when the transmitted file contains an action made
impossible because of the stock condition in the cycle in question.
Finally, does the krpsim_verif indicate that everything is OK if it is
so with a data tracing?

non-stop

Test the "recre" configuration or any other simple process file that's
self-sustained. There must be potential blocking situations, occurences
where no process can be executed, that your krpsim should know how to
avoid (as always, the more time it has, the better he will optimize the
goal in order to avoid those blockings).

Performance

Is the performance better if you're playing with the timeframe offered
to the program? (if the group can explain the performance is already
optimized and they cannot do better, it's fine).

Bigger

Test with "apple" or any other process complex description, containing
dead branches, loops (like the eggs), potential blocking situations... well,
a lot of difficulties, that is :) Check with the assessor. Check with
the controller.

Performance

If you have already made this project, use your own krpsim to compare
performances, for instance. Otherwise, here is a possible performance
scale for apple after 50000 cycles:

• less thant 50 000 euros (no box sold) : 0pt
• up to 100 000 euros
• up to 200 000 euros
• up to 500 000 euros
• up to 1M euros
• higher than 1M euros : 5pt. This scale will probably change along with the evaluation and the various projects' results.