Optimal Multileaf Collimator Leaf Sequencing in IMRT ... - CiteSeerX

Optimal Multileaf Collimator Leaf Sequencing in IMRT Treatment Planning Z. Caner Ta¸skın∗

J. Cole Smith†

H. Edwin Romeijn‡

James F. Dempsey§ June 24, 2007

Abstract We consider a problem dealing with the efficient delivery of Intensity Modulated Radiation Therapy (IMRT) to individual patients. IMRT treatment planning is usually performed in three phases. The first phase determines a set of beam angles through which radiation is delivered, followed by a second phase that determines an optimal radiation intensity profile (or fluence map). This intensity profile is selected to ensure that certain targets receive a required amount of dose while functional organs are spared. In order to deliver these intensity profiles to the patient, a third phase must decompose them into a collection of apertures and corresponding intensities. In this paper, we investigate this last problem. Formally, an intensity profile is represented as ∗

Department of Industrial and Systems Engineering, University of Florida, 303 Weil Hall, P.O. Box

116595, Gainesville, Florida 32611-6595; e-mail: [email protected]. † Department of Industrial and Systems Engineering, University of Florida, 303 Weil Hall, P.O. Box 116595, Gainesville, Florida 32611-6595; e-mail: [email protected]. ‡ Department of Industrial and Systems Engineering, University of Florida, 303 Weil Hall, P.O. Box 116595, Gainesville, Florida 32611-6595; e-mail: [email protected]. The work of this author was supported by the National Science Foundation under grant no. DMI-0457394. § Department of Radiation Oncology, University of Florida, P.O. Box 100385, Gainesville, Florida 326100385; e-mail: [email protected]. The work of this author was supported by the National Science Foundation under grant no. DMI-0457394.

1

a nonnegative integer matrix; an aperture is represented as a binary matrix, each row of which obeys the so-called consecutive ones property (all ones appear consecutively in each row); and the aperture intensities must be integers. A feasible decomposition is one in which the original desired intensity profile is equal to the sum of a number of feasible binary matrices multiplied by corresponding intensity values. In order to most efficiently treat a patient, we wish to minimize a measure of total treatment time, which is given as a weighted sum of the number of apertures and the sum of the aperture intensities used in the decomposition. We develop the first exact algorithm capable of solving real-world problem instances to optimality (or to within provably small optimality gaps) within practicable computational limits, using a combination of integer programming decomposition and combinatorial search techniques. We demonstrate the efficacy of our approach on a set of 25 test instances derived from actual clinical data.

1

Introduction and Literature Survey

Cancer is one of the leading causes of death throughout the world. In the last century, external beam radiation therapy has emerged as a very important and powerful modality for treating many forms of cancer, either in primary form or in conjunction with other treatment modalities such as surgery, chemotherapy, or medication. In the United States today, approximately two-thirds of all newly diagnosed cancer patients receive radiation therapy for treatment. Since the radiation beams employed in radiation therapy damages all cells traversed by the beams, both in targeted areas in the patient that contain cancerous cells as well as any cells in healthy organs and tissues, the treatment must be carefully designed. This can partially be achieved by delivering radiation from several different directions, also called beam orientations. Therefore, patients receiving radiation therapy are typically treated on a clinical radiation-delivery device which can rotate around the patient. The most common device is called a linear accelerator, and is typically equipped with a so-called multileaf collimator (MLC) system which can be used to judiciously shape the beams by forming apertures, thereby providing a high degree of control over the dose distribution that is received by a patient (see Figure 1). This technique has been named intensity modulated radiation 2

Multileaf collimator system

Photon therapy beam

Left and right leaves form aperture, creating an irregularly shaped beam

(a)

(b)

Figure 1: (a) A multileaf collimator system1 ; (b) the projection of an aperture onto a patient. therapy (IMRT). Since the mid 1990’s, large-scale optimization of the fluence applied from a number of beam orientations around a patient has been used to design treatments from MLC-equipped linear accelerators. A typical approach to IMRT treatment planning is to first select the number and orientations of the beams to use as well as an intensity profile or fluence map for each of these beams, where the fluence map takes the form of a matrix of intensities. This problem has been studied extensively and can be solved satisfactorily, in particular when (as is common in clinical practice) the beam orientations are selected manually by the physician or clinician based on their insight and expertise regarding treatment planning. For optimization approaches to this so-called fluence map optimization problem we refer to the review paper by Shepard et al. [30]. More recently, Lee et al. [22, 23] studied mixed-integer programming approaches, Romeijn et al. [29] proposed new convex programming models, and Hamacher and K¨ ufer [10] and K¨ ufer et al. [20] considered a multi-criteria approach to the problem. However, to enable delivery of the optimal fluence maps by the MLC system, they need to be decomposed into a collection of deliverable apertures. (For examples of integrated approaches to fluence map optimization, also referred to as aperture modulation, we refer to Preciado-Walters et al. [26] and Romeijn et al. [28]). The vast majority of MLC systems contain a collection of leaves that can be moved in parallel, thereby blocking part of the radiation beam. This architecture implies that we can view each beam as a matrix of 1

Varian Medical Systems; http://www.varian.com/orad/prd056.html.

3

beamlets or bixels (the smallest deliverable square beam that can be created by the MLC), so that each aperture can be represented by a collection of rows (or, by rotating the MLC head, columns) of beamlets, each of which should be convex. In other words, each fluence map should be decomposed into either constant-intensity row-convex apertures or constantintensity column-convex apertures. Due to the time required for setup and verification, clinical practice prohibits using both types of apertures for a given fluence map, so that without loss of generality we will in this paper focus on row-convex apertures only. Note that while some manufacturers of MLC systems impose additional constraints on the apertures, we will assume throughout this paper that all row-convex apertures are deliverable. As an example, consider the fluence map given by the following 2 × 3 matrix of beamlet intensities (see Baatar [3]):  

3 6 4 2 1 5

 .

If we represent an aperture by a binary matrix in which an element is equal to one if and only if the associated beamlet is exposed (i.e., not blocked by either the left or right leaf of the MLC system), row-convexity corresponds to the property that, in each row of the corresponding matrix, the elements that are equal to one are consecutive (often referred to as the consecutive ones property). Now observe that this fluence map can be decomposed into three apertures with corresponding intensities:         3 6 4 1 0 0 1 1 0 0 1 1  =1× +2× +4× . 2 1 5 0 1 1 1 0 0 0 0 1 Since, in general, there are many ways of decomposing a given fluence map into rowconvex apertures, it is desirable to select the decomposition that can be delivered most efficiently. The two main efficiency criteria that play a role are the total beam-on-time, i.e., the total amount of time that the patient is being irradiated, and the total setup time, i.e., the total amount of time that is spent shaping the apertures. The former metric is proportional to the sum of intensities used in the decomposition, while the latter is approximately proportional to the number of matrices used in the decomposition. Although closely related, these two efficiency criteria are not equivalent. The example given above shows the unique decomposition using only three apertures and with a beam-on-time of 7. However, the min4

imum beam-on-time for this fluence map is 6, which can be realized by four apertures using the following decomposition:           0 1 1 1 1 1 0 1 0 1 1 0 3 6 4 . +2× +2× +1× =1×  0 0 1 0 0 1 1 1 1 1 0 0 2 1 5 The problem of decomposing a fluence map while minimizing beam-on-time is polynomially solvable and has been widely studied, leading to several different solution approaches for this problem. We refer in particular to Ahuja and Hamacher [1], Bortfeld [5], Kamath et al. [15], and Siochi [32]; in addition, Baatar et al. [3], Boland et al. [4], Kamath et al. [16, 17, 18, 19], Lenzen [24], and Siochi [32] study the problem under additional hardware constraints, while Kalinowski [14] studies the benefits of allowing rotation of the MLC head. Although the time required by the MLC system to transition between apertures formally depends on the apertures themselves, the fact that these times are similar and the presence of significant (aperture-independent) verification and recording overhead times justifies the use of the total number of setups (or, equivalently, the total number of apertures) to measure the total setup time. In addition, delivering IMRT with a small number of apertures provides the additional benefits of less wear-and-tear on the collimators (less stopping and starting) and a more robust or less error-prone delivery as IMRT delivery errors are known to be proportional to the number of apertures (see Stell et al. [33]). The problem of decomposing a fluence map into the minimum number of row-convex apertures has been shown to be strongly NP-hard (see Baatar et al. [3]), leading to the development of a large number of heuristics for solving this problem. Notable examples are the heuristics proposed by Baatar et al. [3] (who also identify some polynomially solvable special cases), Dai and Zhu [6], Que [27], Siochi [32], and Xia and Verhey [34]. In addition, Engel [8], Kalinowski [13], and Lim and Choi [25] developed heuristics to minimize the number of apertures while constraining the total beam-on-time to be minimal. Finally, Langer et al. [21] developed a mixed-integer programming formulation of the problem, while Kalinowski [12] proposed an exact dynamic programming approach. However, while the latter approaches can be used to efficiently solve small problem instances to optimality, they have proven unsuccessful in solving problems of clinically relevant dimensions. The primary contribution of this paper is that we develop the first algorithm capable of solving clinical problem instances to optimality (or to provably 5

near-optimality) within acceptable computational time limits. In this paper, our focus is on the problem of finding a decomposition of a fluence map into row-convex apertures that minimizes total treatment time, as measured by the sum of the total setup time and beam-on-time. In Section 2 we discuss the merits of a mixed-integer programming approach based on the formulation due to Langer et al. [21], and conclude that even employing several techniques to tighten the formulation does not provide an approach that is viable from a clinical point of view. In Section 3 we develop our decompositionbased solution approach, while in Section 4 we discuss the application of our algorithm on a collection of clinical test data and compare the performance with a mixed-integer programming approach. We conclude the paper in Section 5.

