hadar.optimizer.lp package

Submodules

hadar.optimizer.lp.domain module

class hadar.optimizer.lp.domain.JSONLP

Bases: hadar.optimizer.utils.JSON, abc.ABC

static from_json(dict, factory=None)
to_json()
class hadar.optimizer.lp.domain.LPConsumption(quantity: int, variable: Union[ortools.linear_solver.pywraplp.Variable, float], cost: float = 0, name: str = '')

Bases: hadar.optimizer.lp.domain.JSONLP

Consumption element for linear programming.

static from_json(dict, factory=None)
class hadar.optimizer.lp.domain.LPConverter(name: str, src_ratios: Dict[Tuple[str, str], float], var_flow_src: Dict[Tuple[str, str], Union[ortools.linear_solver.pywraplp.Variable, float]], dest_network: str, dest_node: str, var_flow_dest: Union[ortools.linear_solver.pywraplp.Variable, float], cost: float, max: float)

Bases: hadar.optimizer.lp.domain.JSONLP

Converter element for linear programming

static from_json(dict, factory=None)

Bases: hadar.optimizer.lp.domain.JSONLP

Link element for linear programming

static from_json(dict, factory=None)
class hadar.optimizer.lp.domain.LPNetwork(nodes: Dict[str, hadar.optimizer.lp.domain.LPNode] = None)

Bases: hadar.optimizer.utils.JSON

Network element for linear programming

static from_json(dict, factory=None)
class hadar.optimizer.lp.domain.LPNode(consumptions: List[hadar.optimizer.lp.domain.LPConsumption], productions: List[hadar.optimizer.lp.domain.LPProduction], storages: List[hadar.optimizer.lp.domain.LPStorage], links: List[hadar.optimizer.lp.domain.LPLink])

Bases: hadar.optimizer.utils.JSON

Node element for linear programming

static from_json(dict, factory=None)
class hadar.optimizer.lp.domain.LPProduction(quantity: int, variable: Union[ortools.linear_solver.pywraplp.Variable, float], cost: float = 0, name: str = 'in')

Bases: hadar.optimizer.lp.domain.JSONLP

Production element for linear programming.

static from_json(dict, factory=None)
class hadar.optimizer.lp.domain.LPStorage(name, capacity: int, var_capacity: Union[ortools.linear_solver.pywraplp.Variable, float], flow_in: float, var_flow_in: Union[ortools.linear_solver.pywraplp.Variable, float], flow_out: float, var_flow_out: Union[ortools.linear_solver.pywraplp.Variable, float], cost: float = 0, init_capacity: int = 0, eff: float = 0.99)

Bases: hadar.optimizer.lp.domain.JSONLP

Storage element

static from_json(dict, factory=None)
class hadar.optimizer.lp.domain.LPTimeStep(networks: Dict[str, hadar.optimizer.lp.domain.LPNetwork], converters: Dict[str, hadar.optimizer.lp.domain.LPConverter])

Bases: hadar.optimizer.utils.JSON

static create_like_study(study: hadar.optimizer.domain.input.Study)
static from_json(dict, factory=None)

hadar.optimizer.lp.mapper module

class hadar.optimizer.lp.mapper.InputMapper(solver: ortools.linear_solver.pywraplp.Solver, study: hadar.optimizer.domain.input.Study)

Bases: object

Input mapper from global domain to linear programming specific domain

get_conv_var(name: str, t: int, scn: int) → hadar.optimizer.lp.domain.LPConverter

Map Converter to LPConverter.

Parameters

  • name – converter name

  • t – time step

  • scn – scenario index

Returns

LPConverter

get_node_var(network: str, node: str, t: int, scn: int) → hadar.optimizer.lp.domain.LPNode

Map InputNode to LPNode.

Parameters

  • network – network name

  • node – node name

  • t – time step

  • scn – scenario index

Returns

LPNode according to node name at t in study

class hadar.optimizer.lp.mapper.OutputMapper(study: hadar.optimizer.domain.input.Study)

Bases: object

Output mapper from specific linear programming domain to global domain.

get_result() → hadar.optimizer.domain.output.Result

Get result.

Returns

final result after map all nodes

set_converter_var(name: str, t: int, scn: int, vars: hadar.optimizer.lp.domain.LPConverter)
set_node_var(network: str, node: str, t: int, scn: int, vars: hadar.optimizer.lp.domain.LPNode)

Map linear programming node to global node (set inside intern attribute).

Parameters

  • network – network name

  • node – node name

  • t – timestamp index

  • scn – scenario index

  • vars – linear programming node with ortools variables inside

Returns

None (use get_result)

hadar.optimizer.lp.optimizer module

class hadar.optimizer.lp.optimizer.AdequacyBuilder(solver: ortools.linear_solver.pywraplp.Solver)

Bases: object

Build adequacy flow constraint.

add_converter(conv: hadar.optimizer.lp.domain.LPConverter, t: int)

Add converter element in equation. Sources are like consumptions, destination like production

Parameters

  • conv – converter element to add

  • t – time index to use

Returns

add_node(name_network: str, name_node: str, node: hadar.optimizer.lp.domain.LPNode, t: int)

Add flow constraint for a specific node.

Parameters

  • name_network – network name. Used to differentiate each equation

  • name_node – node name. Used to differentiate each equation

  • node – node to map constraint

Returns

build()

Call when all node are added. Apply all import flow for each node.

Returns

class hadar.optimizer.lp.optimizer.ConverterMixBuilder(solver: ortools.linear_solver.pywraplp.Solver)

Bases: object

Build equation to determine ratio mix between sources converter.

add_converter(conv: hadar.optimizer.lp.domain.LPConverter)
build()
class hadar.optimizer.lp.optimizer.ObjectiveBuilder(solver: ortools.linear_solver.pywraplp.Solver)

Bases: object

Build objective cost function.

add_converter(conv: hadar.optimizer.lp.domain.LPConverter)

Add converter. Apply cost on output of converter.

Parameters

conv – converter to cost

Returns

add_node(node: hadar.optimizer.lp.domain.LPNode)

Add cost in objective for each node element.

Parameters

node – node to add

Returns

build()
class hadar.optimizer.lp.optimizer.StorageBuilder(solver: ortools.linear_solver.pywraplp.Solver)

Bases: object

Build storage constraints

add_node(name_network: str, name_node: str, node: hadar.optimizer.lp.domain.LPNode, t: int) → ortools.linear_solver.pywraplp.Constraint
build()
hadar.optimizer.lp.optimizer.solve_lp(study: hadar.optimizer.domain.input.Study, out_mapper=None) → hadar.optimizer.domain.output.Result

Solve adequacy flow problem with a linear optimizer.

Parameters

  • study – study to compute

  • out_mapper – use only for test purpose to inject mock. Keep None as default.

Returns

Result object with optimal solution

Module contents

hadar.optimizer.domain package hadar.optimizer.remote package