power-grid-optimization

電力系統の最適化

電力系統の最適化と電力ネットワーク管理の専門家として、信頼性が高く、費用対効果に優れ、持続可能な電力供給を実現するために、系統の安定性を維持し、規制要件を満たしながら、電力の発電、送電、配電の最適化を支援します。

初期評価

電力系統の運用を最適化する前に、次の項目を把握します。

1. 系統の構成と規模

   • 系統のレベルはどれですか？（送電、配電、マイクログリッド）
   • 対象地域はどこですか？（地域内、広域、全国）
   • ノード、送電線、変電所の数はどれくらいですか？
   • 電圧レベルはどれですか？（HV、MV、LV）

2. 発電構成

   • どのような発電源がありますか？（化石燃料、原子力、再生可能エネルギー、水力）
   • 総発電容量と各発電ユニットの容量はどれくらいですか？
   • 再生可能エネルギーの導入率はどれくらいですか？
   • 発電の柔軟性と出力変化率はどれくらいですか？

3. 負荷特性

   • 最大需要とベース負荷はどれくらいですか？
   • 負荷パターン（日次、季節別）はどのようなものですか？
   • 産業用、商業用、家庭用の構成比はどれくらいですか？
   • デマンドレスポンスには対応できますか？

4. 目的と制約

   • 主な目標は何ですか？（コスト、信頼性、排出量、安定性）
   • 系統の制約は何ですか？（送電線容量、電圧制限）
   • 規制要件は何ですか？（信頼性基準、市場ルール）
   • 統合に関する課題は何ですか？（再生可能エネルギー、EV、蓄電）

---

電力系統のフレームワーク

系統の構成要素

発電：

• 従来型発電所（石炭、ガス、原子力）
• 再生可能エネルギー発電（風力、太陽光）
• 水力発電
• エネルギー貯蔵システム
• 分散型電源（屋根置き太陽光、マイクログリッド）

送電：

• 高圧送電線（115-765 kV）
• 変電所と変圧器
• 系統間連系
• HVDC（高圧直流）送電線

配電：

• 中圧フィーダー（4-35 kV）
• 低圧配電（< 1 kV）
• 配電用変電所
• スマートメーターとセンサー

制御システム：

• SCADA（監視制御およびデータ収集）
• EMS（エネルギー管理システム）
• DMS（配電管理システム）
• DERMS（分散型エネルギーリソース管理システム）

---

最適潮流計算（OPF）

AC最適潮流計算

電力系統運用における基本的な最適化問題です。

import numpy as np
import pandas as pd
from pyomo.environ import *

