![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\" "\\"Open"){kind=icon}
![\"Download\"](\"https://img.shields.io/badge/Github-Download-blue.svg\" "\\"Download"){kind=icon}
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Scheduling State-Task Networks"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example (Kondili, et al., 1993)\n",
"\n",
"A state-task network is a graphical representation of the activities in a multiproduct batch process. The representation includes the minimum details needed for short term scheduling of batch operations.\n",
"\n",
"Shown below is a well-studied example due to Kondili (1993). Other examples are available in the references cited above.\n",
"\n",
"\n",
"\n",
"Each circular node in the diagram designates material in a particular state. The materials are generally held in suitable vessels with a known capacity. The relevant information for each state is the initial inventory, storage capacity, and the unit price of the material in that state. The price of materials in intermediate states may be assigned penalities in order to minimize the amount of work in progress.\n",
"\n",
"The rectangular nodes denote process tasks. When scheduled for execution, each task is assigned an appropriate piece of equipment, and assigned a batch of material according to the incoming arcs. Each incoming arc begins at a state where the associated label indicates the mass fraction of the batch coming from that particular state. Outgoing arcs indicate the disposition of the batch to product states. The outgoing are labels indicate the fraction of the batch assigned to each product state, and the time necessary to produce that product. \n",
"\n",
"Not shown in the diagram is the process equipment used to execute the tasks. A separate list of process units is available, each characterized by a capacity and list of tasks which can be performed in that unit."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Encoding the STN data\n",
"\n",
"The basic data structure specifies the states, tasks, and units comprising a state-task network. The intention is for all relevant problem data to be contained in a single JSON-like structure."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [],
"source": [
"H = 12\n",
"\n",
"Kondili = {\n",
" 'TIME': range(0,H+1),\n",
" 'STATES': {\n",
" 'Feed_A' : {'capacity': 500, 'initial': 500, 'price': 0},\n",
" 'Feed_B' : {'capacity': 500, 'initial': 500, 'price': 0},\n",
" 'Feed_C' : {'capacity': 500, 'initial': 500, 'price': 0},\n",
" 'Hot_A' : {'capacity': 100, 'initial': 0, 'price': -1},\n",
" 'Int_AB' : {'capacity': 200, 'initial': 0, 'price': -10},\n",
" 'Int_BC' : {'capacity': 150, 'initial': 0, 'price': -1},\n",
" 'Impure_E' : {'capacity': 100, 'initial': 0, 'price': -1},\n",
" 'Product_1': {'capacity': 500, 'initial': 0, 'price': 10},\n",
" 'Product_2': {'capacity': 500, 'initial': 0, 'price': 10},\n",
" },\n",
" 'ST_ARCS': {\n",
" ('Feed_A', 'Heating') : {'rho': 1.0},\n",
" ('Feed_B', 'Reaction_1'): {'rho': 0.5},\n",
" ('Feed_C', 'Reaction_1'): {'rho': 0.5},\n",
" ('Feed_C', 'Reaction_3'): {'rho': 0.2},\n",
" ('Hot_A', 'Reaction_2'): {'rho': 0.4},\n",
" ('Int_AB', 'Reaction_3'): {'rho': 0.8},\n",
" ('Int_BC', 'Reaction_2'): {'rho': 0.6},\n",
" ('Impure_E', 'Separation'): {'rho': 1.0},\n",
" },\n",
" 'TS_ARCS': {\n",
" ('Heating', 'Hot_A') : {'dur': 1, 'rho': 1.0},\n",
" ('Reaction_2', 'Product_1'): {'dur': 2, 'rho': 0.4},\n",
" ('Reaction_2', 'Int_AB') : {'dur': 2, 'rho': 0.6},\n",
" ('Reaction_1', 'Int_BC') : {'dur': 2, 'rho': 1.0},\n",
" ('Reaction_3', 'Impure_E') : {'dur': 1, 'rho': 1.0},\n",
" ('Separation', 'Int_AB') : {'dur': 2, 'rho': 0.1},\n",
" ('Separation', 'Product_2'): {'dur': 1, 'rho': 0.9},\n",
" },\n",
" 'UNIT_TASKS': {\n",
" ('Heater', 'Heating') : {'Bmin': 0, 'Bmax': 100, 'Cost': 1, 'vCost': 0, 'Tclean': 0},\n",
" ('Reactor_1', 'Reaction_1'): {'Bmin': 0, 'Bmax': 80, 'Cost': 1, 'vCost': 0, 'Tclean': 0},\n",
" ('Reactor_1', 'Reaction_2'): {'Bmin': 0, 'Bmax': 80, 'Cost': 1, 'vCost': 0, 'Tclean': 0},\n",
" ('Reactor_1', 'Reaction_3'): {'Bmin': 0, 'Bmax': 80, 'Cost': 1, 'vCost': 0, 'Tclean': 0},\n",
" ('Reactor_2', 'Reaction_1'): {'Bmin': 0, 'Bmax': 80, 'Cost': 1, 'vCost': 0, 'Tclean': 0},\n",
" ('Reactor_2', 'Reaction_2'): {'Bmin': 0, 'Bmax': 80, 'Cost': 1, 'vCost': 0, 'Tclean': 0},\n",
" ('Reactor_2', 'Reaction_3'): {'Bmin': 0, 'Bmax': 80, 'Cost': 1, 'vCost': 0, 'Tclean': 0},\n",
" ('Reactor_3', 'Reaction_1'): {'Bmin': 0, 'Bmax': 120, 'Cost': 1, 'vCost': 0, 'Tclean': 0},\n",
" ('Reactor_3', 'Reaction_2'): {'Bmin': 0, 'Bmax': 120, 'Cost': 1, 'vCost': 0, 'Tclean': 0},\n",
" ('Reactor_3', 'Reaction_3'): {'Bmin': 0, 'Bmax': 120, 'Cost': 1, 'vCost': 0, 'Tclean': 0},\n",
" ('Still', 'Separation'): {'Bmin': 0, 'Bmax': 200, 'Cost': 1, 'vCost': 0, 'Tclean': 0},\n",
" },\n",
"}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Setting a Time Grid\n",
"\n",
"The following computations can be done on any time grid, including real-valued time points. TIME is a list of time points commencing at 0."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Creating a Pyomo Model\n",
"\n",
"The following Pyomo model closely follows the development in Kondili, et al. (1993). In particular, the first step in the model is to process the STN data to create sets as given in Kondili. Two differences from Kondili are: \n",
"\n",
"* a natural time scale commencing at $t = 0$ and extending to $t = H$ (rather than from 1 to H+1).\n",
"* an additional decision variable denoted by $Q_{j,t}$ indicating the amount of material in unit $j$ at time $t$. A material balance then reads\n",
"\n",
"\\begin{align*}\n",
"Q_{jt} & = Q_{j(t-1)} + \\sum_{i\\in I_j}B_{ijt} - \\sum_{i\\in I_j}\\sum_{\\substack{s \\in \\bar{S}_i\\\\s\\ni t-P_{is} \\geq 0}}\\bar{\\rho}_{is}B_{ij(t-P_{is})} \\qquad \\forall j,t\n",
"\\end{align*}\n",
"\n",
"Following Kondili's notation, $I_j$ is the set of tasks that can be performed in unit $j$, and $\\bar{S}_i$ is the set of states fed by task $j$. We assume the units are empty at the beginning and end of production period, i.e.,\n",
"\n",
"\\begin{align*}\n",
"Q_{j(-1)} & = 0 \\qquad \\forall j \\\\\n",
"Q_{j,H} & = 0 \\qquad \\forall j\n",
"\\end{align*}\n",
"\n",
"The unit allocation constraints are written the full backward aggregation method described by Shah (1993). The allocation constraint reads\n",
"\n",
"\\begin{align*}\n",
"\\sum_{i \\in I_j} \\sum_{t'=t}^{t-p_i+1} W_{ijt'} & \\leq 1 \\qquad \\forall j,t\n",
"\\end{align*}\n",
"\n",
"Each processing unit $j$ is tagged with a minimum and maximum capacity, $B_{ij}^{min}$ and $B_{ij}^{max}$, respectively, denoting the minimum and maximum batch sizes for each task $i$. A minimum capacity may be needed to cover heat exchange coils in a reactor or mixing blades in a blender, for example. The capacity may depend on the nature of the task being performed. These constraints are written\n",
"\n",
"\\begin{align*}\n",
"B_{ij}^{min}W_{ijt} & \\leq B_{ijt} \\leq B_{ij}^{max}W_{ijt} \\qquad \\forall j, \\forall i\\in I_j, \\forall t\n",
"\\end{align*}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Characterization of Tasks"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [],
"source": [
"STN = Kondili\n",
"\n",
"STATES = STN['STATES']\n",
"ST_ARCS = STN['ST_ARCS']\n",
"TS_ARCS = STN['TS_ARCS']\n",
"UNIT_TASKS = STN['UNIT_TASKS']\n",
"TIME = STN['TIME']\n",
"H = max(TIME)"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [],
"source": [
"TASKS = set([i for (j,i) in UNIT_TASKS]) # set of all tasks \n",
"\n",
"S = {i: set() for i in TASKS} # S[i] input set of states which feed task i\n",
"for (s,i) in ST_ARCS:\n",
" S[i].add(s)\n",
"\n",
"S_ = {i: set() for i in TASKS} # S_[i] output set of states fed by task i\n",
"for (i,s) in TS_ARCS:\n",
" S_[i].add(s)\n",
"\n",
"rho = {(i,s): ST_ARCS[(s,i)]['rho'] for (s,i) in ST_ARCS} # rho[(i,s)] input fraction of task i from state s\n",
"\n",
"rho_ = {(i,s): TS_ARCS[(i,s)]['rho'] for (i,s) in TS_ARCS} # rho_[(i,s)] output fraction of task i to state s\n",
"\n",
"P = {(i,s): TS_ARCS[(i,s)]['dur'] for (i,s) in TS_ARCS} # P[(i,s)] time for task i output to state s \n",
"\n",
"p = {i: max([P[(i,s)] for s in S_[i]]) for i in TASKS} # p[i] completion time for task i\n",
"\n",
"K = {i: set() for i in TASKS} # K[i] set of units capable of task i\n",
"for (j,i) in UNIT_TASKS:\n",
" K[i].add(j) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Characterization of States"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [],
"source": [
"T = {s: set() for s in STATES} # T[s] set of tasks receiving material from state s \n",
"for (s,i) in ST_ARCS:\n",
" T[s].add(i)\n",
"\n",
"T_ = {s: set() for s in STATES} # set of tasks producing material for state s\n",
"for (i,s) in TS_ARCS:\n",
" T_[s].add(i)\n",
"\n",
"C = {s: STATES[s]['capacity'] for s in STATES} # C[s] storage capacity for state s"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Characterization of Units"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [],
"source": [
"UNITS = set([j for (j,i) in UNIT_TASKS])\n",
"\n",
"I = {j: set() for j in UNITS} # I[j] set of tasks performed with unit j\n",
"for (j,i) in UNIT_TASKS:\n",
" I[j].add(i)\n",
"\n",
"Bmax = {(i,j):UNIT_TASKS[(j,i)]['Bmax'] for (j,i) in UNIT_TASKS} # Bmax[(i,j)] maximum capacity of unit j for task i\n",
"Bmin = {(i,j):UNIT_TASKS[(j,i)]['Bmin'] for (j,i) in UNIT_TASKS} # Bmin[(i,j)] minimum capacity of unit j for task i"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Pyomo Model"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"scrolled": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"# ==========================================================\n",
"# = Solver Results =\n",
"# ==========================================================\n",
"# ----------------------------------------------------------\n",
"# Problem Information\n",
"# ----------------------------------------------------------\n",
"Problem: \n",
"- Name: unknown\n",
" Lower bound: 6992.91666666667\n",
" Upper bound: 6992.91666666667\n",
" Number of objectives: 1\n",
" Number of constraints: 659\n",
" Number of variables: 471\n",
" Number of nonzeros: 1991\n",
" Sense: maximize\n",
"# ----------------------------------------------------------\n",
"# Solver Information\n",
"# ----------------------------------------------------------\n",
"Solver: \n",
"- Status: ok\n",
" Termination condition: optimal\n",
" Statistics: \n",
" Branch and bound: \n",
" Number of bounded subproblems: 12747\n",
" Number of created subproblems: 12747\n",
" Error rc: 0\n",
" Time: 7.91475510597229\n",
"# ----------------------------------------------------------\n",
"# Solution Information\n",
"# ----------------------------------------------------------\n",
"Solution: \n",
"- number of solutions: 0\n",
" number of solutions displayed: 0\n"
]
}
],
"source": [
"from pyomo.environ import *\n",
"import numpy as np\n",
"\n",
"TIME = np.array(TIME)\n",
"\n",
"model = ConcreteModel()\n",
"\n",
"model.W = Var(TASKS, UNITS, TIME, domain=Boolean) # W[i,j,t] 1 if task i starts in unit j at time t\n",
"model.B = Var(TASKS, UNITS, TIME, domain=NonNegativeReals) # B[i,j,t,] size of batch assigned to task i in unit j at time t\n",
"model.S = Var(STATES.keys(), TIME, domain=NonNegativeReals) # S[s,t] inventory of state s at time t\n",
"model.Q = Var(UNITS, TIME, domain=NonNegativeReals) # Q[j,t] inventory of unit j at time t\n",
"model.Cost = Var(domain=NonNegativeReals)\n",
"model.Value = Var(domain=NonNegativeReals)\n",
"\n",
"# Objective is to maximize the value of the final state (see Kondili, Sec. 5)\n",
"model.Obj = Objective(expr = model.Value - model.Cost, sense = maximize)\n",
"\n",
"# Constraints\n",
"model.cons = ConstraintList()\n",
"model.cons.add(model.Value == sum([STATES[s]['price']*model.S[s,H] for s in STATES]))\n",
"model.cons.add(model.Cost == sum([UNIT_TASKS[(j,i)]['Cost']*model.W[i,j,t] +\n",
" UNIT_TASKS[(j,i)]['vCost']*model.B[i,j,t] for i in TASKS for j in K[i] for t in TIME])) \n",
"\n",
"# unit constraints\n",
"for j in UNITS:\n",
" rhs = 0\n",
" for t in TIME:\n",
" # a unit can only be allocated to one task \n",
" lhs = 0\n",
" for i in I[j]:\n",
" for tprime in TIME:\n",
" if tprime >= (t-p[i]+1-UNIT_TASKS[(j,i)]['Tclean']) and tprime <= t:\n",
" lhs += model.W[i,j,tprime]\n",
" model.cons.add(lhs <= 1)\n",
"\n",
" # capacity constraints (see Konkili, Sec. 3.1.2)\n",
" for i in I[j]:\n",
" model.cons.add(model.W[i,j,t]*Bmin[i,j] <= model.B[i,j,t])\n",
" model.cons.add(model.B[i,j,t] <= model.W[i,j,t]*Bmax[i,j])\n",
"\n",
" # unit mass balance\n",
" rhs += sum([model.B[i,j,t] for i in I[j]])\n",
" for i in I[j]:\n",
" for s in S_[i]:\n",
" if t >= P[(i,s)]:\n",
" rhs -= rho_[(i,s)]*model.B[i,j,max(TIME[TIME <= t-P[(i,s)]])]\n",
" model.cons.add(model.Q[j,t] == rhs)\n",
" rhs = model.Q[j,t]\n",
" \n",
" # terminal condition \n",
" model.cons.add(model.Q[j,H] == 0)\n",
"\n",
"# state constraints\n",
"for s in STATES.keys():\n",
" rhs = STATES[s]['initial']\n",
" for t in TIME:\n",
" # state capacity constraint\n",
" model.cons.add(model.S[s,t] <= C[s])\n",
" \n",
" # state mass balanace\n",
" for i in T_[s]:\n",
" for j in K[i]:\n",
" if t >= P[(i,s)]: \n",
" rhs += rho_[(i,s)]*model.B[i,j,max(TIME[TIME <= t-P[(i,s)]])] \n",
" for i in T[s]:\n",
" rhs -= rho[(i,s)]*sum([model.B[i,j,t] for j in K[i]])\n",
" model.cons.add(model.S[s,t] == rhs)\n",
" rhs = model.S[s,t] \n",
" \n",
"# additional production constraints \n",
"model.cons.add(model.S['Product_2',H] >= 250)\n",
"\n",
"\n",
"SolverFactory('glpk').solve(model).write()\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Analysis"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Profitability\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Value of State Inventories = 7017.92\n",
" Cost of Unit Assignments = 25.00\n",
" Net Objective = 6992.92\n"
]
}
],
"source": [
"print(\"Value of State Inventories = {0:12.2f}\".format(model.Value()))\n",
"print(\" Cost of Unit Assignments = {0:12.2f}\".format(model.Cost()))\n",
"print(\" Net Objective = {0:12.2f}\".format(model.Value() - model.Cost()))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### State Inventories"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
| \n", " | Feed_A | \n", "Feed_B | \n", "Feed_C | \n", "Hot_A | \n", "Int_AB | \n", "Int_BC | \n", "Impure_E | \n", "Product_1 | \n", "Product_2 | \n", "
|---|---|---|---|---|---|---|---|---|---|
| 0 | \n", "424.000000 | \n", "360.0 | \n", "360.00 | \n", "0.000000 | \n", "0.0 | \n", "0.0 | \n", "0.00 | \n", "0.000000 | \n", "0.0 | \n", "
| 1 | \n", "324.000000 | \n", "360.0 | \n", "360.00 | \n", "76.000000 | \n", "0.0 | \n", "0.0 | \n", "0.00 | \n", "0.000000 | \n", "0.0 | \n", "
| 2 | \n", "324.000000 | \n", "360.0 | \n", "360.00 | \n", "64.000000 | \n", "0.0 | \n", "112.0 | \n", "0.00 | \n", "0.000000 | \n", "0.0 | \n", "
| 3 | \n", "324.000000 | \n", "360.0 | \n", "360.00 | \n", "64.000000 | \n", "0.0 | \n", "112.0 | \n", "0.00 | \n", "0.000000 | \n", "0.0 | \n", "
| 4 | \n", "324.000000 | \n", "360.0 | \n", "320.00 | \n", "32.000000 | \n", "8.0 | \n", "64.0 | \n", "0.00 | \n", "112.000000 | \n", "0.0 | \n", "
| 5 | \n", "324.000000 | \n", "300.0 | \n", "260.00 | \n", "0.000000 | \n", "8.0 | \n", "16.0 | \n", "0.00 | \n", "112.000000 | \n", "0.0 | \n", "
| 6 | \n", "233.333333 | \n", "300.0 | \n", "246.00 | \n", "0.000000 | \n", "0.0 | \n", "16.0 | \n", "0.00 | \n", "144.000000 | \n", "180.0 | \n", "
| 7 | \n", "233.333333 | \n", "300.0 | \n", "230.00 | \n", "10.666667 | \n", "4.0 | \n", "16.0 | \n", "70.00 | \n", "176.000000 | \n", "180.0 | \n", "
| 8 | \n", "233.333333 | \n", "300.0 | \n", "230.00 | \n", "10.666667 | \n", "4.0 | \n", "16.0 | \n", "0.00 | \n", "176.000000 | \n", "180.0 | \n", "
| 9 | \n", "233.333333 | \n", "300.0 | \n", "199.00 | \n", "0.000000 | \n", "0.0 | \n", "0.0 | \n", "0.00 | \n", "256.000000 | \n", "315.0 | \n", "
| 10 | \n", "233.333333 | \n", "300.0 | \n", "199.00 | \n", "0.000000 | \n", "15.0 | \n", "0.0 | \n", "0.00 | \n", "256.000000 | \n", "315.0 | \n", "
| 11 | \n", "233.333333 | \n", "300.0 | \n", "191.25 | \n", "0.000000 | \n", "0.0 | \n", "0.0 | \n", "0.00 | \n", "266.666667 | \n", "454.5 | \n", "
| 12 | \n", "233.333333 | \n", "300.0 | \n", "191.25 | \n", "0.000000 | \n", "15.5 | \n", "0.0 | \n", "38.75 | \n", "266.666667 | \n", "454.5 | \n", "
| \n", " | Heater | \n", "Reactor_1 | \n", "Reactor_2 | \n", "Reactor_3 | \n", "Still | \n", "
|---|---|---|---|---|---|
| 0 | \n", "(Heating, 76.0) | \n", "(Reaction_1, 80.0) | \n", "(Reaction_1, 80.0) | \n", "(Reaction_1, 120.0) | \n", "None | \n", "
| 1 | \n", "(Heating, 100.0) | \n", "None | \n", "None | \n", "None | \n", "None | \n", "
| 2 | \n", "None | \n", "(Reaction_2, 80.0) | \n", "(Reaction_2, 80.0) | \n", "(Reaction_2, 120.0) | \n", "None | \n", "
| 3 | \n", "None | \n", "None | \n", "None | \n", "None | \n", "None | \n", "
| 4 | \n", "None | \n", "(Reaction_3, 80.0) | \n", "(Reaction_2, 80.0) | \n", "(Reaction_3, 120.0) | \n", "None | \n", "
| 5 | \n", "None | \n", "(Reaction_2, 80.0) | \n", "None | \n", "(Reaction_1, 120.0) | \n", "(Separation, 200.0) | \n", "
| 6 | \n", "(Heating, 90.6666666666667) | \n", "None | \n", "(Reaction_3, 70.0) | \n", "None | \n", "None | \n", "
| 7 | \n", "None | \n", "(Reaction_2, 80.0) | \n", "(Reaction_3, 80.0) | \n", "(Reaction_2, 120.0) | \n", "None | \n", "
| 8 | \n", "None | \n", "None | \n", "None | \n", "None | \n", "(Separation, 150.0) | \n", "
| 9 | \n", "None | \n", "(Reaction_3, 80.0) | \n", "(Reaction_3, 75.0) | \n", "(Reaction_2, 26.6666666666667) | \n", "None | \n", "
| 10 | \n", "None | \n", "None | \n", "None | \n", "None | \n", "(Separation, 155.0) | \n", "
| 11 | \n", "None | \n", "None | \n", "None | \n", "(Reaction_3, 38.75) | \n", "None | \n", "
| 12 | \n", "None | \n", "None | \n", "None | \n", "None | \n", "None | \n", "
| \n", " | Still | \n", "Reactor_2 | \n", "Reactor_3 | \n", "Heater | \n", "Reactor_1 | \n", "
|---|---|---|---|---|---|
| 0 | \n", "0.0 | \n", "80.0 | \n", "120.000000 | \n", "76.000000 | \n", "80.0 | \n", "
| 1 | \n", "0.0 | \n", "80.0 | \n", "120.000000 | \n", "100.000000 | \n", "80.0 | \n", "
| 2 | \n", "0.0 | \n", "80.0 | \n", "120.000000 | \n", "0.000000 | \n", "80.0 | \n", "
| 3 | \n", "0.0 | \n", "80.0 | \n", "120.000000 | \n", "0.000000 | \n", "80.0 | \n", "
| 4 | \n", "0.0 | \n", "80.0 | \n", "120.000000 | \n", "0.000000 | \n", "80.0 | \n", "
| 5 | \n", "200.0 | \n", "80.0 | \n", "120.000000 | \n", "0.000000 | \n", "80.0 | \n", "
| 6 | \n", "20.0 | \n", "70.0 | \n", "120.000000 | \n", "90.666667 | \n", "80.0 | \n", "
| 7 | \n", "0.0 | \n", "80.0 | \n", "120.000000 | \n", "0.000000 | \n", "80.0 | \n", "
| 8 | \n", "150.0 | \n", "0.0 | \n", "120.000000 | \n", "0.000000 | \n", "80.0 | \n", "
| 9 | \n", "15.0 | \n", "75.0 | \n", "26.666667 | \n", "0.000000 | \n", "80.0 | \n", "
| 10 | \n", "155.0 | \n", "0.0 | \n", "26.666667 | \n", "0.000000 | \n", "0.0 | \n", "
| 11 | \n", "15.5 | \n", "0.0 | \n", "38.750000 | \n", "0.000000 | \n", "0.0 | \n", "
| 12 | \n", "0.0 | \n", "0.0 | \n", "0.000000 | \n", "0.000000 | \n", "0.0 | \n", "
"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.4"
}
},
"nbformat": 4,
"nbformat_minor": 2
}