energy-storage-optimization

name

energy-storage-optimization

description

When the user wants to optimize battery storage systems, manage energy storage operations, or plan storage deployment. Also use when the user mentions "battery optimization," "BESS," "energy storage management," "battery dispatch," "storage arbitrage," "grid-scale storage," "battery sizing," or "storage scheduling." For renewable integration, see renewable-energy-planning. For grid operations, see power-grid-optimization.

Energy Storage Optimization

You are an expert in energy storage optimization and battery management. Your goal is to help optimize the deployment, sizing, operation, and economics of energy storage systems (batteries, pumped hydro, compressed air, etc.) for grid services, renewable integration, and cost reduction.

Initial Assessment

Before optimizing energy storage, understand:

1. Storage Application

   • Primary use case? (arbitrage, peak shaving, renewables, backup)
   • Grid services? (frequency regulation, voltage support, black start)
   • Customer type? (utility, commercial, industrial, residential)
   • Location and grid connection?

2. Storage Technology

   • Technology type? (Li-ion, flow battery, pumped hydro, CAES)
   • Power capacity (MW or kW)?
   • Energy capacity (MWh or kWh)?
   • Round-trip efficiency?
   • Cycle life and degradation?

3. System Parameters

   • Load profile and patterns?
   • Renewable generation (if applicable)?
   • Electricity pricing structure? (TOU, real-time, demand charges)
   • Grid constraints or requirements?

4. Objectives & Constraints

   • Primary goal? (cost savings, reliability, renewable integration)
   • Budget and economics? (capex, payback period)
   • Physical constraints? (space, temperature, safety)
   • Regulatory requirements or incentives?

---

Energy Storage Framework

Storage Technologies

Electrochemical (Batteries):

• Lithium-ion: High efficiency (90-95%), fast response, declining costs
• Flow batteries: Long duration, independent power/energy scaling
• Lead-acid: Mature, low cost, limited cycle life
• Sodium-sulfur: High energy density, high temperature operation

Mechanical:

• Pumped hydro: Largest capacity, 70-85% efficiency, site-specific
• Compressed air (CAES): Large scale, geological storage required
• Flywheels: High power, short duration, long cycle life

Thermal:

• Molten salt: CSP integration, 6-15 hours duration
• Ice storage: Cooling applications, load shifting

Hydrogen:

• Power-to-gas: Seasonal storage, 30-40% round-trip efficiency
• Fuel cells: Backup power, longer duration

---

Storage Sizing Optimization

Optimal Battery Sizing

import numpy as np
import pandas as pd
from pulp import *

def optimize_battery_sizing(load_profile, solar_generation, electricity_prices,
                           max_power_mw=10, max_energy_mwh=40):
    """
    Determine optimal battery size for load shifting and solar firming

    Parameters:
    - load_profile: array of load (MW) by hour
    - solar_generation: array of solar output (MW) by hour
    - electricity_prices: array of prices ($/MWh) by hour
    - max_power_mw: maximum power capacity to consider
    - max_energy_mwh: maximum energy capacity to consider
    """

    # Evaluate different battery sizes
    power_sizes = np.linspace(1, max_power_mw, 10)
    energy_sizes = np.linspace(2, max_energy_mwh, 10)

    results = []

    for power_mw in power_sizes:
        for energy_mwh in energy_sizes:
            # Energy/Power ratio (hours)
            duration = energy_mwh / power_mw

            if duration < 0.5 or duration > 10:
                continue  # Skip infeasible ratios

            # Calculate annual value
            annual_value = optimize_battery_dispatch(
                load_profile,
                solar_generation,
                electricity_prices,
                power_mw,
                energy_mwh
            )['annual_value']

            # Calculate cost
            power_cost = power_mw * 150000  # $/MW
            energy_cost = energy_mwh * 300000  # $/MWh
            total_capex = power_cost + energy_cost

            
            discount_rate = 
            years = 
            npv = -total_capex + ([annual_value / ( + discount_rate)**y
                                      y  (, years + )])

            results.append({
                : power_mw,
                : energy_mwh,
                : duration,
                : total_capex,
                : annual_value,
                : npv,
                : total_capex / annual_value  annual_value >   
            })

    
    results_df = pd.DataFrame(results)
    optimal = results_df.loc[results_df[].idxmax()]

     {
        : {
            : optimal[],
            : optimal[],
            : optimal[]
        },
        : {
            : optimal[],
            : optimal[],
            : optimal[],
            : optimal[]
        },
        : results_df
    }

 ():
    
    T = (load)
    prob = LpProblem(, LpMaximize)

    
    charge = [LpVariable(, lowBound=, upBound=power_mw)
              t  (T)]
    discharge = [LpVariable(, lowBound=, upBound=power_mw)
                 t  (T)]
    soc = [LpVariable(, lowBound=, upBound=energy_mwh)
           t  (T)]

    
    prob += lpSum([(discharge[t] * prices[t] - charge[t] * prices[t])
                   t  (T)])

    
     t  (T):
        
         t == :
            prob += soc[t] == energy_mwh *  + \
                    charge[t] * efficiency - discharge[t] / efficiency
        :
            prob += soc[t] == soc[t-] + \
                    charge[t] * efficiency - discharge[t] / efficiency

    
    prob += soc[T-] == energy_mwh * 

    
    prob.solve(PULP_CBC_CMD(msg=))

    
    daily_value = value(prob.objective)
    annual_value = daily_value * 

     {
        : daily_value,
        : annual_value,
        : [charge[t].varValue  t  (T)],
        : [discharge[t].varValue  t  (T)],
        : [soc[t].varValue  t  (T)]
    }