def solve_optimal_power_flow(buses, generators, lines, demand):
    """
    Solve AC Optimal Power Flow problem

    Objective: Minimize generation cost while satisfying power balance
              and network constraints

    Parameters:
    - buses: list of {id, type, voltage_limits}
    - generators: list of {id, bus, pmin, pmax, cost_coefficients}
    - lines: list of {from_bus, to_bus, resistance, reactance, limit}
    - demand: dict of {bus_id: {active_power, reactive_power}}
    """

    model = ConcreteModel()

    # Sets
    model.BUSES = Set(initialize=[b['id'] for b in buses])
    model.GENERATORS = Set(initialize=[g['id'] for g in generators])
    model.LINES = Set(initialize=range(len(lines)))

    # Variables

    # Voltage magnitude and angle at each bus
    model.V = Var(model.BUSES, domain=NonNegativeReals, bounds=(0.95, 1.05))
    model.theta = Var(model.BUSES, domain=Reals, bounds=(-np.pi, np.pi))

    # Active and reactive power generation
    model.Pg = Var(model.GENERATORS, domain=NonNegativeReals)
    model.Qg = Var(model.GENERATORS, domain=Reals)

    # Power flow on lines
    model.Pij = Var(model.LINES, domain=Reals)
    model.Qij = Var(model.LINES, domain=Reals)

    # Objective: Minimize generation cost
    def cost_rule(m):
        total_cost = 0
        for g in generators:
            gen_id = g['id']
            # Quadratic cost: c2*P^2 + c1*P + c0
            c2, c1, c0 = g['cost_coefficients']
            total_cost += c2 * m.Pg[gen_id]**2 + c1 * m.Pg[gen_id] + c0
        return total_cost

    model.cost = Objective(rule=cost_rule, sense=minimize)

    # Constraints

    # Power balance at each bus
    def active_power_balance_rule(m, bus):
        generation = sum(m.Pg[g['id']]
                        for g in generators if g['bus'] == bus)

        demand_p = demand.get(bus, {}).get('active_power', 0)

        # Net injections from lines
        injection = sum(m.Pij[l] for l, line in enumerate(lines)
                       if line['from_bus'] == bus) - \
                   sum(m.Pij[l] for l, line in enumerate(lines)
                       if line['to_bus'] == bus)

        return generation - demand_p == injection

    model.active_balance = Constraint(model.BUSES, rule=active_power_balance_rule)

    # Generator limits
    def gen_limit_rule(m, gen_id):
        g = next(gen for gen in generators if gen['id'] == gen_id)
        return (g['pmin'], m.Pg[gen_id], g['pmax'])

    model.gen_limits = Constraint(model.GENERATORS, rule=gen_limit_rule)

    # Line flow limits
    def line_limit_rule(m, line_idx):
        line = lines[line_idx]
        # Apparent power limit: S = sqrt(P^2 + Q^2) <= Smax
        return m.Pij[line_idx]**2 + m.Qij[line_idx]**2 <= line['limit']**2

    model.line_limits = Constraint(model.LINES, rule=line_limit_rule)

    # Reference bus (slack bus)
    slack_bus = next(b['id'] for b in buses if b['type'] == 'slack')
    model.slack_constraint = Constraint(expr=model.theta[slack_bus] == 0)

    # Solve
    solver = SolverFactory('ipopt')
    results = solver.solve(model, tee=False)

    # Extract results
    solution = {
        'status': results.solver.status,
        'objective': value(model.cost),
        'generation': {g: value(model.Pg[g]) for g in model.GENERATORS},
        'voltages': {b: value(model.V[b]) for b in model.BUSES},
        'angles': {b: value(model.theta[b]) for b in model.BUSES},
        'line_flows': {l: value(model.Pij[l]) for l in model.LINES}
    }

    return solution

# Example usage
buses = [
    {'id': 'Bus1', 'type': 'slack', 'voltage_limits': (0.95, 1.05)},
    {'id': 'Bus2', 'type': 'PQ', 'voltage_limits': (0.95, 1.05)},
    {'id': 'Bus3', 'type': 'PQ', 'voltage_limits': (0.95, 1.05)},
]

generators = [
    {'id': 'Gen1', 'bus': 'Bus1', 'pmin': 0, 'pmax': 200,
     'cost_coefficients': (0.01, 40, 0)},  # c2, c1, c0
    {'id': 'Gen2', 'bus': 'Bus2', 'pmin': 0, 'pmax': 150,
     'cost_coefficients': (0.015, 30, 0)},
]

lines = [
    {'from_bus': 'Bus1', 'to_bus': 'Bus2',
     'resistance': 0.01, 'reactance': 0.1, 'limit': 100},
    {'from_bus': 'Bus2', 'to_bus': 'Bus3',
     'resistance': 0.02, 'reactance': 0.15, 'limit': 80},
]

demand = {
    'Bus2': {'active_power': 80, 'reactive_power': 20},
    'Bus3': {'active_power': 100, 'reactive_power': 25},
}

# result = solve_optimal_power_flow(buses, generators, lines, demand)

DC潮流計算（簡易版）

