Commit f65ff1ef authored by Niina Helistö's avatar Niina Helistö
Browse files

Adding a threshold time index for omitting start-up and shutdown trajectories.

parent 7a856a42
......@@ -107,4 +107,7 @@ if (mType('building'),
// Define unit aggregation and efficiency levels starting indeces
mSettingsEff('building', 'level1') = 1;
// Define threshold for omitting start-up and shutdown trajectories
mSettings('schedule', 't_omitTrajectories') = 8761;
); // END if(mType)
......@@ -113,6 +113,9 @@ if (mType('invest'),
// Define unit aggregation and efficiency levels starting indeces
mSettingsEff('invest', 'level1') = 1;
// Define threshold for omitting start-up and shutdown trajectories
mSettings('schedule', 't_omitTrajectories') = 8761;
); // END if(mType)
......@@ -119,4 +119,7 @@ if (mType('schedule'),
mSettingsEff('schedule', 'level1') = 1;
mSettingsEff('schedule', 'level2') = 12;
// Define threshold for omitting start-up and shutdown trajectories
mSettings('schedule', 't_omitTrajectories') = 8761;
); // END if(mType)
......@@ -50,7 +50,8 @@ Sets
// Features
t_reserveLength, // Length of reserve provision horizon in time steps
t_aggregate // Unit aggregation threshold time index
t_aggregate, // Unit aggregation threshold time index
t_omitTrajectories // Threshold time index for omitting start-up and shutdown trajectories
/
// Solve info
......
......@@ -107,6 +107,8 @@ Sets
uft_online(unit, f, t) "Units with any online and startup variables on intervals"
uft_onlineLP(unit, f, t) "Units with LP online and startup variables on intervals"
uft_onlineMIP(unit, f, t) "Units with MIP online and startup variables on intervals"
uft_startupTrajectory(unit, f, t) "Units with start-up trajectories on intervals"
uft_shutdownTrajectory(unit, f, t) "Units with shutdown trajectories on intervals"
nuft(node, unit, f, t) "Enables aggregation of nodes and units for later intervals"
gnuft(grid, node, unit, f, t) "Enables aggregation of nodes and units for later intervals"
gnuft_ramp(grid, node, unit, f, t) "Units with ramp requirements or costs"
......
......@@ -174,7 +174,8 @@ q_maxDownward(m, gnuft(grid, node, unit, f, t))${ [ ord(t) < tSolveFirst + m
// Units that are in the run-up phase need to keep up with the run-up ramp rate (contained in p_ut_runUp)
+ p_gnu(grid, node, unit, 'unitSizeGen')
* sum(t_activeNoReset(t_)${ ord(t_) > ord(t) + dt_next(t) + dt_toStartup(unit, t + dt_next(t))
and ord(t_) <= ord(t) and uft_online(unit, f, t)},
and ord(t_) <= ord(t)
and uft_startupTrajectory(unit, f, t)},
+ sum(unitStarttype(unit, starttype),
+ v_startup(unit, starttype, f+df_central(f,t), t_)
* sum(t_full(t__)${ord(t__) = p_u_runUpTimeIntervalsCeil(unit) - ord(t) - dt_next(t) + 1 + ord(t_)}, // last step in the interval
......@@ -182,32 +183,33 @@ q_maxDownward(m, gnuft(grid, node, unit, f, t))${ [ ord(t) < tSolveFirst + m
* * 1 // test values [0,1] to provide some flexibility
) // END sum(t__)
) // END sum(unitStarttype)
)$p_u_runUpTimeIntervals(unit) // END sum(t_)
) // END sum(t_)
// Units that are in the last time interval of the run-up phase are limited by the minimum load (contained in p_ut_runUp(unit, 't00000'))
+ p_gnu(grid, node, unit, 'unitSizeGen')
* sum(t_activeNoReset(t_)${ ord(t_) = ord(t) + dt_next(t) + dt_toStartup(unit, t + dt_next(t))
and uft_online(unit, f, t)},
and uft_startupTrajectory(unit, f, t)},
+ sum(unitStarttype(unit, starttype),
+ v_startup(unit, starttype, f+df_central(f,t), t_)
* sum(t_full(t__)${ord(t__) = 1}, p_ut_runUp(unit, t__))
) // END sum(unitStarttype)
)$p_u_runUpTimeIntervals(unit) // END sum(t_)
) // END sum(t_)
// Units that are in the shutdown phase need to keep up with the shutdown ramp rate (contained in p_ut_shutdown)
+ p_gnu(grid, node, unit, 'unitSizeGen')
* sum(t_activeNoReset(t_)${ ord(t_) >= ord(t) + dt_next(t) + dt_toShutdown(unit, t + dt_next(t))
and ord(t_) < ord(t) and uft_online(unit, f, t)},
and ord(t_) < ord(t)
and uft_shutdownTrajectory(unit, f, t)},
+ v_shutdown(unit, f+df_central(f,t), t_)
* sum(t_full(t__)${ord(t__) = ord(t) - ord(t_) + 1},
+ p_ut_shutdown(unit, t__)
) // END sum(t__)
)$p_u_shutdownTimeIntervals(unit) // END sum(t_)
) // END sum(t_)
// Units that are in the first time interval of the shutdown phase are limited by the minimum load (contained in p_ut_shutdown(unit, 't00000'))
+ p_gnu(grid, node, unit, 'unitSizeGen')
* (
+ v_shutdown(unit, f+df_central(f,t), t)${uft_online(unit, f, t)}
+ v_shutdown(unit, f+df_central(f,t), t)${uft_shutdownTrajectory(unit, f, t)}
* sum(t_full(t__)${ord(t__) = 1}, p_ut_shutdown(unit, t__))
)$p_u_shutdownTimeIntervals(unit) // END * p_gnu(unitSizeGen)
) // END * p_gnu(unitSizeGen)
// Consuming units, greater than maxCons
// Available capacity restrictions
......@@ -315,38 +317,38 @@ q_maxUpward(m, gnuft(grid, node, unit, f, t))${ [ ord(t) < tSolveFirst + mSett
// Units that are in the run-up phase need to keep up with the run-up ramp rate (contained in p_ut_runUp)
+ p_gnu(grid, node, unit, 'unitSizeGen')
* sum(t_activeNoReset(t_)${ ord(t_) > ord(t) + dt_next(t) + dt_toStartup(unit, t + dt_next(t))
and ord(t_) <= ord(t) and uft_online(unit, f, t)},
and ord(t_) <= ord(t) and uft_startupTrajectory(unit, f, t)},
+ sum(unitStarttype(unit, starttype),
+ v_startup(unit, starttype, f+df_central(f,t), t_)
* sum(t_full(t__)${ord(t__) = p_u_runUpTimeIntervalsCeil(unit) - ord(t) - dt_next(t) + 1 + ord(t_)}, // last step in the interval
+ p_ut_runUp(unit, t__)
) // END sum(t__)
) // END sum(unitStarttype)
)$p_u_runUpTimeIntervals(unit) // END sum(t_)
) // END sum(t_)
// Units that are in the last time interval of the run-up phase are limited by the p_u_maxOutputInLastRunUpInterval
+ p_gnu(grid, node, unit, 'unitSizeGen')
* sum(t_activeNoReset(t_)${ ord(t_) = ord(t) + dt_next(t) + dt_toStartup(unit, t + dt_next(t))
and uft_online(unit, f, t)},
and uft_startupTrajectory(unit, f, t)},
+ sum(unitStarttype(unit, starttype),
+ v_startup(unit, starttype, f+df_central(f,t), t_) * p_u_maxOutputInLastRunUpInterval(unit)
) // END sum(unitStarttype)
)$p_u_runUpTimeIntervals(unit) // END sum(t_)
) // END sum(t_)
// Units that are in the shutdown phase need to keep up with the shutdown ramp rate (contained in p_ut_shutdown)
+ p_gnu(grid, node, unit, 'unitSizeGen')
* sum(t_activeNoReset(t_)${ ord(t_) >= ord(t) + dt_next(t) + dt_toShutdown(unit, t + dt_next(t))
and ord(t_) < ord(t) and uft_online(unit, f, t)},
and ord(t_) < ord(t) and uft_shutdownTrajectory(unit, f, t)},
+ v_shutdown(unit, f+df_central(f,t), t_)
* sum(t_full(t__)${ord(t__) = ord(t) - ord(t_) + 1},
+ p_ut_shutdown(unit, t__)
) // END sum(t__)
)$p_u_shutdownTimeIntervals(unit) // END sum(t_)
) // END sum(t_)
// Units that are in the first time interval of the shutdown phase are limited by p_u_maxOutputInFirstShutdownInterval
+ p_gnu(grid, node, unit, 'unitSizeGen')
* (
+ v_shutdown(unit, f+df_central(f,t), t)${uft_online(unit, f, t)}
+ v_shutdown(unit, f+df_central(f,t), t)${uft_shutdownTrajectory(unit, f, t)}
* p_u_maxOutputInFirstShutdownInterval(unit)
)$p_u_shutdownTimeIntervals(unit) // END * p_gnu(unitSizeGen)
) // END * p_gnu(unitSizeGen)
;
* --- Unit Startup and Shutdown -----------------------------------------------
......@@ -530,24 +532,24 @@ q_rampUpLimit(m, s, gnuft_ramp(grid, node, unit, f, t))${ ord(t) > msStart(m, s
// Units that are in the run-up phase need to keep up with the run-up ramp rate (contained in p_ut_runUp)
+ p_gnu(grid, node, unit, 'unitSizeGen')
* sum(t_activeNoReset(t_)${ ord(t_) > ord(t) + dt_next(t) + dt_toStartup(unit, t + dt_next(t))
and ord(t_) <= ord(t) and uft_online(unit, f, t)},
and ord(t_) <= ord(t) and uft_startupTrajectory(unit, f, t)},
+ sum(unitStarttype(unit, starttype),
+ v_startup(unit, starttype, f+df_central(f,t), t_)
* p_unit(unit, 'rampSpeedToMinLoad')
* 60 // Unit conversion from [p.u./min] to [p.u./h]
) // END sum(unitStarttype)
)$p_u_runUpTimeIntervals(unit) // END sum(t_)
) // END sum(t_)
// Units that are in the last time interval of the run-up phase are limited by the p_u_maxOutputInLastRunUpInterval
+ p_gnu(grid, node, unit, 'unitSizeGen')
* sum(t_activeNoReset(t_)${ ord(t_) = ord(t) + dt_next(t) + dt_toStartup(unit, t + dt_next(t))
and uft_online(unit, f, t)},
and uft_startupTrajectory(unit, f, t)},
+ sum(unitStarttype(unit, starttype),
+ v_startup(unit, starttype, f+df_central(f,t), t_)
* max(p_unit(unit, 'rampSpeedToMinLoad'), p_gnu(grid, node, unit, 'maxRampUp')) // could also be weighted average from 'maxRampUp' and 'rampSpeedToMinLoad'
* 60 // Unit conversion from [p.u./min] to [p.u./h]
) // END sum(unitStarttype)
)$p_u_runUpTimeIntervals(unit) // END sum(t_)
) // END sum(t_)
// Shutdown of consumption units from full load
+ v_shutdown(unit, f+df_central(f,t), t)${uft_online(unit, f, t) and gnu_input(grid, node, unit)}
......@@ -597,27 +599,28 @@ q_rampDownLimit(m, s, gnuft_ramp(grid, node, unit, f, t))${ ord(t) > msStart(m,
// Units that are in the shutdown phase need to keep up with the shutdown ramp rate (contained in p_ut_shutdown)
- p_gnu(grid, node, unit, 'unitSizeGen')
* sum(t_activeNoReset(t_)${ ord(t_) >= ord(t) + dt_toShutdown(unit, t)
and ord(t_) < ord(t) + dt(t) and uft_online(unit, f, t)},
and ord(t_) < ord(t) + dt(t)
and uft_shutdownTrajectory(unit, f, t)},
+ v_shutdown(unit, f+df_central(f,t), t_)
* p_unit(unit, 'rampSpeedFromMinLoad')
* 60 // Unit conversion from [p.u./min] to [p.u./h]
)$p_u_shutdownTimeIntervals(unit) // END sum(t_)
) // END sum(t_)
// Units that are in the first time interval of the shutdown phase are limited by the p_u_maxOutputInFirstShutdownInterval
- p_gnu(grid, node, unit, 'unitSizeGen')
* (
+ v_shutdown(unit, f+df_central(f,t), t + dt(t))${uft_online(unit, f, t)}
+ v_shutdown(unit, f+df_central(f,t), t + dt(t))${uft_shutdownTrajectory(unit, f, t)}
* max(p_unit(unit, 'rampSpeedFromMinLoad'), p_gnu(grid, node, unit, 'maxRampDown')) // could also be weighted average from 'maxRampDown' and 'rampSpeedFromMinLoad'
* 60 // Unit conversion from [p.u./min] to [p.u./h]
)$p_u_shutdownTimeIntervals(unit) // END * p_gnu(unitSizeGen)
) // END * p_gnu(unitSizeGen)
// Units just starting the shutdown phase are limited by the maxRampDown
- p_gnu(grid, node, unit, 'unitSizeGen')
* (
+ v_shutdown(unit, f+df_central(f,t), t)${uft_online(unit, f, t)}
+ v_shutdown(unit, f+df_central(f,t), t)${uft_shutdownTrajectory(unit, f, t)}
* p_gnu(grid, node, unit, 'maxRampDown')
* 60 // Unit conversion from [p.u./min] to [p.u./h]
)$p_u_shutdownTimeIntervals(unit) // END * p_gnu(unitSizeGen)
) // END * p_gnu(unitSizeGen)
;
* --- Ramps separated into upward and downward ramps --------------------------
......@@ -673,13 +676,14 @@ q_rampSlack(m, s, gnuft_rampCost(grid, node, unit, slack, f, t))${ ord(t) > msS
// Ramping of units that are in the run-up phase
+ p_gnu(grid, node, unit, 'unitSizeGen')
* sum(t_activeNoReset(t_)${ ord(t_) >= ord(t) + dt_next(t) + dt_toStartup(unit, t + dt_next(t))
and ord(t_) <= ord(t) and uft_online(unit, f, t)},
and ord(t_) <= ord(t)
and uft_startupTrajectory(unit, f, t)},
+ sum(unitStarttype(unit, starttype),
+ v_startup(unit, starttype, f+df_central(f,t), t_)
* p_gnuBoundaryProperties(grid, node, unit, slack, 'rampLimit')
* 60 // Unit conversion from [p.u./min] to [p.u./h]
) // END sum(unitStarttype)
)$p_u_runUpTimeIntervals(unit) // END sum(t_)
) // END sum(t_)
// Shutdown of consumption units from full load
+ v_shutdown(unit, f+df_central(f,t), t)${uft_online(unit, f, t) and gnu_input(grid, node, unit)}
......@@ -696,11 +700,12 @@ q_rampSlack(m, s, gnuft_rampCost(grid, node, unit, slack, f, t))${ ord(t) > msS
// Ramping of units that are in the shutdown phase
+ p_gnu(grid, node, unit, 'unitSizeGen')
* sum(t_activeNoReset(t_)${ ord(t_) >= ord(t) + dt_toShutdown(unit, t)
and ord(t_) <= ord(t) + dt(t) and uft_online(unit, f, t)},
and ord(t_) <= ord(t) + dt(t)
and uft_shutdownTrajectory(unit, f, t)},
+ v_shutdown(unit, f+df_central(f,t), t_)
* p_gnuBoundaryProperties(grid, node, unit, slack, 'rampLimit')
* 60 // Unit conversion from [p.u./min] to [p.u./h]
)$p_u_shutdownTimeIntervals(unit) // END sum(t_)
) // END sum(t_)
;
* --- Fixed Output Ratio ------------------------------------------------------
......@@ -752,11 +757,11 @@ q_conversionDirectInputOutput(suft(effDirect(effGroup), unit, f, t)) ..
// Main fuel is not used during run-up and shutdown phases
+ [
// Units that are in the run-up phase need to keep up with the run-up ramp rate (contained in p_ut_runUp)
+ sum(gnu_output(grid, node, unit)$p_u_runUpTimeIntervals(unit),
+ sum(gnu_output(grid, node, unit)$uft_startupTrajectory(unit, f, t),
+ p_gnu(grid, node, unit, 'unitSizeGen')
) // END sum(gnu_output)
* sum(t_activeNoReset(t_)${ ord(t_) > ord(t) + dt_next(t) + dt_toStartup(unit, t + dt_next(t))
and ord(t_) <= ord(t) and uft_online(unit, f, t)
and ord(t_) <= ord(t)
},
+ sum(unitStarttype(unit, starttype),
+ v_startup(unit, starttype, f+df_central(f,t), t_)
......@@ -766,11 +771,10 @@ q_conversionDirectInputOutput(suft(effDirect(effGroup), unit, f, t)) ..
) // END sum(unitStarttype)
) // END sum(t_)
// Units that are in the last time interval of the run-up phase are limited by the minimum load (contained in p_ut_runUp(unit, 't00000'))
+ sum(gnu_output(grid, node, unit)$p_u_runUpTimeIntervals(unit),
+ sum(gnu_output(grid, node, unit)$uft_startupTrajectory(unit, f, t),
+ p_gnu(grid, node, unit, 'unitSizeGen')
) // END sum(gnu_output)
* sum(t_activeNoReset(t_)${ ord(t_) = ord(t) + dt_next(t) + dt_toStartup(unit, t + dt_next(t))
and uft_online(unit, f, t)
},
+ sum(unitStarttype(unit, starttype),
+ v_startup(unit, starttype, f+df_central(f,t), t_)
......@@ -779,22 +783,23 @@ q_conversionDirectInputOutput(suft(effDirect(effGroup), unit, f, t)) ..
) // END sum(t_)
// Units that are in the shutdown phase need to keep up with the shutdown ramp rate (contained in p_ut_shutdown)
+ sum(gnu_output(grid, node, unit)$p_u_shutdownTimeIntervals(unit),
+ sum(gnu_output(grid, node, unit)$uft_shutdownTrajectory(unit, f, t),
+ p_gnu(grid, node, unit, 'unitSizeGen')
) // END sum(gnu_output)
* sum(t_activeNoReset(t_)${ ord(t_) >= ord(t) + dt_next(t) + dt_toShutdown(unit, t + dt_next(t))
and ord(t_) < ord(t) and uft_online(unit, f, t)},
and ord(t_) < ord(t)
},
+ v_shutdown(unit, f+df_central(f,t), t_)
* sum(t_full(t__)${ord(t__) = ord(t) - ord(t_) + 1},
+ p_ut_shutdown(unit, t__)
) // END sum(t__)
) // END sum(t_)
// Units that are in the first time interval of the shutdown phase are limited by the minimum load (contained in p_ut_shutdown(unit, 't00000'))
+ sum(gnu_output(grid, node, unit)$p_u_shutdownTimeIntervals(unit),
+ sum(gnu_output(grid, node, unit)$uft_shutdownTrajectory(unit, f, t),
+ p_gnu(grid, node, unit, 'unitSizeGen')
) // END sum(gnu_output)
* (
+ v_shutdown(unit, f+df_central(f,t), t)${uft_online(unit, f, t)}
+ v_shutdown(unit, f+df_central(f,t), t)
* sum(t_full(t__)${ord(t__) = 1}, p_ut_shutdown(unit, t__))
) // END * p_gnu(unitSizeGen)
] // END run-up and shutdown phases
......@@ -899,11 +904,11 @@ q_conversionSOS2IntermediateOutput(suft(effLambda(effGroup), unit, f, t)) ..
) // END sum(effSelector)
// Units that are in the run-up phase need to keep up with the run-up ramp rate (contained in p_ut_runUp)
+ sum(gnu_output(grid, node, unit)$p_u_runUpTimeIntervals(unit),
+ sum(gnu_output(grid, node, unit)$uft_startupTrajectory(unit, f, t),
+ p_gnu(grid, node, unit, 'unitSizeGen')
) // END sum(gnu_output)
* sum(t_activeNoReset(t_)${ ord(t_) > ord(t) + dt_next(t) + dt_toStartup(unit, t + dt_next(t))
and ord(t_) <= ord(t) and uft_online(unit, f, t)
and ord(t_) <= ord(t)
},
+ sum(unitStarttype(unit, starttype),
+ v_startup(unit, starttype, f+df_central(f,t), t_)
......@@ -913,11 +918,10 @@ q_conversionSOS2IntermediateOutput(suft(effLambda(effGroup), unit, f, t)) ..
) // END sum(unitStarttype)
) // END sum(t_)
// Units that are in the last time interval of the run-up phase are limited by the minimum load (contained in p_ut_runUp(unit, 't00000'))
+ sum(gnu_output(grid, node, unit)$p_u_runUpTimeIntervals(unit),
+ sum(gnu_output(grid, node, unit)$uft_startupTrajectory(unit, f, t),
+ p_gnu(grid, node, unit, 'unitSizeGen')
) // END sum(gnu_output)
* sum(t_activeNoReset(t_)${ ord(t_) = ord(t) + dt_next(t) + dt_toStartup(unit, t + dt_next(t))
and uft_online(unit, f, t)
},
+ sum(unitStarttype(unit, starttype),
+ v_startup(unit, starttype, f+df_central(f,t), t_)
......@@ -926,22 +930,23 @@ q_conversionSOS2IntermediateOutput(suft(effLambda(effGroup), unit, f, t)) ..
) // END sum(t_)
// Units that are in the shutdown phase need to keep up with the shutdown ramp rate (contained in p_ut_shutdown)
+ sum(gnu_output(grid, node, unit)$p_u_shutdownTimeIntervals(unit),
+ sum(gnu_output(grid, node, unit)$uft_shutdownTrajectory(unit, f, t),
+ p_gnu(grid, node, unit, 'unitSizeGen')
) // END sum(gnu_output)
* sum(t_activeNoReset(t_)${ ord(t_) >= ord(t) + dt_next(t) + dt_toShutdown(unit, t + dt_next(t))
and ord(t_) < ord(t) and uft_online(unit, f, t)},
and ord(t_) < ord(t)
},
+ v_shutdown(unit, f+df_central(f,t), t_)
* sum(t_full(t__)${ord(t__) = ord(t) - ord(t_) + 1},
+ p_ut_shutdown(unit, t__)
) // END sum(t__)
) // END sum(t_)
// Units that are in the first time interval of the shutdown phase are limited by the minimum load (contained in p_ut_shutdown(unit, 't00000'))
+ sum(gnu_output(grid, node, unit)$p_u_shutdownTimeIntervals(unit),
+ sum(gnu_output(grid, node, unit)$uft_startupTrajectory(unit, f, t),
+ p_gnu(grid, node, unit, 'unitSizeGen')
) // END sum(gnu_output)
* (
+ v_shutdown(unit, f+df_central(f,t), t)${uft_online(unit, f, t)}
+ v_shutdown(unit, f+df_central(f,t), t)
* sum(t_full(t__)${ord(t__) = 1}, p_ut_shutdown(unit, t__))
) // END * p_gnu(unitSizeGen)
......
......@@ -391,8 +391,8 @@ loop(m,
// Find the time step displacements needed to define the downtime requirements (include run-up phase and shutdown phase)
Option clear = cc;
cc(counter)${ ord(counter) <= ceil(p_unit(unit, 'minShutdownHours') / mSettings(m, 'intervalInHours'))
+ ceil(p_u_runUpTimeIntervals(unit))
+ ceil(p_u_shutdownTimeIntervals(unit))
+ ceil(p_u_runUpTimeIntervals(unit)) // NOTE! Check this
+ ceil(p_u_shutdownTimeIntervals(unit)) // NOTE! Check this
}
= yes;
dt_downtimeUnitCounter(unit, cc(counter)) = - ord(counter);
......
......@@ -470,6 +470,16 @@ loop(effLevelGroupUnit(effLevel, effGroup, unit)${ mSettingsEff(mSolve, effLeve
= smin(effSelector$effGroupSelectorUnit(effGroup, unit, effSelector), ts_effUnit(effGroup, unit, effSelector, 'slope', f, t)); // Uses maximum efficiency for the group
); // END loop(effLevelGroupUnit)
// Determine the intervals when units need to follow start-up and shutdown trajectories.
loop(uft_online(unit, f, t)${ p_u_runUpTimeIntervals(unit) },
uft_startupTrajectory(unit, f, t)${ord(t) <= tSolveFirst + mSettings(mSolve, 't_omitTrajectories')}
= yes;
); // END loop(uf_online)
loop(uft_online(unit, f, t)${ p_u_shutdownTimeIntervals(unit) },
uft_shutdownTrajectory(unit, f, t)${ord(t) <= tSolveFirst + mSettings(mSolve, 't_omitTrajectories')}
= yes;
); // END loop(uf_online)
* -----------------------------------------------------------------------------
* --- Probabilities -----------------------------------------------------------
* -----------------------------------------------------------------------------
......@@ -495,7 +505,7 @@ dtt(t_active(t),t_activeNoReset(t_))${ ord(t_) <= ord(t) }
// displacement needed to reach the time period where the unit was started up
Option clear = dt_toStartup;
loop(unit$(p_u_runUpTimeIntervals(unit)),
loop(t_active(t),
loop(t_active(t)${sum(f_solve(f), uft_startupTrajectory(unit, f, t))},
tmp = 1;
loop(t_activeNoReset(t_)${ ord(t_) > ord(t) - p_u_runUpTimeIntervals(unit) // time periods after the start up
and ord(t_) <= ord(t) // time periods before and including the current time period
......@@ -520,7 +530,7 @@ loop(unit$(p_u_runUpTimeIntervals(unit)),
// the shutdown decisions was made
Option clear = dt_toShutdown;
loop(unit$(p_u_shutdownTimeIntervals(unit)),
loop(t_active(t),
loop(t_active(t)${sum(f_solve(f), uft_shutdownTrajectory(unit, f, t))},
tmp = 1;
loop(t_activeNoReset(t_)${ ord(t_) > ord(t) - p_u_shutdownTimeIntervals(unit) // time periods after the shutdown decision
and ord(t_) <= ord(t) // time periods before and including the current time period
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment