1 Introduction
The payload of a communications satellite is the onboard equipment that is actually relevant to the mission: receiving, amplifying and returning the signal. A set of tests are necessary to certify that the payload will correctly perform its mission. A test is characterized by a set of active equipment units and several thermal constraints limit the number of equipment units that can be made active simultaneously. The duration of the tests themselves is incompressible. However, activating some equipment takes time as each equipment unit much reach a given temperature and the temperature of the entire payload must be stabilized before tests can resume. Therefore, the total transition time depends on the order in which tests are sequenced. The goal is to sequence all the tests so that the overall duration is minimized.
Two main approaches have been previously considered. In the first approach [maillet2011constraint], tests requiring the same subset of active equipment are packed together in the same payload configuration. The transition time between tests run in the same configuration is null since no equipment activation is required. Between two configurations, however, some equipment units must be activated or deactivated and the heat of the payload must be stabilized before the next configuration, which entails important transition times. The objective of this approach is to minimize the number of configurations necessary for running all the tests. Moreover, a secondary objective is to minimize the overall number of activations and deactivations since the time required to stabilize the temperature of the payload is correlated, though not linearly, to the number of simultaneous activations. In practice, the transition time between two configurations is considered as a constant value sufficient to stabilize the temperature in the payload. Maillet et al. [maillet2011constraint]
first proposed a constraint programming approach to address this problem, using backjumping and dedicated heuristics.
It is in principle possible to activate an equipment unit whilst tests on other units are being run. The second approach, presented in [bochesauvan:hal01166683], relies on this idea. An equipment activation is viewed as a task with a given duration. If an equipment unit is not tested during a period equal to this duration and if the thermal constraints allow it, then it can be activated at the beginning of this period, and becomes available for other tests at the end. It may be possible to do so for several or even all equipment activations, thus effectively masking the transition times. A local search method (simulated annealing) was proposed in [bochesauvan:hal01166683] for this second approach, that is, with “online” activation allowed. It was shown that this approach can reduce the overall duration of the test campaign. However, the total number of activations can be higher in some instances.
Finally, since the focus in [maillet2011constraint] was on selecting a subset of tests to be run rather than sequencing them, a straightforward improvement of the first approach was proposed in [bochesauvan:hal01166683]: Once every test is allocated to a configuration and the number of configurations is minimized, the problem of minimizing the number of activations between consecutive configurations can be seen as a Traveling Salesman Problem (TSP). As the number of configurations is typically small, this problem can be solved optimally even with relatively basic TSP methods.
The second approach is difficult to implement in practice as activations and deactivations can happen continuously, making the detailed thermal analysis of the process a difficult task, whereas thermal engineers only need to worry about transitions between configurations in the first approach. In this work, we present a study for Airbus, which currently only implements the first approach. We propose an improved constraint programming approach to solve the problem.
Since thermal constraints limit the number of tests that can be run in the same configuration, this problem has a packing component, where tests have to be allocated to a minimum number of configurations. We introduce a set of implied constraints to improve the lower bound on this objective.
Moreover, this packing component is intertwined with a sequencing component where configurations must be ordered so that the number of equipment activations is minimized. We observe that this secondary objective can be easily modeled using the constraint Switch [DBLP:conf/cpaior/BessiereHMQW14]. This constraint models a resource operating as a buffer of limited capacity and whose content can be changed, however at a cost. Tests require equipment to be active and thermal constraints limit the number of simultaneously active equipment units, which can thus be seen as buffered. Moreover, the number of activations, which correspond to switches in the buffer, should be minimized. We introduce a simple improvement of the propagation algorithm for this constraint in the very common case where we have prior knowledge about the items that must be eventually buffered.
Next, we introduce a search strategy in which we sequentially solve the two subproblems. We solve first the packing problem with a dedicated branching heuristic to find upper and lower bounds on this objective quickly. Then we solve a much simplified sequencing problem since tests are already allocated to configurations. This approach is not complete, and hence we must solve the overall problem in order to find optimal solutions. However this is made significantly easier thanks to the upper and lower bounds found in the previous phases.
Finally, we experimentally evaluate the different contributions and assess the benefit of our method with respect to the current approach in use at Airbus.
2 Formal Background
A constraint satisfaction problem (CSP) consists of a set of variables, where each variable has a finite domain of values , and a set of constraints specifying allowed combinations of values for subsets of variables. A solution of a CSP is an assignment of values to the variables satisfying the constraints.
We consider both integer and set variables. A set variable is represented by its lower bound which contains the required elements and an upper bound which contains the possible elements. For a finite universe , we identify a set variable with the set of Boolean variables . The predicates and are equivalent, as are and .
For two integers , we denote the set of consecutive integers , and use the shortcut notation for .
We shall often denote a sequence of variables or constants by (where the length is either recalled or clear from the context).
2.1 The constraints Switch and BufferedResource
The constraints Switch and BufferedResource [DBLP:conf/cpaior/BessiereHMQW14] were introduced to model a type of resource corresponding to a buffer which must contain the items required by some tasks when they are being processed. Such resources are limited in two ways: first, the buffer can only hold a limited number of items, and second, there is an upper bound on the number of item switches along the sequence.
In our context, these constraints are useful to model thermal constraints together with the objective to minimize the number of activations (switches) of equipment units (items to be buffered). The constraint Switch involves a sequence of set variables and an integer variable . The set variable represents the content of the buffer at position (or time) , and the variable represents the total number of items that are removed from the buffer to make room for new items: . Moreover, the buffer has a minimum and maximum capacity (lower and upper bound on ) which are allowed to be different at every position . Let be a sequence of set variables, and be two sequences of constants of same size .
Definition 1 (Switch)
Often, we know beforehand which tasks are to be performed and which items are required by each task. In this case, one can use the BufferedResource constraint which involves a sequence of integer variables representing a permutation of tasks, and a sequence of sets of integers standing for the items required by each task. Achieving arc consistency on this constraint is NPhard, and there is no dedicated propagation algorithm for this constraint, besides the obvious decomposition using Switch, AllDifferent [regin1] and some Element [Hentenryck88] constraints.
Definition 2 (BufferedResource)
In our test planning problem, the buffers have equal upper and lower bounds. We shall therefore use a single integer parameter to denote the sequences and in the remainder of the paper.
3 Test Planning
3.1 Data and Constraints
A test campaign involves tests and equipment units. Every test involves a subset of equipment units to be active.^{1}^{1}1Throughout the paper, an equipment unit is said to be “active” if it is switched on and “inactive” otherwise. A payload configuration (or simply configuration) is defined by a partition of the equipment into active and inactive units. A test can occur in a configuration if the set of active equipment units in that configuration is a superset of .
However, one cannot use a single configuration where every equipment unit is active, because the payload would overheat. Equipment units that are on the same wall or blade of the satellite contribute to the overall temperature of that wall/blade. Therefore, we have constraints, one for every set of equipment units whose thermal profiles are linked. For each thermal constraint , we define a subset of size of equipment units, among which exactly^{2}^{2}2Alternatively, one may only consider an upper bound only to prevent the system from overheating, however thermal engineers advise to keep the system as stable as possible, hence our choice of an equality. should be active at the same time, i.e., in the same configuration.
3.2 Decisions and Objectives
A test plan with configurations is a mapping from tests to a set of consecutive integers (without loss of generality, we assume that configurations are numbered to ), and a mapping from configurations to subsets of equipment units such that the equipment units required to run a test are active when this test is run and every configuration satisfies all thermal constraints.
The main objective is to minimize the number of configurations , in order to reduce the transition time between tests, that is, the time spent in reconfiguring the payload.
Moreover it is important to take into account the total number of changes in the status of an equipment unit. Indeed, even though several equipment units can be switched on or off simultaneously, changing the status of more units requires a more careful analysis of the thermal dynamics of the system and is more likely to destabilize it. The second objective therefore is the total number of times an equipment unit is switched on besides the initial activation: , where is assumed to be empty.
Indeed, it is important to take into account the total number of changes in the status of the equipment. Even though several equipment units can be switched on or off simultaneously, changing the status of more units requires a more careful analysis of the thermal dynamics of the system and is more likely to destabilize it. In order to count the total number of times each equipment unit is switched from inactive to active and vice versa, we must decide the order in which the planned configurations will be visited. By convention, since configuration names are arbitrary, the tests allocated to configuration are run at the th position. Therefore, the same mapping defines both the allocation of tests to configurations and the sequence in which tests will be run.
We consider here that the packing objective has higher priority than the sequencing objective and thus that they are lexicographically ordered.
Example 1
Consider a set of tests and equipment units shown in Figure (a)a. The equipment required by each test is indicated with the symbol ✖. Moreover, assume that we have two thermal constraints with scopes and both of capacity .
The solution shown in Figure (a)a (✕ symbols indicate active equipment not involved in the current test) is suboptimal as it requires three configurations. Additionally, equipment units 1 and 6 must be activated twice.
However, with the permutation shown in Figure (b)b, we only need two configurations and every equipment unit is activated exactly once.