hours = 
load = [, , , , , , , , , , , ,
       , , , , , , , , , , , ]

solar = [, , , , , , , , , , , ,
        , , , , , , , , , , , ]

prices = [, , , , , , , , , , , ,
         , , , , , , , , , , , ]

result = optimize_battery_sizing(load, solar, prices,
                                max_power_mw=, max_energy_mwh=)

(
     )
()
()

---

Energy Arbitrage Optimization

Price-Based Arbitrage

def optimize_energy_arbitrage(prices, power_capacity, energy_capacity,
                              efficiency=0.9, cycles_per_day=1):
    """
    Optimize battery operation for energy arbitrage

    Buy low, sell high based on electricity prices
    """
    from pulp import *

    T = len(prices)
    prob = LpProblem("Arbitrage", LpMaximize)

    # Variables
    charge = [LpVariable(f"Charge_{t}", lowBound=0, upBound=power_capacity)
             for t in range(T)]
    discharge = [LpVariable(f"Discharge_{t}", lowBound=0, upBound=power_capacity)
                for t in range(T)]
    soc = [LpVariable(f"SOC_{t}", lowBound=0, upBound=energy_capacity)
          for t in range(T)]

    # Binary variables for charge/discharge (prevent simultaneous)
    u_charge = [LpVariable(f"U_charge_{t}", cat='Binary') for t in range(T)]
    u_discharge = [LpVariable(f"U_discharge_{t}", cat='Binary') for t in range(T)]

    # Objective: maximize profit
    revenue = lpSum([discharge[t] * prices[t] for t in range(T)])
    cost = lpSum([charge[t] * prices[t]  t  (T)])
    prob += revenue - cost

    
     t  (T):
        
         t == :
            initial_soc = energy_capacity * 
            prob += soc[t] == initial_soc + \
                    charge[t] * efficiency - discharge[t] / efficiency
        :
            prob += soc[t] == soc[t-] + \
                    charge[t] * efficiency - discharge[t] / efficiency

        
        prob += u_charge[t] + u_discharge[t] <= 

        
        prob += charge[t] <= power_capacity * u_charge[t]
        prob += discharge[t] <= power_capacity * u_discharge[t]

    
    max_throughput = energy_capacity * cycles_per_day
    prob += lpSum([discharge[t]  t  (T)]) <= max_throughput

    
    prob.solve(PULP_CBC_CMD(msg=))

     {
        : value(prob.objective),
        : ([discharge[t].varValue * prices[t]  t  (T)]),
        : ([charge[t].varValue * prices[t]  t  (T)]),
        : [charge[t].varValue  t  (T)],
        : [discharge[t].varValue  t  (T)],
        : [soc[t].varValue  t  (T)],
        : ([discharge[t].varValue  t  (T)]) / energy_capacity
    }

---

Peak Shaving & Demand Charge Reduction

Commercial/Industrial Peak Shaving

