diff --git a/.gitignore b/.gitignore
index a44bd2d..cec277d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
+logs
+
 # Python compiled files #
 #########################
 *.pyc
diff --git a/afc/ctrlWrapper.py b/afc/ctrlWrapper.py
index d652526..96f76d6 100644
--- a/afc/ctrlWrapper.py
+++ b/afc/ctrlWrapper.py
@@ -26,8 +26,10 @@
 
 try:
     root = os.path.dirname(os.path.abspath(__file__))
+    from .utility.thermostat import compute_thermostat_setpoints
 except:
     root = os.getcwd()
+    from afc.utility.thermostat import compute_thermostat_setpoints
 
 warnings.simplefilter(action='ignore', category=pd.errors.PerformanceWarning)
 
@@ -41,27 +43,22 @@ def __init__(self):
         super().__init__()
 
         self.input = {
-            'paths':None,
-            'radiance':None,
-            'df_input':None,
-            'wf_all':None,
-            'facade_initial':None,
-            'temps_initial':None,
-            'parameter':None}
+            'input-data': None,
+            'wf-all': None,
+            'facade-initial': None,
+            'temps-initial': None,
+            'parameter': None
+        }
         self.output = {
-            'rad_duration':None,
-            'varts_duration':None,
-            'opt_objective':None,
-            'glaremode':None,
-            'opt_duration':None,
-            'optall_duration':None,
-            'opt_termination':None,
-            'outputs_duration':None,
-            'duration':None,
-            'glare_duration':None,
-            'uShade':None,
-            'uTroom':None,
-            'df_output':None}
+            'duration': None,
+            'opt-stats': None,
+            'glaremode': None,
+            'ctrl-facade': None,
+            'ctrl-thermostat': None,
+            'ctrl-troom': None,
+            'output-data': None,
+            'valid': None
+        }
         self.init = True
         self.root = root
 
@@ -82,6 +79,7 @@ def __init__(self):
         self.glare_handler = None
         self.data = None
         self.res = None
+        self.parameter = None
 
     def init_functions(self):
         """Function to initialize controller."""
@@ -145,42 +143,46 @@ def compute(self):
             self.msg = ''
 
             # Parse input dataframe
-            inputs = pd.DataFrame().from_dict(self.input['df_input'])
+            inputs = pd.DataFrame().from_dict(self.input['input-data'])
             inputs.index = pd.to_datetime(inputs.index)#, unit='ms')
 
+            # configuration
+            self.parameter = self.input['parameter']
+
             # Setup controller
             if self.init:
                 self.init_functions()
                 from afc.optModel import control_model#, pyomo_to_pandas
-                if self.input['parameter']['wrapper']['solver_dir']:
+                if self.parameter['wrapper']['solver_dir']:
                     solver_path = \
-                        self.get_solver(self.input['parameter']['wrapper']['solver_name'],
-                                        solver_dir=self.input['parameter']['wrapper']['solver_dir'])
+                        self.get_solver(self.parameter['wrapper']['solver_name'],
+                                        solver_dir=self.parameter['wrapper']['solver_dir'])
                 else:
-                    solver_path = self.get_solver(self.input['parameter']['wrapper']['solver_name'])
+                    solver_path = self.get_solver(self.parameter['wrapper']['solver_name'])
                 pyomo_logger = \
-                    logging.WARNING if self.input['parameter']['wrapper']['printing'] else \
+                    logging.WARNING if self.parameter['wrapper']['printing'] else \
                         logging.ERROR
-                self.tariff = self.get_tariff(self.input['parameter']['wrapper']['tariff_name'])
-                output_list = self.input['parameter']['wrapper']['output_list']
+                self.tariff = self.get_tariff(self.parameter['wrapper']['tariff_name'])
+                output_list = self.parameter['wrapper']['output_list']
                 self.controller = self.doper(model=control_model,
-                                             parameter=self.input['parameter'],
+                                             parameter=self.parameter,
                                              solver_path=solver_path,
                                              pyomo_logger=pyomo_logger,
                                              output_list=output_list)
+                rad_paths = self.parameter['radiance']['paths']
                 filestruct = {}
-                filestruct['resources'] = self.input['paths']['rad_bsdf']
-                filestruct['matrices'] = self.input['paths']['rad_mtx']
+                filestruct['resources'] = rad_paths['rad_bsdf']
+                filestruct['matrices'] = rad_paths['rad_mtx']
                 self.forecaster = \
-                    self.forecaster.Forecast(self.input['paths']['rad_config'],
-                                             regenerate=self.input['radiance']['regenerate'],
-                                             location=self.input['radiance']['location'],
-                                             facade_type=self.input['parameter']['facade']['type'],
-                                             wpi_loc=self.input['radiance']['wpi_loc'],
+                    self.forecaster.Forecast(rad_paths['rad_config'],
+                                             regenerate=self.parameter['radiance']['regenerate'],
+                                             location=self.parameter['radiance']['location'],
+                                             facade_type=self.parameter['facade']['type'],
+                                             wpi_loc=self.parameter['radiance']['wpi_loc'],
                                              filestruct=filestruct,
-                                             dimensions=self.input['radiance']['dimensions'])
-                if self.input['parameter']['wrapper']['precompute_radiance']:
-                    wf_all = pd.DataFrame().from_dict(self.input['wf_all'])
+                                             dimensions=self.parameter['radiance']['dimensions'])
+                if self.parameter['wrapper']['precompute_radiance']:
+                    wf_all = pd.DataFrame().from_dict(self.input['wf-all'])
                     wf_all.index = pd.to_datetime(wf_all.index, unit='ms')
                     temp = pd.DataFrame()
                     for d in sorted(np.unique(wf_all.index.date)):
@@ -193,12 +195,12 @@ def compute(self):
                     self.forecaster = temp
 
                 # Glare handler