def solve_dc_power_flow(buses, generators, lines, demand):
    """
    Solve DC Optimal Power Flow (linearized)

    Simpler and faster than AC-OPF, suitable for real-time operations
    """
    from pulp import *

    prob = LpProblem("DC_OPF", LpMinimize)

    # Variables
    P = {}  # Generator output
    theta = {}  # Voltage angles
    Pij = {}  # Line flows

    for g in generators:
        P[g['id']] = LpVariable(f"P_{g['id']}",
                               lowBound=g['pmin'],
                               upBound=g['pmax'])

    for b in buses:
        if b['type'] == 'slack':
            theta[b['id']] = 0  # Reference
        else:
            theta[b['id']] = LpVariable(f"theta_{b['id']}",
                                       lowBound=-3.14,
                                       upBound=3.14)

    for idx, line in enumerate(lines):
        Pij[idx] = LpVariable(f"Pij_{idx}",
                             lowBound=-line['limit'],
                             upBound=line['limit'])

    # Objective: minimize generation cost
    prob += lpSum([g['cost_coefficients'][1] * P[g['id']]
                  for g in generators])

    # Constraints

    # Power balance at each bus
    for b_id in [b['id'] for b in buses]:
        generation = lpSum([P[g['id']] for g in generators if g['bus'] == b_id])
        demand_p = demand.get(b_id, {}).get('active_power', 0)

        # Line flows
        outflow = lpSum([Pij[idx] for idx, line in enumerate(lines)
                        if line['from_bus'] == b_id])
        inflow = lpSum([Pij[idx] for idx, line in enumerate(lines)
                       if line['to_bus'] == b_id])

        prob += generation - demand_p == outflow - inflow

    # DC power flow equation: Pij = B * (theta_i - theta_j)
    for idx, line in enumerate(lines):
        susceptance = 1 / line['reactance']  # B = 1/X

        if isinstance(theta[line['from_bus']], LpVariable) and \
           isinstance(theta[line['to_bus']], LpVariable):
            prob += Pij[idx] == susceptance * (
                theta[line['from_bus']] - theta[line['to_bus']]
            )
        elif isinstance(theta[line['from_bus']], LpVariable):
            prob += Pij[idx] == susceptance * theta[line['from_bus']]
        elif isinstance(theta[line['to_bus']], LpVariable):
            prob += Pij[idx] == -susceptance * theta[line['to_bus']]

    # Solve
    prob.solve(PULP_CBC_CMD(msg=0))

    return {
        'status': LpStatus[prob.status],
        'total_cost': value(prob.objective),
        'generation': {g: P[g].varValue for g in P},
        'line_flows': {idx: Pij[idx].varValue for idx in Pij},
        'angles': {b: theta[b].varValue if isinstance(theta[b], LpVariable)
                  else theta[b] for b in theta}
    }

---

発電ユニット起動停止計画

火力発電ユニットの起動停止計画

計画期間にわたって、どの発電機を起動・停止するかを決定します。

def solve_unit_commitment(generators, demand_forecast, time_periods=24):
    """
    Solve unit commitment problem with startup/shutdown costs

    Parameters:
    - generators: list of {id, pmin, pmax, marginal_cost, startup_cost,
                          min_up_time, min_down_time, initial_status}
    - demand_forecast: list of demand for each time period
    - time_periods: number of hours to optimize
    """
    from pulp import *

    prob = LpProblem("Unit_Commitment", LpMinimize)

    T = range(time_periods)

    # Variables

    # Generator commitment (on/off)
    u = {}
    # Generator output
    p = {}
    # Startup/shutdown
    v = {}  # startup
    w = {}  # shutdown

    for g in generators:
        for t in T:
            u[g['id'], t] = LpVariable(f"u_{g['id']}_{t}", cat='Binary')
            p[g['id'], t] = LpVariable(f"p_{g['id']}_{t}", lowBound=0)
            v[g['id'], t] = LpVariable(f"v_{g['id']}_{t}", cat='Binary')
            w[g['id'], t] = LpVariable(f"w_{g['id']}_{t}", cat='Binary')

    # Objective: minimize total cost
    total_cost = []

    # Generation cost
    for g in generators:
        for t in T:
            total_cost.append(g['marginal_cost'] * p[g['id'], t])

    # Startup cost
    for g in generators:
        for t in T:
            total_cost.append(g['startup_cost'] * v[g['id'], t])

    prob += lpSum(total_cost)

    # Constraints

    # Demand satisfaction
    for t in T:
        prob += lpSum([p[g['id'], t] for g in generators]) >= demand_forecast[t]

    # Generation limits
    for g in generators:
        for t in T:
            prob += p[g['id'], t] >= g['pmin'] * u[g['id'], t]
            prob += p[g['id'], t] <= g['pmax'] * u[g['id'], t]

    # Startup/shutdown logic
    for g in generators:
        for t in range(1, time_periods):
            # v = 1 if unit starts (off -> on)
            # w = 1 if unit shuts down (on -> off)
            prob += u[g['id'], t] - u[g['id'], t-1] == \
                    v[g['id'], t] - w[g['id'], t]

    # Minimum up time
    for g in generators:
        min_up = g.get('min_up_time', 4)
        for t in range(time_periods - min_up + 1):
            # If starts at t, must stay on for min_up periods
            prob += lpSum([u[g['id'], t + tau] for tau in range(min_up)]) >= \
                    min_up * v[g['id'], t]

    # Minimum down time
    for g in generators:
        min_down = g.get('min_down_time', 4)
        for t in range(time_periods - min_down + 1):
            # If shuts down at t, must stay off for min_down periods
            prob += lpSum([1 - u[g['id'], t + tau] for tau in range(min_down)]) >= \
                    min_down * w[g['id'], t]

    # Solve
    prob.solve(PULP_CBC_CMD(msg=0))

    # Extract schedule
    schedule = {}
    for g in generators:
        schedule[g['id']] = {
            'commitment': [u[g['id'], t].varValue for t in T],
            'generation': [p[g['id'], t].varValue for t in T]
        }

    return {
        'status': LpStatus[prob.status],
        'total_cost': value(prob.objective),
        'schedule': schedule
    }