def optimize_peak_shaving(load_forecast, demand_charge_rate,
                         energy_rate, power_capacity, energy_capacity):
    """
    Optimize battery to reduce demand charges

    Demand charges based on monthly peak demand
    """
    from pulp import *

    T = len(load_forecast)
    prob = LpProblem("Peak_Shaving", LpMinimize)

    # Variables
    charge = [LpVariable(f"Charge_{t}", lowBound=0, upBound=power_capacity)
             for t in range(T)]
    discharge = [LpVariable(f"Discharge_{t}", lowBound=0, upBound=power_capacity)
                for t in range(T)]
    soc = [LpVariable(f"SOC_{t}", lowBound=0, upBound=energy_capacity)
          for t in range(T)]

    # Net load from grid
    net_load = [LpVariable(f"NetLoad_{t}", lowBound=0) for t in range(T)]

    # Peak demand (maximum of net load)
    peak_demand = LpVariable("PeakDemand", lowBound=0)

    # Objective: minimize total cost
    demand_cost = demand_charge_rate * peak_demand
    energy_cost = lpSum([net_load[t] * energy_rate[t] for t in range(T)])

    prob += demand_cost + energy_cost

    # Constraints
    for t  (T):
        
        prob += net_load[t] == load_forecast[t] - discharge[t] + charge[t]

        
        prob += peak_demand >= net_load[t]

        
         t == :
            prob += soc[t] == energy_capacity *  + \
                    charge[t] *  - discharge[t] / 
        :
            prob += soc[t] == soc[t-] + \
                    charge[t] *  - discharge[t] / 

    
    prob.solve(PULP_CBC_CMD(msg=))

    original_peak = (load_forecast)
    new_peak = peak_demand.varValue

     {
        : value(prob.objective),
        : new_peak,
        : original_peak,
        : original_peak - new_peak,
        : (original_peak - new_peak) / original_peak * ,
        : demand_charge_rate * (original_peak - new_peak),
        : [charge[t].varValue  t  (T)],
        : [discharge[t].varValue  t  (T)],
        : [net_load[t].varValue  t  (T)]
    }


load_forecast = [, , , , , , , , , , , ,
                , , , , , , , , , , , ]

demand_charge =   
energy_rate = [] *   

result = optimize_peak_shaving(load_forecast, demand_charge, energy_rate,
                               power_capacity=, energy_capacity=)

(
     )
()

---

Renewable Energy Firming

Solar + Storage Optimization

def optimize_solar_plus_storage(solar_generation, load, power_capacity,
                                energy_capacity, tariff_structure):
    """
    Optimize storage with solar to maximize self-consumption
    and minimize grid imports
    """
    from pulp import *

    T = len(solar_generation)
    prob = LpProblem("Solar_Storage", LpMinimize)

    # Variables
    charge = [LpVariable(f"Charge_{t}", lowBound=0, upBound=power_capacity)
             for t in range(T)]
    discharge = [LpVariable(f"Discharge_{t}", lowBound=0, upBound=power_capacity)
                for t in range(T)]
    soc = [LpVariable(f"SOC_{t}", lowBound=0, upBound=energy_capacity)
          for t in range(T)]

    grid_import = [LpVariable(f"Import_{t}", lowBound=0) for t in range(T)]
    grid_export = [LpVariable(f"Export_{t}", lowBound=0) for t in range(T)]

    # Objective: minimize electricity cost
    import_cost = lpSum([grid_import[t] * tariff_structure['import_rate'][t]
                        for t in range(T)])
    export_revenue = lpSum([grid_export[t] * tariff_structure[][t]
                            t  (T)])

    prob += import_cost - export_revenue

    
     t  (T):
        
        
        prob += load[t] == solar_generation[t] + discharge[t] - charge[t] + \
                grid_import[t] - grid_export[t]

        
        prob += charge[t] <= solar_generation[t]

        
         t == :
            prob += soc[t] == energy_capacity *  + \
                    charge[t] *  - discharge[t] / 
        :
            prob += soc[t] == soc[t-] + \
                    charge[t] *  - discharge[t] / 

    
    prob.solve(PULP_CBC_CMD(msg=))

    
    total_import = ([grid_import[t].varValue  t  (T)])
    total_export = ([grid_export[t].varValue  t  (T)])
    total_load = (load)
    total_solar = (solar_generation)

    self_consumption = total_solar - total_export
    self_consumption_rate = self_consumption / total_solar * 

     {
        : value(prob.objective),
        : total_import,
        : total_export,
        : self_consumption,
        : self_consumption_rate,
        : [charge[t].varValue  t  (T)],
        : [discharge[t].varValue  t  (T)],
        : [soc[t].varValue  t  (T)]
    }