3.3 Complexity
It is relatively easy to see that the test planning problem described above is NPhard. We show that the decision version TestPlanning, which asks whether there exists a plan with at most configurations is NPcomplete.
Theorem 3.1
TestPlanning is NPcomplete.
Proof
It is in NP since a plan can be checked in polynomial time.
To prove hardness, we use a straightforward reduction from 3coloring, which asks, given a graph , whether there exists a coloring of with at most 3 colors such that no edge has its two end points of the same color.
From a graph , we build an instance of TestPlanning as follows:

[itemsep=0pt]

For every edge , there are two equipment units and and a thermal constraint on these two units with capacity .

For every vertex we create a test involving equipment units for every such that .
It is easy to see that two tests and can share the same configuration if and only if there is no edge . Therefore, has a 3coloring if and only if there is a plan with at most 3 configurations, and hence TestPlanning is NPhard for . ∎
Moreover, even if we let the number of configurations free, minimizing the number of switches is also NPhard for a single thermal constraint over all equipment of capacity since it corresponds exactly to the constraint:
where (resp. ) is a sequence of integer (resp. set) variables, and for every the variable has domain and the variable ranges between the empty set and .
The number of simultaneously active equipment units must be equal to , therefore, we can consider actived equipment as a buffer of capacity exactly . Moreover, the set of equipment units required by a test corresponds to the items required to be in the buffer when processing this task. Finally, the objective is to minimize the number activations which is equivalent, up to a constant, to the number of switches . The reduction from Hamiltonian path to BufferedResource provided in [DBLP:conf/cpaior/BessiereHMQW14] can be lifted to this particular case.
4 A Constraint Model for Test Planning
Let be some known upper bound on the number of configurations. We use allocation variables with domain standing for the configuration allocated to each test. Unless we have a valid upper bound, the maximum number of configurations is equal to . Next, we use activity variables standing for the status of equipment unit in configuration , i.e., is equal to 1 if unit in switched ON in and is equal to 0 otherwise. Moreover, we denote
the set variable with characteristic function
. For instance, has as characteristic function the set of variables in the column of the matrix formed by the activity variables, i.e., the set of equipment units active in configuration . We introduce a variable for each constraint standing for the total number of switches on the equipment units . Finally, we have two variables to express the objective function: a variable standing for the number of configurations and a variable for the total number of switches.To model the test planning problem, we then post the following constraints:
(1)  
(2)  
(3)  
(4)  
(5) 
Constraints (1) channel the allocation variables and the activity variables to ensure that every equipment unit required by a test is active in the slot in which the test is ran. They are implemented as Element constraints.
Constraints (2) enforce the thermal constraints on the number of equipment units active simultaneously within given subsets. They are implemented as simple Sum constraints.
Constraints (3) ensure that the variable representing the number of configurations is greater than or equal than the maximum allocated slot. We do not use a Maximum constraint nor an equality as we minimize this criterion.
Constraints (4) count the number of switches in the sequence of set variables for every thermal constraint . The Switch constraint standing for the thermal constraint ensures that the number of switches , for a capacity of the buffer. The constant term is used to count only from the second activation of each equipment unit. The constraint Switch counts the number of deactivations. Moreover, the items contained in the buffer at the last position are not counted by Switch, even though they will eventually be switched off. The total number of deactivations is thus and it is equal to the number of activations. Then each of the equipment units constrained by must be activated at least once, so we can subtract this number to obtain the number of activation besides the first.
Finally, Constraint (5) computes the overall sum of switches.
We consider the number of configurations as a higher priority objective than the total number of switches. Therefore, we express the objective function to minimize as the weighted sum .
The Test Planning problem may be decomposed into two subproblems:

[itemsep=0pt]
For the type of satellites we have considered in this study, there is no overlap in the scope of thermal constraints since they stand for the physical support of a disjoint subset of equipment units. However, overlaps may exist in some satellite architectures. In this case, we need to replace the constraints (4) and (5) by a single Switch constraint on the sequence of set variables :
(6) 
5 Lower Bound for Test Packing
The problem restricted to Constraints (1), (2) and (3) has some similarities with the multidimensional bin packing problem [Chekuri:1999:MPP:314500.314555]. Instead of a one dimensional capacity, the bins have a capacity for each of the dimension/thermal constraint. Moreover, for a test requiring a set of equipment units , we can compute a
vector representing its weight in each of these dimensions. However, the weights are not additive since every equipment unit is activated at most once per configuration, irrespective of the number of tests requiring it in this configuration. As discussed previously, it can also be seen as a coloring problem. The particular case where each test is on a single equipment unit could be seen as a generalization of list coloring to hypergraphs, as thermal constraints can be mapped to hyperedges. However, to our knowledge, there is no known method for this specific problem.
We therefore use a simple lower bound on the number of configurations based on the “capacity” of the thermal constraints. Indeed, if a thermal constraint ensures that at most equipment units are active in a given configuration, and if the tests involve units, then at least configurations are needed. More generally, suppose that we have a lower bound on the number of configurations in which an equipment unit will be active. Given a thermal constraint , the sum of these lower bounds over all equipment units in cannot be greater than the number of configurations multiplied by the capacity , in other words, for any constraint , is a valid lower bound for .
Now, consider an equipment unit , and let be its “neighborhood”, that is, the set of units that will necessarily be active when running the tests requiring . It might not be possible to activate all these equipment units within a single configuration because of the thermal constraints. More generally, the equipment unit must be active in at least as many configurations as are required to visit , i.e., , let be this lower bound.
The following two implied constraints enforce this lower bound:
(7)  
(8) 
However, Constraints 2 in the base model force every set variable to have cardinality , even if no test is allocated to configuration . In this case, the configuration would be a copy of configuration since it satisfies every constraint and minimize the number of switches. However, this is not compatible with Constraint 7 since equipment units active in “dummy” configurations would still be counted. We therefore replace Constraints 2 with the following constraints on extra Boolean variables :
(9)  
(10)  
(11) 
Constraints 9 ensure that equals 1 iff at least one equipment unit constrained by is active in configuration . Constraints 10 ensure that, for every configuration , either there is no active equipment ( is a dummy configuration) or exactly for every thermal constraint . Finally, Constraints 11 channel these extra variables with the objective variable by ensuring that is its unary order encoding [Tamura2008]. These constraints are necessary to obtain a filtering as strong as in the base model, while improving the lower bound on .
6 Test Sequencing
The problem of minimizing the number of equipment activations can be naturally represented using the Switch constraint, since, as shown in Section 4, thermal constraints and the fact that tests require some equipment units to be active can be modeled as buffered resources. Moreover, as often in problems that can be represented with a buffered resource, we know beforehand the set of items (here equipment units) that will be activated at least once. In other words, the total number of items to be buffered minus the capacity of the buffer is a trivial lower bound on the required number of switches. However, the constraint Switch does not take this information into account and hence is “suboptimal”, especially when only a few tests have been allocated a configuration.
In this section, we propose an improvement of the propagator for Switch for the very common case where we have prior knowledge on a set of items that must eventually be buffered. In some cases, we can simply add the number of nonbuffered items to the lower bound computed by the algorithm for Switch. However, this is not always true. We define a correct lower bound based on this idea in Theorem 6.1.
We define the variant Switch of the Switch constraint with an extra parameter indicating the items that must be put in the buffer at some point in the sequence. Let be a set of integers, an integer variable, be a sequence of set variables, and be two sequences of integers.
Definition 3
We next recall some background about the constraint and in particular its propagation algorithm in Definitions 4 and 5. It is possible to find an optimal buffer sequence , that is, an assignment of that minimizes the value of with the greedy procedure FindSupport introduced by [DBLP:conf/cpaior/BessiereHMQW14] (Algorithm 1 in [DBLP:conf/cpaior/BessiereHMQW14]). This algorithm explores the sequence once while maintaining all items in a list ordered by a priority relation based on two indices ( and ) for each item .
Definition 4
is the least index such that if it exists and otherwise. is the least index such that if it exists and otherwise.
The priority relation between two items is defined by the following criteria:
Definition 5
At index , and given two items , we have if:

and , or

and
and otherwise.
The procedure starts with and when moving to index , it first adds all required items (i.e., in ) and removes all impossible items (i.e., not in ), which yields the set . If it then removes the last items for the order in . Otherwise, if it adds the first items for the order in .
Definition 6
A stretch of a buffer sequence is a triple such that the value is buffered in during the interval and is not buffered at nor at (we assume that no item is buffered at 0 or ). We say that a stretch is optional if there is no such that . We say that the item is optional if there exists a stretch and for all , .
Every stretch entails one switch, except if it extends until the end of the sequence. Therefore, if is the cardinality of the buffer at the last index of the sequence, the following observation holds:
Observation 1
A solution with switches has stretches.
Lemma 1
If and are two buffer sequences found by FindSupport on two instances and equal on every index except one for which the lower bound of the buffer at this index contains a single additional item in , then .
Proof
An item not in the buffer at index is added at index only if:

the item is the lower bound or

and it is in the first for .
Only item can satisfies case 1 in but not in .
Moreover, by definition, the order is equal in and , except for which may be ranked higher in . Therefore, the only item that may satisfy case 2 in but not in is again . Therefore, . ∎
Lemma 2
Let be a buffer sequence of an instance with minimal number of switches and let be an item not buffered in . For any , a sequence on the instance obtained by adding the constraint has at least one more nonoptional stretch than .
Proof
We can assume that and were found by FindSupport as this algorithm is complete. The sequence has necessarily a nonoptional stretch , and there was no stretch in . Therefore, if the number of nonoptional stretches is not larger in than in , it must have one less nonoptional stretch for an item . This can only happen if the gap between two nonoptional stretches and with is bridged by buffering the value in the interval . Hence there exists such that . However, by Lemma 1 we have . ∎
Theorem 6.1
For any two sets , if there is an optimal buffer sequence visiting exactly the items in with switches, optional stretches, and optional items, then there is no buffer sequence visiting all items in in less than switches.
Proof
First, notice that we can reduce the case with optional items to the case without optional item, and optional stretches. Indeed, if there exists an optimal sequence visiting all items in , we can add a constraint for every pair where and . The procedure FindSupport will then find a sequence with same number of switches, same number of stretches, and less optional stretches than . Therefore, we suppose and prove the lower bound .
Now, if has nonoptional stretches, then by Lemma 2, we know that a solution visiting all items in must have at least (nonoptional) stretches, and hence at least switches. ∎
Counting the number of optional stretches and items in the sequence returned by FindSupport can be done in linear time. Therefore, Theorem 6.1 improves the lower bound found by this algorithm without changing its worst case complexity when we know that some items must be buffered but do not appear in the lower bound of a set variable. This is true in the test sequencing problem, as it is in most applications of this constraint.
7 Search Strategy
In this section we introduce a dedicated branching heuristic for the packing problem. The basic idea is that we can easily evaluate the impact of allocating a test to a configuration by counting how many equipment activations are required and how these equipment units are already constrained in this configuration. Second, we propose to decompose the problem into packing and sequencing aspects in order to find good upper bounds quickly for the test planning problem.
7.1 Branching Heuristic
Let be the number of equipment units constrained by that will be active in configuration if test was to be run in that configuration, i.e., the number of nonground Boolean activation variables concerning equipment of test constrained by :
We consider the ratio to be proportional to the tightness of the constraint , and we use the change in tightness resulting from the decision of running test in configuration to evaluate the impact of this decision. After the decision , the tightness becomes . Therefore, the factor represents the factor by which the tightness of constraint would increase. As , we use 1 minus its inverse as a measure, in , of the impact of that decision, that is:
Now, we can use the average of these impacts on all thermal constraints to define the impact of allocating test to configuration .
Notice that allocation variables may have many more values than necessary to satisfy the thermal constraints. Indeed, it is important, for a coloring heuristic, to branch only values in where is the highest allocated value so far. Hence, given a test we consider the intersection instead of its actual domain . We therefore select the variable minimizing:
And we branch on the value minimizing .
7.2 Multistage Approach
We use Boolean variables to represent the status of every equipment unit in every configuration. Moreover, without an upper bound on the number of configurations required to pack every test, we can only assume that configurations (as many as there are tests) may be needed, i.e., . However, in practice is a gross overestimate of . For instance, in one of the industrial instances that we considered, several hundreds of tests can be run in as few as three configurations.
Furthermore, since we consider two criteria in a hierarchical way, it makes sense to optimize a relaxation of the problem where only Constraints 1 to 3 are kept (the packing subproblem), i.e., the model is complete with respect to the objective with highest priority. Observe that since the order of the bins does not matter in this case, configurations are symmetric. We therefore used lexicographic ordering constraints [lexchain, Frisch2006803] on the set variables .
Last, we also considered the pure sequencing aspect of the problem. Given a packing, finding the optimal sequence for that packing can be modeled with a set of BufferedResource constraints, one for each thermal constraint, all sharing the same permutation. Another way to understand this is that we can consider a packing solution using configurations as a new instance with only tests to sequence (it is unlikely that two such tests could share a single configuration given the thermal constraints) and consider Constraints 1, 4 and 5 of the complete model (the sequencing subproblem). Solving this problem to optimality does not give us a lower bound on the total number of switches, however, it is much simpler and can often provide a good upper bound quickly.
We therefore implemented the following fourphase strategy:

We run a greedy descent on the packing problem to find an initial upper bound. The trivial heuristic that branch on the lexicographically least configuration for a test gives relatively good results, so we stop this phase at the first solution found, which is backtrackfree.

We run the packing model (initialized with the previous upper bound) for a given period of time, or until optimality is proven.

We run the sequencing model for a given period of time, or until optimality is proven (though in this case we cannot deduce a lower bound).

We run the complete model (packing & sequencing) (initialized with lower and/or upper bounds, accordingly) for the rest of the allocated time.
8 Experimental Evaluation
We tested the different approaches that we propose on industrial and generated instances. We have only six real instances, corresponding to three already launched communications satellites. The same tests are usually run in two types of thermal environments. The hot and cold test phases respectively simulate the periods where the satellite is facing the sun, or when it is in Earth’s shadow. Instances labeled cold are much more thermally constrained and thus typically require more configurations than those labeled hot. We diversified the pool of instances by randomly shuffling tests in order to produce 5 randomized variants of every instance. Moreover, we used random instances designed to be similar to the real cases, generated as follows: for a given number of tests , we set the number of equipment units to . The equipment of instances with and tests are equally partitioned into thermal constraints. Each test requires equipment units from two different thermal constraints. Other instances have thermal constraints and each test requires or equipment units belonging to different thermal constraints. Then, for each generated instance, we consider two levels of tightness for thermal constraints to simulate the hot (/ =0.6) and the cold phases (/ =0.4).
We generated 5 variants of 12 classes of instances. Instance XXX.YY denote a set of XXX tests with YY giving the ratio of the thermal constraints. Instances A, B and C are industrial instances. All models have been implemented in Choco 3 [choco] and ran on Intel Xeon E5 processors for a total of thirty minutes on every instance. We compared the five following approaches:

[itemsep=4pt]

base is the straightforward model with Constraints 1 to 5, using Weighted Degree [04wdeg] for variable selection and lexicographic branching. Notice that the strategy is set up to branch on all allocation variables before branching on activity variables. Other predefined heuristics in Choco were less efficient. It is important to note that due to the “coloring” aspect of the problem, branching on the lexicographically least value (color) in the domain is extremely important. However Impact Based Search [Refalo2004] and Activity Based Search [Michel2012] cannot trivially be made to branch on the lexicographically least value and thus gave extremely poor results for that reason.

heuristic is the same model as base, however with the dedicated heuristic described in Section 7.1 for variable ordering.

multistage is the same model as base, however, using the fourphase strategy described in Section 7.2.

full is the same model as propagation, however it uses the fourphases strategy and the branching heuristic described in Section 7.
Note that for every approach, we first applied a preprocessing to the data in order to merge identical tests. Indeed, on top of the packing based on the configuration of active equipment units, one must, in the real setting, further partition the tests because of different requirements on signal routing equipment. This second packing phase is exactly a listcoloring problem on the tests of each the configurations. The size of these problems is very modest with respect to state of the art coloring algorithms, so we do not study this aspect in the current paper. As a consequence, some tests in the data require the same set of equipment units to be active, and can be thought of as a single test for our purpose.
instance  base  heuristic  multistage  propagation  full  