# Example
generators = [
    {'id': 'Coal_1', 'pmin': 100, 'pmax': 400, 'marginal_cost': 30,
     'startup_cost': 10000, 'min_up_time': 4, 'min_down_time': 4},
    {'id': 'Gas_1', 'pmin': 50, 'pmax': 200, 'marginal_cost': 45,
     'startup_cost': 2000, 'min_up_time': 2, 'min_down_time': 2},
    {'id': 'Gas_2', 'pmin': 50, 'pmax': 200, 'marginal_cost': 50,
     'startup_cost': 2000, 'min_up_time': 2, 'min_down_time': 2},
]

demand_forecast = [300, 280, 260, 250, 270, 300, 350, 400,
                  450, 480, 500, 510, 500, 490, 480, 470,
                  460, 480, 500, 480, 450, 400, 360, 320]

result = solve_unit_commitment(generators, demand_forecast)

---

再生可能エネルギーの統合

風力・太陽光発電の予測における不確実性

def optimize_dispatch_with_renewables(generators, renewable_forecast,
                                     demand_forecast, reserve_requirement=0.15):
    """
    Optimal dispatch considering renewable uncertainty

    Include spinning reserve for renewable variability
    """
    from pulp import *

    prob = LpProblem("Dispatch_with_Renewables", LpMinimize)

    # Variables
    P_conventional = {}
    P_renewable_scheduled = LpVariable("P_renewable", lowBound=0)
    reserve = {}

    for g in generators:
        P_conventional[g['id']] = LpVariable(f"P_{g['id']}",
                                            lowBound=g['pmin'],
                                            upBound=g['pmax'])
        reserve[g['id']] = LpVariable(f"Reserve_{g['id']}", lowBound=0)

    # Objective: minimize cost
    generation_cost = lpSum([g['marginal_cost'] * P_conventional[g['id']]
                            for g in generators])

    # Reserve cost (opportunity cost)
    reserve_cost = lpSum([g['marginal_cost'] * 0.1 * reserve[g['id']]
                         for g in generators])

    prob += generation_cost + reserve_cost

    # Constraints

    # Energy balance
    total_demand = demand_forecast
    renewable_expected = renewable_forecast['expected']

    prob += (lpSum([P_conventional[g['id']] for g in generators]) +
            P_renewable_scheduled >= total_demand)

    # Renewable forecast
    prob += P_renewable_scheduled <= renewable_expected

    # Reserve requirement (handle renewable uncertainty)
    renewable_std = renewable_forecast.get('std_dev', renewable_expected * 0.2)
    required_reserve = reserve_requirement * total_demand + 2 * renewable_std

    prob += lpSum([reserve[g['id']] for g in generators]) >= required_reserve

    # Generator capacity with reserve
    for g in generators:
        prob += P_conventional[g['id']] + reserve[g['id']] <= g['pmax']

    # Solve
    prob.solve(PULP_CBC_CMD(msg=0))

    return {
        'status': LpStatus[prob.status],
        'total_cost': value(prob.objective),
        'conventional_generation': {g: P_conventional[g].varValue for g in P_conventional},
        'renewable_scheduled': P_renewable_scheduled.varValue,
        'reserves': {g: reserve[g].varValue for g in reserve}
    }