2

A Mixed-Integer Programming Approach

In this section, we discuss an integer programming approach to decomposing a fluence map into a number of apertures and corresponding intensities that is based on a model proposed by Langer et al. [21]. Given a maximum number of unit-intensity apertures, say T , this formulation determines the positions of the left and right leaves in each row of each of these apertures. Throughout this paper, we will denote the fluence map to be delivered by a matrix B ∈ Nm×n , where the element at row i and column j, (i, j), corresponds to a bixel with required intensity bij . We will next develop the model by separately studying four important components: • Fluence map requirements: Define, for each aperture t = 1, . . . , T and each bixel (i, j) ∈ {1, . . . , m} × {1, . . . , n}, a binary variable dtij that is equal to one if and only if bixel (i, j) is exposed, i.e., not covered by a left leaf or a right leaf. Since each aperture has unit intensity, the following constraints then ensure that the desired fluence map is delivered: T X

dtij = bij

∀ i = 1, . . . , m, j = 1, . . . , n.

t=1

• Aperture deliverability constraints: Define, for each aperture t = 1, . . . , T and each bixel (i, j) ∈ {1, . . . , m} × {1, . . . , n}, 6

t binary variables ptij and lij that are equal to one if and only if bixel (i, j) is covered by

the right leaf or the left leaf in row i of aperture t, respectively. The following set of constraints then ensure that each of the T apertures is deliverable: t ptij + lij + dtij = 1

∀ i = 1, . . . , m, j = 1, . . . , n, t = 1, . . . , T

(1)

ptij ≤ pti,j+1

∀ i = 1, . . . , m, j = 1, . . . , n − 1, t = 1, . . . , T

(2)

t t lij ≤ li,j−1

∀ i = 1, . . . , m, j = 2, . . . , n, t = 1, . . . , T.

(3)

In particular, constraints (1) state that each bixel is either covered by a right-hand leaf, covered by a left-hand leaf, or uncovered (where the d-variables are included only for convenience and can be substituted out of the formulation). Constraints (2) and (3) state that if any bixel (i, j) is covered by a right-hand leaf (resp. left-hand leaf), then bixel (i, j + 1) (resp. (i, j − 1)) should be covered by a right-hand leaf (resp. left-hand leaf) as well. • Beam-on-time: One important measure of treatment plan delivery efficiency is the total beam-on-time. This quantity is in fact equal to the number of unit-intensity apertures in the solution that contain uncovered bixels in this model. We therefore associate a binary variable z t with each aperture t = 1, . . . , T that is equal to one if there are uncovered bixels in aperture t and zero otherwise, so that the beam-on-time is simply given by T X

zt.

(4)

t=1

While Langer et al. [21] impose the following constraints to ensure that these variables have (at least) their desired value: m X n X

dtij ≤ (mn)z t

∀ t = 1, . . . , T,

(5)

i=1 j=1

we note that a stronger formulation, which would actually not require enforcing the z-variables to be binary, would instead impose dtij ≤ z t

∀ i = 1, . . . , m, j = 1, . . . , n, t = 1, . . . , T. 7

(50 )

Note that this model allows z t to be equal to one even if in aperture t no bixels are exposed, so that formally speaking (4) is an upper bound on the beam-on-time. An appropriate objective function or set of constraints will ensure that the z-variables are chosen sufficiently small. • Number of apertures: The second important measure of treatment plan delivery efficiency is the setup time, which we assume to be proportional to the number of times the aperture is changed, i.e., the number of setups. We therefore associate a binary variable gt with each aperture t = 1, . . . , T − 1 that is equal to one if aperture t is different from aperture t + 1 and zero otherwise. The number of setups is then given by T X

gt .

(6)

t=1

Now let ctij and utij be auxiliary binary variables such that the former is equal to one if bixel (i, j) is exposed in aperture t but not in aperture t + 1 and zero otherwise, and the latter is equal to one if bixel (i, j) is covered in aperture t but not in aperture t + 1. This relationship is stated by t t −ctij ≤ dt+1 ij − dij ≤ uij

∀ i = 1, . . . , m, j = 1, . . . , n, t = 1, . . . , T − 1.

Langer et al. [21] then use the following constraints to ensure that the variables gt have (at least) their desired value: m X n X


ctij + utij ≤ (mn)g t

∀ t = 1, . . . , T − 1.

(7)

i=1 j=1

However, note that again a stronger set of inequalities (that permit g to be equivalently relaxed as continuous variables) is given by: ctij + utij ≤ g t

∀ i = 1, . . . , m, j = 1, . . . , n, t = 1, . . . , T − 1.

(70 )

Similar to the case of the beam-on-time, this model allows g t to be equal to one even if apertures t and t + 1 are identical, although our objective function will ensure that the g-variables are chosen sufficiently small. 8

Langer et al. [21] then study the problem of minimizing the number of setups (6) subject to the constraints (1)–(3), (5), (7), the constraint that the beam-on-time is minimal: T X

z t ≤ z˜

(8)

t=1

and binary constraints on the variables, where we recommend determining z˜ via one of the polynomial-time procedures mentioned in Section 1. We note that an equivalent model is obtained by simply setting T = z˜, which reduces the problem dimension, and hence should be more efficient than adding a beam-on-time constraint. In this paper, we are concerned with the problem of minimizing the total treatment time as measured by w1

T X

gt + w2

T X

zt

(9)

t=1

t=1

subject to constraints (1)–(3), (50 ), (70 ), and binary constraints on the appropriate variables (and hence we do not impose (8)). Here w1 is the time required for a transition between two apertures and w2 denotes the time required for the delivery of one unit of fluence. We will refer to this problem as the optimal leaf sequencing problem. Unfortunately, the approach presented above is faced with several computational difficulties. The most obvious is that the formulation requires many binary variables: in its original form, the model contains O(mnT ) binary variables. In addition, it has a weak linear programming relaxation. For example, constraints (5) suffer from the use of a so-called “big-M ” implement in which z t must be switched to 1 if any dtij value equals 1. However, the P P linear programming relaxation will set z t = i j dtij /mn, requiring the branch-and-bound solver to branch on the z-variables. Even under the strengthened formulation given in (50 ), we have z t = maxi,j {dtij } in the linear programming relaxation. Now, if the d-variables are binary-valued, then the z-variables will be as well. However, this minimax structure also spawns weak linear relaxations by encouraging fractional d-values. A similar behavior occurs for (7) and (70 ). Another issue regards the presence of symmetry in the model (see Sherali and Smith [31]). For instance, a valid set of inequalities would state that z t ≥ z t+1

∀ t = 1, . . . , T − 1 9

in order to insist that the apertures actually used in the solution are the lowest-indexed apertures. But even if z˜ apertures are predesignated for use, and so z t = 1 ∀ t = 1, . . . , z˜ with z t = 0 otherwise, there still exists symmetry among the distinct apertures. Given an optimal solution to the optimal leaf sequencing problem with g˜ distinct apertures, there exist g˜! − 1 permutations of this solution by rearranging the index blocks corresponding to distinct apertures. Another source of symmetry is the fact that given an optimal solution to the optimal leaf sequencing problem in which there exist two distinct apertures having the same intensity, rows of those apertures can be swapped to yield an exponential number of alternative optimal solutions. A branch-and-bound solver must explore and fathom each of these permutations, which requires a significant amount of repeated computational effort. These weaknesses appear to be inherent in the formulation approach, and while we have attempted to augment the model proposed by Langer et al. [21] with valid inequalities and symmetry-breaking hierarchies to ameliorate the problems listed above, no single formulation that we developed was capable of solving real problem instances to optimality within practical computational limits. As an alternative approach, we instead developed a decomposition approach as discussed in the following section.

