Microservices-driven distributed incremental acceleration method for large-scale optimization problems

Abstract

An acceleration method leveraging distributed microservices for large-scale optimization problems. The method is applicable to a generalized Benders decomposition problem, a least-cost planning and a reliability analysis. The invention decomposes the optimization problem into a set of optimization subproblems which are solved iteratively. Each subproblem carries out the following tasks: data loading; data preprocessing; optimization problem creation; optimization problem resolution; results validation; and results storing and sending. The invention is implemented asynchronously and uses distributed incremental acceleration. Instead of creating and solving a different mathematical problem on each iteration, the same problem is solved on each iteration with minor modifications. This allows the leveraging of microservices-driven distributed computing with a sufficient quantity of processors leading to a dramatic improvement in performance and accuracy.

Description

[0001]MICROSERVICE-DRIVEN DISTRIBUTED INCREMENTAL ACCELERATION METHOD FOR LARGE-SCALE OPTIMIZATION PROBLEMS DESCRIPTION OBJECT OF THE INVENTION The invention discloses a distributed incremental acceleration method for solving large-scale optimization problems according to claim 1. The invention has been validated using two common problems in the electricity sector, minimum cost planning, reliability analysis, and has also been generalized for decomposition problems. BACKGROUND OF THE INVENTION The energy sector, like other industries such as logistics, transportation, infrastructure planning, sports leagues or manufacturing, use computer applications for essential business decisions.These processes include new infrastructure planning, cost-effectiveness assessment, reliability analysis, price forecasting, supply optimization, storage operation, and maintenance scheduling, among others. These applications frequently present computational limitations related to the achievable accuracy or the long computation times they entail, which can reach several days. The impact of this lack of accuracy and the inability to apply optimization to problems is expected to be on the order of several billion dollars annually. As an example, consider global investments in electricity and transmission, which are expected to require $600 billion annually by 2030.If, by leveraging a highly accurate and rapid optimization-based solution, infrastructure needs could be assessed 5% more efficiently, either by reducing necessary investments or by investing more in areas that, for example, present excessive losses or renewable energy discharges, the annual improvements in social welfare would exceed $30 billion each year. There are three well-known and widespread use cases that benefit from our solution: (a) Benders decomposition, as an example of decomposition (b) Minimum-cost planning (c) Reliability analysis Benders decomposition is a decomposition technique that allows large optimization problems to be solved into smaller ones iteratively by taking advantage of the special structure of blocks that have many problems.The applications are broad and include minimum-cost planning, stochastic optimization, and coordination problems, among others. Minimum-cost planning is a widely used technique today for planning infrastructure expansion in many sectors such as electricity, transportation, and logistics. Investors and regulated utility companies use this technique to assess the need for new infrastructure and generate future electricity price scenarios, which are used to evaluate the profitability of investments. In order to produce results with the available computing infrastructure, currently available solutions make significant simplifications, such as using typical days or other types of grouping.Even with these simplifications, simulations often take more than 12 hours to complete, and because multiple runs are required, a simple study could require more than a week of model runtime. Another problem with least-cost planning is related to accuracy. Historically, these simplifications have not led to substantial distortions; however, in renewable-intensive scenarios, such as those expected in the coming years in Europe, the distortions may be unacceptable. Current developments by research institutes to overcome these distortions have followed three main strategies: (1) single-machine decomposition using commercial mathematical solvers, (2) decomposition using multiple machines on a private network, and (3) the use of parallel mathematical solvers such as PIPS on high-performance computers: 1.Execution on a single machine limits the maximum number of parallel processes to the available CPUs on the machine, which is usually below the desired level, resulting in lower performance. 2. Using interconnected machines in a local area network makes it possible to overcome the limitation of CPUs on the same machine. However, it requires a difficult configuration, which would make deployment excessively complex, making it practically impossible to create a product that can be marketed and maintained. 3. The use of parallel solvers in high-performance computing (HPC) theoretically allows for the best performance, and although the approach is of great scientific interest, it currently has limited practical and commercial applicability for the following reasons: ¾ In its current implementation, if any thread fails, the entire process must be interrupted because it cannot continue.¾ Parallel solvers are not mature compared to those used to solve the smaller problems frequently solved in commercial applications. Reliability analysis is usually evaluated using Monte Carlo simulation. In industries such as the energy sector, this implies large and long computational efforts until convergence is reached for two reasons: (1) computational capacity is often limited by the capacity of the machine running the simulations, and (2) real-world systems have many components that can affect the overall process, so considering all relevant and possible combinations of interruptions, some of them with small probabilities, requires running many samples.Monte Carlo simulation is often enhanced with variance reduction techniques that enable faster convergence; some of the most commonly used are stratification, such as Latin hypercube sampling, importance sampling, or Markov chain Monte Carlo. Microservice-driven distributed computing is the method of having multiple computers work together to solve a common problem using small, independent services. The application runs on multiple computers instead of just one, with each service performing a different task and communicating with the rest to build the final solution. The advantages of this invention are extensible to microservices built with containers, serverless microservices, as well as loosely coupled HPC instances. Its use offers several advantages compared to traditional applications: ▪ The capacity of a computer is limited by its own capacity.A distributed system allows multiple computers to be connected simultaneously, increasing capacity. ▪ It allows for standardized implementation and high reliability. This standardized implementation is essential for developing a licensable and maintainable product. The use of small, independent services increases the robustness of the solution process, so that if one of the independent services fails, another can continue where the previous one left off. ▪ It also allows capacity to be scaled up or down precisely, improving cost efficiency. ▪ For cloud deployments, it allows for virtually unlimited capacity without the need to acquire, maintain, or even insure it.In [Bruno Colonetti, Erlon Finardi, Paulo Larroyd, Felipe Beltrán, "A novel cooperative multi-search benders decomposition for solving the hydrothermal unit-commitment problem" International Journal of Electrical Power & Energy Systems, Volume 134, 2022, 107390, ISSN 0142-0615, https: / / doi.org / 10.1016 / j.ijepes.2021.107390] renewable energy and the modernization of energy operations require Independent System Operators to solve increasingly complex and large-scale scheduling problems in order to securely and economically schedule energy resources. A key step in the scheduling process is unit allocation. In a system with high hydraulic penetration, this process also involves reservoir management and is called hydrothermal.Due to its size, non-convex nature, and strict solution time requirements, the hydrothermal problem remains a challenging problem for operators even in its deterministic form. Relying on a commercial solver to directly address this problem might require careful configuration of solver parameters and, given the generality of commercial solvers, might not fully exploit all the features of the hydrothermal problem. Alternatively, researchers have recently proposed dual decomposition strategies to address the problem, allowing subproblems to be solved in parallel. However, dualizing a non-convex problem often results in a duality gap and requires ad hoc techniques to recover a primary solution. In this work, we propose a novel cooperative multi-search Benders decomposition approach to solve the deterministic problem.Our approach benefits from being a primal method while exploiting the problem structure to solve subproblems in parallel. To evaluate the effectiveness of our proposal, we use the state-of-the-art solver Gurobi as a benchmark and conduct our experiments on 25 instances of a large-scale system with over 1,000 generating units and 7,000 nodes. On average, our approach is more than 15 times faster than Gurobi and is able to solve the problems in less than 20 min with a tolerance of 0.1%. [Artamonov, Ivan & Sukhodolov, Alexander. (2019). “CPN Tools-based Software Solution for Reliability Analysis of Processes in Microservice Environments”. International journal of simulation: systems, science & technology. 19. 10.5013 / IJSSST.a.19.06.56] reveals that microservices are a popular contemporary method for building scalable distributed systems (e.g., websites).It is difficult to predict the reliability of executable operations of the future system due to the large number of components and their nonlinear relationships. In this paper, we consider the operation executed by multiple microservices as a single atomic transaction. The transaction only matters if it completes successfully. In case of an error during execution, or due to the need to discard the results, the transaction must be rolled back or compensated. To analyze the execution reliability of such an operation, we introduce a dedicated software solution based on colored Petri net (CPN) tools. Consequently, the interactive microservices system must be described using Petri net terms, and the operation must adhere to certain business process modeling rules, for example, having an entry / exit point.The software solution consists of several interconnected units, including the CPN, ACCESS / CPN, and PostgreSQL tools. These programs are controlled by an application server via a web interface. The software solution allows analysis to be performed simultaneously by multiple examiners through the use of web technologies. Finally, document US2022318189 relates to a solution for providing a highly efficient image delivery system for container-based in-memory databases within a database-as-a-service framework that provides storage and bandwidth cost savings and introduces advanced features of container techniques. This solution takes full advantage of the concurrent and distributed capabilities of in-memory databases within a database-as-a-service framework.A container operator manager provides operators for various uses, such as the "diff" operator and the "merge" operator. A submission manager acts as a centralized service for maintaining diff content, publishing patches, and managing submission worker nodes. A patch worker on each node has the ability to execute specified patches and validation between images located on either side of the in-memory database within a database-as-a-service framework. DESCRIPTION OF THE INVENTION The object of the present invention is a computational method for solving large optimization problems quickly and accurately.The invention relates to an acceleration method for large-scale optimization problems, which could be any problem that can benefit from mathematical decomposition, including least-cost scheduling as well as reliability analysis, comprising the steps of: • decomposing the large-scale optimization problem into a master problem and a set of subproblems, which are solved iteratively; • modifying the master problem and the subproblems to use incremental optimization: in the master problem, adding new constraints during its execution, in the subproblems, the value of some of the variables is updated at each iteration with the new value of the master problem proposals; solving the master problem and the subproblems using distributed computing, employing several computers at the same time.In the method of the invention, the decomposition step may be performed by a technique selected from Bender, Danzig-Wolfe, or Lagrangian relaxation decomposition, which have been shown to be equivalent (see Lim, C.; Cochran, J.J.; Cox, L.A.; Keskinocak, P.; Kharoufeh, J.P.; Smith, J.C. Relationship among Benders, Dantzig-Wolfe, and Lagrangian Optimization. In Wiley Encyclopedia of Operations Research and Management Science; John Wiley & Sons, Inc: Hoboken, NJ, USA, 2010). Furthermore, the master problem and subproblems may be implemented by asynchronous parallel computing allowing that when faster optimization subproblems finish, new optimization subproblems may continue without having to wait for slower ones. When solving a reliability analysis problem, variance reduction techniques may also be applied in conjunction with asynchronous optimization.Preferably, the master problem and / or subproblems could be implemented using microservices or loosely coupled HPC instances. Likewise, the microservices can be implemented using serverless microservices or using containers. In the context of the invention, large-scale optimization problems could be applied to electrical power generation, storage, transmission, and distribution. Furthermore, the optimization problem could include representing active and reactive load flows by linearized equations or with second-order conic programming. The claimed invention solves the aforementioned technical problem accurately and effectively helps reduce computation times by a factor of more than 100x. To achieve the increase in accuracy with shorter execution times, the invention features (a) algorithmic improvements; and (b) computational improvements.Algorithmic improvements may comprise at least one of the following: (1) Benders decomposition; (2) incremental optimization; (3) asynchrony; and (4) variance reduction. Implementation technology improvements may also comprise: (5) efficient and robust use of distributed computing; and (6) use of databases for intermediate information. 1. Benders decomposition is an approach that allows large optimization problems to be broken down into smaller pieces to be solved iteratively. This avoids solving larger optimization problems, which are usually limited by the size of the computer used to solve the problem. Other decomposition algorithms, such as Danzig-Wolfe or Lagrangian relaxation, are equivalent, since they can be reformulated in terms of each other. 2.Incremental optimization avoids running a different problem in each iteration, but rather solves the same problem with additional constraints in each iteration until convergence. The code should be formulated so that modifications introduced in each iteration do not require the creation of a new problem. This can be achieved in the master problem by using callbacks and in the subproblem by updating the values ​​of some variables. This saves the construction time of each problem and reduces the solution search time, since the starting point is the values ​​from the previous iteration. 3. Asynchrony allows new executions to begin when some executions finish without waiting for the slower ones to finish, thus using capacity more efficiently. 4.Variance reduction methods such as Latin hypercube sampling, which distributes random variables more evenly; importance sampling, which increases the probability of critical events occurring; or Markov chain Monte Carlo reduce sample variance, accelerating convergence. 5. The implementation of distributed computing enables a highly effective combination of Benders decomposition with incremental optimization. The use of distributed computing translates into the need for fast data transfer to speed up the process, but also for fault isolation, so that if one instance fails, the system can recover by starting a new one. These advantages are not limited to distributed computing in containers but can also be achieved using serverless microservices and on loosely coupled HPC instances. 6.The use of databases or even shared storage allows for storing intermediate information so that, in the event of a failure of one of the processes involved in the calculation, the system can be recovered by booting a new computer and loading the previously stored state. In-memory databases allow communication latency to be reduced to microseconds. HPC communication channels such as the Message Passing Interface (MPI) offer a latency of only about 10 microseconds, but they also require more complex configuration and offer lower reliability than storing intermediate calculations in a database. The main benefit of the presented approach is the more precise recommendations made as a result of increased accuracy and the possibility of using optimization when this was not possible. However, there is another benefit derived from the shorter execution times that can be achieved with this approach.A simulation that takes several hours to complete not only consumes computing power but also significant specialized labor, which is costly. Each 12-hour simulation can cost between $300 and $1,500 in labor alone, depending on the skilled person's salary. The method of the invention, by decreasing run times by a factor of 100x, makes both the labor (waiting for a simulation to complete) and the computational costs negligible compared to the prior art approach. Throughout the description and claims, the word "comprise" and its variations are not intended to exclude other technical features, components, or steps. For those skilled in the art, other objects, advantages, and features of the invention will emerge partly from the description and partly from the practice of the invention. The following examples are provided by way of illustration and are not intended to restrict the present invention.Furthermore, the present invention encompasses all possible combinations of the particular and preferred embodiments indicated herein. DESCRIPTION OF THE DRAWINGS In order to complement the description provided and in order to help better understand the characteristics of the invention, in accordance with a preferred exemplary practical embodiment thereof, said description is accompanied, as an integral part thereof, by a set of drawings where, in an illustrative and non-limiting manner, the following has been represented: Figure 1. Shows a comparison between the method of the invention and a traditional approach. PREFERRED EMBODIMENT OF THE INVENTION The present invention implements the Benders decomposition approach in a generic manner, as well as specifically for minimum cost planning and for Monte Carlo simulation for reliability analysis (as non-limiting examples).The implementations for least-cost planning and Monte Carlo cover power generation, electricity transmission, distribution, storage, and natural gas, fuel, and hydrogen infrastructure. For Benders decomposition, we have defined a generic formulation to demonstrate that the method can be used to accelerate any problem formulated using Benders decomposition. For least-cost planning, we have implemented it using Benders decomposition, in which the master problem proposes new infrastructure expansion plans, typically in monthly or annual steps, while the subproblems return the operating costs of the given plans.Regarding reliability analysis, the master problem generates random outage schedules, while subproblems, which coincide with the minimum-cost scheduling subproblems, calculate the resulting level of unserved energy. The core of the invention is the technological implementation of incremental optimization on a distributed computing platform using mathematical decomposition for the aforementioned problems. Incremental optimization offers substantial advantages for solving optimization problems more quickly; this applies to both the master problem and the subproblems. This drastically reduces the time required to solve problems in subsequent iterations, both for the master problem and the subproblem.By solving the master problem using Benders decomposition in modern solvers, we can progressively incorporate new cuts while the solver is running using the callbacks available in modern solvers. For subproblems, the input received from the master problem can be defined as a variable, and its value can be updated at each iteration. This avoids the need to rebuild the problem at each iteration and allows the previous solution to be used as a starting point, speeding up the solution process. Additional savings can be achieved with asynchrony. In most implementations, the master problem is executed iteratively, waiting for all subproblems to complete at each iteration.However, there is a small portion of subproblems that can take twice as long to complete as the majority, meaning that most of the time is wasted waiting for only a few threads to complete. To solve this problem, the invention implements decomposition asynchronously as follows: - For the master problem: the next iteration starts when the rate at which new subproblems are completed falls below a threshold and the proportion of completed runs exceeds the minimum bound. - For the subproblems: they are configured to always take the most recent new infrastructure expansion plan to avoid spending time on already obsolete solutions. The modifications introduced to the inventive method make it possible to reduce the time spent solving the problem by more than 99% for the evaluated minimum-cost scheduling problem.For other large problems that can be formulated using Benders decomposition, the benefits are expected to be comparable. For reliability analysis, the situation is different, as random outage schedules can be generated without having to wait for intermediate results and launch new processes. This means that subproblems can run continuously without the main process having to continue generating new proposals. Variance reduction is relevant for reliability analysis. In this case, we employed two different variance reduction techniques called Latin Hypercube Sampling (LHS), a stratification technique, and Importance Sampling (IS). On the one hand, LHS helps reduce variance by more evenly distributing the outages generated in the Monte Carlo simulation.On the other hand, the IS overweights the occurrence of low-probability scenarios, such as those in which security of supply may be compromised, by allocating fewer samples to more conventional situations that do not present security-related problems. The traditional Monte Carlo approach requires 38 runs to converge to a 3% tolerance, while the current invention requires six runs to converge thanks to the variance reduction. Due to the reformulation, runs after the first take only a few seconds. These combined effects result in a total savings of approximately 97%. The problem formulation for a Benders decomposition problem, as found in the literature, for minimum-cost scheduling and reliability analysis is presented below, followed by the modifications required to implement the innovation.Figure 1 illustrates the advantages of the invention compared to the traditional approach: 1. While the traditional approach can only utilize the available CPUs in a single instance, meaning that each parallel process needs to perform several executions before the next one can be started, with the invention the next iteration can be started right after a single process execution has been executed. 2. While the traditional approach needs to wait for all the executions of each iteration, our approach can continue without waiting for slower processes. 3. While the traditional approach requires building and executing a different mathematical problem from scratch in each iteration, the same problem is solved with minor modifications, meaning that subsequent iterations take much less time. 4.While the traditional approach exchanges information using shared storage with high latency, our approach only exhibits latencies of milliseconds to microseconds. From the above, it can be seen in Figure 1 that while the traditional approach was only able to complete 32 threads in the first iteration, with the invention it is possible to complete the 3960 processes necessary until convergence. FORMULATION OF BENDERS DECOMPOSITION The academic literature frequently presents problems suitable for Benders decomposition as follows: Where c. T represents the costs applicable to the first stage decisions (x) and q Trepresents the costs applicable to second-stage decisions (y). There are also two groups of restrictions: the first (^^^^ = ^^) only affect first-stage decisions, and the second (^^^^ + ^^^^ = ℎ) affect both first-stage and second-stage decisions. The decomposed problem can be formulated as: Main problem Indices i: Index of first-stage decisions (total of I) j: Index of second-stage decisions (total of J) m: Index of the first group of restrictions (total of M) n: Index of the second group of restrictions (total of N) Variables x: First-phase decisions θ: Contribution of first-stage decisions to the function ^^ ^^^^ Parameters A: Coefficients of the first group of constraints T: Coefficients of the second group of constraints and decisions of the first stage W: Coefficients of the second group of constraints and decisions of the second stage b: Right side of the first group of constraints h: Right side of the second group of constraints c: Cost coefficients of the decisions of the first stage ^̂^: Decisions of the first stage of the previous iteration ^̃^ ^^ : Optimality gradient for the first-stage decisions of the previous iteration. Feasibility gradient for the first-stage decisions of the previous iteration. ^^^^ ^^^^^̂^Value of the objective function of the subproblem at the previous iteration. Constraints Equation (a) implements the first set of constraints:(a) ^^^^ = ^^Equation (b) implements the constraints that must be applied to the master problem to ensure that the results satisfy all the constraints of the full problem (feasibility cuts): Equation (c) represents the relationship of the first stage decisions (x) on the contribution of the costs of the second stage variables (optimality cuts): Objective Function The model will then minimize the objective function defined as:(d) ^^^^ ^^^^^^^^^^^^^ = ^^ ^^ + ^^Outcomes The results of the first decisions are passed to the subproblems. ^̂^ = x Variables y: Second phase decisions Parameters T: Coefficients of the first set of constraints and first stage decisions W: Coefficients of the first set of constraints and second stage decisions h: Right hand side of the second set of constraints q: Cost coefficients of the second stage decisions ^̂^: First stage decisions of the current iteration Constraints Equation (e) implements the constraints that should be applied to the subproblem to ensure that the outcome is feasible:(e) ^^^^ = ℎ − ^^^̂^Objective function The model will then minimize the objective function defined as:(f) ^^^^^^^^^^ = ^^ ^^^^ If the solution to the problem becomes infeasible, the constraints within (e) causing the infeasibility will be deactivated and a new objective function will be declared with the objective of minimizing the sum of the infeasibility:(g) ^^^^^^^^^^ = ∑^^ ℎ − ^^^^ − ^^^̂^Results The results of the subproblem consist of the value of the objective function (^^^^ ^^^^^̂^ ) and the gradients of the objective function for changes in the first stage decisions (^̃^^^ , ^̃^^^). If feasible: If not feasible: The proposed implementation of the master problem presents a modification with respect to the traditional implementation in which the cut envelope of the master problem that forms the resource function (c) is updated using callbacks in each iteration.Callback function Shares result with subproblems Waits for subproblems Loads results from subproblems Adds new feasibility and optimality cuts End In this advanced implementation, the gradients of the first-stage decisions (^̃^^^ , ^̃^^^) are defined using the reduced cost of the first-stage variables instead of from the dual variable of the constraints: If feasible: ^̃^^^ = ^^^^^^^^^^^^^^^^^^^^^^^^^^(^^) If not feasible: ^̃^^^ = ^^^^^^^^^^^^^^^^^^^^^^^^^^^(^^) In this case, the first-stage decisions (^̂^) should be defined as a variable instead of a parameter, and its value should be updated at each iteration based on the outcome of the master problem. FORMULATION OF MINIMUM COST PLANNING This implementation is the traditional one of Benders decomposition to solve the least cost planning problem for the expansion of the electrical system.Master Problem The master problem optimizes system expansion by minimizing power system costs. Power system costs result from the discounted sum of capital expenditures, fixed operating expenses, and variable operating expenses. While the first two components are easy to calculate, as they depend only on capacity expansions, the last is not straightforward. It is represented by a set of linear cutting planes that depend on the installed capacity, defining an envelope. Each execution of the subproblem computes, for each stage—a month, for example—a cutting plane that contributes to the formation of the aforementioned envelope. The cutting planes are defined with the resulting variable operating costs, as well as the dual variables, which represent the slope of these cutting planes.The problem is formulated below only for generators, since the representation for branches (B) and storage facilities (S) is analogous, as well as for any other type of infrastructure. Indices g: Index of power generators (total G) t: Index by stages, usually months (total T) Variables g_ext: Available generating capacity [MW] g_inv: Generation capacity increase [MW]. capex: Capital expenditures [monetary unit] opexfix: Fixed operating expenses [monetary unit] opexvar: Variable operating expenses [monetary unit]. Parameters GenLif: Generator life [years] GenCPX: Capital expenditures [monetary unit / MW] GenOMf: Fixed operating expenses [monetary unit / MW / year]. GenDual: Dual variable [monetary unit / MW] GenCap: Installed capacity [MW] Rate: Cumulative discount rate [%] OpexVar: Variable operating costs [monetary unit / MWh].Iter: Current iteration [#] Constraints Constraint (1) determines the available capacity based on capacity additions prior to the current stage. (1) g_ext[g, t] = sum ( g_inv[g, tt] for tt in [t-GenLif[g], t] ) Constraints (2,3) calculate the fixed capital and operating expenses based on the capacity additions and the available capacity. (2) capex[t] = suma ( g_inv [g, t] * GenCPX[g, t] for g in [1,G] ) (3) opexfix[t] = suma ( g_ext [g, t] * GenOMf [g, t] for g in [1,G] ) Constraint (4) defines for each stage (t) and iteration (Iter) a set of cutting planes that represent the envelope that models the variable operating costs using the results of the subproblems.(4) opexvar[t] ≥ OpexVar[t,Iter] + suma ( GenDual[Iter, g, t] * ( g_ext[g,t] - GenUni[Iter,g,t] * GenCap[g,t] ) for g in [1, G] ) Equation (4) above can be reformulated for stochastic optimization by making opexvar, OpexVar and GenDual scenario dependent and then making the resulting new variable opexvar[t] the weighted average of the scenario dependent opexvar[t,s] as follows opexvar[t] = ∑^^ opexvar[t, s] · ^^^^^^^^^^^^^^^^^^^^^^^[^^] . Objective Function The model will then minimize the objective function defined as: (5) suma( (capex[t] + opexfix [t] + opexvar [t]) * Rate[t] for t in T ) Results GenUni[iter,g,t] = g_ext[g,t] / GenCap[g,t] Subproblem The formulation of the subproblem for the traditional method is presented in an illustrative way below.Minimizes the operating costs of the system for a given generation capacity plan produced by the master problem for a given stage and also the scenario in case of stochastic optimization. Returns both the total operating costs and the dual variables needed in the master problem. Sets g: Index of power generators (total G) b: Index of branches (lines, cables and transformers) (total B) s: Index of storage facilities (total S) t: Index of time periods (total T) Variables g_cap: Installed generating capacity [MW]. g_gen: Power generation [MW] g_gen_max: Maximum power generation [MW].g_onl: Number of units that are on [#] g_sta: Number of units that start [#] g_stp: Number of units that stop [#] g_res: Generation reserves to be ramped up [MW] g_rea: Reactive power generation [MVAr] s_cap: Installed storage capacity considering all units [MW]. s_gen: Storage generation [MW] s_sto: Storage power [MW] s_lev: Storage level [MWh] s_gen_max: Maximum storage generation [MW]. s_res: Storage reserves to be ramped up [MW]. s_rea: Reactive storage generation [MVAr] b_flujo: Apparent flow [MVA] b_act: Active flow [MW] b_rea: Reactive flow [MVAr] b_break: Breaker status [binary, 1: open, 0: closed]. b_angdelta: Delta angle on both sides of the branch [Rad] b_voldelta: Voltage delta on both sides of the branch [pu]. b_slack: Slack in the branch [MW / MVAr]. b_slack_bin: Line status [binary, 1: not available, 0: available].b_tap: Tap position on the branch [#] b_actloss: Active power losses [MW] b_realoss: Reactive power losses [MVAr] n_ang: Voltage angle [Rad] n_vol: Voltage amplitude [up] n_rea: Reactive power at the node [MVAr]. Parameters GenRat: Power generator availability [pu] GenCap: Capacity of each power generation unit [MW]. GenTMi: Technical minimum generation as a percentage of capacity [up]. GenRUp: Ramp-up rate as a percentage of capacity [up / min]. GenRDo: Ramp-down rate as a percentage of capacity [up / min]. GenPRe: Maximum reserves to be ramped up per unit [MW].GenMUT: First time period to consider for the minimum uptime constraint [#] GenMDT: First time period to consider for the minimum downtime constraint [#] GenUMx: Maximum number of generation units allowed [#] GenUni: Number of generation units available in the current iteration [#] GenStC: Generator start-up costs [currency / #] GenOMV: Generator variable costs [currency / MWh]. StoRat: Storage availability [pu]. StoCap: Capacity of each storage unit [MW]. StoRes: Maximum upstream reserves as a percentage of capacity [up]. StoUMx: Maximum number of storage units allowed [#] StoUni: Number of storage units available in the current iteration [#] StoSto: Storage capacity per unit [MWh]. StoPRe: Storage reserves per unit [MW] StoEff: Storage efficiency [up] StoMax: Storage capacity per unit [MWh] BraRat: Branch availability [pu] BraCap: Capacity of each branch unit [MW]. BraUni: Number of branch units available in the current iteration [#] BraImA: Imaginary admittance of branch [up] BraReA: Actual admittance of branch [up] BraAnS: Sensitivity of angular difference to tap [Rad / tap]. BraAnR: Angle difference at nominal position [Rad / tap]. BraVoS: Sensitivity of voltage difference to tap [up / tap]. BraVoR: Voltage difference at nominal position [pu / tap]. BraBRe: Slope of active losses segment [MW / tap]. BraARe: Reference of active losses segment [MW] BraBRq: Slope of reactive losses segment [MVAr / tap]. BraARq: Reference of reactive losses segment [MVAr]. BraRea: Branch reactance [up] BraRes: Branch resistance [up] BraShu: Shunt reactive power at nominal voltage [MVAr].NodBra: List of branches connected to a node NodGen: List of generators connected to a node NodSto: List of storage devices connected to a node FNoBra: List of branches connected to a node from TNoBra: List of branches connected to a node to PDeDem: Power demand [MW] PDeRea : Reactive power demand [MW] SysRes: System reserve needs [MW] Duration: Duration of the current time period [hours]. Constraints Constraints (1, 2) limit the available power generation taking into account the available capacity, the rated power as well as the number of started units. (1) g_gen_max[g, t] <= GenRat[g, t] * GenCap[g, t] * GenUni[iter,g,t] (2) g_gen_max[g, t] <= g_onl[g, t] * GenCap[g, t] * GenRat[g,t] Constraints (3, 4) limit the power generation taking into account the available power generation as well as the technical minimum factor.(3) g_gen[g, t] >= g_gen_max[g,t] * GenTMi[g,t] (4) g_gen[g, t] <= g_gen_max[g,t] The restrictions (5, 6) limit the ramps up and down of the power generators when they are started, during starts and stops the ramp limits are deactivated. (5) g_gen[g, t] - g_gen[g, t-1] <= GenRUp[g,t] * 60 * Duration [t] * GenCap[g, t] * GenUni[iter,g,t] + GenUni[iter,g, t] * GenCap[g, t] * g_sta[g, t] (6) g_gen[g, t] - g_gen[g, t-1] >=- GenRDo[g,t] * 60 * Duration [t] * GenCap[g, t] * GenUni[iter,g,t] - GenUni[iter,g, t] * GenCap[g, t] * g_stp[g, t] The restrictions (7, 8) limit the provision of reserves taking into account the available electricity generation, as well as the maximum reserve factor to be increased. [g, t]. [iter,g,t] Constraints (9, 10) trigger start and stop procedures when changes in the starting state of the generators occur. (9) g_onl[g, t-1] - g_onl[g, t] <= g_stp[g, t] (10) g_onl[g, t] - g_onl[g, t-1] <= g_sta[g, t] Constraints (11, 12) force the units to be started or stopped for at least a predefined time after the start or stop procedures. (11) g_onl[g, t] >= sum( g_sta[g, tt] for tt in GenMUT[g, t]:(t-1) ) (12) g_onl[g, t] <= GenUni[iter,g,t] - sum( g_stp[g, tt] for tt in GenMDT[g, t]:(t- 1)) The constraints (13, 14, 15) limit the storage generation and loading taking into account the available capacity, the power as well as the number of available units. (13) s_gen_max[s, t] <= StoRat[s, t] * StoCap[s, t] * StoUni[iter,s,t] [iter,s,t] The constraints (16, 17) limit the provision of reserves taking into account the available generation, as well as the maximum reserve factor to be increased. s_gen[s, t] [iter,s,t] Constraints (18, 19) calculate and limit the storage level. (18) s_lev Duration (19) s_lev[s, t] <= StoMax[s, t] * StoUni[iter,s,t] Constraint (20) limits the power flows to the available capacity, taking into account the nominal power, the number of started units and the breaker status if any. (20) b_flow[b, t] <= BraRat[b, t] * BraCap[b, t] * BraUni[iter,b,t] * (1-b_break[b, t]) The power flows result from the combination of the active and reactive power flows. The relationship is not linear and is approximated by constraints 21 to 28; however, more constraints can be added to increase the accuracy. (21) b_act[b, t] <= b_flow[b, t] (22) -b_act[b, t] <= b_flow[b, t] (23) b_rea[b, t] <= b_flow[b, t] (24) -b_rea[b, t] <= b_flow[b, t] (25) ( b_act[b, t] + b_rea[b, t] ) / sqrt(2) <= b_flow[b, t] (26) (-b_act[b, t] + b_rea[b, t] ) / sqrt(2) <= b_flow[b, t] (27) ( b_act[b, t] - b_rea[b, t] ) / sqrt(2) <= b_flow[b, t] (28) (-b_act[b, t] - b_rea[b, t] ) / sqrt(2) <= b_flow[b,t] The active and reactive flows in electricity transmission networks and potentially in distribution networks result in this invention from the utilization of linear factors relating these flows to the angles and voltage moduli for each network element of the system. (28) b_act[b,t] + ( n_ang[ni(b),t] - n_ang [nj(b),t] + b_angdelta[b,t]) / BraImA [b,t] - ( n_vol[ni(b), t] - n_vol [nj(b), t] + b_voldelta[Re]= b[b, t]) / (29) b_act[b,t] + ( n_ang[ni(b),t] - n_ang [nj(b),t] + b_angdelta[b,t]) / BraImA [b,t] - ( n_vol[ni(b), t] - n_vol [nj(b), t] + b_voldelta[Re]= Brab[b[b]) / t] (30) b_rea[b,t] + ( n_ang[ni(b),t] - n_ang [nj(b),t] + b_angdelta[b,t]) / BraReA [b,t] + ( n_vol[ni(b), t] - n_vol [nj(b), t] + b_voldelta[B]m[b] b[b][ (31) b_rea[b,t] + ( n_ang[ni(b),t] - n_ang [nj(b),t] + b_angdelta[b,t]) / BraReA [b,t] + ( n_vol [ni(b),t] - n_vol [nj(b),t] + b_voldelta[b,t=b]) - b_m[t] The voltage angles and moduli are also limited: (32) - π <= b_ang[n, t] <= π (33) 0.9 <= b_vol[n, t] <= 1.1 The following constraints determine the slack that disables the constraints determining the active and reactive power flows (28-31) for those lines that are not built (where l_slack_bin is equal to one) and when the breaker is open (where b_break is equal to one). (34) b_slack[b, t] <= ( b_slack_bin[l,t] + b_break[b,t] * 5 ) * BraCap[b, t] The impact of the transformer taps is represented by linear factors that relate the tap position to the voltage angles and moduli: (35) b_angdelta[b, t] == ​​b_tap[b, t] * BraAnS[b] + BraAnR[b] (36) b_voldelta[b, t] == ​​b_tap[b, t] * BraAnS[b] + BraAnR[b](37) b_actloss[b, t] >= b_flow[b, t] * BraBRe[b,seg] + BraARe[b,seg] (38) b_realoss[b, t] >= b_flow[b, t] * BraBRq[b,seg] + BraARq[b,seg] (39) b_realoss[b, t] <= b_actloss[b, t] * BraRea[b] / BraRes[b] While the shunts and line capacitance can be approximated using linear factors with the voltage level and considering the breaker position:, for b in NodBra(n)) Constraint (41) establishes the requirements to satisfy the reserve needs of the system. (41) sum( g_res [g, t] for g in [1,G] ) + sum( s_res [s, t] for s in [1,S] ) >= SysRes[t] Constraints (42, 43) evaluate the coverage of the active and reactive power demand. (42) sum( g_gen [g, t] for g in NodGen(n)) + sum( s_gen [s, t] for s in NodSto(n))+ sum( b_act[b, t] for b in TNoBra(n) ) - sum( b_act[b, t] for b in FNoBra(n) ) - 0.5 * sum(b_actloss[b, t] for b in TNoBra(n)) - 0.5 * sum(b_actloss [b, t] for b in FNoBra(n)) == PDeDem[n,t] (43) sum(g_rea[g,t] for g in NodGen(n))+sum(s_rea[s,t] for s in NodSto(n))+ sum( b_rea[b, t] for b in TNoBra(n)) - sum(b_rea[b, t] for b in FNoBra(n)) - 0.5 * sum(b_realoss[b, t] for b in TNoBra(n)) - 0.5 * sum(b_realoss[b, t] for b in FNoBra(n)) + n_rea[n,t] == ​​PDeRea[n,t] Objective function (44) sum(g_gen[g,t]*GenOMV[g]+g_sta[g,t]*GenStC[g] for t in [1,T] and g in [1,G]) Results OpexVar[t]=sum(g_gen[g,t]*GenOMV[g]+g_sta[g,t]*GenStC[g] for t in [1,T] and g in [1,G]) GenDual[iter, g, t] = Dual(1) * GenRat[g, t] StoDual[iter, s, t] = Dual(13) * StoRat[s, t] + Dual(15) * StoRat[s, t] * StoSto[s, t] / StoCap[s, t] + Dual(19) * StoRat[s, t] * StoMax[s, t] / StoCap[s, t] BraDual[iter, b, t] = Dual(20) * BraRat[b, t] * value(b_break[b, t]) + Dual(34) * ( valor(b_slack_bin[b,t]) + 5 * valor(b_break[b, t])) The above dual variables can only be calculated in linear problems, and there are two binary variables that make the problem integer: • In the case of the breaker activation variable (b_break), in the reliability analysis it can be declared as a binary variable while for minimum cost planning it would have to be relaxed, which would be an approximation. However,It is possible to transfer the variable to the master problem to consider it as a main decision variable, taking into account its value also in the optimality cuts. • In the case of the binary variable that reflects the availability of the branch (b_slack_bin), it would be set according to whether the line is available or not. of the master problem presents a modification with respect to the traditional implementation in which the cut envelope of the master problem (4) that forms the resource function is updated using callback functions at each iteration. Callback function Shares the result with the subproblems Waits for the subproblems Loads the results from the subproblems Adds new cuts to the envelope that describe the operating costs End Results The results required by the subproblems are derived from the proposed expansion plan reflecting the installed capacity (e.g., g_cap) that is calculated as: g_cap[g,t] = g_ext[g,t] The calculation of the results for storage (s) and branches (b) is analogous. The modifications of the subproblem formulation are presented in an illustrative way below.In this case, the parameters indicating the available capacity are replaced by a variable (g_cap, s_cap, b_cap) that is updated each time the master problem proposes a new plan. In this section, we only represent the constraints that require modification with respect to the traditional implementation. Constraints Constraints (1, 2) limit the available energy generation taking into account the available capacity, the rated power, as well as the number of units started. Constraints (5, 6) limit the ramp-up and ramp-down of the power generators when they are started, during starts and stops the ramp limits are deactivated. (5) g_gen[g, t] - g_gen[g, t-1] <= GenRUp[g,t] * 60 * Duration [t] * g_cap[g,t] + GenUMx[g, t] * GenCap[g, t] * g_sta[g, t] (6) g_gen[g, t] - g_gen[g, t-1] >= - GenRDo[g,t] * 60 * Duration [t] * g_cap[g,t] - GenUMx[g, t] * GenCap[g, t] * g_stp[g, t] Constraint (8) limits the provision of reserves taking into account the available electricity generation as well as the maximum reserve factor to be ramped up. (8) g_res[g, t] <= GenPRe[g, t] * g_cap[g,t] / GenCap[g, t] Constraint (12) forces the units to be started or stopped for at least a predefined time after the start or stop procedures.(12) g_onl[g,t] <= g_cap[g,t] / GenCap[g,t] - sum(g_stp[g,tt] for tt in GenMDT[g,t]:(t-1)) The constraints (13,15,19) correct the value to set the limit of the output power (s_gen_max), the load power (s_sto) and the storage level (s_lev). Constraints (20a, 20b) limit the maximum flow through a branch. The two constraints have been split to avoid a nonlinear representation, in which the capacity variable would be multiplying the switch activation variable. The following constraint forces the branch slack binary variable to zero when the line is available: (34b) b_slack_bin[b, t] <= 1 - b_cap[b,t] / BraCap[b, t] Results In this advanced implementation, the dual variables are defined using the reduced cost of the capacity variable instead of from the dual variable of the constraints. GenDual[iter, g, t] = CosteReducido(g_cap[g, t]) StoDual[iter, s, t] = CosteReducido (s_cap[s, t]) BraDual[iter, b, t] = CosteReducido (b_cap[b, t]) RELIABILITY ANALYSIS FORMULATION For the reliability analysis, the master problem does not use optimization but Monte Carlo based variance reduction techniques to generate the outage schedules. The subproblems are the same as those used for minimum-cost planning, however, in this case the available capacity does not change because the expansion plan changes, but because the random failure schedule changes.The master problem generates a list of subproblems to be solved. It generates different random failure schedules and shares them with the subproblems. It considers them by updating the available capacity variables (g_cap, s_cap, and b_cap), and solves them asynchronously. The master problem oversees the computation, collects results as they become available, and evaluates progress. Once the target stopping criteria are met, it stops the ongoing processes and outputs the model results. Schedules are generated using random variables that take into account the probability distribution of the time between outages and the repair time. These variance reduction techniques have been shown to reduce the number of samples required: • Latin hypercube sampling (LHS): This is a stratification technique that has been shown to reduce the variance associated with variable interactions.It more evenly distributes the random variables used to determine outage schedules, ensuring that the feasible space is covered more evenly. To do this, we first define the batch size, typically one or two years, then evaluate the possible number of failures expected to occur in that period, divide the range of the random variables by the number of failures, generate a stratified sample of the random variables, and finally, randomly reorder the variables. • Importance sampling (IS): Its advantages derive from the overweighting of those events that, although they have a low probability of occurrence, may have a greater impact on the results. The probabilities are modified to increase the relevance of the samples while covering a wide range of situations. The results are adjusted using Bayesian probability.ALTERNATIVE POWER FLOW FORMULATIONS The approach can also be applied using second-order conic programming, which is very accurate for radial distribution networks. Second-order conic programming considers variable substitution to linearize power flows as shown in the following equations: ^^^^^^ = ^^^^^^^^^^^^^^^^^^^(^^^^^^ )^^^^^^ = ^^^^^^^^(^^^^^^ )^^ ^^ ^^^^ = ^^^^^^^^^^^^^^^^^^^^(^^^^^^^ − 0.5 · ^^ · ^^^ ^ ^ ^ ^ ℎ ^ ) ^^ ^^ ^^^^ = ^^^^^^^^(^^^^^^ − 0.5 · ^^ · ^^^ ^ ^ ^ ^ ℎ ^ ) ^^^^^^ = ^^^^^^^^^^^^^^^^^^^^^ branch^^ ^^ℎ ^^^^ = ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^Relaxing constraint (c) makes the problem convex: The above equations, due to the substitution of variables, do not guarantee that in the case of meshed networks the sum of voltage angles across branches in a closed loop is zero, so cyclic constraints of the following form can be added to enforce them: This approach is also applicable when not all network elements can be modeled and the impact of transformer tapping, breaker / switchgear reconfiguration and redistribution on power flows is assessed with sensitivity factors, in this case the sensitivities would need to be recalculated outside the optimization problem and the load flows would be evaluated using the following equations:(f) ^^^^^^ = ^^^^^^,0 + ∑^^ ^^ ... ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^The present invention may be implemented as a programmatically executable process.Furthermore, the present invention may be implemented within a computing device in which programmatic instructions are stored and from which programmatic instructions may be loaded into the memory of a data processing system and executed therefrom for the purpose of performing the aforementioned programmatically executable process. Similarly, the present invention may be implemented within a data processing system adapted to load programmatic instructions from a computing device and subsequently execute the programmatic instructions for the purpose of performing the aforementioned programmatically executable process. For this purpose, the computing device is a non-transitory computer-readable storage medium or media that preserves or stores computer-readable program instructions.These instructions, when executed from memory by one or more processing units of a data processing system, cause the processing units to carry out different programmatic processes exemplifying different aspects of the programmatically executable process. In this sense, the processing units each include an instruction execution device, such as a central processing unit or "CPU" of a computer. One or more computers may be included in the data processing system. It should be noted that although the CPU may be single-core, it should be understood that multiple CPU cores may operate within the CPU, and in either case, instructions are loaded directly from memory into one or more of the cores of one or more of the CPUs for execution.Aside from directly loading instructions from memory for execution by one or more cores of a CPU or CPUs, the computer-readable program instructions described herein may alternatively be retrieved from a computer communications network into the memory of a data processing system computer for execution thereon. Furthermore, only a portion of the program instructions may be retrieved into memory via the computer communications network, while other portions may be loaded from the computer's persistent storage.Likewise, only a portion of the program instructions may be executed by one or more processing cores of one or more CPUs of one of the computers of the data processing system, while other portions may be executed cooperatively within a different computer of the data processing system that is co-located with the computer or remotely located from the computer via the computer communications network, sharing the computational results of both computers. The structures, materials, acts, and corresponding equivalents of all means or elements of the step plus function of the following claims are intended to include any structure, material, or act for carrying out the function in combination with other claimed elements as specifically claimed.The description of the present invention has been presented for illustrative and descriptive purposes, but is not intended to be exhaustive or to be limited to the invention as disclosed. Numerous modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the invention. The embodiments were chosen and described to best explain the principles of the invention and its practical application, and to enable others skilled in the art to understand the invention in various embodiments with various modifications as appropriate for the particular use contemplated.

Claims

MODIFIED CLAIMS received by the International Bureau on December 30, 2024 (30.12.2024) 1. A speedup method for large-scale optimization problems comprising the steps of: • decompose the large-scale optimization problem into a master problem and a set of subproblems, using a technique selected from Benders decomposition, Danzig Wolfe decomposition or Lagrangian relaxation, which are solved iteratively; • modify the master problem and subproblems to use incremental optimization: in the master problem, by adding new constraints during its execution, where the new constraints separate feasible solutions from infeasible solutions and where the set of constraints defines an envelope of feasible solutions; and in the subproblems, the value of the master problem's proposals is an input defined as a variable that is updated at each iteration; • where the master problem and subproblems are solved using distributed computing techniques, involving multiple computers at the same time where the master problem and subproblems are implemented using asynchronous parallel computing, the master problem starting a next iteration when the rate at which new subproblems are completed falls below a predefined threshold and the proportion of completed runs exceeds a minimum bound, and the subproblems being configured to take the most recent solution to the master problem, allowing that when faster optimization subproblems have finished, new optimization subproblems can continue without having to wait for slower ones and where the master problem and / or subproblems are implemented using microservices or loosely coupled HPC instances.

2. The method according to claim 1, wherein the large-scale optimization problem is a minimum-cost planning or a reliability analysis.

3. The method according to claim 2, wherein the variance reduction techniques are selected from Latin Hypercube Sampling (LHS) and Importance Sampling (IS), and are implemented in conjunction with asynchronous optimization when solves a reliability analysis problem.

4. The method according to claim 1, wherein the microservices can be implemented using serverless microservices or using containers.

5. The method according to claims 1 to 4, wherein the large-scale optimization problems are applied to the generation, storage, transmission and distribution of electrical energy.

6. The method according to claim 5, wherein the optimization problem includes the representation of active and reactive load flows with linearized equations, with second order cones with or without cyclic restrictions.

7. The method according to claims 1 to 6, wherein Benders decomposition is used and the envelope represents a relation of the decisions of the first stage (x) on the objective function of the subproblem (optimality cuts) that is updated in each iteration using callback functions.

8. The method according to claim 7, wherein the gradients of the decisions of the first stage (ü k ,or L ) are defined as the reduced cost of the first-stage variables, and the first-stage decisions (x) are defined as a variable of the subproblem, and its value is updated at each iteration based on the outcome of the master problem: If feasible: ü k= ResidualCost(y) If it is not feasible: ü t = ResidualCost(y) 9. The method according to claims 1 to 6, wherein the optimization problem is a least-cost scheduling problem, wherein the master problem proposes a new infrastructure expansion, the subproblems return the operating costs for the given expansion, and the cutting plane envelope, representing the operating costs, is updated at each iteration by callback functions.

10. The method according to claims 1 to 6, wherein the optimization problem is a reliability analysis, wherein the master problem uses reduction techniques. Monte Carlo-based variance estimators are used to generate random outage schedules, and subproblems that consider available capacity evaluate the resulting unserved energy. 1 1. The method according to claim 10, wherein the master problem generates a list of subproblems to be solved, and for each execution it generates a different schedule of faults and shares them with the subproblems to update the capacity variables available for asynchronous solving, also the master problem supervises the computation without interfering, collects results as they become available and evaluates their progress and once some objective stopping criteria are met it generates model results and stops the ongoing processes.

12. The method according to claim 10, wherein the failure programs are generated using random variables taking into account the probability distribution of the time between outages and the repair time.

13. The method according to claim 10, implemented for second order cones, which considers a variable substitution to linearize the power flows as shown in the following equations: (a) Pj = g t c j • w ¿ - g tj • wj + b tj ■ w L L ¡ (b) Qi¡ = b t c j • w ¿ - b tj • wj - 9ij ■ w L L ¡ where: w ¿ = (v ¿ ) 2 W ij = V i ■ V j ■ C0S (^i — ^7 ) w L-Jj = V Ij ■ VJ ■ sin Í xi9; I — i9 J; Zb L = Imaginary(and L ) 9ij = Real yg ) 0.5 • i • dT) 9 = Realty^ - 0.5 • i • b ) yij = Branch admittance bj - 1 = Branch charge susceptance relaxing the constraint (c) makes it convex: (C) w ¿- Wj > (wfj) 2 + (wL) 2 14. The method according to claim 13, wherein cyclic constraints of the following form are added to enforce that, in case of meshed networks, the sum of the tension angles across the branches in a closed loop is zero:

15. The method according to claim 13, wherein the impact of a transformer tap, breaker / switch reconfiguration and redistribution on the power flows is evaluated with sensitivity factors, recalculating the sensitivities at each iteration outside the optimization problem and evaluating the load flows by the following equations: (f) Ptj = Ptj0+ Z ' m modifications m ■ Sensitivities m (9) Qij = Qij.o + im modifications m ■ Sensitivities m 16. A speedup method for large-scale optimization problems comprising the steps of: • decompose the large-scale optimization problem into a master problem and a set of subproblems, using a Benders decomposition, which are solved iteratively; • modify the master problem and subproblems to use incremental optimization: in the master problem, by adding new constraints during its execution, where the new constraints separate feasible solutions from infeasible solutions and where the set of constraints defines an envelope of feasible solutions; and in the subproblems, the value of the master problem's proposals is an input defined as a variable that is updated at each iteration; • where the master problem and subproblems are solved using distributed computing techniques, involving several computers at the same time where the master problem and subproblems are implemented using asynchronous parallel computing, the master problem starting a next iteration when the the rate at which new subproblems are completed falls below a predefined threshold and the proportion of completed runs exceeds a minimum bound, and the subproblems being configured to take the most recent solution from the master problem, allowing that when the faster optimization subproblems have finished, new optimization subproblems can continue without having to wait for the slower ones and where the envelope represents a ratio of the first stage decisions (x) over the subproblem objective function (optimality cuts) that is updated at each iteration using callback functions. [0001] [0002]DECLARATION PURSUANT TO PARAGRAPH 1 OF ARTICLE 19 [0003]In accordance with Article 19.1 of the PCT, a new set of claims has been filed which replaces the set of claims originally filed, in which the following modifications have been made: [0004]- New claim 1 has been modified to match the scope of original claims 1, 2, 3 and 6, in accordance with the Examiner's suggestion. [0005]- Original claims 2, 3 and 6 have been deleted. [0006]- New claims 2 to 15 have been renumbered accordingly. [0007]- New claim 16 has been introduced to coincide with the scope of original claims 1, 2, 3 and 10, in accordance with the Examiner's suggestion.

Images