#conf  #switch  #conf  #switch  #conf  #switch  #conf  #switch  #conf  #switch  
03004  6.4  (5)  1.6  (5)  6.4  (5)  1.6  (5)  6.4  (5)  1.6  (4)  6.4  (5)  1.6  (5)  6.4  (5)  1.6  (4) 
03006  3.4  (5)  0.8  (5)  3.4  (5)  0.8  (5)  3.4  (5)  0.8  (3)  3.4  (5)  0.8  (5)  3.4  (5)  0.8  (2) 
05004  5.2  (2)  2.2  (2)  5.2  (3)  2.0  (3)  5.2  (5)  2.0  (3)  5.2  (5)  2.0  (5)  5.2  (5)  2.0  (5) 
05006  3.6  (2)  0.8  (2)  3.6  (5)  0.6  (5)  3.6  (5)  0.6  (3)  3.6  (5)  0.6  (5)  3.6  (5)  0.6  (2) 
08004  9.6  19.0  9.0  (1)  15.0  (1)  9.0  15.4  9.0  (1)  13.8  (1)  9.0  (3)  13.8  (1)  
08006  5.6  6.0  5.4  (3)  4.8  (3)  5.4  (3)  5.2  (1)  5.4  (3)  4.2  (3)  5.4  (4)  4.2  (3)  
10004  14.0  40.6  13.0  43.4  13.2  31.8  13.0  34.4  12.8  30.2  
10006  4.4  5.8  4.0  (4)  2.8  (4)  4.0  (5)  4.0  4.0  (4)  3.0  (4)  4.0  (5)  2.8  (5)  
20004  12.6  67.2  10.2  62.8  10.2  46.2  10.4  53.6  10.0  47.8  
20006  5.8  24.2  5.0  18.2  5.0  17.2  5.0  14.0  5.0  14.4  
30004      10.4  111.2  10.2  85.0  10.2  94.0  10.0  81.8  
30006  5.7  45.3  4.8  37.0  4.6  26.8  4.2  25.4  4.0  22.4  
A cold  6.0  16.0  6.0  14.2  6.0  8.8  6.0  9.6  6.0  7.0  
A hot  4.0  2.0  4.0  4.6  4.0  2.0  4.0  2.0  4.0  (5)  2.0  
B cold      9.0  106.6  9.0  50.2  9.0  78.8  9.0  50.2  
B hot      4.0  19.6  4.0  3.6  4.0  1.2  4.0  (5)  0.8  (2)  
C cold      8.0  82.8  8.0  46.8  8.0  64.8  8.0  50.6  
C hot      3.0  15.0  3.0  2.0  3.0  (4)  0.2  (4)  3.0  (5)  0.0  (5) 
The results are reported in Table 1. For each method, we show the objective values, where #conf stands for the average number of configurations over the five variants of the instance, and #switch stands for the average number of switches for the same instances. Next to these values, we report in brackets, the number of instances for which the reported objective value was proven optimal within a 30 minutes time limit (no value means that none of the runs was complete). For each instance, the methods proving optimality in the most cases, among those giving the minimum average objective value, are colorhighlighted.
First, we observe that the straightforward model base is very poor, in most of the larger instances it does not even find a feasible solution in less than ten minutes. On the other hand, augmenting this model either with stronger propagation, better branching heuristic, or the multistage approach is sufficient to obtain decent results. Combining all these improvements clearly yields the best and most robust results, and sometimes allows to prove optimality even on real industrial instances.
Second, multistage approaches (multistage and full) are clearly better for larger instances, however, they tend to hinder the ability of Choco to prove optimality on small instances. Moreover, we observed that they tend to be less robust, in the sense that the final result greatly depends on the initial packing which gives no guarantees on the number of switches. This is especially true for large instances in which the complete model often cannot improve on the heuristic sequence found during the third phase.
instance  lb conf  lb switch  full lb switch  full lb conf.  