出力抑制の最小化

def minimize_renewable_curtailment(renewable_generation, demand,
                                  transmission_capacity, storage_capacity):
    """
    Minimize renewable energy curtailment using transmission and storage

    Parameters:
    - renewable_generation: array of renewable output by time period
    - demand: array of demand by time period
    - transmission_capacity: max power flow between regions
    - storage_capacity: {energy_capacity_mwh, power_capacity_mw, efficiency}
    """
    from pulp import *

    T = len(renewable_generation)
    prob = LpProblem("Curtailment_Minimization", LpMinimize)

    # Variables
    curtailment = [LpVariable(f"Curtail_{t}", lowBound=0)
                  for t in range(T)]

    storage_charge = [LpVariable(f"Charge_{t}", lowBound=0,
                                upBound=storage_capacity['power_capacity_mw'])
                     for t in range(T)]

    storage_discharge = [LpVariable(f"Discharge_{t}", lowBound=0,
                                   upBound=storage_capacity['power_capacity_mw'])
                        for t in range(T)]

    storage_level = [LpVariable(f"Storage_{t}", lowBound=0,
                               upBound=storage_capacity['energy_capacity_mwh'])
                    for t in range(T)]

    # Objective: minimize curtailment
    prob += lpSum(curtailment)

    # Constraints
    for t in range(T):
        # Energy balance
        prob += (renewable_generation[t] - curtailment[t] +
                storage_discharge[t] - storage_charge[t] >= demand[t])

        # Storage dynamics
        if t == 0:
            prev_level = storage_capacity['energy_capacity_mwh'] * 0.5  # Initial 50%
        else:
            prev_level = storage_level[t-1]

        eff = storage_capacity['efficiency']
        prob += storage_level[t] == prev_level + \
                storage_charge[t] * eff - storage_discharge[t] / eff

    # Solve
    prob.solve(PULP_CBC_CMD(msg=0))

    return {
        'total_curtailment_mwh': value(prob.objective),
        'curtailment_by_period': [curtailment[t].varValue for t in range(T)],
        'storage_operation': {
            'charge': [storage_charge[t].varValue for t in range(T)],
            'discharge': [storage_discharge[t].varValue for t in range(T)],
            'level': [storage_level[t].varValue for t in range(T)]
        }
    }

---

系統信頼性と事故解析

N-1事故解析

def n_minus_1_contingency_analysis(base_case, lines, generators):
    """
    Analyze grid reliability under single contingency (N-1 criterion)

    Test if grid can handle loss of any single element
    """
    import copy

    contingencies = []

    # Test line outages
    for idx, line in enumerate(lines):
        # Create contingency case
        contingency_lines = copy.deepcopy(lines)
        contingency_lines.pop(idx)

        # Try to solve OPF
        try:
            result = solve_dc_power_flow(
                base_case['buses'],
                generators,
                contingency_lines,
                base_case['demand']
            )

            if result['status'] == 'Optimal':
                # Check for overloads
                overloads = []
                for line_idx, flow in result['line_flows'].items():
                    if abs(flow) > contingency_lines[line_idx]['limit'] * 0.95:
                        overloads.append({
                            'line': line_idx,
                            'flow': flow,
                            'limit': contingency_lines[line_idx]['limit']
                        })

                contingencies.append({
                    'contingency_type': 'line_outage',
                    'element': f"Line_{idx}",
                    'status': 'Acceptable' if not overloads else 'Violation',
                    'overloads': overloads,
                    'cost_increase': result['total_cost'] - base_case['cost']
                })
            else:
                contingencies.append({
                    'contingency_type': 'line_outage',
                    'element': f"Line_{idx}",
                    'status': 'Infeasible',
                    'message': 'Cannot serve load'
                })

        except Exception as e:
            contingencies.append({
                'contingency_type': 'line_outage',
                'element': f"Line_{idx}",
                'status': 'Error',
                'message': str(e)
            })

    # Test generator outages
    for gen in generators:
        contingency_gens = [g for g in generators if g['id'] != gen['id']]

        try:
            result = solve_dc_power_flow(
                base_case['buses'],
                contingency_gens,
                lines,
                base_case['demand']
            )

            contingencies.append({
                'contingency_type': 'generator_outage',
                'element': gen['id'],
                'status': 'Acceptable' if result['status'] == 'Optimal' else 'Violation',
                'cost_increase': result['total_cost'] - base_case['cost']
                                if result['status'] == 'Optimal' else None
            })

        except Exception as e:
            contingencies.append({
                'contingency_type': 'generator_outage',
                'element': gen['id'],
                'status': 'Error',
                'message': str(e)
            })

    return {
        'total_contingencies': len(contingencies),
        'violations': [c for c in contingencies if c['status'] == 'Violation'],
        'contingency_details': contingencies
    }