3

Decomposition Algorithm

We start this section by describing a decomposition framework for the optimal leaf sequencing problem in Section 3.1 and use this to formulate our master problem as an integer programming problem in Section 3.2. This framework gives rise to an important subproblem for which we provide a complexity analysis and solution approach in Section 3.3. We enhance the empirical performance of our decomposition algorithm by introducing classes of valid inequalities to the master problem in Section 3.4, and by discussing master problem reoptimization strategies in Section 3.5.

3.1

Decomposition Framework

To establish motivation for our approach, observe that if the objective is to minimize beamon-time, the optimal leaf sequencing problem is decomposable by the rows of the fluence 10

map. In particular, if the beam-on-time is minimized for each beamlet row, the maximum of the corresponding beam-on-time values is equal to the minimum beam-on-time for the overall fluence map (see, e.g., Ehrgott et al. [7]). However, this approach is not directly applicable when the objective is to minimize the total treatment time as given in equation (9). Even though the optimal leaf sequencing problem, in general, is not directly decomposable by rows, the fact that leaves corresponding to different rows can be positioned independently can still be exploited. If we refer to a particular positioning of left and right leaves for a row as a leaf position, an aperture is composed of a leaf position for each bixel row. Our main observation is that given a set of intensities, which can be used in apertures that collectively cover the fluence map, the rows are independent of one another. That is, we can determine the leaf positions to be used for covering each row independently, and then form apertures for covering the entire fluence map by combining individual leaf positions for each row that are assigned to the same intensity. We define an allowable intensity set to be a collection of (potentially non-unique) intensity values, each of which can be assigned to a single aperture in our solution. We say that an allowable intensity set is compatible with a row if there exists a feasible decomposition of the row into leaf positions using a subset of that allowable intensity set. If an allowable intensity set is compatible with all rows, then it corresponds to a feasible decomposition of the fluence map and we call it a feasible intensity set. If a feasible intensity set minimizes (9), then it is an optimal solution to our problem. As an example, consider the fluence map given by the following 3 × 3 matrix: 

1 4 8

  B= 3 8 5  4 5 3

   . 

Assume that an allowable intensity set consists of the values 1, 3, and 5. Assigning each of these values to at most one leaf position, the first row can be decomposed as [1 4 8] = 1 × [1 1 0] + 3 × [0 1 1] + 5 × [0 0 1] , so that the allowable intensity set is compatible with the first row. Similarly, the second row

11

can be decomposed as [3 8 5] = 3 × [1 1 0] + 5 × [0 1 1] . However, the first bixel in the third row must be covered by two leaf positions assigned to intensities 1 and 3, and the second bixel must be covered by a single leaf position assigned to intensity 5. Therefore, all allowable intensities must be used to cover the first two bixels, and the third bixel with required intensity 3 cannot be covered. Hence, the allowable intensity set is not compatible with the third row, and therefore it is not a feasible intensity set. Alternatively, consider an allowable intensity set that contains the values 1, 3, and 4 for the same fluence map. The rows can be decomposed as [1 4 8] = 1 × [1 1 1] + 3 × [0 1 1] + 4 × [0 0 1] , [3 8 5] = 1 × [0 1 1] + 3 × [1 1 0] + 4 × [0 1 1] , and [4 5 3] = 1 × [0 1 0] + 3 × [0 0 1] + 4 × [1 1 0] . Since the allowable intensity set is compatible with all rows, it is a feasible intensity set having three leaf positions and a beam-on-time of 8. Furthermore, observe that the intensity requirements of the bixels in the first row strictly increase from left to right, implying that a leaf position must start at each bixel. Thus, any feasible decomposition of the first row uses at least three leaf positions, which yields a lower bound on the number of apertures. Also, the largest element of B is 8, which yields a lower bound on the beam-on-time. Since the given decomposition achieves the lower bounds on both objectives, we have an optimal solution to the optimal leaf sequencing problem.

3.2

Master Problem Formulation and Solution Approach

We represent an allowable intensity set by an integer vector x = (x1 , . . . , xL ), where L = maxi=1,...,m; j=1,...,n bij is the maximum intensity value in the fluence map, and where x` is the number of times that intensity value ` occurs in the allowable intensity set. In other words, x` is the number of times we may use intensity value ` for decomposing each bixel row. It is easy to see that, assuming all allowable intensity values are used, the number of apertures

12

and the beam-on-time are, respectively, equal to L X

L X

x` and

`=1

`x` .

`=1

The master problem can therefore succinctly be written as minimize w1

L X

x` + w2

`=1

L X

`x`

`=1

subject to x

is compatible with row i

∀ i = 1, . . . , m

x`

integer

∀ ` = 1, . . . , L.

Clearly, our model contains the problem of minimizing the number of apertures as a special case by setting w1 = 1 and w2 = 0. Moreover, if we wish to minimize the number of apertures required while limiting the beam-on-time to no more than T˜, we simply add the following constraint to the model:

L X

`x` ≤ T˜

`=1

where of course T˜ should at least be equal to the minimum achievable beam-on-time z˜. In order to formulate our master problem as an integer programming problem, we introduce binary variables y`r , ∀ ` = 1, . . . , L, r = 1, . . . , R` , where y`r = 1 if and only if x` = r, and R` is an upper bound on the number of apertures having intensity ` used in an optimal solution. Using these decision variables, we can reformulate the problem as follows: minimize w1

L X

x` + w2

`=1

L X

`x`

`=1

subject to R` X

(MP) ∀ ` = 1, . . . , L

ry`r = x`

r=1 R` X

y`r ≤ 1

∀ ` = 1, . . . , L

r=1

x

is compatible with row i

∀ i = 1, . . . , m

x`

integer

∀ ` = 1, . . . , L.

y`r

binary

∀ ` = 1, . . . , L, r = 1, . . . , R` . 13

(10)

We will next formulate (10) as a set of linear inequalities by deriving valid inequalities that cut off precisely those vectors x that violate (10). To this end, consider a particular allowable intensity set represented by x ˆ that is incompatible with at least one row. It is then clear that we should only consider vectors x that are different from x ˆ in at least one component. We can achieve this by imposing the following constraint: R` L X X

y`r ≥ 1.

(11)

`=1 r=1 r6=x ˆ`

Since all integer solutions except for x ˆ satisfy (11), it is indeed a valid inequality. Constraint (11) can be tightened by observing that if the solution x ˆ is incompatible with row i, then any solution x such that x` ≤ xˆ` , ∀ ` = 1, . . . , L, is also incompatible with row i. In other words, we should not only restrict ourselves to vectors that differ from x ˆ, but even to vectors for which at least one component is larger than that in x ˆ. This leads to the stronger valid inequality R` L X X

y`r ≥ 1.

(12)

`=1 r=ˆ x` +1

Constraint (12) can, in turn, be tightened further by explicitly considering the rows for which x is incompatible. Let Li = maxj=1,...,n bij be the maximum intensity in the fluence map for row i. By the same argument as above, if the current solution x ˆ is incompatible with row i, then any solution x such that x` ≤ xˆ` , ∀ ` = 1, . . . , Li , is also incompatible with row i, since no leaf positions with intensity greater than Li can be used in decomposing row i. Therefore, we can restrict ourselves to vectors x that are larger than x ˆ in at least one of the components 1, . . . , Li : R` Li X X