---

Grid Services & Frequency Regulation

Frequency Regulation Bidding

def optimize_frequency_regulation(regulation_prices, energy_prices,
                                 power_capacity, energy_capacity,
                                 performance_score=0.95):
    """
    Optimize battery participation in frequency regulation market

    Parameters:
    - regulation_prices: dict with 'reg_up' and 'reg_down' prices ($/MW)
    - energy_prices: real-time energy prices ($/MWh)
    - power_capacity: battery power rating (MW)
    - energy_capacity: battery energy capacity (MWh)
    - performance_score: historical performance (affects payment)
    """
    from pulp import *

    T = len(regulation_prices['reg_up'])
    prob = LpProblem("Frequency_Regulation", LpMaximize)

    # Variables
    reg_up_capacity = [LpVariable(f"RegUp_{t}", lowBound=0, upBound=power_capacity)
                      for t in range(T)]
    reg_down_capacity = [LpVariable(f"RegDown_{t}", lowBound=0, upBound=power_capacity)
                        for t in range(T)]

    energy_position = [LpVariable(f"Energy_{t}") for t in range(T)]

    # Objective: maximize regulation revenue
    reg_up_revenue = lpSum([reg_up_capacity[t] * regulation_prices['reg_up'][t] *
                           performance_score for t in range(T)])
    reg_down_revenue = lpSum([reg_down_capacity[t] * regulation_prices['reg_down'][t] *
                             performance_score for t in range(T)])

    prob += reg_up_revenue + reg_down_revenue

    
     t  (T):
        
        prob += reg_up_capacity[t] + reg_down_capacity[t] <= power_capacity

        
        
        prob += energy_position[t] +  * reg_up_capacity[t] <= energy_capacity
        prob += energy_position[t] -  * reg_down_capacity[t] >= 

        
         t > :
            prob += energy_position[t] == energy_position[t-]

    prob += energy_position[] == energy_capacity * 

    
    prob.solve(PULP_CBC_CMD(msg=))

     {
        : value(prob.objective),
        : [reg_up_capacity[t].varValue  t  (T)],
        : [reg_down_capacity[t].varValue  t  (T)],
        : np.mean([reg_up_capacity[t].varValue + reg_down_capacity[t].varValue
                                         t  (T)])
    }

---

Battery Degradation & Lifetime Management

Degradation Modeling

class BatteryDegradationModel:
    """
    Model battery degradation from cycling and calendar aging
    """

    def __init__(self, initial_capacity_mwh, chemistry='li-ion'):
        self.initial_capacity = initial_capacity_mwh
        self.current_capacity = initial_capacity_mwh
        self.chemistry = chemistry
        self.total_cycles = 0
        self.total_throughput = 0

    def calculate_cycle_aging(self, depth_of_discharge, num_cycles):
        """
        Calculate capacity loss from cycling

        Cycle life depends on DOD:
        - 10% DOD: ~100,000 cycles
        - 50% DOD: ~10,000 cycles
        - 80% DOD: ~5,000 cycles
        - 100% DOD: ~3,000 cycles
        """
        if self.chemistry == 'li-ion':
            # Empirical cycle life model
            cycle_life_100 = 3000  # cycles at 100% DOD

            # Cycle life increases with lower DOD (roughly exponential)
            cycle_life = cycle_life_100 * (1 / depth_of_discharge) ** 0.5

            # Capacity loss per cycle
            loss_per_cycle = 0.2 / cycle_life  # 20% loss at EOL

            capacity_loss = loss_per_cycle * num_cycles

        elif self.chemistry == 'flow-battery':
            # Flow batteries have minimal cycle degradation
            capacity_loss = 0.0001 * num_cycles

        else:
            capacity_loss = 0

        .current_capacity -= capacity_loss
        .total_cycles += num_cycles

         capacity_loss

     ():
        
         .chemistry == :
            
            base_rate =  /   

            
            temp_factor = np.exp((avg_temp_c - ) * )

            
            soc_factor =  + (avg_soc - )

            daily_loss_rate = base_rate * temp_factor * soc_factor
            capacity_loss = daily_loss_rate * days * .initial_capacity

        :
            capacity_loss = 

        .current_capacity -= capacity_loss

         capacity_loss

     ():
        
         (.current_capacity / .initial_capacity) * 

     ():
        
        target_capacity = .initial_capacity * 
        remaining_capacity_to_lose = .current_capacity - target_capacity

         remaining_capacity_to_lose <= :
               

        
        cycle_loss_per_day = .calculate_cycle_aging(avg_dod, daily_cycles)

        
        calendar_loss_per_day = .calculate_calendar_aging()

        total_daily_loss = cycle_loss_per_day + calendar_loss_per_day

         total_daily_loss <= :
             ()

        remaining_days = remaining_capacity_to_lose / total_daily_loss

         remaining_days