---

デマンドレスポンスと負荷管理

デマンドレスポンスの最適化

def optimize_demand_response(demand_baseline, dr_programs, generation_cost):
    """
    Optimize demand response programs to reduce peak demand

    Parameters:
    - demand_baseline: array of baseline demand by hour
    - dr_programs: list of {id, max_reduction_mw, cost_per_mwh, hours_available}
    - generation_cost: array of marginal generation cost by hour
    """
    from pulp import *

    T = len(demand_baseline)
    prob = LpProblem("Demand_Response", LpMinimize)

    # Variables: DR activation by program and hour
    dr_activation = {}
    for p, program in enumerate(dr_programs):
        for t in range(T):
            if t in program['hours_available']:
                dr_activation[p, t] = LpVariable(
                    f"DR_{p}_{t}",
                    lowBound=0,
                    upBound=program['max_reduction_mw']
                )

    # Net demand after DR
    net_demand = {}
    for t in range(T):
        net_demand[t] = LpVariable(f"NetDemand_{t}", lowBound=0)

    # Objective: minimize total cost (generation + DR payments)
    prob += lpSum([generation_cost[t] * net_demand[t] for t in range(T)]) + \
            lpSum([dr_programs[p]['cost_per_mwh'] * dr_activation[p, t]
                  for (p, t) in dr_activation])

    # Constraints
    for t in range(T):
        # Net demand = baseline - DR reductions
        dr_reductions = lpSum([dr_activation[p, t]
                              for (p_, t_) in dr_activation
                              if t_ == t])
        prob += net_demand[t] == demand_baseline[t] - dr_reductions

    # Solve
    prob.solve(PULP_CBC_CMD(msg=0))

    return {
        'total_cost': value(prob.objective),
        'net_demand': [net_demand[t].varValue for t in range(T)],
        'dr_activations': {(p, t): dr_activation[p, t].varValue
                          for (p, t) in dr_activation
                          if dr_activation[p, t].varValue > 0.1},
        'peak_reduction': max(demand_baseline) - max([net_demand[t].varValue
                                                      for t in range(T)])
    }

---

ツールとライブラリ

Pythonライブラリ

電力系統解析：

• PyPSA：電力系統解析
• PYPOWER：潮流計算とOPF
• pandapower：電力系統のモデリングと解析
• PowerModels.jl (Julia)：高度な電力系統最適化
• GridCal：系統計算ソフトウェア

最適化：

• Pyomo：最適化モデリング
• PuLP：線形計画法
• gurobipy、cplex：商用ソルバー

データと可視化：

• pandas、numpy：データ操作
• matplotlib、plotly：可視化
• networkx：ネットワーク解析

商用ソフトウェア

系統運用：

• GE ADMS：高度配電管理システム
• Siemens Spectrum Power：エネルギー管理システム
• ABB Network Manager：SCADA/EMS
• OSIsoft PI System：リアルタイムデータ基盤

計画と解析：

• PSS/E (Siemens)：電力系統シミュレーション
• PowerWorld Simulator：系統解析と可視化
• ETAP：電力系統解析
• DIgSILENT PowerFactory：電力系統計画

