def initialize_by_time_element(fs, time, **kwargs):
"""
Function to initialize Flowsheet fs element-by-element along
ContinuousSet time. Assumes sufficient initialization/correct degrees
of freedom such that the first finite element can be solved immediately
and each subsequent finite element can be solved by fixing differential
and derivative variables at the initial time point of that finite element.
Args:
fs : Flowsheet to initialize
time : Set whose elements will be solved for individually
solver : Pyomo solver object initialized with user's desired options
outlvl : IDAES logger outlvl
ignore_dof : Bool. If True, checks for square problems will be skipped.
Returns:
None
"""
if not isinstance(fs, FlowsheetBlock):
raise TypeError('First arg must be a FlowsheetBlock')
if not isinstance(time, ContinuousSet):
raise TypeError('Second arg must be a ContinuousSet')
if time.get_discretization_info() == {}:
raise ValueError('ContinuousSet must be discretized')
scheme = time.get_discretization_info()['scheme']
fep_list = time.get_finite_elements()
nfe = time.get_discretization_info()['nfe']
if scheme == 'LAGRANGE-RADAU':
ncp = time.get_discretization_info()['ncp']
elif scheme == 'LAGRANGE-LEGENDRE':
msg = 'Initialization does not support collocation with Legendre roots'
raise NotImplementedError(msg)
elif scheme == 'BACKWARD Difference':
ncp = 1
elif scheme == 'FORWARD Difference':
ncp = 1
msg = 'Forward initialization (explicit Euler) has not yet been implemented'
raise NotImplementedError(msg)
elif scheme == 'CENTRAL Difference':
msg = 'Initialization does not support central finite difference'
raise NotImplementedError(msg)
else:
msg = 'Unrecognized discretization scheme. '
'Has the model been discretized along the provided ContinuousSet?'
raise ValueError(msg)
# Disallow Central/Legendre discretizations.
# Neither of these seem to be square by default for multi-finite element
# initial value problems.
# Create logger objects
outlvl = kwargs.pop('outlvl', idaeslog.NOTSET)
init_log = idaeslog.getInitLogger(__name__, level=outlvl)
solver_log = idaeslog.getSolveLogger(__name__, level=outlvl)
ignore_dof = kwargs.pop('ignore_dof', False)
solver = kwargs.pop('solver', get_solver())
fix_diff_only = kwargs.pop('fix_diff_only', True)
# This option makes the assumption that the only variables that
# link constraints to previous points in time (which must be fixed)
# are the derivatives and differential variables. Not true if a controller
# is being present, but should be a good assumption otherwise, and is
# significantly faster than searching each constraint for time-linking
# variables.
if not ignore_dof:
if degrees_of_freedom(fs) != 0:
msg = ('Original model has nonzero degrees of freedom. This was '
'unexpected. Use keyword arg igore_dof=True to skip this '
'check.')
init_log.error(msg)
raise ValueError('Nonzero degrees of freedom.')
# Get dict telling which constraints/blocks are already inactive:
# dict: id(compdata) -> bool (is active?)
was_originally_active = get_activity_dict(fs)
# Deactivate flowsheet except at t0, solve to ensure consistency
# of initial conditions.
non_initial_time = [t for t in time]
non_initial_time.remove(time.first())
deactivated = deactivate_model_at(fs,
time,
non_initial_time,
outlvl=idaeslog.ERROR)
if not ignore_dof:
if degrees_of_freedom(fs) != 0:
msg = (
'Model has nonzero degrees of freedom at initial conditions.'
' This was unexpected. Use keyword arg igore_dof=True to skip'
' this check.')
init_log.error(msg)
raise ValueError('Nonzero degrees of freedom.')
init_log.info(
'Model is inactive except at t=0. Solving for consistent initial conditions.'
)
with idaeslog.solver_log(solver_log, level=idaeslog.DEBUG) as slc:
results = solver.solve(fs, tee=slc.tee)
if results.solver.termination_condition == TerminationCondition.optimal:
init_log.info('Successfully solved for consistent initial conditions')
else:
init_log.error('Failed to solve for consistent initial conditions')
raise ValueError('Solver failed in initialization')
deactivated[time.first()] = deactivate_model_at(
fs, time, time.first(), outlvl=idaeslog.ERROR)[time.first()]
# Here, deactivate non-time-indexed components. Do this after solve
# for initial conditions in case these were used to specify initial
# conditions
con_unindexed_by_time = deactivate_constraints_unindexed_by(fs, time)
var_unindexed_by_time = fix_vars_unindexed_by(fs, time)
# Now model is completely inactive
# For each timestep, we need to
# 1. Activate model at points we're solving for
# 2. Fix initial conditions (differential variables at previous timestep)
# of finite element
# 3. Solve the (now) square system
# 4. Revert the model to its prior state
# This will make use of the following dictionaries mapping
# time points -> time derivatives and time-differential variables
derivs_at_time = get_derivatives_at(fs, time, [t for t in time])
dvars_at_time = {
t: [
d.parent_component().get_state_var()[d.index()]
for d in derivs_at_time[t]
]
for t in time
}
# Perform a solve for 1 -> nfe; i is the index of the finite element
init_log.info(
'Flowsheet has been deactivated. Beginning element-wise initialization'
)
for i in range(1, nfe + 1):
t_prev = time[(i - 1) * ncp + 1]
# Non-initial time points in the finite element:
fe = [time[k] for k in range((i - 1) * ncp + 2, i * ncp + 2)]
init_log.info(f'Entering step {i}/{nfe} of initialization')
# Activate components of model that were active in the presumably
# square original system
for t in fe:
for comp in deactivated[t]:
if was_originally_active[id(comp)]:
comp.activate()
# Get lists of derivative and differential variables
# at initial time point of finite element
init_deriv_list = derivs_at_time[t_prev]
init_dvar_list = dvars_at_time[t_prev]
# Variables that were originally fixed
fixed_vars = []
if fix_diff_only:
for drv in init_deriv_list:
# Cannot fix variables with value None.
# Any variable with value None was not solved for
# (either stale or not included in previous solve)
# and we don't want to fix it.
if not drv.fixed:
fixed_vars.append(drv)
if not drv.value is None:
drv.fix()
for dv in init_dvar_list:
if not dv.fixed:
fixed_vars.append(dv)
if not dv.value is None:
dv.fix()
else:
for con in fs.component_data_objects(Constraint, active=True):
for var in identify_variables(con.expr, include_fixed=False):
t_idx = get_implicit_index_of_set(var, time)
if t_idx is None:
continue
if t_idx <= t_prev:
fixed_vars.append(var)
var.fix()
# Initialize finite element from its initial conditions
for t in fe:
copy_values_at_time(fs,
fs,
t,
t_prev,
copy_fixed=False,
outlvl=idaeslog.ERROR)
# Log that we are solving finite element {i}
init_log.info(f'Solving finite element {i}')
if not ignore_dof:
if degrees_of_freedom(fs) != 0:
msg = (
f'Model has nonzero degrees of freedom at finite element'
' {i}. This was unexpected. '
'Use keyword arg igore_dof=True to skip this check.')
init_log.error(msg)
raise ValueError('Nonzero degrees of freedom')
with idaeslog.solver_log(solver_log, level=idaeslog.DEBUG) as slc:
results = solver.solve(fs, tee=slc.tee)
if results.solver.termination_condition == TerminationCondition.optimal:
init_log.info(f'Successfully solved finite element {i}')
else:
init_log.error(f'Failed to solve finite element {i}')
raise ValueError('Failure in initialization solve')
# Deactivate components that may have been activated
for t in fe:
for comp in deactivated[t]:
comp.deactivate()
# Unfix variables that have been fixed
for var in fixed_vars:
var.unfix()
# Log that initialization step {i} has been finished
init_log.info(f'Initialization step {i} complete')
# Reactivate components of the model that were originally active
for t in time:
for comp in deactivated[t]:
if was_originally_active[id(comp)]:
comp.activate()
for con in con_unindexed_by_time:
con.activate()
for var in var_unindexed_by_time:
var.unfix()
# Logger message that initialization is finished
init_log.info('Initialization completed. Model has been reactivated')
def initialize_by_element_in_range(model,
time,
t_start,
t_end,
time_linking_vars=[],
dae_vars=[],
max_linking_range=0,
**kwargs):
"""Function for solving a square model, time element-by-time element,
between specified start and end times.
Args:
model : Flowsheet model to solve
t_start : Beginning of timespan over which to solve
t_end : End of timespan over which to solve
Kwargs:
solver : Solver option used to solve portions of the square model
outlvl : idaes.logger output level
"""
solver = kwargs.pop('solver', SolverFactory('ipopt'))
outlvl = kwargs.pop('outlvl', idaeslog.NOTSET)
init_log = idaeslog.getInitLogger('nmpc', outlvl)
solver_log = idaeslog.getSolveLogger('nmpc', outlvl)
solve_initial_conditions = kwargs.pop('solve_initial_conditions', False)
#TODO: Move to docstring
# Variables that will be fixed for time points outside the finite element
# when constraints for a finite element are activated.
# For a "normal" process, these should just be differential variables
# (and maybe derivative variables). For a process with a (PID) controller,
# these should also include variables used by the controller.
# If these variables are not specified,
# Timespan over which these variables will be fixed, counting backwards
# from the first time point in the finite element (which will always be
# fixed)
# Should I specify max_linking_range as an integer number of finite
# elements, an integer number of time points, or a float in actual time
# units? Go with latter for now.
assert t_start in time.get_finite_elements()
assert t_end in time.get_finite_elements()
#assert degrees_of_freedom(model) == 0
# No need to check dof here as we will check right before each solve
#dae_vars = kwargs.pop('dae_vars', [])
if not dae_vars:
scalar_vars, dae_vars = flatten_dae_components(model, time, ctype=Var)
for var in scalar_vars:
var.fix()
deactivate_constraints_unindexed_by(model, time)
ncp = time.get_discretization_info()['ncp']
fe_in_range = [
i for i, fe in enumerate(time.get_finite_elements())
if fe >= t_start and fe <= t_end
]
t_in_range = [t for t in time if t >= t_start and t <= t_end]
fe_in_range.pop(0)
n_fe_in_range = len(fe_in_range)
was_originally_active = get_activity_dict(model)
was_originally_fixed = get_fixed_dict(model)
# Deactivate model
if not solve_initial_conditions:
time_list = [t for t in time]
deactivated = deactivate_model_at(model,
time,
time_list,
outlvl=idaeslog.ERROR)
else:
time_list = [t for t in time if t != time.first()]
deactivated = deactivate_model_at(model,
time,
time_list,
outlvl=idaeslog.ERROR)
assert degrees_of_freedom(model) == 0
with idaeslog.solver_log(solver_log, level=idaeslog.DEBUG) as slc:
results = solver.solve(model, tee=slc.tee)
if results.solver.termination_condition == TerminationCondition.optimal:
pass
else:
raise ValueError(
'Failed to solve for consistent initial conditions.')
deactivated[time.first()] = deactivate_model_at(
model, time, time.first(), outlvl=idaeslog.ERROR)[time.first()]
# "Integration" loop
for i in fe_in_range:
t_prev = time[(i - 1) * ncp + 1]
fe = [time[k] for k in range((i - 1) * ncp + 2, i * ncp + 2)]
con_list = []
for t in fe:
# These will be fixed vars in constraints at t
# Probably not necessary to record at what t
# they occur
for comp in deactivated[t]:
if was_originally_active[id(comp)]:
comp.activate()
if not time_linking_vars:
if isinstance(comp, _ConstraintData):
con_list.append(comp)
elif isinstance(comp, _BlockData):
# Active here should be independent of whether block
# was active
con_list.extend(
list(
comp.component_data_objects(Constraint,
active=True)))
if not time_linking_vars:
fixed_vars = []
for con in con_list:
for var in identify_variables(con.expr, include_fixed=False):
# use var_locator/ComponentMap to get index somehow
t_idx = get_implicit_index_of_set(var, time)
if t_idx is None:
assert not is_in_block_indexed_by(var, time)
continue
if t_idx <= t_prev:
fixed_vars.append(var)
var.fix()
else:
fixed_vars = []
time_range = [
t for t in time
if t_prev - t <= max_linking_range and t <= t_prev
]
time_range = [t_prev]
for _slice in time_linking_vars:
for t in time_range:
#if not _slice[t].fixed:
_slice[t].fix()
fixed_vars.append(_slice[t])
# Here I assume that the only variables that can appear in
# constraints at a different (later) time index are derivatives
# and differential variables (they do so in the discretization
# equations) and that they only participate at t_prev.
#
# This is not the case for, say, PID controllers, in which case
# I should pass in a list of "complicating variables," then fix
# them at all time points outside the finite element.
#
# Alternative solution is to identify_variables in each constraint
# that is activated and fix those belonging to a previous finite
# element. (Should not encounter variables belonging to a future
# finite element.)
# ^ This option is easier, less efficient
#
# In either case need to record whether variable was previously fixed
# so I know if I should unfix it or not.
for t in fe:
for _slice in dae_vars:
if not _slice[t].fixed:
# Fixed DAE variables are time-dependent disturbances,
# whose values should not be altered by this function.
_slice[t].set_value(_slice[t_prev].value)
assert degrees_of_freedom(model) == 0
with idaeslog.solver_log(solver_log, level=idaeslog.DEBUG) as slc:
results = solver.solve(model, tee=slc.tee)
if results.solver.termination_condition == TerminationCondition.optimal:
pass
else:
raise ValueError('Failed to solve for finite element %s' % i)
for t in fe:
for comp in deactivated[t]:
comp.deactivate()
for var in fixed_vars:
if not was_originally_fixed[id(var)]:
var.unfix()
for t in time:
for comp in deactivated[t]:
if was_originally_active[id(comp)]:
comp.activate()