y`r ≥ 1 ∀ rows i incompatible with x ˆ.

(13)

`=1 r=ˆ x` +1

Since (13) is stronger than (11) or (12), we opt to use the latter inequalities in our model. Note also that (13) stated for row i1 dominates a cut generated for row i2 if Li1 < Li2 . Thus, we consider the bixel rows in nondecreasing order of their Li -values, halt when an infeasible row is detected, and add a single inequality of the form (13). This sequence also tends to minimize subproblem execution time, since rows having a small maximum intensity are easier to solve by the nature of the backtracking algorithm discussed in Section 3.3.2. 14

Since the collection (13) contains an exponential number of valid inequalities, we add them only as needed in a cutting-plane fashion. In particular, this means that we will relax (13), solve the relaxation of (MP) and generate an x-solution representing a candidate allowable intensity set. We then solve a subproblem for each bixel row to determine if the allowable intensity set is incompatible with that row. If not, we have found an optimal solution to (MP). Otherwise, we add a constraint of the form (13) to (MP) that cuts off that solution.

3.3

Subproblem Analysis and Solution Approach

In this section, we will consider the subproblem of checking whether a given intensity set x is compatible with a particular bixel row. For convenience and wherever the interpretation is clear from the context, we will suppress the index i of the bixel row and denote a typical row of the fluence map B by b = (b1 , . . . , bn ). 3.3.1

Complexity

We will represent a feasible decomposition as a set of n-dimensional binary vectors v`r (` = 1, . . . , L; r = 1, . . . , x` ) that correspond to the leaf positions used (i.e., they satisfy the consecutive ones property). If v`r = 0 for some (`, r), then a corresponding intensity value ` is not used in the decomposition. On the other hand, if v`r 6= 0 for some (`, r), then the decomposition uses a leaf position represented by v`r for delivering ` units of intensity. The subproblem can then formally be presented as follows: C1-Partition INSTANCE: An n-dimensional vector of nonnegative integers b and an integer vector x = (x1 , . . . , xL ). QUESTION: Do there exist n-dimensional binary vectors v`r (` = 1, . . . , L; r = 1, . . . , x` ) P P` that satisfy the consecutive ones property such that L`=1 xr=1 `v`r = b? We next establish the NP-completeness of the subproblem. Proposition 1. C1-Partition is strongly NP-complete. 15

Proof. Formally speaking, the problem size is given by log2 (L), n, and

PL

`=1

x` (since the

zero entries of x need not be encoded). One can guess binary vectors v`r (` = 1, . . . , L; r = P P` P 1, . . . , x` ) and verify whether or not L`=1 xr=1 `v`r = b in O(n L`=1 x` ) time. Therefore, C1-Partition is in NP. In order to show that C1-Partition is NP-complete, we reduce 3-Partition to it. 3-Partition is a strongly NP-complete problem seeks whether a given multiset of integers can be partitioned into triplets having the same sum. Formally, it can be defined as follows (see Garey and Johnson [9]): 3-Partition INSTANCE: A multiset A of 3ν positive integers a1 , . . . , a3ν and a positive integer B such P that B/4 < ai < B/2 for i = 1, . . . , 3ν and such that 3ν i=1 ai = νB. P QUESTION: Can A be partitioned into ν disjoint sets A1 , . . . , Ap such that j∈Ai aj = B for i = 1, . . . , ν? Given an arbitrary instance of 3-Partition, we construct an instance for C1-Partition as follows. First, we define xˆ to be an integer vector whose `th component, x` , is equal to the number of indices i for which ai = `. Furthermore, we let b be a (2ν − 1)-dimensional vector of the form [B 0 B 0 · · · 0 B]. Since all positive values in b are adjacent to 0, in any feasible solution to the instance of C1-Partition, each of the vectors v`r should be a unit vector whose single value of 1 is an element with odd index. Furthermore, since B/4 < ai < B/2 ∀ i = 1, . . . , 3ν, there must exist three vectors v`r whose value 1 has index 2i − 1, i = 1, . . . , ν. Now assume that the 3-Partition instance is a yes-instance, and P hence there exist sets A1 , . . . , Aν such that j∈Ai aj = B. Let ij be the index of the subset to which aj belongs, i.e., aj ∈ Aij . In this case, a feasible solution of the C1-Partition instance assigns to intensity ak a unit vector vak r with a 1 in position 2ik − 1. Similarly if the C1-Partition instance is a yes-instance, a feasible solution of the 3-Partition instance is given as sets A1 , . . . , Aν where ak ∈ Ai if, for some r, the component of vak r that is equal to 1 is in position 2ik − 1. Therefore, an arbitrary 3-Partition instance is a yes-instance if and only if the corresponding transformed C1-Partition instance is a yes-instance. Since 3-Partition is strongly NP-complete, and since the transformation provided is polynomial in terms of the size of the problem and the instance data, it follows that C1-Partition is

16

also strongly NP-complete. 3.3.2

Backtracking Algorithm for C1-Partition

In principle, the C1-Partition problem can be formulated and solved as an integer programming problem. However, we will develop a computationally more effective backtracking algorithm that is based on what can be viewed as a bixel decomposition approach. The main idea of this approach is to first find a way of partitioning intensity requirements individually for each bixel. An integer vector pj = (pj1 , . . . , pjL ) provides a bixel decomposition of bixel P j ∈ {1, . . . , n} in the current bixel row b if and only if bj = L`=1 `pj` . We then attempt to form a set of leaf positions that realizes the individual bixel partitions. In order to more effectively conduct our subproblem searches, we describe a property that will hold in some leaf positioning solution (if any exist) that satisfies the given set of bixel decompositions. Lemma 1. Consider candidate bixel decompositions for bixels j and j + 1, for some j ∈ {1, . . . , n − 1}, and suppose that these have a common decomposition intensity value `, i.e., pj` , pj+1,` > 0. Then, if a leaf position solution exists that realizes the given bixel decomposition, a solution exists in which a leaf position having intensity ` exposes both bixels j and j + 1. Proof. Assume that there exists a feasible set of leaf positions V in which bixels j and j + 1 are exposed by two separate leaf positions, each having intensity `. Let these leaf positions be represented by the binary vectors v1 and v2 , respectively. Clearly, we have v1j = 1 and v1,j+1 = 0; similarly, we have v2j = 0 and v2,j+1 = 1. Now consider the leaf position v3 = v1 + v2 with intensity value `. Then the set of leaf positions V 0 = {v3 } ∪ V\{v1 , v2 } is a feasible set of leaf positions that realizes the given bixel decomposition. We next derive a necessary condition that any feasible bixel decomposition has to satisfy so that the corresponding set of leaf positions is compatible with a given allowable intensity set x. Similar to the idea behind Lemma 1, if pj` > pj+1,` , then pj` − pj+1,` leaf positions with intensity ` must expose bixel j but not j + 1. Therefore pj` − pj+1,` copies of the intensity ` cannot be used for decomposing bixels j + 2, . . . , n. Lemma 2 formalizes this idea. 17

Lemma 2. Let x represent an allowable intensity set, and pj and pj+1 denote candidate bixel decompositions for bixels j and j + 1, for some j ∈ {1, . . . , n − 2}. If pj` > pj+1,` , then pj 0 ` ≤ x` − (pj,` − pj+1,` ) for all j 0 ∈ {j + 2, . . . , n}. Proof. By Lemma 1 we may assume without loss of generality that pj` > pj+1,` implies that exactly pj+1,` leaf positions expose bixels j and j + 1 simultaneously. Therefore, exactly pj` − pj+1,` leaf positions having intensity ` must have their right leaf ending at j + 1, and so intensity value ` can be used at most x` − (pj` − pj+1,` ) times in a bixel decomposition of j 0 ∈ {j + 2, . . . , n}. We next describe our backtracking algorithm. In this algorithm, we first enumerate all possible ways of decomposing the bixel intensities in b using a subset of the allowable intensity set given by x. For convenience, we denote the set of all bixel decompositions for bixel j by Pj . Since a bixel decomposition represents a feasible way of satisfying the intensity requirement of a bixel j, we must have p` ≤ x` ∀ ` = 1, . . . , L. The backtracking algorithm for solving the subproblem is stated formally in Algorithm 1. We examine bixel decompositions for each bixel one at a time, from left-to-right. In each iteration, we seek an untried bixel decomposition for the current bixel j ∈ {1, . . . , n} that is compatible with the allowable intensity set and with the active bixel decompositions of bixels 1, . . . , j − 1. If we find such a bixel decomposition, we make that bixel decomposition active for bixel j and invoke Lemma 2 to update the allowable intensity set for bixels j+1, . . . , n. We then move on to bixel j + 1 and repeat the procedure. Otherwise, if we cannot find a feasible bixel decomposition for bixel j given the active bixel decompositions for bixels 1, . . . , j − 1, we return back to bixel j − 1 and move on to its next compatible bixed decomposition. We stop either when we find a feasible bixel decomposition for bixel n, in which case a set of leaf positions to realize the bixel decompositions for bixels 1, . . . , n can be found by invoking Lemma 1, or when we exhaust all bixel decompositions for bixel 1 without finding a feasible solution, in which case the current allowable intensity set is incompatible with the current row. Since Algorithm 1 is a backtracking algorithm, and therefore in the worst case investigates all possible bixel decompositions, it is of exponential time complexity (as expected, due to 18

Algorithm 1 C1-Partition(b, x) INPUT: b {n-dimensional vector representing bixel intensity requirements} INPUT: x {L-dimensional vector representing an allowable intensity set} {This algorithm finds whether there exists a C1-Partition of b that is compatible with x} p`j ← 0, ∀ ` = 1, . . . , L, j = 1, . . . , n {P is an L × n matrix representing the current iterate, where the j th column of P , denoted by pj , represents the current bixel decomposition for bixel j} j ← 1 {index of the current bixel} while j ≥ 1 do x0 ← UpdateAllowableIntensitySet(x, P , j) if there exists an untried p ∈ Pj such that p` ≤ x0` , ∀ ` = 1, . . . , L, then pj ← p if j = n then return true {P represents a feasible solution} else j ←j+1 end if else j ← j − 1 {backtrack} end if end while return false {no feasible solution was found} Algorithm 2 UpdateAllowableIntensitySet(x, P , j) INPUT: x {L-dimensional vector representing allowable intensity set} INPUT: P {L × n matrix representing the current iterate} INPUT: j {index of the current bixel} {This algorithm examines the current iterate and returns an updated allowable intensity set} j 0 ← 1, x0 ← x {updated allowable intensity set} while j 0 < j − 1 do p1 ← pj 0 , p2 ← pj 0 +1 for ` = 1, . . . , L do if p1` > p2` then x0` ← x0` − (p1` − p2` ) end if end for end while return x0 19

Proposition 1). However, the empirical running time of the algorithm can be reduced using the following observations: (i) If two adjacent bixels in a row have the same required intensity value, there must exist an optimal solution in which they are exposed by the same leaf positions. This result can be proven in a similar way as Lemma 1, and is therefore omitted for brevity. This observation implies that we can preprocess the data by merging all adjacent bixels in a bixel row having the same intensity requirement, thereby reducing the dimensionality of the problem instance. (ii) In choosing the next candidate bixel decomposition p ∈ Pj , for j ≥ 2, we select an untried bixel decomposition having the maximum number of decomposition intensity values in common with the current bixel decomposition for bixel j − 1. We break ties in favor of the bixel decomposition of j that uses the largest decomposition intensity. This rule tends to retain the availability of more elements of the allowable intensity set for the remaining bixels, and therefore makes it easier to find a feasible solution (if one exists).