battery = BatteryDegradationModel(initial_capacity_mwh=, chemistry=)


 day  ():
    
    battery.calculate_cycle_aging(depth_of_discharge=, num_cycles=)
    
    battery.calculate_calendar_aging(days=, avg_soc=, avg_temp_c=)

()
()

---

Multi-Use Case Value Stacking

Stacked Revenue Optimization

def optimize_multi_use_storage(use_cases, power_capacity, energy_capacity,
                               time_horizon=24):
    """
    Optimize battery across multiple revenue streams (value stacking)

    Use cases can include:
    - Energy arbitrage
    - Demand charge reduction
    - Frequency regulation
    - Capacity market
    - Renewable firming
    """
    from pulp import *

    prob = LpProblem("Value_Stacking", LpMaximize)

    T = time_horizon

    # Variables: power allocation to each use case
    allocation = {}
    for use_case in use_cases:
        for t in range(T):
            allocation[use_case['name'], t] = LpVariable(
                f"{use_case['name']}_{t}",
                lowBound=0,
                upBound=power_capacity
            )

    # Objective: maximize total revenue
    total_revenue = []

    for use_case in use_cases:
        for t in range(T):
            value_rate = use_case['value_per_mw_hour'][t]
            total_revenue.append(allocation[use_case['name'], t] * value_rate)

    prob += lpSum(total_revenue)

    # Constraints

    # Total power allocation cannot exceed capacity
    for t in range(T):
        prob += lpSum([allocation[uc['name'], t] for uc in use_cases]) <= power_capacity

    # Use case specific constraints
    for use_case in use_cases:
           use_case:
            
             t  (T):
                prob += allocation[use_case[], t] >= \
                        use_case[] * power_capacity

           use_case:
            
            prob += lpSum([allocation[use_case[], t]
                           t  (T)]) <= use_case[] * power_capacity

    
    prob.solve(PULP_CBC_CMD(msg=))

    
    revenue_breakdown = {}
     use_case  use_cases:
        revenue = ([allocation[use_case[], t].varValue *
                      use_case[][t]
                       t  (T)])
        revenue_breakdown[use_case[]] = revenue

     {
        : value(prob.objective),
        : revenue_breakdown,
        : {
            use_case[]: [allocation[use_case[], t].varValue
                               t  (T)]
             use_case  use_cases
        }
    }


use_cases = [
    {
        : ,
        : [, , , , , , , , , , , ,
                             , , , , , , , , , , , ]
    },
    {
        : ,
        : [] * ,
        : ,  
    },
    {
        : ,
        : []* + [, , , ] + []*,
        :   
    }
]

result = optimize_multi_use_storage(use_cases, power_capacity=,
                                   energy_capacity=, time_horizon=)

()
 uc, rev  result[].items():
    ()

---

Tools & Libraries

Python Libraries

Optimization:

• PuLP: Linear programming
• Pyomo: Advanced optimization modeling
• cvxpy: Convex optimization
• gurobipy: Gurobi optimizer

Battery Modeling:

• PyBaMM: Physics-based battery modeling
• scikit-learn: Machine learning for degradation

Energy Analysis:

• pvlib: Solar PV modeling
• pandapower: Power system analysis
• SAM (NREL): System Advisor Model

Data & Visualization:

• pandas, numpy: Data manipulation
• matplotlib, plotly: Visualization

Commercial Software

Energy Storage:

• Energy Toolbase: Battery storage analysis and proposals
• Homer Energy: Hybrid renewable energy system design
• CAISO BESS: Battery energy storage system tools
• Stem Athena: AI-powered storage optimization

Grid Integration:

• AutoGrid Flex: Distributed energy resource optimization
• Greensmith GEMS: Grid energy management system
• Fluence Mosaic: Battery energy storage platform
• Tesla Autobidder: Automated energy trading

Financial Analysis:

• Aurora: Energy market modeling
• Ascend Analytics: Storage valuation
• NREL REopt: Renewable energy integration

---

Common Challenges & Solutions

Challenge: Revenue Uncertainty

Problem:

• Volatile electricity prices
• Changing market rules
• Technology cost trends

Solutions:

• Conservative financial projections
• Diversified revenue streams (value stacking)
• Flexible contracts and PPAs
• Real options analysis
• Scenario-based planning

Challenge: Degradation Management

Problem:

• Battery capacity fade over time
• Warranty compliance
• Optimal replacement timing

Solutions:

• Degradation-aware dispatch algorithms
• State-of-health monitoring
• Conservative DOD and cycle limits
• Predictive maintenance
• Augmentation strategies

Challenge: Grid Integration

Problem:

• Interconnection delays and costs
• Grid service requirements
• Utility coordination

Solutions:

• Early interconnection applications
• Pre-approved equipment lists
• Clear operating procedures
• Regular communication with utility
• Compliance testing and certification

Challenge: Optimal Sizing

Problem:

• Uncertain future load/generation
• Technology cost evolution
• Competing use cases

Solutions:

• Sensitivity analysis on key parameters
• Modular/scalable designs
• Option value of waiting
• Pilot programs before full deployment
• Multi-year optimization

---

Output Format

Energy Storage Optimization Report

Executive Summary:

• Recommended storage system configuration
• Economic analysis and payback
• Primary value drivers
• Implementation roadmap

System Specifications:

Parameter	Value	Notes
Technology	Li-ion NMC	High energy density
Power Capacity	5 MW	AC rating
Energy Capacity	20 MWh	Usable capacity
Duration	4 hours	At rated power
Round-trip Efficiency	88%	AC-AC
Warranty	10 years / 5,000 cycles	80% EOL capacity

Economic Analysis:

Metric	Value
Capital Cost	$7.5M
Installation & EPC	$1.5M
Total Project Cost	$9.0M
Annual Revenue	$1.2M
Annual O&M	$75K
Net Annual Benefit	$1.125M
Simple Payback	8.0 years
NPV (15 years, 8%)	$3.2M
IRR	12.5%

Revenue Streams:

Revenue Source	Annual Value	% of Total
Energy Arbitrage	$450K	37%
Demand Charge Reduction	$380K	32%
Frequency Regulation	$270K	22%
Capacity Market	$100K	8%
Total	$1,200K	100%

Operational Strategy:

Time Period	Primary Use	Secondary Use	Avg. SOC Target
00:00-06:00	Charge (arbitrage)	-	80%
06:00-10:00	Frequency regulation	-	50%
10:00-14:00	Solar firming	Regulation	40%
14:00-20:00	Peak shaving	Arbitrage	20%
20:00-24:00	Discharge (arbitrage)	-	40%

Performance Metrics:

Metric	Target	Monitoring
Daily Cycles	1.2	SCADA logging
Avg. DOD	70%	BMS data
Availability	> 95%	Uptime tracking
Response Time	< 1 sec	Market compliance
SOH Degradation	< 2.5%/year	Quarterly testing

---

Questions to Ask

If you need more context:

1. What's the primary application? (arbitrage, peak shaving, renewables, grid services)
2. What's the scale? (residential, commercial, utility)
3. What's the grid tariff structure? (TOU, demand charges, real-time pricing)
4. What renewable generation exists or is planned?
5. What's the available budget or target payback period?
6. Are there space, temperature, or safety constraints?
7. What's the expected project lifetime?

---

Related Skills

• power-grid-optimization: For grid integration and dispatch
• renewable-energy-planning: For solar and wind pairing
• energy-logistics: For energy supply chain management
• demand-forecasting: For load and generation forecasting
• optimization-modeling: For advanced optimization techniques
• capacity-planning: For long-term capacity planning
• risk-mitigation: For financial and operational risk management