def setUp(self):
self.start_time = '1/1/2017'
self.final_time = '1/2/2017'
# Set .mo path
self.mopath = os.path.join(utility.get_MPCPy_path(), 'resources',
'model', 'Simple.mo')
# Gather inputs
control_csv_filepath = utility.get_MPCPy_path(
) + os.sep + 'resources' + os.sep + 'model' + os.sep + 'SimpleRC_Input.csv'
control_variable_map = {
'q_flow_csv': ('q_flow', units.W)
}
self.controls = exodata.ControlFromCSV(control_csv_filepath,
control_variable_map)
self.controls.collect_data(self.start_time, self.final_time)
# Set measurements
self.measurements = {}
self.measurements['T_db'] = {
'Sample': variables.Static('T_db_sample', 1800, units.s)
}
self.measurements['q_flow'] = {
'Sample': variables.Static('q_flow_sample', 1800, units.s)
}
# Gather constraints
constraint_csv_filepath = utility.get_MPCPy_path(
) + os.sep + 'resources' + os.sep + 'optimization' + os.sep + 'SimpleRC_Constraints.csv'
constraint_variable_map = {'q_flow_min' : ('q_flow', 'GTE', units.W), \
'T_db_min' : ('T_db', 'GTE', units.K), \
'T_db_max' : ('T_db', 'LTE', units.K)}
self.constraints = exodata.ConstraintFromCSV(constraint_csv_filepath,
constraint_variable_map)
self.constraints.collect_data(self.start_time, self.final_time)
self.constraints.data['T_db']['Initial'] = variables.Static(
'T_db_start', 295, units.K)
def setUp(self):
# Time
start_time_occupancy = '3/1/2012'
final_time_occupancy = '3/7/2012 23:55:00'
# Load occupancy models
with open(os.path.join(utility.get_MPCPy_path(), 'unittests', 'references', 'test_models',\
'OccupancyFromQueueing', 'occupancy_model_estimated.txt'), 'r') as f:
occupancy_model = pickle.load(f)
# Define state variables and values
state_variable_list = [
'wesTdb', 'wesTdb', 'easTdb', 'easTdb', 'halTdb', 'halTdb'
]
values_list = [[25, 30], [20, 15], [25 + 273.15, 30 + 273.15],
[20 + 273.15, 15 + 273.15], [25, 30], [20, 15]]
constraint_type_list = ['LTE', 'GTE', 'LTE', 'GTE', 'LTE', 'GTE']
unit_list = [
units.degC, units.degC, units.K, units.K, units.degC, units.degC
]
# Simulate occupancy model
simulate_options = occupancy_model.get_simulate_options()
simulate_options['iter_num'] = 5
np.random.seed(1)
# start with same seed for random number generation
occupancy_model.simulate(start_time_occupancy, final_time_occupancy)
# Instantiate constraint object
self.constraints = exodata.ConstraintFromOccupancyModel(
state_variable_list, values_list, constraint_type_list, unit_list,
occupancy_model)
def setUp(self):
self.parameter_data = {}
self.parameter_data['par'] = {}
self.parameter_data['par']['Value'] = 1
# instantiate building fmu v1.0
self.building_1 = systems.EmulationFromFMU(
{},
fmupath=utility.get_MPCPy_path() + os.sep + 'resources' + os.sep +
'building' + os.sep + 'LBNL71T_Emulation_JModelica_v1.fmu',
parameter_data=self.parameter_data)
# instantiate building fmu v2.0
self.building_2 = systems.EmulationFromFMU(
{},
fmupath=utility.get_MPCPy_path() + os.sep + 'resources' + os.sep +
'building' + os.sep + 'LBNL71T_Emulation_JModelica_v2.fmu',
parameter_data=self.parameter_data)
def get_ref_path(self):
ref_path = os.path.join(utility.get_MPCPy_path(), 'unittests',
'references',
self.__module__.split('.')[-1],
self.__class__.__name__)
return ref_path
def setUp(self):
# Time
start_time_occupancy = '4/1/2013'
final_time_occupancy = '4/7/2013 23:55:00'
# Load occupancy models
with open(os.path.join(utility.get_MPCPy_path(), 'unittests', 'references', \
'test_models', 'OccupancyFromQueueing', \
'occupancy_model_estimated.txt'), 'r') as f:
occupancy_model = pickle.load(f)
# Define zones and loads
zone_list = ['wes', 'hal', 'eas']
load_list = [[0.4, 0.4, 0.2], [0.4, 0.4, 0.2], [0.4, 0.4, 0.2]]
# Simulate occupancy models for each zone
occupancy_model_list = []
np.random.seed(1)
# start with same seed for random number generation
for zone in zone_list:
simulate_options = occupancy_model.get_simulate_options()
simulate_options['iter_num'] = 5
occupancy_model.simulate(start_time_occupancy,
final_time_occupancy)
occupancy_model_list.append(copy.deepcopy(occupancy_model))
# Instantiate internal object
self.internal = exodata.InternalFromOccupancyModel(
zone_list, load_list, units.W_m2, occupancy_model_list)
def setUp(self):
# Testing time
self.start_time = '3/8/2013'
self.final_time = '3/15/2013 23:59'
# Set path variable(s)
self.MPCPyPath = utility.get_MPCPy_path()
# Setup building measurement collection from csv
self.csv_filepath = self.MPCPyPath + os.sep + 'resources' + os.sep + 'building' + os.sep + 'OccData.csv'
# Measurements
self.measurements = {}
self.measurements['occupancy'] = {
'Sample': variables.Static('occupancy_sample', 300, units.s)
}
self.measurement_variable_map = {
'Total People Count for the whole building (+)':
('occupancy', units.unit1)
}
# Instantiate building measurement source
self.building = systems.RealFromCSV(self.csv_filepath, \
self.measurements,
self.measurement_variable_map,
time_header = 'Date')
# Where to save ref occupancy model
self.occupancy_model_file = self.get_ref_path(
) + os.sep + 'occupancy_model_estimated.txt'
def get_unittest_path(self):
'''Returns the path to the unittest directory.
'''
unittest_path = os.path.join(utility.get_MPCPy_path(), 'unittests');
return unittest_path;
def get_ref_path(self):
'''Returns the path to the test data reference file.
'''
ref_path = os.path.join(utility.get_MPCPy_path(), 'unittests', 'references', self.__module__.split('.')[-1], self.__class__.__name__);
return ref_path;
def setUp(self):
self.csv_filepath = os.path.join(utility.get_MPCPy_path(), 'resources',
'weather', 'BerkeleyCSV.csv')
self.geography = [37.8716, -122.2727]
self.variable_map = {'TemperatureF' : ('weaTDryBul', units.degF), \
'Dew PointF' : ('weaTDewPoi', units.degF), \
'Humidity' : ('weaRelHum', units.percent), \
'Sea Level PressureIn' : ('weaPAtm', units.inHg), \
'WindDirDegrees' : ('weaWinDir', units.deg)}
def setUp(self):
csv_filepath = os.path.join(utility.get_MPCPy_path(), 'resources',
'weather', 'Tamb.csv')
variable_map = {
'T': ('Tamb', units.degC)
}
# Instantiate other input object
self.otherinput = exodata.OtherInputFromCSV(csv_filepath, \
variable_map)
def setUp(self):
csv_filepath = os.path.join(utility.get_MPCPy_path(), 'resources',
'building', 'ControlCSV_0.csv')
variable_map = {'conHeat_wes' : ('conHeat_wes', units.unit1), \
'conHeat_hal' : ('conHeat_hal', units.unit1), \
'conHeat_eas' : ('conHeat_eas', units.unit1)}
# Instantiate control object
self.control = exodata.ControlFromCSV(csv_filepath, \
variable_map)
def setUp(self):
self.start_time = '1/1/2017'
self.final_time = '1/2/2017'
self.MPCPyPath = utility.get_MPCPy_path()
# Set measurements
self.measurements = {}
self.measurements['T_db'] = {
'Sample': variables.Static('T_db_sample', 1800, units.s)
}
def setUp(self):
csv_filepath = os.path.join(utility.get_MPCPy_path(), 'resources',
'optimization', 'PriceCSV.csv')
variable_map = {
'pi_e': ('pi_e', units.unit1)
}
# Instantiate weather object
self.prices = exodata.PriceFromCSV(csv_filepath, \
variable_map)
def setUp(self):
self.MPCPyPath = utility.get_MPCPy_path();
## Setup building fmu emulation
self.building_source_file_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'building' + os.sep + 'LBNL71T_Emulation_JModelica_v2.fmu';
self.zone_names = ['wes', 'hal', 'eas'];
self.weather_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'weather' + os.sep + 'USA_IL_Chicago-OHare.Intl.AP.725300_TMY3.epw';
self.internal_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'internal' + os.sep + 'sampleCSV.csv';
self.internal_variable_map = {'intRad_wes' : ('wes', 'intRad', units.W_m2), \
'intCon_wes' : ('wes', 'intCon', units.W_m2), \
'intLat_wes' : ('wes', 'intLat', units.W_m2), \
'intRad_hal' : ('hal', 'intRad', units.W_m2), \
'intCon_hal' : ('hal', 'intCon', units.W_m2), \
'intLat_hal' : ('hal', 'intLat', units.W_m2), \
'intRad_eas' : ('eas', 'intRad', units.W_m2), \
'intCon_eas' : ('eas', 'intCon', units.W_m2), \
'intLat_eas' : ('eas', 'intLat', units.W_m2)};
self.control_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'building' + os.sep + 'ControlCSV_0.csv';
self.control_variable_map = {'conHeat_wes' : ('conHeat_wes', units.unit1), \
'conHeat_hal' : ('conHeat_hal', units.unit1), \
'conHeat_eas' : ('conHeat_eas', units.unit1)};
# Measurements
self.measurements = {};
self.measurements['wesTdb'] = {'Sample' : variables.Static('wesTdb_sample', 1800, units.s)};
self.measurements['halTdb'] = {'Sample' : variables.Static('halTdb_sample', 1800, units.s)};
self.measurements['easTdb'] = {'Sample' : variables.Static('easTdb_sample', 1800, units.s)};
self.measurements['wesPhvac'] = {'Sample' : variables.Static('easTdb_sample', 1800, units.s)};
self.measurements['halPhvac'] = {'Sample' : variables.Static('easTdb_sample', 1800, units.s)};
self.measurements['easPhvac'] = {'Sample' : variables.Static('easTdb_sample', 1800, units.s)};
self.measurements['Ptot'] = {'Sample' : variables.Static('easTdb_sample', 1800, units.s)};
## Setup model
self.mopath = self.MPCPyPath + os.sep + 'resources' + os.sep + 'model' + os.sep + 'LBNL71T_MPC.mo';
self.modelpath = 'LBNL71T_MPC.MPC';
self.libraries = os.environ.get('MODELICAPATH');
self.estimate_method = models.JModelica;
self.validation_method = models.RMSE;
# Instantiate exo data sources
self.weather = exodata.WeatherFromEPW(self.weather_path);
self.internal = exodata.InternalFromCSV(self.internal_path, self.internal_variable_map, tz_name = self.weather.tz_name);
self.control = exodata.ControlFromCSV(self.control_path, self.control_variable_map, tz_name = self.weather.tz_name);
# Parameters
self.parameters = exodata.ParameterFromCSV(self.MPCPyPath + os.sep + 'resources' + os.sep + 'model' + os.sep + 'LBNL71T_Parameters.csv');
self.parameters.collect_data();
self.parameters.data['lat'] = {};
self.parameters.data['lat']['Value'] = self.weather.lat;
# Instantiate building
building_parameters_data = {};
building_parameters_data['lat'] = {};
building_parameters_data['lat']['Value'] = self.weather.lat;
self.building = systems.EmulationFromFMU(self.measurements, \
fmupath = self.building_source_file_path, \
zone_names = self.zone_names, \
parameter_data = building_parameters_data);
def test_set_problem_type(self):
'''Test the dynamic setting of a problem type.
'''
modelpath = 'Simple.RC'
# Instantiate model
parameter_data = {}
parameter_data['heatCapacitor.C'] = {}
parameter_data['heatCapacitor.C']['Free'] = variables.Static(
'C_free', False, units.boolean)
parameter_data['heatCapacitor.C']['Value'] = variables.Static(
'C_value', 3e6, units.boolean)
model = models.Modelica(models.JModelica, \
models.RMSE, \
self.measurements, \
moinfo = (self.mopath, modelpath, {}), \
control_data = self.controls.data, \
parameter_data = parameter_data)
# Instantiate optimization problem
opt_problem = optimization.Optimization(model, \
optimization.EnergyMin, \
optimization.JModelica, \
'q_flow', \
constraint_data = self.constraints.data)
# Solve optimization problem
opt_problem.optimize(self.start_time, self.final_time)
# Update model
model = opt_problem.Model
# Check references
df_test = model.display_measurements('Simulated')
self.check_df_timeseries(df_test, 'optimize_energy.csv')
# Set new problem type
opt_problem.set_problem_type(optimization.EnergyCostMin)
# Gather prices
price_csv_filepath = os.path.join(utility.get_MPCPy_path(),
'resources', 'optimization',
'SimpleRC_Prices.csv')
price_variable_map = {
'energy': ('pi_e', units.unit1)
}
price = exodata.PriceFromCSV(price_csv_filepath, price_variable_map)
price.collect_data(self.start_time, self.final_time)
opt_problem.optimize(self.start_time,
self.final_time,
price_data=price.data)
# Update model
model = opt_problem.Model
# Check references
df_test = model.display_measurements('Simulated')
self.check_df_timeseries(df_test, 'optimize_energycost.csv')
def setUp(self):
# Set path variable(s)
MPCPyPath = utility.get_MPCPy_path();
# Setup building measurement collection from csv
self.csv_filepath = os.path.join(MPCPyPath, 'resources', 'building', 'OccData.csv');
# Measurements
self.measurements = {};
self.measurements['occupancy'] = {'Sample' : variables.Static('occupancy_sample', 300, units.s)};
self.measurement_variable_map = {'Total People Count for the whole building (+)' : ('occupancy', units.unit1)};
# Instantiate building measurement source
self.building = systems.RealFromCSV(self.csv_filepath, \
self.measurements,
self.measurement_variable_map,
time_header = 'Date');
def setUp(self):
self.csv_filepath = os.path.join(utility.get_MPCPy_path(), 'resources',
'internal', 'sampleCSV.csv')
self.variable_map = {'intRad_wes' : ('wes', 'intRad', units.W_m2), \
'intCon_wes' : ('wes', 'intCon', units.W_m2), \
'intLat_wes' : ('wes', 'intLat', units.W_m2), \
'intRad_hal' : ('hal', 'intRad', units.W_m2), \
'intCon_hal' : ('hal', 'intCon', units.W_m2), \
'intLat_hal' : ('hal', 'intLat', units.W_m2), \
'intRad_eas' : ('eas', 'intRad', units.W_m2), \
'intCon_eas' : ('eas', 'intCon', units.W_m2), \
'intLat_eas' : ('eas', 'intLat', units.W_m2)}
# Instantiate internal object
self.internal = exodata.InternalFromCSV(self.csv_filepath, \
self.variable_map)
def setUp(self):
csv_filepath = os.path.join(utility.get_MPCPy_path(), 'resources',
'optimization',
'sampleConstraintCSV_Setback.csv')
variable_map = {'wesTdb_min' : ('wesTdb', 'GTE', units.degC), \
'wesTdb_max' : ('wesTdb', 'LTE', units.degC), \
'easTdb_min' : ('easTdb', 'GTE', units.degC), \
'easTdb_max' : ('easTdb', 'LTE', units.degC), \
'halTdb_min' : ('halTdb', 'GTE', units.degC), \
'halTdb_max' : ('halTdb', 'LTE', units.degC), \
'conHeat_wes_min' : ('conHeat_wes', 'GTE', units.unit1), \
'conHeat_wes_max' : ('conHeat_wes', 'LTE', units.unit1), \
'conHeat_hal_min' : ('conHeat_hal', 'GTE', units.unit1), \
'conHeat_hal_max' : ('conHeat_hal', 'LTE', units.unit1), \
'conHeat_eas_min' : ('conHeat_eas', 'GTE', units.unit1), \
'conHeat_eas_max' : ('conHeat_eas', 'LTE', units.unit1)}
# Instantiate weather object
self.constraints = exodata.ConstraintFromCSV(csv_filepath, \
variable_map)
def setUp(self):
self.start_time = '1/1/2017';
self.final_time = '1/2/2017';
MPCPyPath = utility.get_MPCPy_path();
# Set model paths
mopath = os.path.join(MPCPyPath, 'resources', 'model', 'Simple.mo');
modelpath = 'Simple.RC';
# Gather control inputs
control_csv_filepath = os.path.join(MPCPyPath, 'resources', 'model', 'SimpleRC_Input.csv');
variable_map = {'q_flow_csv' : ('q_flow', units.W)};
controls = exodata.ControlFromCSV(control_csv_filepath, variable_map);
controls.collect_data(self.start_time, self.final_time);
# Set measurements
measurements = {};
measurements['T_db'] = {'Sample' : variables.Static('T_db_sample', 1800, units.s)};
# Instantiate model
self.model = models.Modelica(models.JModelica, \
models.RMSE, \
measurements, \
moinfo = (mopath, modelpath, {}), \
control_data = controls.data);
def setUp(self):
# Set path variable(s)
MPCPyPath = utility.get_MPCPy_path();
# Setup building
self.building_source_file_path = os.path.join(MPCPyPath, 'resources', 'building', \
'LBNL71T_Emulation_JModelica_v2.fmu');
self.zone_names = ['wes', 'hal', 'eas'];
weather_path = os.path.join(MPCPyPath, 'resources', 'weather', \
'USA_IL_Chicago-OHare.Intl.AP.725300_TMY3.epw');
internal_path = os.path.join(MPCPyPath, 'resources', 'internal', 'sampleCSV.csv');
internal_variable_map = {'intRad_wes' : ('wes', 'intRad', units.W_m2), \
'intCon_wes' : ('wes', 'intCon', units.W_m2), \
'intLat_wes' : ('wes', 'intLat', units.W_m2), \
'intRad_hal' : ('hal', 'intRad', units.W_m2), \
'intCon_hal' : ('hal', 'intCon', units.W_m2), \
'intLat_hal' : ('hal', 'intLat', units.W_m2), \
'intRad_eas' : ('eas', 'intRad', units.W_m2), \
'intCon_eas' : ('eas', 'intCon', units.W_m2), \
'intLat_eas' : ('eas', 'intLat', units.W_m2)};
control_path = os.path.join(MPCPyPath, 'resources', 'building', 'ControlCSV_0.csv');
control_variable_map = {'conHeat_wes' : ('conHeat_wes', units.unit1), \
'conHeat_hal' : ('conHeat_hal', units.unit1), \
'conHeat_eas' : ('conHeat_eas', units.unit1)};
# Measurements
self.measurements = {};
self.measurements['wesTdb'] = {'Sample' : variables.Static('wesTdb_sample', 600, units.s)};
self.measurements['halTdb'] = {'Sample' : variables.Static('halTdb_sample', 1200, units.s)};
self.measurements['easTdb'] = {'Sample' : variables.Static('easTdb_sample', 1200, units.s)};
# Exodata
self.weather = exodata.WeatherFromEPW(weather_path);
self.internal = exodata.InternalFromCSV(internal_path, internal_variable_map, tz_name = self.weather.tz_name);
self.control = exodata.ControlFromCSV(control_path, control_variable_map, tz_name = self.weather.tz_name);
# Parameters
self.parameter_data = {};
self.parameter_data['lat'] = {};
self.parameter_data['lat']['Value'] = self.weather.lat;
def setUp(self):
self.MPCPyPath = utility.get_MPCPy_path()
## Setup model
self.mopath = self.MPCPyPath + os.sep + 'resources' + os.sep + 'model' + os.sep + 'LBNL71T_MPC.mo'
self.modelpath = 'LBNL71T_MPC.MPC'
self.libraries = os.environ.get('MODELICAPATH')
self.estimate_method = models.JModelica
self.validation_method = models.RMSE
self.zone_names = ['wes', 'hal', 'eas']
# Measurements
self.measurements = {}
self.measurements['wesTdb'] = {
'Sample': variables.Static('wesTdb_sample', 1800, units.s)
}
self.measurements['halTdb'] = {
'Sample': variables.Static('halTdb_sample', 1800, units.s)
}
self.measurements['easTdb'] = {
'Sample': variables.Static('easTdb_sample', 1800, units.s)
}
self.measurements['wesPhvac'] = {
'Sample': variables.Static('easTdb_sample', 1800, units.s)
}
self.measurements['halPhvac'] = {
'Sample': variables.Static('easTdb_sample', 1800, units.s)
}
self.measurements['easPhvac'] = {
'Sample': variables.Static('easTdb_sample', 1800, units.s)
}
self.measurements['Ptot'] = {
'Sample': variables.Static('easTdb_sample', 1800, units.s)
}
## Exodata
# Exogenous collection time
self.start_time_exodata = '1/1/2015'
self.final_time_exodata = '1/30/2015'
# Optimization time
self.start_time_optimization = '1/2/2015'
self.final_time_optimization = '1/3/2015'
# Weather
self.weather_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'weather' + os.sep + 'USA_IL_Chicago-OHare.Intl.AP.725300_TMY3.epw'
self.weather = exodata.WeatherFromEPW(self.weather_path)
self.weather.collect_data(self.start_time_exodata,
self.final_time_exodata)
# Internal
self.internal_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'internal' + os.sep + 'sampleCSV.csv'
self.internal_variable_map = {'intRad_wes' : ('wes', 'intRad', units.W_m2), \
'intCon_wes' : ('wes', 'intCon', units.W_m2), \
'intLat_wes' : ('wes', 'intLat', units.W_m2), \
'intRad_hal' : ('hal', 'intRad', units.W_m2), \
'intCon_hal' : ('hal', 'intCon', units.W_m2), \
'intLat_hal' : ('hal', 'intLat', units.W_m2), \
'intRad_eas' : ('eas', 'intRad', units.W_m2), \
'intCon_eas' : ('eas', 'intCon', units.W_m2), \
'intLat_eas' : ('eas', 'intLat', units.W_m2)}
self.internal = exodata.InternalFromCSV(self.internal_path,
self.internal_variable_map,
tz_name=self.weather.tz_name)
self.internal.collect_data(self.start_time_exodata,
self.final_time_exodata)
# Control (as initialization)
self.control_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'optimization' + os.sep + 'ControlCSV.csv'
self.control_variable_map = {'conHeat_wes' : ('conHeat_wes', units.unit1), \
'conHeat_hal' : ('conHeat_hal', units.unit1), \
'conHeat_eas' : ('conHeat_eas', units.unit1)}
self.control = exodata.ControlFromCSV(self.control_path,
self.control_variable_map,
tz_name=self.weather.tz_name)
self.control.collect_data(self.start_time_exodata,
self.final_time_exodata)
# Parameters
self.parameters_path = self.MPCPyPath + os.sep + 'unittests' + os.sep + 'resources' + os.sep + 'model_parameters.txt'
self.parameters = exodata.ParameterFromCSV(self.parameters_path)
self.parameters.collect_data()
# Constraints
self.constraints_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'optimization' + os.sep + 'sampleConstraintCSV_Constant.csv'
self.constraints_variable_map = {'wesTdb_min' : ('wesTdb', 'GTE', units.degC), \
'wesTdb_max' : ('wesTdb', 'LTE', units.degC), \
'easTdb_min' : ('easTdb', 'GTE', units.degC), \
'easTdb_max' : ('easTdb', 'LTE', units.degC), \
'halTdb_min' : ('halTdb', 'GTE', units.degC), \
'halTdb_max' : ('halTdb', 'LTE', units.degC), \
'der_wesTdb_min' : ('wesTdb', 'dGTE', units.K), \
'der_wesTdb_max' : ('wesTdb', 'dLTE', units.K), \
'der_easTdb_min' : ('easTdb', 'dGTE', units.K), \
'der_easTdb_max' : ('easTdb', 'dLTE', units.K), \
'der_halTdb_min' : ('halTdb', 'dGTE', units.K), \
'der_halTdb_max' : ('halTdb', 'dLTE', units.K), \
'conHeat_wes_min' : ('conHeat_wes', 'GTE', units.unit1), \
'conHeat_wes_max' : ('conHeat_wes', 'LTE', units.unit1), \
'conHeat_hal_min' : ('conHeat_hal', 'GTE', units.unit1), \
'conHeat_hal_max' : ('conHeat_hal', 'LTE', units.unit1), \
'conHeat_eas_min' : ('conHeat_eas', 'GTE', units.unit1), \
'conHeat_eas_max' : ('conHeat_eas', 'LTE', units.unit1)}
self.constraints = exodata.ConstraintFromCSV(
self.constraints_path,
self.constraints_variable_map,
tz_name=self.weather.tz_name)
self.constraints.collect_data(self.start_time_exodata,
self.final_time_exodata)
self.constraints.data['wesTdb']['Cyclic'] = variables.Static(
'wesTdb_cyclic', 1, units.boolean_integer)
self.constraints.data['easTdb']['Cyclic'] = variables.Static(
'easTdb_cyclic', 1, units.boolean_integer)
self.constraints.data['halTdb']['Cyclic'] = variables.Static(
'halTdb_cyclic', 1, units.boolean_integer)
# Prices
self.prices_path = self.MPCPyPath + os.sep + 'resources' + os.sep + 'optimization' + os.sep + 'PriceCSV.csv'
self.price_variable_map = {
'pi_e': ('pi_e', units.unit1)
}
self.prices = exodata.PriceFromCSV(self.prices_path,
self.price_variable_map,
tz_name=self.weather.tz_name)
self.prices.collect_data(self.start_time_exodata,
self.final_time_exodata)
## Parameters
self.parameters.data['lat'] = {}
self.parameters.data['lat']['Value'] = self.weather.lat
## Instantiate model
self.model = models.Modelica(self.estimate_method, \
self.validation_method, \
self.measurements, \
moinfo = (self.mopath, self.modelpath, self.libraries), \
zone_names = self.zone_names, \
weather_data = self.weather.data, \
internal_data = self.internal.data, \
control_data = self.control.data, \
parameter_data = self.parameters.data, \
tz_name = self.weather.tz_name)
print(name + ' tests not run.')
return None
# Main program
# ============
# Setup
# -----
# Change working directory to temporary
cwd = os.getcwd()
tempdir = tempfile.mkdtemp()
os.chdir(tempdir)
# Configure the log
logpath = os.path.join(utility.get_MPCPy_path(), 'unittests', 'outputs',
'unittests.log')
# Configure the argument parser
parser = argparse.ArgumentParser(description='Run the unit tests for mpcpy.')
unit_test_group = parser.add_argument_group("arguments to run unit tests")
unit_test_group.add_argument('-s', '--specify_test', \
metavar='module.class', \
help='test only the module and class specified')
args = parser.parse_args()
# Define test modules and classes, if any
modules = []
classes = []
if args.specify_test:
modules.append(args.specify_test.split('.')[0])
try:
classes.append(args.specify_test.split('.')[1])
def setUp(self):
self.epw_filepath = os.path.join(utility.get_MPCPy_path(), 'resources', 'weather', \
'USA_IL_Chicago-OHare.Intl.AP.725300_TMY3.epw')
self.weather = exodata.WeatherFromEPW(self.epw_filepath)
def setUp(self):
self.mopath = utility.get_MPCPy_path(
) + os.sep + 'resources' + os.sep + 'model' + os.sep + 'Simple.mo'
self.modelpath = 'Simple.RC'
def setUp(self):
csv_filepath = os.path.join(utility.get_MPCPy_path(), 'resources',
'model', 'LBNL71T_Parameters.csv')
# Instantiate weather object
self.parameters = exodata.ParameterFromCSV(csv_filepath)
def setUp(self):
self.epw_filepath = utility.get_MPCPy_path(
) + os.sep + 'resources' + os.sep + 'weather' + os.sep + 'USA_IL_Chicago-OHare.Intl.AP.725300_TMY3.epw'
self.weather = exodata.WeatherFromEPW(self.epw_filepath)