3.4

Valid Inequalities for the Master Problem

The initial optimal solution to the relaxation of (MP) in which none of the inequalities (13) have yet been added to the model will set all variables equal to zero, which is clearly incompatible with all rows. In this section, we derive some characteristics of all feasible solutions and use these to define valid inequalities for (MP). In this way, we attempt to improve the convergence rate of the decomposition algorithm by eliminating some clearly infeasible solutions before the initial execution of the master problem. 3.4.1

Inequalities Based on Beam-on-time and Number of Apertures

Our first observation uses and generalizes the fact that the beam-on-time, number of apertures, and total treatment time, required for the decomposition of any single row into leaf positions provide lower bounds on the minimum beam-on-time, number of apertures, and total treatment time, respectively, needed to deliver the entire fluence map. More generally, 20

consider any set of nonnegative objective weights w10 and w20 in place of w1 and w2 in (9), and let Ti (w10 , w20 ) be the minimum value of the objective with respect to these weights over all decompositions for row i only. Then the following are valid inequalities for (MP): w10

L X

x` +

`=1

w20

L X

`x` ≥ Ti (w10 , w20 ) ∀ i = 1, . . . , m.

(14)

`=1

We formulate an integer programming model to determine Ti (w10 , w20 ) for a given row i. First, denote the set of possible leaf positions for that row by K, and define n-dimensional binary vectors vk for k ∈ K (where |K| = O(n2 )), such that vkj = 1 if and only if bixel j is exposed by leaf position k. In addition to decision variables x` as in (MP), define binary decision variables zk` , ∀ k ∈ K, ` = 1, . . . , Lk , where Lk = minj:vkj =1 bj is an upper bound on the intensity of leaf position k, such that zk` = 1 if and only if leaf position k is used with intensity `. Then, Ti (w10 , w20 ) is the optimal objective function value of minimize

w10

L X

x` +

`=1

w20

L X

`x`

`=1

subject to

(SR) 

X k∈K



k

vjk

L X

∀ j = 1, . . . , n

(15)

zk` ≤ 1

∀k∈K

(16)

zk` = x`

∀ ` = 1, . . . , L

(17)

zk` ∈ {0, 1}

∀ k ∈ K, ` = 1, . . . , Lk

x` ≥ 0 and integer

∀ ` = 1, . . . , Lk .

`zk`  = bj

`=1 k

L X `=1

X k∈K:Lk ≤`

Constraints (15) ensure that each bixel receives exactly its required amount of dose while constraints (16) guarantee that each leaf position is either not used or is assigned to a single intensity value. Finally, constraints (17) relate the x- and z-variables. A practical difficulty in implementing the valid inequalities of the form (14) is that we must determine appropriate values for the weights w10 and w20 . However, Baatar [2] shows that, when decomposing a single beamlet row, there exists a set of leaf positions 21

that simultaneously minimizes both beam-on-time and the number of apertures. If we let Ni = Ti (1, 0) represent the minimum number of apertures for row i, and z˜i = Ti (0, 1) represent the minimum beam-on-time for row i, this implies that Ti (w10 , w20 ) = w10 Ni + w20 z˜i , so that we can replace (14) by w10

L X

x` +

`=1

w20

L X

`x` ≥ w10 Ni + w20 z˜i

∀ i = 1, . . . , m.

`=1

It is easy to see that we can capture all of these valid inequalities by restricting ourselves to the coefficient pairs (w10 , w20 ) = (1, 0) and (0, 1) only: L X

x` ≥

`=1 L X

`x` ≥

`=1

max {Ni }

i=1,...,m

max {˜ zi }.

i=1,...,m

We can generalize this idea as follows. Let R(L) denote the set of rows for which the maximum intensity requirement is bounded by L for some L ∈ {1, . . . , L}, i.e., R(L) = {i ∈ {1, . . . , m} : Li ≤ L}. Since intensity values greater than L cannot be used in decomposing the rows in R(L), a similar approach to the one above can be used to derive the following family of valid inequalities L X