-                view_config = self.view_config_from_rad(self.input['paths']['rad_config'],
+                view_config = self.view_config_from_rad(rad_paths['rad_config'],
                                                         start_lx=20e3, end_lx=12.5e3)
                 self.glare_handler = \
-                    self.glare_handler_class(config=self.input['radiance']['location'],
+                    self.glare_handler_class(config=self.parameter['radiance']['location'],
                                              view_config=view_config)
-                if self.input['parameter']['wrapper']['precompute_radiance']:
+                if self.parameter['wrapper']['precompute_radiance']:
                     wf = wf_all[['dni','dhi']].copy(deep=True).rename(columns=map_weather)
                     for ix in wf.index:
                         wf.loc[ix, ['alt', 'azi_shift', 'inci', 'azi']] = \
@@ -211,23 +213,24 @@ def compute(self):
 
             # Compute radiance
             st1 = time.time()
+            self.output['duration'] = {}
 
-            if self.input['parameter']['wrapper']['precompute_radiance']:
+            if self.parameter['wrapper']['precompute_radiance']:
                 data = self.forecaster.loc[inputs.index]
             else:
                 data = self.forecaster.compute2(inputs[['dni','dhi']])
             # cutoff
-            rad_cutoff = self.input['parameter']['facade']['rad_cutoff']
+            rad_cutoff = self.parameter['facade']['rad_cutoff']
             for k in rad_cutoff.keys():
                 for c in data.columns:
                     if k in c:
                         data.loc[:,c] = data[c].mask(data[c] < rad_cutoff[k][0], 0)
                         data.loc[:,c] = data[c].mask(data[c] > rad_cutoff[k][1], rad_cutoff[k][1])
-            self.output['rad_duration'] = time.time() - st1
+            self.output['duration']['radiance'] = time.time() - st1
 
             # Glare handler
             st1 = time.time()
-            if self.input['parameter']['wrapper']['precompute_radiance']:
+            if self.parameter['wrapper']['precompute_radiance']:
                 wf = self.glare_handler.loc[inputs.index]
             else:
                 wf = inputs[['dni','dhi']].copy(deep=True).rename(columns=map_weather)
@@ -239,10 +242,10 @@ def compute(self):
                     for i, g in enumerate(gmodes):
                         wf.loc[ix, f'zone{i}_gmode'] = int(g)
 
-            zones = self.input['parameter']['facade']['windows']
-            states = self.input['parameter']['facade']['states']
-            flip_z = 'shade' in self.input['parameter']['facade']['type']
-            if self.input['parameter']['facade']['type'] == 'blinds':
+            zones = self.parameter['facade']['windows']
+            states = self.parameter['facade']['states']
+            flip_z = 'shade' in self.parameter['facade']['type']
+            if self.parameter['facade']['type'] == 'blinds':
                 darkstates = [s for s in states if s not in [0, 9, 10, 11]] # Specific for blinds
             else:
                 darkstates = states[1:]
@@ -255,7 +258,7 @@ def compute(self):
                     gmodes.append(wf.loc[wf.index[0], wf_key])
                     data[f'ev_{nz}_{t}'] =  data[f'ev_{nz}_{t}'].mask( \
                         (wf[wf_key] > 0) & (data[f'wpi_{nz}_{t}']>0), 2e4)
-            self.output['glare_duration'] = time.time() - st1
+            self.output['duration']['glare'] = time.time() - st1
 
             # Compute other inputs
             data = pd.concat([data, inputs], axis=1)
@@ -265,16 +268,24 @@ def compute(self):
             data['battery_0_demand'] = 0
             data['battery_reg'] = 0
 
-            # Update SOC
-            self.input['parameter']['zone']['temps_initial'] = self.input['temps_initial']
-            self.input['parameter']['facade']['fstate_initial'] = self.input['facade_initial']
+            # Update SOCs
+            self.parameter['zone']['temps_initial'] = self.input['temps-initial']
+            self.parameter['facade']['fstate_initial'] = self.input['facade-initial']
+
+            # Make sure temp_initial is feasible
+            dead_band = 1e-2
+            cool_set = data['temp_room_max'].values[0]
+            heat_set = data['temp_room_min'].values[0]
+            troom = self.parameter['zone']['temps_initial'][0]
+            troom = max(heat_set+dead_band, min(cool_set-dead_band, troom))
+            self.parameter['zone']['temps_initial'][0] = troom
 
             # Variable timestep
             st1 = time.time()
-            if self.input['parameter']['wrapper']['resample_variable_ts']:
+            if self.parameter['wrapper']['resample_variable_ts']:
 
                 # check columns
-                cols = self.input['parameter']['wrapper']['cols_fill']
+                cols = self.parameter['wrapper']['cols_fill']
                 if not 'temp_room_max' in cols[0].lower():
                     print('ERROR: "temp_room_max" is not in first column of "cols_fill".')
 
@@ -292,23 +303,23 @@ def compute(self):
                         data.loc[data.index[max(0, data.index.get_loc(ix)-1)], cols].values
 
                 # limit starting ramp
-                t_init = self.input['temps_initial'][0]
+                t_init = self.parameter['zone']['temps_initial'][0]
                 data[cols[0]] = \
-                    np.min([[t_init+(i+1)*self.input['parameter']['wrapper']['limit_slope'] \
+                    np.min([[t_init+(i+1)*self.parameter['wrapper']['limit_slope'] \
                              for i in range(len(data))], data[cols[0]]], axis=0)
                 data[cols[1]] = \
-                    np.max([[t_init-(i+1)*self.input['parameter']['wrapper']['limit_slope'] \
+                    np.max([[t_init-(i+1)*self.parameter['wrapper']['limit_slope'] \
                              for i in range(len(data))], data[cols[1]]], axis=0)
 
                 # resample
                 data = self.resample_variable_ts(data, \
-                    reduced_start=int(self.input['parameter']['wrapper']['reduced_start']),
-                    reduced_ts=int(self.input['parameter']['wrapper']['reduced_ts']),
-                    cols_fill=self.input['parameter']['wrapper']['cols_fill'])
-            self.output['varts_duration'] = time.time() - st1
+                    reduced_start=int(self.parameter['wrapper']['reduced_start']),
+                    reduced_ts=int(self.parameter['wrapper']['reduced_ts']),
+                    cols_fill=self.parameter['wrapper']['cols_fill'])
+            self.output['duration']['varts'] = time.time() - st1
 
             # Compute and update tariff
-            data, _ = self.compute_periods(data, self.tariff, self.input['parameter'])
+            data, _ = self.compute_periods(data, self.tariff, self.parameter)
 
             # Check for nan
             if pd.isnull(data).any().any():
@@ -319,47 +330,55 @@ def compute(self):
 
             # Run optimization
             st1 = time.time()
-            self.data = data.round(self.input['parameter']['wrapper']['inputs_cutoff'])
+            self.data = data.round(self.parameter['wrapper']['inputs_cutoff'])
 
             # Store for debug
             # data.to_csv('inputs_{}.csv'.format(data.index[0]))
             # cfg = {}
-            # cfg['parameter'] = self.input['parameter']
-            # cfg['options'] = self.input['parameter']['options']
+            # cfg['parameter'] = self.parameter
+            # cfg['options'] = self.parameter['options']
             # with open('cfg_{}.json'.format(data.index[0]), 'w') as f:
             #     f.write(json.dumps(cfg))
 
-            printing = self.input['parameter']['wrapper']['printing']
+            printing = self.parameter['wrapper']['printing']
             self.res = \
                 self.controller.do_optimization(self.data,
-                                                parameter=self.input['parameter'],
-                                                options=self.input['parameter']['solver_options'],
+                                                parameter=self.parameter,
+                                                options=self.parameter['solver_options'],
                                                 tee=printing,
                                                 print_error=printing)
             duration, objective, df, model, result, termination, parameter = self.res
-            self.output['optall_duration'] = time.time() - st1
+            df = pd.concat([df, data], axis=1)
+            self.output['duration']['optall'] = time.time() - st1
 
             # Write outputs
             st1 = time.time()
-            self.output['opt_duration'] = float(duration)
-            self.output['opt_termination'] = str(termination)
-            self.output['opt_objective'] = float(objective) if objective else None
+            self.output['opt-stats'] = {'duration': float(duration),
+                                        'termination': str(termination),
+                                        'objective': float(objective) if objective else None}
+            self.output['valid'] = bool(objective)
             self.output['glaremode'] = list(gmodes)
+
+            # Compute thermostat setpoints
+            thermostat = compute_thermostat_setpoints(df, self.output['valid'], True, False)
+            self.output['ctrl-thermostat'] = thermostat
+            self.output['ctrl-troom'] = float(df['Temperature 0 [C]'].values[1])
+
+            # Compute shade state
             if objective:
                 uShade = df[[f'Facade State {z}' for \
-                    z in self.input['parameter']['facade']['windows']]].iloc[0].values
+                    z in self.parameter['facade']['windows']]].iloc[0].values
                 #uShade = df[['Tint Bottom [-]', 'Tint Middle [-]', 'Tint Top [-]']].iloc[0].values
-                self.output['uShade'] = [round(float(u),1) for u in uShade]
-                self.output['uTroom'] = float(df['Temperature 0 [C]'].values[1])
-            df = pd.concat([df, data], axis=1)
+                self.output['ctrl-facade'] = [round(float(u),1) for u in uShade]
+
             df.index = (df.index.astype(np.int64) / 10 ** 6).astype(str)
             df = df.astype(float).fillna(-1)
-            self.output['df_output'] = df.to_dict()
-            self.output['duration'] = time.time() - st
-            self.output['outputs_duration'] = time.time() - st1
+            self.output['output-data'] = df.to_dict()
+            self.output['duration']['outputs'] = time.time() - st1
+            self.output['duration']['all'] = time.time() - st
 
             # Store if long optimization
-            if self.output['duration'] > self.input['parameter']['wrapper']['log_overtime']:
+            if self.output['duration']['all'] > self.parameter['wrapper']['log_overtime']:
                 self.log_results()
 
             self.init = False
@@ -400,6 +419,7 @@ def make_inputs(parameter, df, ext_df=pd.DataFrame()):
     df.loc[:, 'temp_slab_min'] = 0
     df.loc[:, 'temp_wall_max'] = 1e3
     df.loc[:, 'temp_wall_min'] = 0
+    df.loc[:, 'grid_co2_intensity'] = 0
 
     # Add External inputs (if any)
     for c in ext_df:
@@ -407,13 +427,11 @@ def make_inputs(parameter, df, ext_df=pd.DataFrame()):
 
     # Map parameter and make Inputs object
     inputs = {}
-    inputs['radiance'] = parameter['radiance']
-    inputs['df_input'] = df.to_dict()
-    inputs['wf_all'] = None
-    inputs['facade_initial'] = parameter['facade']['fstate_initial']
-    inputs['temps_initial'] = parameter['zone']['temps_initial']
+    inputs['input-data'] = df.to_dict()
+    inputs['wf-all'] = None
+    inputs['facade-initial'] = parameter['facade']['fstate_initial']
+    inputs['temps-initial'] = parameter['zone']['temps_initial']
     inputs['parameter'] = parameter
-    inputs['paths'] = parameter['radiance']['paths']
 
     return inputs
 
@@ -447,20 +465,13 @@ def make_inputs(parameter, df, ext_df=pd.DataFrame()):
     inputs = make_inputs(parameter, wf)
 
     # Query controller
-    ctrl.do_step(inputs=inputs) # Initialize
     print('Log-message:\n', ctrl.do_step(inputs=inputs))
-    print('Duration:\n', ctrl.get_output(keys=['rad_duration', 'varts_duration',
-                                               'optall_duration', 'glare_duration',
-                                               'opt_duration', 'outputs_duration', 'duration']))
-    print('Optimization:\n', ctrl.get_output(keys=['opt_objective', 'opt_duration',
-                                                   'opt_termination', 'duration']))
-    df = pd.DataFrame(ctrl.get_output(keys=['df_output'])['df_output'])
+    print('Duration:\n', ctrl.get_output(keys=['duration']))
+    print('Optimization:\n', ctrl.get_output(keys=['opt-stats']))
+    df = pd.DataFrame(ctrl.get_output(keys=['output-data'])['output-data'])
     df.index = pd.to_datetime(pd.to_numeric(df.index), unit='ms')
 
     try:
-        # Remove slab constraints for plotting
-        df['Temperature 1 Min [C]'] = None
-        df['Temperature 1 Max [C]'] = None
         plot_standard1(pd.concat([wf, df], axis=1).ffill().iloc[:-1])
     except:
         pass
diff --git a/afc/defaultConfig.py b/afc/defaultConfig.py
index 6852a08..c9e0ebf 100644
--- a/afc/defaultConfig.py
+++ b/afc/defaultConfig.py
@@ -283,6 +283,7 @@ def default_parameter(tariff_name='e19-2020', hvac_control=True,
     parameter['objective']['weight_actuation'] = weight_actuation # Weight of facade actuation
     parameter['objective']['weight_glare'] = weight_glare # Weight of glare penalty in objective
     parameter['objective']['weight_view'] = 0 # Weight of view penalty in objective
+    parameter['objective']['weight_ghg'] = 0 # Weight of GHG emissions
     parameter['solver_options'] = {} # Pyomo solver options
     parameter['solver_options']['seconds'] = int(60) # Maximal solver time, in seconds
     #parameter['solver_options']['maxIterations'] = int(1e6) # Maximal iterations
diff --git a/afc/glare/view_angle.py b/afc/glare/view_angle.py
index a0a84eb..d546be5 100644
--- a/afc/glare/view_angle.py
+++ b/afc/glare/view_angle.py
@@ -17,7 +17,7 @@ def sun_in_view(view_dist, view_height, window_bottom_height, window_top_height,
         right_azi: Right aziumth when sun in view through the window
     """
     if view_height > window_top_height:
-        print("WARNING: view_angle: Window below viewpoint.")
+        # print("WARNING: view_angle: Window below viewpoint.")
         bot_alt, top_alt, left_azi, right_azi, view_window_angle = 0, 0, 0, 0, 0
     else:
         bot_vw = abs(window_bottom_height - view_height)
diff --git a/afc/optModel.py b/afc/optModel.py
index d2406f8..99465ed 100644
--- a/afc/optModel.py
+++ b/afc/optModel.py
@@ -456,7 +456,8 @@ def objective_function(model):
                + model.sum_export_revenue * parameter['objective']['weight_export'] \
                + model.sum_zone_actuation * parameter['objective']['weight_actuation'] \
                + model.sum_glare_penalty * parameter['objective']['weight_glare'] \
-               + model.sum_view_penalty * parameter['objective']['weight_view']
+               + model.sum_view_penalty * parameter['objective']['weight_view'] \
+               + model.co2_total * parameter['objective']['weight_ghg']
                #+ model.sum_regulation_revenue * parameter['objective']['weight_regulation']
     model.objective = Objective(rule=objective_function, sense=minimize, doc='objective function')
     return model
@@ -499,6 +500,8 @@ def afc_output_list():
                         'index': 'temps'}) # room, slab
     ctrlOutputs.append({'data': 'zone_temp_max', 'df_label': 'Temperature %s Max [C]',
                         'index': 'temps'}) # room, slab
+    ctrlOutputs.append({'data': 'co2_profile_total', 'df_label': 'GHG Emissions [kg]'})
+
     for d in ctrlOutputs:
         d['name'] = d['data']
     return ctrlOutputs
diff --git a/afc/utility/plotting.py b/afc/utility/plotting.py
index 7e15c63..1667a0c 100644
--- a/afc/utility/plotting.py
+++ b/afc/utility/plotting.py
@@ -83,8 +83,8 @@ def plot_standard1(data, title=None, plot=True, tight=True):
                  labels=['Room','Slab'])
     axs[5].plot(data[['Temperature 0 Max [C]']], color='blue', linestyle='--')
     axs[5].plot(data[['Temperature 0 Min [C]']], color='red', linestyle='--')
-    axs[5].plot(data[['Temperature 1 Max [C]']], color='blue', linestyle=':')
-    axs[5].plot(data[['Temperature 1 Min [C]']], color='red', linestyle=':')
+    #axs[5].plot(data[['Temperature 1 Max [C]']], color='blue', linestyle=':')
+    #axs[5].plot(data[['Temperature 1 Min [C]']], color='red', linestyle=':')
     plot_plot_xy(axs[6],data[['Glare [-]']],title='Glare Level',ylab='DGP [1]',
                  labels=['Glare'])
     axs[6].plot(data[['Glare Max [-]']], color='black', linestyle='--')
diff --git a/afc/utility/thermostat.py b/afc/utility/thermostat.py
new file mode 100644
index 0000000..edaed59
--- /dev/null
+++ b/afc/utility/thermostat.py
@@ -0,0 +1,67 @@
+# Advanced Fenestration Controller (AFC) Copyright (c) 2023, The
+# Regents of the University of California, through Lawrence Berkeley
+# National Laboratory (subject to receipt of any required approvals
+# from the U.S. Dept. of Energy). All rights reserved.
+
+""""Advanced Fenestration Controller
+Thermostat control module.
+"""
+
+def afc_to_hvac_setpoint(ctrl_outputs, tdead=0.5):
+    """Utility to convert from AFC to thermostat setpoints."""
+
+    # no control by default
+    hvac_mode = 'X'
+    new_cool_set = float(ctrl_outputs['cool_set'])
+    new_heat_set = float(ctrl_outputs['heat_set'])
+
+    if ctrl_outputs['hvac_control'] and ctrl_outputs['feasible']:
+
+        # float by default
+        hvac_mode = 'F'
+
+        # get new setpoints if not occupied (make sure within bounds)
+        if not ctrl_outputs['occupied']:
+
+            # cooling
+            if ctrl_outputs['power_cool'] > 1:
+                hvac_mode = 'C'
+                new_cool_set = min(ctrl_outputs['cool_set'],
+                                   ctrl_outputs['t_room'])
+                # make sure cool > heat
+                new_cool_set = max(new_cool_set, new_heat_set + tdead)
+
+            # heating
+            elif ctrl_outputs['power_heat'] > 1:
+                hvac_mode = 'H'
+                new_heat_set = max(ctrl_outputs['heat_set'],
+                                   ctrl_outputs['t_room'])
+                # make sure heat < cool
+                new_heat_set = min(new_heat_set, new_cool_set - tdead)
+
+    return {'feasible': ctrl_outputs['feasible'],
+            'mode': hvac_mode,
+            'csp': new_cool_set,
+            'hsp': new_heat_set}
+
+def compute_thermostat_setpoints(df, feasible, control_hvac, occupied):
+    """wrapper to compute thermostat setpoints"""
+
+    cool_set = df['Temperature 0 Max [C]'].values[0]
+    heat_set = df['Temperature 0 Min [C]'].values[0]
+    t_room = df['Temperature 0 [C]'].values[1]
+    power_cool = df['Power Cooling [W]'].iloc[0]
+    power_heat = df['Power Heating [W]'].iloc[0]
+
+    ctrl_outputs = {
+        'hvac_control': control_hvac,
+        'feasible': feasible,
+        't_room': t_room,
+        'cool_set': cool_set,
+        'heat_set': heat_set,
+        'occupied': occupied,
+        'power_cool': power_cool,
+        'power_heat': power_heat,
+    }
+
+    return afc_to_hvac_setpoint(ctrl_outputs, tdead=0.5)
diff --git a/dev/Development-Controller.ipynb b/dev/Development-Controller.ipynb
index 3548418..17ac7b8 100644
--- a/dev/Development-Controller.ipynb
+++ b/dev/Development-Controller.ipynb
@@ -557,7 +557,8 @@
     "               + model.sum_export_revenue * parameter['objective']['weight_export'] \\\n",
     "               + model.sum_zone_actuation * parameter['objective']['weight_actuation'] \\\n",
     "               + model.sum_glare_penalty * parameter['objective']['weight_glare'] \\\n",
-    "               + model.sum_view_penalty * parameter['objective']['weight_view']\n",
+    "               + model.sum_view_penalty * parameter['objective']['weight_view'] \\\n",
+    "               + model.co2_total * parameter['objective']['weight_ghg']\n",
     "               #+ model.sum_regulation_revenue * parameter['objective']['weight_regulation']\n",
     "    model.objective = Objective(rule=objective_function, sense=minimize, doc='objective function')\n",
     "    return model\n",
@@ -600,6 +601,8 @@
     "                        'index': 'temps'}) # room, slab\n",
     "    ctrlOutputs.append({'data': 'zone_temp_max', 'df_label': 'Temperature %s Max [C]',\n",
     "                        'index': 'temps'}) # room, slab\n",
+    "    ctrlOutputs.append({'data': 'co2_profile_total', 'df_label': 'GHG Emissions [kg]'})\n",
+    "\n",
     "    for d in ctrlOutputs:\n",
     "        d['name'] = d['data']\n",
     "    return ctrlOutputs\n",
diff --git a/dev/Development-ControllerWrapper.ipynb b/dev/Development-ControllerWrapper.ipynb
index d3029e4..0b54797 100644
--- a/dev/Development-ControllerWrapper.ipynb
+++ b/dev/Development-ControllerWrapper.ipynb
@@ -9,7 +9,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 4,
    "metadata": {
     "scrolled": true
    },
@@ -58,23 +58,22 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "All Input variables: dict_keys(['paths', 'radiance', 'df_input', 'wf_all', 'facade_initial', 'temps_initial', 'parameter'])\n",
-      "WARNING: view_angle: Window below viewpoint.\n",
+      "All Input variables: dict_keys(['input-data', 'wf-all', 'facade-initial', 'temps-initial', 'parameter'])\n",
       "Log-message:\n",
-      " Duration [s]\t\t0.29\n",
+      " Duration [s]\t\t0.2\n",
       "Objective [$]\t\t20.29\t\t\t7.58 (Total Cost)\n",
-      "Cost [$]\t\t13.32 (Energy)\t6.98 (Demand)\n",
+      "Cost [$]\t\t13.31 (Energy)\t6.98 (Demand)\n",
       "CO2 Emissions [kg]\t\t0.0\n",
       "\n",
       "Duration:\n",
-      " {'rad_duration': 17.785902976989746, 'varts_duration': 0.18678975105285645, 'optall_duration': 0.43532633781433105, 'glare_duration': 96.1897702217102, 'opt_duration': 0.2924964427947998, 'outputs_duration': 0.009624481201171875, 'duration': 114.62892770767212}\n",
+      " {'duration': {'radiance': 28.713886737823486, 'glare': 68.22607159614563, 'varts': 0.12781977653503418, 'optall': 0.5022704601287842, 'outputs': 0.0056383609771728516, 'all': 101.4219479560852}}\n",
       "Optimization:\n",
-      " {'opt_objective': 20.29202698, 'opt_duration': 0.2924964427947998, 'opt_termination': 'optimal', 'duration': 114.62892770767212}\n"
+      " {'opt-stats': {'duration': 0.20232176780700684, 'termination': 'optimal', 'objective': 20.28974844}}\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 864x1728 with 8 Axes>"
       ]
@@ -112,8 +111,10 @@
     "\n",
     "try:\n",
     "    root = os.path.dirname(os.path.abspath(__file__))\n",
+    "    from .utility.thermostat import compute_thermostat_setpoints\n",
     "except:\n",
     "    root = os.getcwd()\n",
+    "    from afc.utility.thermostat import compute_thermostat_setpoints\n",
     "\n",
     "warnings.simplefilter(action='ignore', category=pd.errors.PerformanceWarning)\n",
     "\n",
@@ -127,27 +128,22 @@
     "        super().__init__()\n",
     "\n",
     "        self.input = {\n",
-    "            'paths':None,\n",
-    "            'radiance':None,\n",
-    "            'df_input':None,\n",
-    "            'wf_all':None,\n",
-    "            'facade_initial':None,\n",
-    "            'temps_initial':None,\n",
-    "            'parameter':None}\n",
+    "            'input-data': None,\n",
+    "            'wf-all': None,\n",
+    "            'facade-initial': None,\n",
+    "            'temps-initial': None,\n",
+    "            'parameter': None\n",
+    "        }\n",
     "        self.output = {\n",
-    "            'rad_duration':None,\n",
-    "            'varts_duration':None,\n",
-    "            'opt_objective':None,\n",
-    "            'glaremode':None,\n",
-    "            'opt_duration':None,\n",
-    "            'optall_duration':None,\n",
-    "            'opt_termination':None,\n",
-    "            'outputs_duration':None,\n",
-    "            'duration':None,\n",
-    "            'glare_duration':None,\n",
-    "            'uShade':None,\n",
-    "            'uTroom':None,\n",
-    "            'df_output':None}\n",
+    "            'duration': None,\n",
+    "            'opt-stats': None,\n",
+    "            'glaremode': None,\n",
+    "            'ctrl-facade': None,\n",
+    "            'ctrl-thermostat': None,\n",
+    "            'ctrl-troom': None,\n",
+    "            'output-data': None,\n",
+    "            'valid': None\n",
+    "        }\n",
     "        self.init = True\n",
     "        self.root = root\n",
     "\n",
@@ -168,6 +164,7 @@
     "        self.glare_handler = None\n",
     "        self.data = None\n",
     "        self.res = None\n",
+    "        self.parameter = None\n",
     "\n",
     "    def init_functions(self):\n",
     "        \"\"\"Function to initialize controller.\"\"\"\n",
@@ -231,42 +228,46 @@
     "            self.msg = ''\n",
     "\n",
     "            # Parse input dataframe\n",
-    "            inputs = pd.DataFrame().from_dict(self.input['df_input'])\n",
+    "            inputs = pd.DataFrame().from_dict(self.input['input-data'])\n",
     "            inputs.index = pd.to_datetime(inputs.index)#, unit='ms')\n",
     "\n",
+    "            # configuration\n",
+    "            self.parameter = self.input['parameter']\n",
+    "\n",
     "            # Setup controller\n",
     "            if self.init:\n",
     "                self.init_functions()\n",
     "                from afc.optModel import control_model#, pyomo_to_pandas\n",
-    "                if self.input['parameter']['wrapper']['solver_dir']:\n",
+    "                if self.parameter['wrapper']['solver_dir']:\n",
     "                    solver_path = \\\n",
-    "                        self.get_solver(self.input['parameter']['wrapper']['solver_name'],\n",
-    "                                        solver_dir=self.input['parameter']['wrapper']['solver_dir'])\n",
+    "                        self.get_solver(self.parameter['wrapper']['solver_name'],\n",
+    "                                        solver_dir=self.parameter['wrapper']['solver_dir'])\n",
     "                else:\n",
-    "                    solver_path = self.get_solver(self.input['parameter']['wrapper']['solver_name'])\n",
+    "                    solver_path = self.get_solver(self.parameter['wrapper']['solver_name'])\n",
     "                pyomo_logger = \\\n",
-    "                    logging.WARNING if self.input['parameter']['wrapper']['printing'] else \\\n",
+    "                    logging.WARNING if self.parameter['wrapper']['printing'] else \\\n",
     "                        logging.ERROR\n",
-    "                self.tariff = self.get_tariff(self.input['parameter']['wrapper']['tariff_name'])\n",
-    "                output_list = self.input['parameter']['wrapper']['output_list']\n",
+    "                self.tariff = self.get_tariff(self.parameter['wrapper']['tariff_name'])\n",
+    "                output_list = self.parameter['wrapper']['output_list']\n",
     "                self.controller = self.doper(model=control_model,\n",
-    "                                             parameter=self.input['parameter'],\n",
+    "                                             parameter=self.parameter,\n",
     "                                             solver_path=solver_path,\n",
     "                                             pyomo_logger=pyomo_logger,\n",
     "                                             output_list=output_list)\n",
+    "                rad_paths = self.parameter['radiance']['paths']\n",
     "                filestruct = {}\n",
-    "                filestruct['resources'] = self.input['paths']['rad_bsdf']\n",
-    "                filestruct['matrices'] = self.input['paths']['rad_mtx']\n",
+    "                filestruct['resources'] = rad_paths['rad_bsdf']\n",
+    "                filestruct['matrices'] = rad_paths['rad_mtx']\n",
     "                self.forecaster = \\\n",
-    "                    self.forecaster.Forecast(self.input['paths']['rad_config'],\n",
-    "                                             regenerate=self.input['radiance']['regenerate'],\n",
-    "                                             location=self.input['radiance']['location'],\n",
-    "                                             facade_type=self.input['parameter']['facade']['type'],\n",
-    "                                             wpi_loc=self.input['radiance']['wpi_loc'],\n",
+    "                    self.forecaster.Forecast(rad_paths['rad_config'],\n",
+    "                                             regenerate=self.parameter['radiance']['regenerate'],\n",
+    "                                             location=self.parameter['radiance']['location'],\n",
+    "                                             facade_type=self.parameter['facade']['type'],\n",
+    "                                             wpi_loc=self.parameter['radiance']['wpi_loc'],\n",
     "                                             filestruct=filestruct,\n",
-    "                                             dimensions=self.input['radiance']['dimensions'])\n",
-    "                if self.input['parameter']['wrapper']['precompute_radiance']:\n",
-    "                    wf_all = pd.DataFrame().from_dict(self.input['wf_all'])\n",
+    "                                             dimensions=self.parameter['radiance']['dimensions'])\n",
+    "                if self.parameter['wrapper']['precompute_radiance']:\n",
+    "                    wf_all = pd.DataFrame().from_dict(self.input['wf-all'])\n",
     "                    wf_all.index = pd.to_datetime(wf_all.index, unit='ms')\n",
     "                    temp = pd.DataFrame()\n",
     "                    for d in sorted(np.unique(wf_all.index.date)):\n",
@@ -279,12 +280,12 @@
     "                    self.forecaster = temp\n",
     "\n",
     "                # Glare handler\n",
-    "                view_config = self.view_config_from_rad(self.input['paths']['rad_config'],\n",
+    "                view_config = self.view_config_from_rad(rad_paths['rad_config'],\n",
     "                                                        start_lx=20e3, end_lx=12.5e3)\n",
     "                self.glare_handler = \\\n",
-    "                    self.glare_handler_class(config=self.input['radiance']['location'],\n",
+    "                    self.glare_handler_class(config=self.parameter['radiance']['location'],\n",
     "                                             view_config=view_config)\n",
-    "                if self.input['parameter']['wrapper']['precompute_radiance']:\n",
+    "                if self.parameter['wrapper']['precompute_radiance']:\n",
     "                    wf = wf_all[['dni','dhi']].copy(deep=True).rename(columns=map_weather)\n",
     "                    for ix in wf.index:\n",
     "                        wf.loc[ix, ['alt', 'azi_shift', 'inci', 'azi']] = \\\n",
@@ -297,23 +298,24 @@
     "\n",
     "            # Compute radiance\n",
     "            st1 = time.time()\n",
+    "            self.output['duration'] = {}\n",
     "\n",
-    "            if self.input['parameter']['wrapper']['precompute_radiance']:\n",
+    "            if self.parameter['wrapper']['precompute_radiance']:\n",
     "                data = self.forecaster.loc[inputs.index]\n",
     "            else:\n",
     "                data = self.forecaster.compute2(inputs[['dni','dhi']])\n",
     "            # cutoff\n",
-    "            rad_cutoff = self.input['parameter']['facade']['rad_cutoff']\n",
+    "            rad_cutoff = self.parameter['facade']['rad_cutoff']\n",
     "            for k in rad_cutoff.keys():\n",
     "                for c in data.columns:\n",
     "                    if k in c:\n",
     "                        data.loc[:,c] = data[c].mask(data[c] < rad_cutoff[k][0], 0)\n",
     "                        data.loc[:,c] = data[c].mask(data[c] > rad_cutoff[k][1], rad_cutoff[k][1])\n",
-    "            self.output['rad_duration'] = time.time() - st1\n",
+    "            self.output['duration']['radiance'] = time.time() - st1\n",
     "\n",
     "            # Glare handler\n",
     "            st1 = time.time()\n",
-    "            if self.input['parameter']['wrapper']['precompute_radiance']:\n",
+    "            if self.parameter['wrapper']['precompute_radiance']:\n",
     "                wf = self.glare_handler.loc[inputs.index]\n",
     "            else:\n",
     "                wf = inputs[['dni','dhi']].copy(deep=True).rename(columns=map_weather)\n",
@@ -325,10 +327,10 @@
     "                    for i, g in enumerate(gmodes):\n",
     "                        wf.loc[ix, f'zone{i}_gmode'] = int(g)\n",
     "\n",
-    "            zones = self.input['parameter']['facade']['windows']\n",
-    "            states = self.input['parameter']['facade']['states']\n",
-    "            flip_z = 'shade' in self.input['parameter']['facade']['type']\n",
-    "            if self.input['parameter']['facade']['type'] == 'blinds':\n",
+    "            zones = self.parameter['facade']['windows']\n",
+    "            states = self.parameter['facade']['states']\n",
+    "            flip_z = 'shade' in self.parameter['facade']['type']\n",
+    "            if self.parameter['facade']['type'] == 'blinds':\n",
     "                darkstates = [s for s in states if s not in [0, 9, 10, 11]] # Specific for blinds\n",
     "            else:\n",
     "                darkstates = states[1:]\n",
@@ -341,7 +343,7 @@
     "                    gmodes.append(wf.loc[wf.index[0], wf_key])\n",
     "                    data[f'ev_{nz}_{t}'] =  data[f'ev_{nz}_{t}'].mask( \\\n",
     "                        (wf[wf_key] > 0) & (data[f'wpi_{nz}_{t}']>0), 2e4)\n",
-    "            self.output['glare_duration'] = time.time() - st1\n",
+    "            self.output['duration']['glare'] = time.time() - st1\n",
     "\n",
     "            # Compute other inputs\n",
     "            data = pd.concat([data, inputs], axis=1)\n",
@@ -351,16 +353,24 @@
     "            data['battery_0_demand'] = 0\n",
     "            data['battery_reg'] = 0\n",
     "\n",
-    "            # Update SOC\n",
-    "            self.input['parameter']['zone']['temps_initial'] = self.input['temps_initial']\n",
-    "            self.input['parameter']['facade']['fstate_initial'] = self.input['facade_initial']\n",
+    "            # Update SOCs\n",
+    "            self.parameter['zone']['temps_initial'] = self.input['temps-initial']\n",
+    "            self.parameter['facade']['fstate_initial'] = self.input['facade-initial']\n",
+    "\n",
+    "            # Make sure temp_initial is feasible\n",
+    "            dead_band = 1e-2\n",
+    "            cool_set = data['temp_room_max'].values[0]\n",
+    "            heat_set = data['temp_room_min'].values[0]\n",
+    "            troom = self.parameter['zone']['temps_initial'][0]\n",
+    "            troom = max(heat_set+dead_band, min(cool_set-dead_band, troom))\n",
+    "            self.parameter['zone']['temps_initial'][0] = troom\n",
     "\n",
     "            # Variable timestep\n",
     "            st1 = time.time()\n",
-    "            if self.input['parameter']['wrapper']['resample_variable_ts']:\n",
+    "            if self.parameter['wrapper']['resample_variable_ts']:\n",
     "\n",
     "                # check columns\n",
-    "                cols = self.input['parameter']['wrapper']['cols_fill']\n",
+    "                cols = self.parameter['wrapper']['cols_fill']\n",
     "                if not 'temp_room_max' in cols[0].lower():\n",
     "                    print('ERROR: \"temp_room_max\" is not in first column of \"cols_fill\".')\n",
     "\n",
@@ -378,23 +388,23 @@
     "                        data.loc[data.index[max(0, data.index.get_loc(ix)-1)], cols].values\n",
     "\n",
     "                # limit starting ramp\n",
-    "                t_init = self.input['temps_initial'][0]\n",
+    "                t_init = self.parameter['zone']['temps_initial'][0]\n",
     "                data[cols[0]] = \\\n",
-    "                    np.min([[t_init+(i+1)*self.input['parameter']['wrapper']['limit_slope'] \\\n",
+    "                    np.min([[t_init+(i+1)*self.parameter['wrapper']['limit_slope'] \\\n",
     "                             for i in range(len(data))], data[cols[0]]], axis=0)\n",
     "                data[cols[1]] = \\\n",
-    "                    np.max([[t_init-(i+1)*self.input['parameter']['wrapper']['limit_slope'] \\\n",
+    "                    np.max([[t_init-(i+1)*self.parameter['wrapper']['limit_slope'] \\\n",
     "                             for i in range(len(data))], data[cols[1]]], axis=0)\n",
     "\n",
     "                # resample\n",
     "                data = self.resample_variable_ts(data, \\\n",
-    "                    reduced_start=int(self.input['parameter']['wrapper']['reduced_start']),\n",
-    "                    reduced_ts=int(self.input['parameter']['wrapper']['reduced_ts']),\n",
-    "                    cols_fill=self.input['parameter']['wrapper']['cols_fill'])\n",
-    "            self.output['varts_duration'] = time.time() - st1\n",
+    "                    reduced_start=int(self.parameter['wrapper']['reduced_start']),\n",
+    "                    reduced_ts=int(self.parameter['wrapper']['reduced_ts']),\n",
+    "                    cols_fill=self.parameter['wrapper']['cols_fill'])\n",
+    "            self.output['duration']['varts'] = time.time() - st1\n",
     "\n",
     "            # Compute and update tariff\n",
-    "            data, _ = self.compute_periods(data, self.tariff, self.input['parameter'])\n",
+    "            data, _ = self.compute_periods(data, self.tariff, self.parameter)\n",
     "\n",
     "            # Check for nan\n",
     "            if pd.isnull(data).any().any():\n",
@@ -405,47 +415,55 @@
     "\n",
     "            # Run optimization\n",
     "            st1 = time.time()\n",
-    "            self.data = data.round(self.input['parameter']['wrapper']['inputs_cutoff'])\n",
+    "            self.data = data.round(self.parameter['wrapper']['inputs_cutoff'])\n",
     "\n",
     "            # Store for debug\n",
     "            # data.to_csv('inputs_{}.csv'.format(data.index[0]))\n",
     "            # cfg = {}\n",
-    "            # cfg['parameter'] = self.input['parameter']\n",
-    "            # cfg['options'] = self.input['parameter']['options']\n",
+    "            # cfg['parameter'] = self.parameter\n",
+    "            # cfg['options'] = self.parameter['options']\n",
     "            # with open('cfg_{}.json'.format(data.index[0]), 'w') as f:\n",
     "            #     f.write(json.dumps(cfg))\n",
     "\n",
-    "            printing = self.input['parameter']['wrapper']['printing']\n",
+    "            printing = self.parameter['wrapper']['printing']\n",
     "            self.res = \\\n",
     "                self.controller.do_optimization(self.data,\n",
-    "                                                parameter=self.input['parameter'],\n",
-    "                                                options=self.input['parameter']['solver_options'],\n",
+    "                                                parameter=self.parameter,\n",
+    "                                                options=self.parameter['solver_options'],\n",
     "                                                tee=printing,\n",
     "                                                print_error=printing)\n",
     "            duration, objective, df, model, result, termination, parameter = self.res\n",
-    "            self.output['optall_duration'] = time.time() - st1\n",
+    "            df = pd.concat([df, data], axis=1)\n",
+    "            self.output['duration']['optall'] = time.time() - st1\n",
     "\n",
     "            # Write outputs\n",
     "            st1 = time.time()\n",
-    "            self.output['opt_duration'] = float(duration)\n",
-    "            self.output['opt_termination'] = str(termination)\n",
-    "            self.output['opt_objective'] = float(objective) if objective else None\n",
+    "            self.output['opt-stats'] = {'duration': float(duration),\n",
+    "                                        'termination': str(termination),\n",
+    "                                        'objective': float(objective) if objective else None}\n",
+    "            self.output['valid'] = bool(objective)\n",
     "            self.output['glaremode'] = list(gmodes)\n",
+    "\n",
+    "            # Compute thermostat setpoints\n",
+    "            thermostat = compute_thermostat_setpoints(df, self.output['valid'], True, False)\n",
+    "            self.output['ctrl-thermostat'] = thermostat\n",
+    "            self.output['ctrl-troom'] = float(df['Temperature 0 [C]'].values[1])\n",
+    "\n",
+    "            # Compute shade state\n",
     "            if objective:\n",
     "                uShade = df[[f'Facade State {z}' for \\\n",
-    "                    z in self.input['parameter']['facade']['windows']]].iloc[0].values\n",
+    "                    z in self.parameter['facade']['windows']]].iloc[0].values\n",
     "                #uShade = df[['Tint Bottom [-]', 'Tint Middle [-]', 'Tint Top [-]']].iloc[0].values\n",
-    "                self.output['uShade'] = [round(float(u),1) for u in uShade]\n",
-    "                self.output['uTroom'] = float(df['Temperature 0 [C]'].values[1])\n",
-    "            df = pd.concat([df, data], axis=1)\n",
+    "                self.output['ctrl-facade'] = [round(float(u),1) for u in uShade]\n",
+    "\n",
     "            df.index = (df.index.astype(np.int64) / 10 ** 6).astype(str)\n",
     "            df = df.astype(float).fillna(-1)\n",
-    "            self.output['df_output'] = df.to_dict()\n",
-    "            self.output['duration'] = time.time() - st\n",
-    "            self.output['outputs_duration'] = time.time() - st1\n",
+    "            self.output['output-data'] = df.to_dict()\n",
+    "            self.output['duration']['outputs'] = time.time() - st1\n",
+    "            self.output['duration']['all'] = time.time() - st\n",
     "\n",
     "            # Store if long optimization\n",
-    "            if self.output['duration'] > self.input['parameter']['wrapper']['log_overtime']:\n",
+    "            if self.output['duration']['all'] > self.parameter['wrapper']['log_overtime']:\n",
     "                self.log_results()\n",
     "\n",
     "            self.init = False\n",
@@ -486,6 +504,7 @@
     "    df.loc[:, 'temp_slab_min'] = 0\n",
     "    df.loc[:, 'temp_wall_max'] = 1e3\n",
     "    df.loc[:, 'temp_wall_min'] = 0\n",
+    "    df.loc[:, 'grid_co2_intensity'] = 0\n",
     "\n",
     "    # Add External inputs (if any)\n",
     "    for c in ext_df:\n",
@@ -493,13 +512,11 @@
     "\n",
     "    # Map parameter and make Inputs object\n",
     "    inputs = {}\n",
-    "    inputs['radiance'] = parameter['radiance']\n",
-    "    inputs['df_input'] = df.to_dict()\n",
-    "    inputs['wf_all'] = None\n",
-    "    inputs['facade_initial'] = parameter['facade']['fstate_initial']\n",
-    "    inputs['temps_initial'] = parameter['zone']['temps_initial']\n",
+    "    inputs['input-data'] = df.to_dict()\n",
+    "    inputs['wf-all'] = None\n",
+    "    inputs['facade-initial'] = parameter['facade']['fstate_initial']\n",
+    "    inputs['temps-initial'] = parameter['zone']['temps_initial']\n",
     "    inputs['parameter'] = parameter\n",
-    "    inputs['paths'] = parameter['radiance']['paths']\n",
     "\n",
     "    return inputs\n",
     "\n",
@@ -533,20 +550,13 @@
     "    inputs = make_inputs(parameter, wf)\n",
     "\n",
     "    # Query controller\n",
-    "    ctrl.do_step(inputs=inputs) # Initialize\n",
     "    print('Log-message:\\n', ctrl.do_step(inputs=inputs))\n",
-    "    print('Duration:\\n', ctrl.get_output(keys=['rad_duration', 'varts_duration',\n",
-    "                                               'optall_duration', 'glare_duration',\n",
-    "                                               'opt_duration', 'outputs_duration', 'duration']))\n",
-    "    print('Optimization:\\n', ctrl.get_output(keys=['opt_objective', 'opt_duration',\n",
-    "                                                   'opt_termination', 'duration']))\n",
-    "    df = pd.DataFrame(ctrl.get_output(keys=['df_output'])['df_output'])\n",
+    "    print('Duration:\\n', ctrl.get_output(keys=['duration']))\n",
+    "    print('Optimization:\\n', ctrl.get_output(keys=['opt-stats']))\n",
+    "    df = pd.DataFrame(ctrl.get_output(keys=['output-data'])['output-data'])\n",
     "    df.index = pd.to_datetime(pd.to_numeric(df.index), unit='ms')\n",
     "\n",
     "    try:\n",
-    "        # Remove slab constraints for plotting\n",
-    "        df['Temperature 1 Min [C]'] = None\n",
-    "        df['Temperature 1 Max [C]'] = None\n",
     "        plot_standard1(pd.concat([wf, df], axis=1).ffill().iloc[:-1])\n",
     "    except:\n",
     "        pass\n"
diff --git a/examples/example_1.py b/examples/example_1.py
index 153a59e..5ef095d 100644
--- a/examples/example_1.py
+++ b/examples/example_1.py
@@ -35,7 +35,7 @@ def example1():
     weather_path = os.path.join(os.path.dirname(root), 'dev', 'resources', 'weather', 
         'USA_CA_San.Francisco.Intl.AP.724940_TMY3.csv')
     weather, info = read_tmy3(weather_path, coerce_year=2023)
-    #weather = weather.resample('5T').interpolate()
+    #weather = weather.resample('5min').interpolate()
     st = dtm.datetime(2023, 7, 1)
     wf = weather.loc[st:st+pd.DateOffset(hours=24),]
     df = wf[['temp_air','dni','dhi','wind_speed']].copy()
@@ -49,7 +49,6 @@ def example1():
     inputs = make_inputs(parameter, df)
 
     # Query controller
-    #log = ctrl.do_step(inputs=inputs) # first run to initialize
     log = ctrl.do_step(inputs=inputs) # run controller
     
     # Print results
@@ -59,7 +58,7 @@ def example1():
     #                                    'opt_duration','outputs_duration','duration']))
     #print('Optimization:')
     #pprint.pprint(ctrl.get_output(keys=['opt_objective','opt_duration','opt_termination','duration']))
-    df = pd.DataFrame(ctrl.get_output(keys=['df_output'])['df_output'])
+    df = pd.DataFrame(ctrl.get_output(keys=['output-data'])['output-data'])
     df.index = pd.to_datetime(pd.to_numeric(df.index), unit='ms')
     print('Facade actuation during the day (when DNI > 0).')
     print('Facade 0 = bottom zone, Facade 1 = middle zone, Facade 2 = top zone')
diff --git a/test/test_1.py b/test/test_1.py
index ace86ff..294a1c0 100644
--- a/test/test_1.py
+++ b/test/test_1.py
@@ -31,7 +31,7 @@ def test1():
     weather_path = os.path.join(os.path.dirname(root), 'dev', 'resources', 'weather', 
         'USA_CA_San.Francisco.Intl.AP.724940_TMY3.csv')
     weather, info = read_tmy3(weather_path, coerce_year=2023)
-    weather = weather.resample('5T').interpolate()
+    weather = weather.resample('5min').interpolate()
     st = dtm.datetime(2023, 7, 1)
     wf = weather.loc[st:st+pd.DateOffset(hours=24),]
     df = wf[['temp_air','dni','dhi','wind_speed']].copy()
@@ -45,17 +45,13 @@ def test1():
     inputs = make_inputs(parameter, df)
 
     # Query controller
-    ctrl.do_step(inputs=inputs) # Initialize
-    print('Log-message:\n', ctrl.do_step(inputs=inputs))
-    print('Duration:\n', ctrl.get_output(keys=['rad_duration','varts_duration','optall_duration','glare_duration',
-                                               'opt_duration','outputs_duration','duration']))
-    print('Optimization:\n', ctrl.get_output(keys=['opt_objective','opt_duration','opt_termination','duration']))
-    df = pd.DataFrame(ctrl.get_output(keys=['df_output'])['df_output'])
+    ctrl.do_step(inputs=inputs)
+    df = pd.DataFrame(ctrl.get_output(keys=['output-data'])['output-data'])
     df.index = pd.to_datetime(df.index, unit='ms')
 
     # check
-    res = ctrl.get_output(keys=['opt_objective','opt_duration','opt_termination','duration'])
-    assert 19 < res['opt_objective'] < 20.5
-    assert res['opt_duration'] < 5
-    assert res['opt_termination'] == 'optimal'
-    assert res['duration'] < 60*5
+    res = ctrl.get_output(keys=['opt-stats', 'duration'])
+    assert 19.5 < res['opt-stats']['objective'] < 20.5
+    assert res['opt-stats']['duration'] < 5
+    assert res['opt-stats']['termination'] == 'optimal'
+    assert res['duration']['all'] < 60*5