#conf  #switch  #conf  #switch  #conf  #switch  #conf  #switch  
03004  6.4  (5)  1.6  (5)  6.4  (5)  1.6  (5)  6.4  (5)  1.6  (4)  6.4  (5)  1.6  (3) 
03006  3.4  (5)  0.8  (5)  3.4  (5)  0.8  (5)  3.4  (5)  0.8  (2)  3.4  (5)  0.8  (2) 
05004  5.2  (3)  2.2  (3)  5.2  (4)  2.0  (4)  5.2  (5)  2.0  (3)  5.2  (5)  2.0  (4) 
05006  3.6  (4)  0.6  (4)  3.6  (5)  0.6  (5)  3.6  (5)  0.6  (2)  3.6  (5)  0.6  (2) 
08004  9.2  (1)  16.6  (1)  9.0  16.8  9.0  (3)  14.4  (1)  9.0  (3)  13.4  (1)  
08006  5.4  (3)  5.2  (3)  5.4  (3)  4.4  (3)  5.4  (4)  4.6  (3)  5.4  (5)  3.8  (3) 
10004  13.8  37.0  13.8  37.0  12.8  30.8  12.8  30.4  
10006  4.0  4.6  4.0  (1)  4.4  (1)  4.0  (5)  2.8  (5)  4.0  (5)  2.8  (5)  
20004  11.0  57.0  11.0  56.6  10.0  47.2  10.0  47.8  
20006  5.0  18.8  5.0  17.6  5.0  14.4  5.0  14.8  
30004  11.0  98.8  11.0  97.4  10.0  81.8  10.0  85.8  
30006  5.0  28.2  5.0  29.8  4.0  22.0  4.0  21.8  
A cold  6.0  10.2  6.0  7.6  6.0  12.0  6.0  7.2  
A hot  4.0  3.0  4.0  2.8  4.0  (5)  3.2  4.0  (5)  2.0  
B cold  9.0  64.8  9.2  65.4  9.0  50.6  9.0  52.2  
B hot  4.0  3.8  4.0  4.0  4.0  (5)  1.8  4.0  2.4  
C cold  8.0  55.4  8.0  55.2  8.0  49.2  8.0  50.0  
C hot  3.0  5.8  3.0  5.2  3.0  (5)  0.8  3.0  (5)  0.4  (3) 
For a deeper analysis of the two bounds proposed in this paper, we ran four other models on the same instances. The first two are the base model augmented with the lower bound on configurations or the lower bound on switches (base lb conf and base lb switch, respectively). The other two models are the full model from which we removed these lower bounds (full lb switch and full lb conf, respectively). The results of these additional tests, in Table 2 clearly show that both bounds are useful. Surprisingly, the capacity to prove optimality on a criterion is also impacted by the bound on the other criterion.
Finally, in Table 3, we compare the results of our best method (model full) with the method previously used by Airbus Defense & Space [maillet2011constraint] and with a slight improvement of this method described in [bochesauvan:hal01166683]. The former, denoted CM, is a constraint optimization tool build to solve the packing problem only. The second, denoted CM+TSP, is the same approach, however the resulting configurations are then permuted so that the Traveling Salesman Problem defined by the Hamming distance between configurations is optimized. It is not surprising that the first method is very poor in terms of total equipment activation since it makes no attempt to optimize this criterion. However, it is interesting to compare with our results as it is still the method used in practice.
The method CM+TSP gives a better solution in one case (C cold). Indeed, this instance is particular as it involves more than twice as many tests as other instances. The consequence is that the model computing packing and sequencing simultaneously is relatively inefficient. For this instance, we therefore ran a simple randomized sequence of the second and third phases of the multistage approach (i.e., pure packing followed by pure sequencing) and quickly found a similar solution (though we could not improve on it). Notice that in the case of the “hot” test campaign for satellite C, carefully packing and sequencing the tests makes it possible to get rid of all equipment activation besides the mandatory one, whereas 14 activations are necessary with the current method.
instance  CM  CM+TSP  Choco (full)  

#conf  #switch  #conf  #switch  #conf  #switch  
A cold  6  43  6  9  6  7.0  
A hot  4  5  4  3  4  (5)  2.0  
B cold  10  108  10  70  9  50.2  
B hot  5  30  5  1  4  (5)  0.8  (2) 
C cold  8  91  8  41  8  50.6  
C hot  3  14  3  9  3  (5)  0.0  (5) 
9 Conclusion
We have introduced a complete constraint programming approach for the problem of packing and sequencing the validation tests of communications satellites. We proposed a search strategy and lower bound for the packing aspect of the problem. Moreover, we introduced an improvement of the Switch constraint that can be applied in many other contexts. Our experimental evaluation shows that the methods proposed in this paper greatly improve the test plans with respect to those currently used within the Airbus group.
Although this approach is not yet industrially implemented, a previous internal study in Airbus^{3}^{3}3Master’s internship report by Ludivine BocheSauvan for the “Institut Supérieur de l’Aeronautique et de l’Espace” (ISAE) in 2012
(http://www.laas.fr/files/ROC/LAAS_Techreport.pdf).
has shown that,
during a test campaign, around 30% of the total duration is spent on transitions between configurations. Moreover, in many cases, tests must be interrupted because the payload is overheating and can only resume after the system has been stabilized. The constraint model we introduced should help with both of these issues.
Since such test campaigns require an extremely costly and energy greedy thermal vacuum chamber as well as a large team of engineers in 3shift rosters, significant financial savings are expected from this approach.