x` ≥

`=1 L X `=1

`x` ≥

max {Ni } ∀ L = 1, . . . , L

(18)

max {˜ zi }

(19)

i∈R(L)

∀ L = 1, . . . , L.

i∈R(L)

Finally, since the minimum beam-on-time decomposition problem is polynomially solvable as we discuss in Section 1, this means that we only need to solve problems of the form (SP) with (w10 , w20 ) = (1, 0). 3.4.2

Inequalities Based on Bixel Subsequences

Recall that (11)–(13) represent necessary conditions for feasibility of an allowable intensity set with respect to a particular row. It is possible to develop stronger necessary conditions if we examine subsequences of a row, i.e., a subset of the required intensity values in a row that 22

preserves their order in the fluence map. First, Lemma 3 shows that, if a given allowable intensity set is incompatible with a subsequence s of row i, then it also must be incompatible with row i. Lemma 3. Consider an allowable intensity set x, an n-dimensional vector b that represents the intensity requirements of the bixels in a particular bixel row, and an n0 -dimensional vector s = (bj1 , . . . , bjn0 ), where 1 ≤ j1 < · · · < jk < jk+1 < · · · jn0 ≤ n. If x is not compatible with s, then it is also not compatible with b. Proof. We prove the equivalent statement that if x is compatible with b, then it is also compatible with s. Assume that x is compatible with b. By definition, there then exists a bixel decomposition for each bixel j = 1, . . . , n so that the resulting set of leaf positions is compatible with x. But then the bixel decompositions corresponding to only the bixels in s is compatible with x, since the order of the bixels in s is the same as that in b. Now, note that we can invoke Lemma 3 to associate a subproblem for any subsequence of a bixel row b. Each of these subproblems can then be used to generate cutting planes of the form (13), as well as valid inequalities of the form (18) and (19). We propose to form subsequences of bixel rows by, for L = 1, . . . , L, considering only those bixels having required intensity less than or equal to L. Even though this causes the number of subproblems to be considered to increase from O(m) to O(mL), our computational results will show that this increase is justified by generation of much stronger cutting planes, which results in faster convergence of the decomposition algorithm.

3.5

Algorithmic Enhancements for the Master Problem

Our computational studies revealed that the master problem solution represents the bottleneck operation of our algorithm. In this section we discuss two avenues for reducing the time consumed in solving the master problem. The first idea is to interrupt the branch-andbound solution process of the master problem every time it finds an integer solution, and check whether the corresponding allowable intensity set is compatible with all rows. If all subproblems are feasible, then we identify the current solution as a candidate incumbent solution and resume solving the master problem. Otherwise, if at least one of the subproblems 23

is infeasible, then we generate a constraint of the form (13) and re-solve the master problem. This approach can be computationally more efficient than solving the master problem to optimality in each iteration, and it also allows us to obtain good feasible solutions for problem instances that are too difficult to solve to optimality. Additionally, suppose that an integer solution x ˆ is found during the branch-and-bound solution of the master problem that turns out to be infeasible to some subproblem. Rather than adding a cut and continuing as before, we can execute a heuristic procedure that attempts to find another integer solution x ¯ with an objective function value no more than that of x ˆ. In doing so, we hope to either aggressively seek an improved upper bound, or quickly determine valid inequalities that may ultimately be necessary to solve the problem. Assume that x ˆ has been found to be incompatible with subproblem i, having maximum intensity value Li , and a constraint of type (13) has been generated. Consider a vector x ¯, which is formed by removing a single intensity value from index `− in x ˆ and replacing it at index `+ , 1 ≤ `+ < `− . That is, x ¯ = [ˆ x1 , . . . , (ˆ x`+ + 1), . . . , (ˆ x`− − 1), . . . , xˆL ]. (We need to have xˆ`− ≥ 1 and xˆ`+ < R` in order for x ¯ to represent an allowable intensity set, and `+ ≤ Li so that x ¯ satisfies the new constraint.) Note that the objective function value of x ¯ is no more than that of x ˆ, since they contain the same number of apertures, but since the beam-on-time corresponding to x ¯ is (`− − `+ ) units smaller than that of x ˆ. We check to see if x ¯ satisfies each inequality of the form (13), (18), and (19); if so, then the heuristic successfully returns the solution x ¯. We use the local search heuristic within our decomposition framework as follows. After we obtain an integer solution from the master problem that is not feasible for a subproblem, we generate a cut (13) as usual and invoke the local search heuristic to find another integer feasible solution to the master problem. If we find one, we check the feasibility of the new solution with respect to the subproblems. If feasible, this solution becomes a new incumbent candidate, and if not, we add a cut, execute the local search heuristic again, and reiterate in this fashion. If the heuristic fails at some point, or provides a feasible solution, we add all accumulated cuts to the master problem at once and solve the master problem to get another solution.

24

4

Computational Results and Comparisons

We have implemented our decomposition algorithm using CPLEX 10.1 [11] running on a Windows XP PC with a 3.4 GHz CPU and 2 GB RAM. Our base set of test problem instances consists of 25 clinical problem instances (“case1beam1”, . . . , “case5beam5”). These instances were obtained from treatment plans for five patients treated using five beam angles each. However, since these problem instances are generally too large to be solvable by the integer programming model from Langer et al. [21] and its modification described in Section 2, we mainly test the performance of the latter models on 11 randomly generated problems (“test3x3”, . . . , “test6x7b”). We will report the problem characteristics in terms of matrix dimensions m and n, as well as the maximum intensity value L. However, since the maximum intensity value is L = 20 for all clinical instances, we will omit this information in tables containing results on clinical instances only. Unless otherwise specified, we have used the following weights for the number of apertures and beam-on-time in the objective function: w1 = 7 and w2 = 1 . In our base algorithm, we use the valid inequalities (18)–(19), the subsequence inequalities described in Section 3.4.2, and the algorithmic enhancements discussed in Section 3.5. We also use Engel’s heuristic [8], which executes in well under one CPU second for each instance, to obtain an initial upper bound. Our first experiment compares our base algorithm to that of Langer et al. [21] and to the modification of their model described in Section 2. We chose randomly generated test instances of various dimensions in order to see the problem sizes that can be solved by each algorithm, and three of the smallest clinical instances to compare effectiveness of the algorithms on real clinical instances. We imposed a one-hour (3600 second) time limit past which we halted the execution of an algorithm. For these experiments, we disabled the use of Engel’s algorithm as an initial heuristic to test the ability of these models to efficiently find good-quality upper bounds. Table 1 summarizes the results of these three algorithms in terms of the execution time and the best upper and lower bounds found within the time limit. Our decomposition algorithm can solve all instances in this data set within a few seconds, where the largest instance

25

that can be solved by either integer programming formulation within an hour has dimensions 5×5. While the modified version of the model from Langer et al. [21] improves the best lower bound attained in every instance that could not be solved within one hour, it substantially increases the computational time required to solve test5x5a and test5x5b. Moreover, neither integer programming model provides a tight bound on the optimal solution for all of the clinical cases. We conclude that even though the integer programming formulation given in [21] can solve small instances to optimality, it cannot be used to exactly solve real problem instances. Decomposition Algorithm

Langer

Modified Langer

Name

m

n

L

Time

Optimal

Time

UB

LB

Time

UB

LB

test3x3

3

3

8

0.3

29

1.0

29

29.00

1.0

29

29.00

test3x4

3

4

8

0.2

37

2.2

37

37.00

1.5

37

37.00

test4x4

4

4

8

0.3

36

21.1

36

36.00

17.3

36

36.00

test5x5a

5

5

10

0.4

45

210.4

45

45.00

2061.9

45

45.00

test5x5b

5

5

15

1.1

50

102.8

50

50.00

3038.3

50

50.00

test5x6a

5

6

10

0.7

55

3600

55

32.31

3600

61

34.22

test5x6b

5

6

18

3.2

71

3600

84

46.00

3600

77

53.22

test6x6a

6

6

13

1.3

51

3600

55

41.73

3600

55

44.00

test6x6b

6

6

13

1.0

52

3600

64

37.80

3600

58

40.13

test6x7a

7

6

10

0.5

45

3600

45

38.50

3600

45

42.39

test6x7b

6

7

15

5.5

74

3600

96

32.97

3600

94

43.17

case1beam1

15

14

20

7.5

111

3600

210

37.38

3600

314

42.00

case1beam2

11

15

20

3.9

104

3600

182

37.00

3600

167

42.14

case1beam5

11

15

20

19.6

104

3600

∞

34.24

3600

195

46.16

Table 1: Comparison of Our Base Algorithm with Langer et al.’s Model Recall from Section 1 that, in clinical practice, we can deliver each fluence map using a decomposition into either row-convex or column-convex apertures, where the latter requires rotation of the MLC head. We therefore next show the results of applying our decomposition algorithm to decompose each of the 25 clinical fluence maps into (i) row-convex apertures, and (ii) column-convex apertures, where the latter is achieved by applying it to the transpose of each fluence map. Table 2 reports the results obtained with an upper bound on the CPU 26

Row-Convex

Column-Convex

Name

m

n

Engel

UB

LB

Time

Engel

UB

LB

Time

case1beam1

15

14

124

111

111

7.5

122

108

108

1.2

case1beam2

11

15

111

104

104

3.9

79

79

79

0.4

case1beam3

15

15

115

108

108

601.5

98

91

91

0.6

case1beam4

15

15

117

110

110

1446

114

114

114

20.0

case1beam5

11

15

111

104

104

19.6

89

87

87

11.5

case2beam1

18

20

146

132

132

34.2

114

107

107

1.9

case2beam2

17

19

139

132

132

73.7

117

110

110

3.5

case2beam3

18

18

154

140

140

71.9

112

105

105

1.5

case2beam4

18

18

156

149

149

876.0

118

118

118

2.0

case2beam5

17

18

137

133

123

1800

104

97

97

1.7

case3beam1

22

17

146

132

125

1800

145

138

138

3.8

case3beam2

15

19

151

151

130

1800

86

79

79

1.3

case3beam3

20

17

154

141

133

1800

138

131

124

1800

case3beam4

19

17

141

138

127

1800

136

129

122

1800

case3beam5

15

19

125

125

125

2.6

90

90

90

1.8

case4beam1

19

22

159

152

152

896.3

144

130

130

6.7

case4beam2

13

24

195

195

174

1800

97

90

90

1013.3

case4beam3

18

23

151

146

130

1800

109

102

102

1.1

case4beam4

17

23

154

147

140

1800

103

97

97

83.9

case4beam5

12

24

206

206

178

1800

87

87

87

65.0

case5beam1

15

16

110

96

96

1.0

112

105

105

0.4

case5beam2

13

17

132

125

125

477.6

86

81

81

1.6

case5beam3

14

16

125

104

104

12.2

93

86

86

1.2

case5beam4

14

16

138

124

124

6.5

109

102

102

10.1

case5beam5

12

17

135

130

121

1800

94

87

87

3.7

Table 2: Effect of Rotating the MLC Head

27

time of 30 minutes for each instance. In particular, the table shows the objective function value of the initial solution found by Engel’s heuristic, the best upper and lower bounds obtained, as well as the CPU time used. We observe that even though the heuristic fails to find an optimal solution in most cases, it is able to find good solutions very quickly. Our algorithm finds an optimal solution to several instances within a few seconds, and provides tight bounds for most instances that it cannot solve to optimality. Comparing the bounds obtained for row-convex and column-convex decompositions, we observe that rotating the MLC head is beneficial (i.e., yields a shorter treatment time) in most instances. This is especially true for the instances in which the number of rows is much smaller than the number of columns, such as case4beam2 and case4beam5, where rotating the MLC head can result in more than 50% reduction in total treatment time. We also note that several problem instances require much less computational time to solve for a column-convex decomposition compared to a row-convex decomposition. Rather than solving both the row-convex and column-convex problems to optimality and choosing the best solution, we can modify the algorithm to directly solve for the best orientation by using obtained upper and lower bounds to quickly prove whether rotating the MLC head is beneficial. Assume that we have lower and upper bounds for the row-convex and column-convex problems, and without loss of generality assume that the lower bound of the row-convex problem is greater than the upper bound of the column-convex problem. In this case, we can conclude that an optimal solution minimizing total treatment time for the given fluence map must be a column-convex decomposition. We use this argument to solve one of the problems, and then use the bound information to avoid having to solve the other one to optimality. We pick the first problem to solve by selecting one having the least initial lower bound, breaking ties if applicable by choosing the problem for which n < m, since the subproblems tend to solve faster for smaller values of n. Table 3 shows the result of our algorithm enhanced with the bounding scheme in the set of columns labeled “Total Time,” to highlight that we minimize total treatment time. Table 3 also illustrates the performance of our algorithm when applied to the problem of minimizing the number of apertures by setting w1 = 1 and w2 = 0 (“# Apertures”), and the problem of minimizing the number of apertures while constraining the beam-on-time to 28

# Apertures Total Time

# Apertures

s.t. min BOT

Name

UB

LB

Aper

BOT

Time

UB

LB

BOT

Time

UB

LB

BOT

Time

case1beam1

108

108

10

38

2.5

10

10

38

2.8

10

10

38

8.6

case1beam2

79

79

8

23

1.2

8

8

23

1.1

8

8

23

1.0

case1beam3

91

91

9

28

2

9

9

28

1.7

9

9

28

1.6

case1beam4

110

110

11

33

1464

11

10

37

1800

11

11

33

99

case1beam5

87

87

8

31

12.0

8

8

32

1.1

9

9

26

2.5

case2beam1

107

107

11

30

4.6

11

11

33

4.6

11

11

30

8.7

case2beam2

110

110

11

33

4.8

11

11

34

4.0

11

11

33

3.9

case2beam3

105

105

11

28

5.2

11

11

29

4.9

11

11

28

4.8

case2beam4

118

118

12

34

34

12

12

34

34.4

12

12

34

5.9

case2beam5

97

97

10

27

4

10

10

27

11

10

10

27

4

case3beam1

132

125

13

41

1800

13

12

51

1800

13

12

41

1800

case3beam2

79

79

8

23

3

8

8

26

3

8

8

23

3

case3beam3

131

124

13

40

1800

12

12

53

627

12

12

40

54

case3beam4

129

122

13

38

1800

13

12

47

1800

13

12

38

1800

case3beam5

90

90

9

27

4.1

9

9

27

4.0

9

9

27

4.3

case4beam1

130

130

12

46

10.2

12

12

46

6.2

12

12

46

7.5

case4beam2

90

90

9

27

1157

9

8

31

1800

9

9

27

36

case4beam3

102

102

10

32

15

10

10

33

99

10

10

32

6

case4beam4

97

97

10

27

268

10

10

28

227

11

11

26

192

case4beam5

87

87

9

24

87

9

9

24

83

9

9

24

8

case5beam1

96

96

10

26

1.4

10

10

37

1.6

10

10

26

1.4

case5beam2

81

81

8

25

2

8

8

30

1.0

9

9

23

1.8

case5beam3

86

86

9

23

2.6

9

9

24

3.0

9

9

23

2.6

case5beam4

102

102

10

32

11.9

10

10

35

15.6

10

10

32

17.8

case5beam5

87

87

8

31

4

8

8

33

1.5

8

8

31

1.4

Table 3: Computational Results for Our Base Algorithm

29

be minimal (“# Apertures s.t. min BOT”). For each of these models, UB and LB represent bounds on the objective function, while BOT and Aper represent the beam-on-time and the number of apertures associated with the best solution found. Since the third model we consider minimizes the number of apertures given the minimum beam-on-time, the BOT column in “# Apertures s.t. min BOT” is in fact the minimum achievable beam-on-time for each instance. Similarly, the UB column under the objective “# Apertures” shows the least known number of apertures needed to decompose each instance. Perhaps surprisingly, in comparing these values with the results of “Total Time,” we observe that there exists a solution that minimizes both the number of shapes and the beam-on-time simultaneously in 18 of the 21 instances for which optimal solutions to all three were found (noting that the minimum total time for case3beam3 is indeed 124, as implied by the results from the “# Apertures” and “# Apertures s.t. min BOT” columns). As a final experiment, we investigate the impact of several implementation strategies that are present in our base model. In particular, in Table 4 we illustrate the performance of our algorithm when (i) omitting the initial impact of Engel’s heuristic (“w/o Engel”), (ii) omitting the subsequence cuts discussed in Section 3.4.2 (“w/o Subsequences”), (iii) skipping the local search heuristic (“w/o Local Search”), and (iv) solving the master problem to optimality in each iteration without generating cuts when integer feasible solutions are found (“w/o Alg Enhance”). Note that the local search heuristic is not applicable when the master problem is solved to optimality, and therefore we have also disabled the local search heuristic for the last test. A comparison of the results in Table 4 with the group of columns under “Total Time” in Table 3 reveals that having the initial feasible solution obtained from Engel’s algorithm does not have a significant effect on the solution time, with the notable exception of case1beam4. This is not a surprising result given the observation that our algorithm usually finds an optimal solution within a few seconds, and then spends the remainder of the time proving optimality. Next, the omission of subsequence cuts significantly increases the computational time required to solve many instances, with the exception of case3beam3. Incidentally, and surprisingly, the base algorithm without subsequence cuts is the only variation of the algorithm tested that solved case3beam3 to optimality. However, the computational results 30

w/o Engel

w/o Subsequences

w/o Local Search

w/o Alg Enhance

Name

UB

LB

Time

UB

LB

Time

UB

LB

Time

UB

LB

Time

case1beam1

108

108

2.9

108

108

112.2

108

108

10.1

108

108

35.7

case1beam2

79

79

1.2

79

79

1.6

79

79

1.1

79

79

1.2

case1beam3

91

91

2

91

91

1.7

91

91

2.0

91

91

1.9

case1beam4

110

103

1800

111

103

1800

110

103

1800

114

105

1800

case1beam5

87

87

10.8

87

87

728.8

87

87

23.5

87

87

63.6

case2beam1

107

107

6.2

107

107

18.0

107

107

12.3

107

107

12.5

case2beam2

110

110

4.9

110

110

25.0

110

110

6.1

110

110

13.6

case2beam3

105

105

5.2

105

105

6.7

105

105

5.3

105

105

6.2

case2beam4

118

118

6

118

118

35.1

118

118

34.1

118

118

34.4

case2beam5

97

97

6

97

97

3

97

97

4

97

97

4

case3beam1

132

125

1800

132

125

1800

132

125

1800

138

125

1800

case3beam2

79

79

3

79

79

3

79

79

3

79

79

4

case3beam3

131

124

1800

124

124

1502

131

124

1800

138

124

1800

case3beam4

132

122

1800

129

122

1800

130

122

1800

136

122

1800

case3beam5

90

90

5.0

90

90

5.8

90

90

4.2

90

90

4.3

case4beam1

130

130

20.3

130

130

267

130

130

23

130

130

18.5

case4beam2

90

90

1249

90

83

1800

90

83

1800

97

86

1800

case4beam3

102

102

6

102

102

16

102

102

15

102

102

15

case4beam4

97

97

257

97

97

504

97

97

298

97

97

590

case4beam5

87

87

67

87

87

311

87

87

126

87

87

281

case5beam1

96

96

1.4

96

96

3.5

96

96

1.7

96

96

1.1

case5beam2

81

81

3

81

81

1.8

81

81

2.6

81

81

4.2

case5beam3

86

86

2.6

86

86

5.4

86

86

2.9

86

86

3.2

case5beam4

102

102

11.4

102

102

16.5

102

102

323.8

102

102

47.6

case5beam5

87

87

2

87

87

6.2

87

87

1.6

87

87

1.8

Table 4: Effect of Implementation Strategies

31

as a whole clearly support the use of subsequence inequalities. Third, disabling the local search heuristic described in Section 3.5 yields a slight-to-modest increase in computational times in some instances, and a substantial increase in others, failing to solve case1beam4 and case4beam2 within the computational limit. Finally, observe that solving the master problem to optimality in each iteration, rather than generating cuts based on intermediate feasible solutions found in the master problem branch-and-bound tree, results in almost uniformly larger solution times. This is particularly true for case1beam4 and case4beam2, which do not solve to optimality under this algorithmic variation.

5

Conclusions and Future Research

In this paper we have described an exact decomposition algorithm for solving a leaf sequencing problem arising in IMRT treatment planning. Our algorithm is based on an integer programming model for finding a set of intensity values to be assigned to apertures, and a backtracking algorithm that forms apertures by finding compatible leaf positions for each row. Computational results show that an optimal solution to many clinical problem instances can be found within a few minutes, and good bounds can be obtained on others within a half-hour. Our algorithm is flexible enough to handle a class of related problems with minor modifications, and is capable of quantifying the effect of rotating the MLC head. As such, not only can this algorithm reasonably be used in real clinical settings, the bounds obtained from our algorithm can serve as benchmark criteria to compare the performance of heuristic methods. The algorithm we have described assumes that leaves corresponding to different rows can be positioned independently, and exploits this assumption to decompose the problem by rows. Therefore, it is not directly applicable for problems in which there are other restrictions on aperture shapes that can be delivered by the available machinery, such as interdigitation or connectedness constraints. We are planning to conduct further research in order to generalize our algorithm to account for such additional technological constraints on the aperture shapes.

32

References [1] R. K. Ahuja and H. W. Hamacher. A network flow algorithm to minimize beam-on-time for unconstrained multileaf collimator problems in cancer radiation therapy. Networks, 45(1):36–41, 2005. [2] D. Baatar. Matrix Decomposition with Time and Cardinality Objectives: Theory, Algorithms, and Application to Multileaf Collimator Sequencing. PhD thesis, Department of Mathematics, Technische Universit¨at Kaiserslautern, Kaiserslautern, Germany, 2005. [3] D. Baatar, H. W. Hamacher, M. Ehrgott, and G. J. Woeginger. Decomposition of integer matrices and multileaf collimator sequencing. Discrete Applied Mathematics, 152(1):6–34, 2005. [4] N. Boland, H. W. Hamacher, and F. Lenzen. Minimizing beam-on time in cancer radiation treatment using multileaf collimators. Networks, 43(4):226–240, 2004. [5] T. R. Bortfeld, D. L. Kahler, T. J. Waldron, and A. L. Boyer. X-ray field compensation with multileaf collimators. International Journal of Radiation Oncology Biology Physics, 28(3):723–730, 1994. [6] J. Dai and Y. Zhu. Minimizing the number of segments in a delivery sequence for intensity-modulated radiation therapy with a multileaf collimator. Medical Physics, 28(10):2113–2120, 2001. [7] M. Ehrgott, H. W. Hamacher, and M. Nußbaum. Decomposition of matrices and static multileaf collimators: A survey. Technical report, Technische Universit¨at Kaiserslautern, Kaiserslautern, Germany, 2006. [8] K. Engel. A new algorithm for optimal multileaf collimator field segmentation. Discrete Applied Mathematics, 152(1):35–51, 2005. [9] M. R. Garey and D. S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman & Co., New York, New York, 1979.

33

[10] H. W. Hamacher and K.-H. K¨ ufer. Inverse radiation therapy planning – a multiple objective optimization approach. Discrete Applied Mathematics, 118(1):145–161, 2002. [11] ILOG. CPLEX 10.1 User’s Manual. ILOG Inc, 2006. [12] T. Kalinowski. The algorithmic complexity of the minimization of the number of segments in multileaf collimator field segmentation. Technical report, Fachbereich Mathematik, Universit¨at Rostock, Rostock, Germany, August 2004. [13] T. Kalinowski. A duality based algorithm for multileaf collimator field segmentation with interleaf collision constraint. Discrete Applied Mathematics, 152(1):52–88, 2005. [14] T. Kalinowski. Reducing the number of monitor units in multileaf collimator field segmentation. Physics in Medicine and Biology, 50(6):1147–1161, 2005. [15] S. Kamath, S. Sahni, J. Li, J. Palta, and S. Ranka. Leaf sequencing algorithms for segmented multileaf collimation. Physics in Medicine and Biology, 48(3):307–324, 2003. [16] S. Kamath, S. Sahni, J. Palta, and S. Ranka. Algorithms for optimal sequencing of dynamic multileaf collimators. Physics in Medicine and Biology, 49(1):33–54, 2004. [17] S. Kamath, S. Sahni, J. Palta, S. Ranka, and J. Li. Optimal leaf sequencing with elimination of tongue-and-groove underdosage. Physics in Medicine and Biology, 49(3):N7–N19, 2004. [18] S. Kamath, S. Sahni, S. Ranka, J. Li, and J. Palta. A comparison of step-and-shoot leaf sequencing algorithms that eliminate tongue-and-groove effects. Physics in Medicine and Biology, 49(14):3137–3143, 2004. [19] S. Kamath, S. Sahni, S. Ranka, J. Li, and J. Palta. Optimal field splitting for large intensity-modulated fields. Medical Physics, 31(12):3314–3323, 2004. [20] K.-H. K¨ ufer, M. Monz, A. Scherrer, H. L. Trinkaus, T. Bortfeld, and C. Thieke. Intensity Modulated Radiotherapy - a large scale multi-criteria programming problem. OR Spektrum, 25:223–249, 2003.

34

[21] M. Langer, V. Thai, and L. Papiez. Improved leaf sequencing reduces segments or monitor units needed to deliver IMRT using multileaf collimators. Medical Physics, 28(12):2450–2458, 2001. [22] E. K. Lee, T. Fox, and I. Crocker. Optimization of radiosurgery treatment planning via mixed integer programming. Medical Physics, 27(5):995–1004, 2000. [23] E. K. Lee, T. Fox, and I. Crocker. Integer programming applied to intensity-modulated radiation treatment planning. Annals of Operations Research, 119:165–181, 2003. [24] F. Lenzen. An integer programming approach to the multileaf collimator problem. Master’s thesis, University of Kaiserslautern, Department of Mathematics, Kaiserslautern, Germany, June 2000. [25] G. J. Lim and J. Choi. A two-stage integer programming approach for optimizing leaf sequence in IMRT. Technical report, Department of Industrial Engineering, University of Houston, Houston, Texas, 2006. [26] F. Preciado-Walters, R. Rardin, M. Langer, and V. Thai. A coupled column generation, mixed integer approach to optimal planning of intensity modulated radiation therapy for cancer. Mathematical Programming, 101(2):319–338, 2004. [27] W. Que. Comparison of algorithms for multileaf collimator field segmentation. Medical Physics, 26(11):2390–2396, 1999. [28] H. E. Romeijn, R. K. Ahuja, J. F. Dempsey, and A. Kumar. A column generation approach to radiation therapy treatment planning using aperture modulation. SIAM Journal on Optimization, 15(3):838–862, 2005. [29] H. E. Romeijn, R. K. Ahuja, J. F. Dempsey, and A. Kumar. A new linear programming approach to radiation therapy treatment planning problems. Operations Research, 54(2):201–216, 2006. [30] D. M. Shepard, M. C. Ferris, G. H. Olivera, and T. R. Mackie. Optimizing the delivery of radiation therapy to cancer patients. SIAM Review, 41(4):721–744, 1999. 35

[31] H. D. Sherali and J. C. Smith. Improving zero-one model representations via symmetry considerations. Management Science, 47(10):1396–1407, 2001. [32] R. A. C. Siochi. Minimizing static intensity modulation delivery time using an intensity solid paradigm. International Journal of Radiation Oncology Biology Physics, 43(3):671– 680, 1999. [33] A. M. Stell, O. A. Zeidan, J. G. Li, and J. F. Dempsey. An extensive log-file analysis of step-and-shoot IMRT subfield delivery errors. International Journal of Radiation Oncology Biology Physics, 31(6):1593–1602, 2004. [34] P. Xia and L. J. Verhey. Multileaf collimator leaf sequencing algorithm for intensity modulated beams with multiple static segments. Medical Physics, 25(8):1424–1434, 1998.

36