市場運用：

• Energy Exemplar PLEXOS：エネルギー市場シミュレーション
• ABB Ability Market Management System
• GE MAPS：市場分析・価格設定システム

---

よくある課題と解決策

課題：再生可能エネルギーの変動性

問題：

• 太陽光発電と風力発電の出力が断続的である
• 予測誤差
• 系統安定性に関する懸念

解決策：

• エネルギー貯蔵の導入
• 柔軟な発電（出力を迅速に調整できるガス発電）
• デマンドレスポンスプログラム
• 予測の改善（機械学習）
• 地理的な多様化

課題：系統混雑

問題：

• 送電線の容量制限
• ピーク時間帯のボトルネック
• 再生可能エネルギーの出力抑制

解決策：

• 動的線路定格（気象条件に応じた定格）
• 送電網の拡張計画
• 需要側管理
• エネルギー貯蔵設備の配置
• 系統トポロジーの最適化

課題：電圧安定性

問題：

• 電圧逸脱（高すぎる、または低すぎる）
• 無効電力の不均衡
• 長距離の配電線

解決策：

• コンデンサバンクと電圧調整器
• 電圧を支援する分散型電源
• スマートインバーター（無効電力制御）
• 負荷時タップ切換器（OLTC）
• ボルト・バール最適化（VVO）

課題：サイバーセキュリティ

問題：

• SCADA システムの脆弱性
• デジタル化の進展
• 重要インフラへの攻撃の脅威

解決策：

• 多層防御型のセキュリティアーキテクチャ
• ネットワークのセグメント化
• 侵入検知システム
• 定期的なセキュリティ監査
• インシデント対応計画

---

出力形式

系統運用レポート

エグゼクティブサマリー：

• 現在の系統状況と性能
• 主な最適化結果
• 信頼性指標
• 実現したコスト削減額

発電機の給電指令：

発電機	容量（MW）	運転指令	出力（MW）	限界費用（$/MWh）	総費用（$）
Coal_1	400	はい	380	30	11,400
Gas_1	200	はい	150	45	6,750
Wind	300	はい	250	0	0
Solar	200	はい	120	0	0

系統信頼性：

指標	値	目標	状況
SAIDI（分／年）	85	< 100	✓ 合格
SAIFI（停電回数／年）	1.2	< 1.5	✓ 合格
N-1 故障時想定の基準を満たした割合	98%	> 95%	✓ 合格
電圧逸脱	0	0	✓ 合格

コスト分析：

カテゴリー	金額	合計に占める割合
発電コスト	$18.15M	85%
予備力コスト	$1.50M	7%
デマンドレスポンスの支払い	$1.20M	6%
アンシラリーサービス	$0.45M	2%
合計	$21.30M	100%

推奨事項：

1. 再生可能エネルギーの出力抑制を減らすため、エネルギー貯蔵を 50 MW 増やす
2. 効率を改善するため、Feeder 23 で電圧最適化を実施する
3. ピーク需要をさらに 30 MW 削減するため、デマンドレスポンスプログラムを拡大する
4. 混雑を緩和するため、送電線 X-Y をアップグレードする

---

質問事項

追加の情報が必要な場合：

1. どの階層の系統を最適化しますか？（送電、配電、または両方）
2. 発電構成と再生可能エネルギーの導入率はどの程度ですか？
3. 主な目標は何ですか？（コスト、信頼性、排出量）
4. どのような系統データを利用できますか？（トポロジー、線路パラメーター、負荷プロファイル）
5. 満たす必要のある制約条件は何ですか？（電圧制限、線路容量制限、N-1）
6. リアルタイム運用と計画のどちらを行いますか？
7. 市場構造はどのようなものですか？（規制対象の電力会社、自由化市場）

---

関連スキル

• renewable-energy-planning：再生可能エネルギーによる発電の導入について
• energy-storage-optimization：蓄電池およびエネルギー貯蔵システムについて
• energy-logistics：燃料供給とエネルギー商品について
• demand-forecasting：負荷予測について
• network-design：送電計画について
• optimization-modeling：高度な最適化手法について
• risk-mitigation：系統のレジリエンスと故障時想定の計画について