def get_pf_chart_data_web(sic_code, report_year, benchmark_year, comparison_type, demand_type, g): """ Gets and calculates all data needed for powerfactor charts :param sic_code: sic code to find data for :param report_year: report year :param benchmark_year: benchmark year :param comparison_type: 'temp'/'dewpt'/'enthalpy' :param demand_type: 'all'/'peak'/'offpeak' :param g: :return: data for the charts """ data_list = [] sic_obj = g.uow.sic.get_by_code(sic_code) descendants = g.uow.sic.get_group_descendants(sic_code) accounts = [] # get all accounts of group descendants of sic code for gr in descendants: accounts += SharedReporting.get_accounts_for_group(gr, 'Electric', report_year, comparison_type, demand_type, g) accounts += SharedReporting.get_accounts_for_group(gr, 'Electric', benchmark_year, comparison_type, demand_type, g) # get the benchmark data for the accounts to avoid looping through benchmark data multiple times report_data = g.uow.compiled_energy_records.get_compiled_energy_records_for_report(accounts, data_field_name='sum_kvar') # create a copy of the benchmark records account_group = defaultdict(list) for d in report_data: account_group[d['group']['value']].append(d) calculated_totals = calculate_pf_data(account_group, report_year, benchmark_year, report_year == benchmark_year) return calculated_totals
def generate_kvarh_report(config, y_units, y_unit_map, total_energy_chart_info, submitted_by_user, submitted_to, g): """ Gathers data for the kVar report and generates it's PDF :param config: report configuration :param y_units: y units :param y_unit_map: database column name for y unit :param total_energy_chart_info: TotalEnergyChartInfo object to hold data :param submitted_by_user: user who submitted the report :param submitted_to: group who the report what submitted to :param g: g :return: path to the report PDF """ for code in config.entity_ids: sic_code = g.uow.sic.get_by_code(code) # get data associated with each account in the sic code accounts = [] group_descendants = g.uow.sic.get_group_descendants(code) for gr in group_descendants: accounts += SharedReporting.get_accounts_for_group(gr, 'Electric', config.report_year, config.comparison_type, config.demand_type, g) data = SharedReporting.get_total_energy_chart_data_pdf(accounts, config.report_year, config.benchmark_year, config.demand_type, y_units, y_unit_map, g) total_energy_chart_info.data.append({'entity': sic_code["name"], 'data': data}) # Generate consumption report with data report_path = DataReports.generate_kvarh_report(config.report_year, config.benchmark_year, total_energy_chart_info, submitted_by_user, submitted_to) return report_path
def get_syrx_data(config): """ Gets the data for the syrx number in config and returns a kendo-formatted object of the data :param config: EquipmentReport :return: """ report_series_dict = {} benchmark_series_dict = {} if len(config.syrx_nums) > 1: target_unit = "mmbtu" else: target_unit = None for syrx_num in config.syrx_nums: # get the equipment point ep = g.uow.equipment.get_equipment_point_by_syrx_num(syrx_num) if not target_unit: target_unit = ep['units'].lower() conversion_factor = SharedReporting.get_component_point_conversion(ep['units'].lower(), 'mmbtu') syrx_series = get_consumption_data_for_year(syrx_num, config.report_year, config.start_month, config.end_month, conversion_factor) # add to the existing series add_to_new_series_data(report_series_dict, syrx_series[0]['data']) syrx_series_benchmark = get_consumption_data_for_year(syrx_num, config.comparison_year, config.start_month, config.end_month, conversion_factor) # add to the existing series add_to_new_series_data(benchmark_series_dict, syrx_series_benchmark[0]['data']) report_difference_list, benchmark_difference_list = calculate_difference_equipment_report(report_series_dict, benchmark_series_dict) consumption_series_list = convert_dict_to_list(report_series_dict) consumption_series_list[0]['name'] = 'Reported Consumption' benchmark_series_list = convert_dict_to_list(benchmark_series_dict) consumption_series_list += benchmark_series_list consumption_series_list[1]['name'] = 'Benchmark Consumption' difference_series_list = convert_dict_to_list(report_difference_list) difference_series_list[0]['name'] = 'Reported Consumption' difference_series_list += convert_dict_to_list(benchmark_difference_list) difference_series_list[1]['name'] = 'Benchmark Consumption' chart_info = ComponentDifferenceDataContainer() chart_info.component_description = "" chart_info.title = "Intensity" chart_info.consumption_data = consumption_series_list chart_info.difference_data = difference_series_list chart_info.x_axis_label = "Temperature (F)" chart_info.y_axis_label = "Energy Consumption (" + SharedReporting.get_y_unit_label(target_unit.lower()) + ")" return chart_info
def get_comparison_chart_data(config): """ Gets a list of the series used for the comparison report charts :param config: ComponentReportingComparisonConfiguration :return: TotalEnergyDataContainer that holds all information for the chart """ series_list = [] for entity in config.component_ids: # get label from the entity label = get_label_for_entity(entity) # get actual component_id from the list syrx_nums = get_syrx_nums_from_entity(entity) # combine the comparison year with the historical mode years all_years = list(set([config.comparison_year] + config.historical_years)) for year in all_years: new_series_data = {} for syrx_num in syrx_nums: # get the equipment point by syrx num ep = g.uow.equipment.get_equipment_point_by_syrx_num(syrx_num) # get the series data for each point syrx_series = g.uow.compiled_point_records.get_data_for_syrx_nums([syrx_num], year, 1, 12) if len(syrx_series) > 0: # convert the data to the new values conversion_factor = SharedReporting.get_component_point_conversion(ep['units'].lower(), config.unit) convert_data_to_btu_unit(syrx_series[0]['data'], conversion_factor) # add to the new_series_data add_to_new_series_data(new_series_data, syrx_series[0]['data']) if len(new_series_data) > 0: new_series_data_list = [] # change the data from a dictionary to list for key in sorted(new_series_data.keys()): new_series_data_list.append([key, new_series_data[key]]) # overwrite the point name with the component name new_series = [{"name": None, "data": new_series_data_list}] new_series[0]["name"] = label + " - " + str(year) series_list += new_series chart_info = TotalEnergyDataContainer() chart_info.title = "Intensity" chart_info.data = series_list chart_info.x_axis_label = "Temperature (F)" chart_info.y_axis_label = "Energy Consumption (" + SharedReporting.get_y_unit_label(config.unit) + ")" return chart_info
def generate_consumption_report(config, y_units, y_unit_map, total_energy_chart_info, submitted_by_user, submitted_to, g): """ Gathers data and generates a pdf from it :param config: :param y_units: :param y_unit_map: :param total_energy_chart_info: :param submitted_by_user: :param submitted_to: :param g: :return: """ # collect information for intensity chart intensity_chart_info = get_intensity_chart_data(config.entity_ids, config.account_type, config.report_year, config.comparison_type, config.demand_type, g) year_group_grouping = {} # loop through every SIC code in the configuration and get their consumption chart data for code in config.entity_ids: # get the sic code and it's group descendants sic_code = g.uow.sic.get_by_code(code) group_descendants = g.uow.sic.get_group_descendants(code) # get all accounts for the SIC code accounts = [] for gr in group_descendants: accounts += SharedReporting.get_accounts_for_group(gr, config.account_type, config.report_year, config.comparison_type, config.demand_type, g) # get data associated with each account data = SharedReporting.get_total_energy_chart_data_pdf(accounts, config.report_year, config.benchmark_year, config.demand_type, y_units, y_unit_map, g) total_energy_chart_info.data.append({'entity': sic_code['name'], 'data': data['chart_data']}) for year in data['year_data']: # check if the year has not been added to the group before if not year in year_group_grouping: # the year hasn't been added to the grouping, so just create a new entry in the dictionary year_group_grouping[year] = [{'entity': sic_code['name'] + ' (' + str(year) + ')', 'data': data['year_data'][year]}] else: # append the entry year_group_grouping[year].append({'entity': sic_code['name'] + ' (' + str(year) + ')', 'data': data['year_data'][year]}) # generate report data and get the report path report_path = DataReports.generate_consumption_report(config.report_year, config.benchmark_year, intensity_chart_info, total_energy_chart_info, year_group_grouping, submitted_by_user, submitted_to, SharedReporting.get_y_unit_label(y_units)) return report_path
def get_y_axis_and_conversion_factor(config): """ Gets the y axis unit and conversion factor :param config: EquipmentReport :return: y_axis_unit, conversion_factor """ y_axis_units = "Btu" same_unit = g.uow.equipment.all_of_same_unit(config.syrx_nums) # if all equipment points have the same unit, then we will use that unit as the y axis if same_unit: y_axis_units = g.uow.equipment.get_equipment_point_by_syrx_num(config.syrx_nums[0]) if 'units' in y_axis_units: y_axis_units = y_axis_units['units'] else: y_axis_units = "Binary" # if the unit is kWh then have a conversion factor, otherwise it will be 1 if y_axis_units.lower() == "kwh": conversion_factor = SharedReporting.get_factor('kwh', 'sum_btu') else: conversion_factor = 1.0 else: # otherwise, we keep the units in Btu conversion_factor = 1.0 return y_axis_units, conversion_factor
def get_paragraph_report(): model = request.get_json() equipments = [{"equipment": g.uow.equipment.get_by_id(equipment_id).__dict__, "paragraphs": g.uow.equipment.get_all_paragraphs_for_equipment(equipment_id)} for equipment_id in model["equipment_ids"]] report_config = {"equipments": equipments} submitted_by = g.uow.users.get_user_by_id(session["current_user"]["id"]) submitted_to = model["submitted_to"] # get the submitted by and submitted to submitted_by, submitted_to = SharedReporting.get_submitted_contacts(submitted_by, submitted_to, g) report_path = generate_paragraph_report(report_config, submitted_to, submitted_by) return send_file(report_path, mimetype='application/pdf')
def get_intensity_chart_data(sic_codes, account_type, report_year, comparison_type, demand_type, g): # Set the x units for the intensity chart on the consumption report x_units = "F" x_axis_label = "Temperature (" + x_units + ")" if comparison_type == "enthalpy": x_axis_label = "Enthalpy" final_data = [] # get all accounts for sic code and it's descendants for nc in sic_codes: data_insert = [] accounts = [] sic_code = g.uow.sic.get_by_code(nc) group_descendants = g.uow.sic.get_group_descendants(nc) for desc in group_descendants: accounts += SharedReporting.get_accounts_for_group(desc, account_type, report_year, comparison_type, demand_type, g) consider_demand_type = False if demand_type != 'all': consider_demand_type = True if len(accounts) > 0: # get data for the consumption report intensity_data = g.uow.compiled_energy_records.get_compiled_energy_records_for_report(accounts, consider_demand_type=consider_demand_type) else: intensity_data = [] # loop through and adjust the values based on size normalization for entry in intensity_data: data_insert.append([entry['group']['value'], entry['reduction']['sum_btu'] / entry['reduction']['sum_size_normalization']]) # add to the final data final_data.append({"name": sic_code["name"], "data": data_insert}) # set the metadata for the consumption report intensity_chart_info = ReportChartInformation() intensity_chart_info.title = "Intensity" intensity_chart_info.y_axis_label = "Energy Intensity (BTU/sqft)" intensity_chart_info.x_axis_label = x_axis_label intensity_chart_info.data = final_data return intensity_chart_info
def get_comparison_pdf_report(config): if not config.submitted_to: return abort(409) submitted_by = g.uow.users.get_user_by_id(session["current_user"]["id"]) submitted_to = config.submitted_to # get the submitted by and submitted to submitted_by, submitted_to = SharedReporting.get_submitted_contacts(submitted_by, submitted_to, g) total_energy_chart_info = TotalEnergyDataContainer() report_name = "Component Comparison Report" total_energy_chart_info.y_axis_label = "Energy Consumption (BTU)" total_energy_chart_info.title = "Intensity" comparison_data = get_comparison_chart_data(config) comparison_table_data = get_comparison_table_data(config, config.comparison_year) report_path = generate_comparison_pdf(config, comparison_data, comparison_table_data, submitted_by, submitted_to) return send_file(report_path, mimetype='application/pdf', as_attachment=True, attachment_filename=report_name + '.pdf')
def get_standards_pdf_report(config): if not config.submitted_to: return abort(409) submitted_by = g.uow.users.get_user_by_id(session["current_user"]["id"]) submitted_to = config.submitted_to # get the submitted by and submitted to submitted_by, submitted_to = SharedReporting.get_submitted_contacts(submitted_by, submitted_to, g) total_energy_chart_info = TotalEnergyDataContainer() report_name = "Component Standards Report" total_energy_chart_info.y_axis_label = "Energy Consumption (BTU/sqft)" total_energy_chart_info.title = "Intensity" standards_data = get_standards_chart_data(config) standards_table_data = get_standards_table_data(config) report_path = generate_standards_pdf(config, standards_data, standards_table_data, submitted_by, submitted_to) # send file back out to user for download return send_file(report_path, mimetype='application/pdf', as_attachment=True, attachment_filename=report_name + '.pdf')
def find_price_for_equipment_points(units, equipment_id): """ Finds the price/unit of the equipment points based on unit :param units: 'kwh'/'btu'/'mcf' :param equipment_id: Equipment id to find price based on :return: """ # find the equipment, which will help find the group equipment = g.uow.equipment.get_by_id(equipment_id) if units == 'kwh': acct = 'electric' else: acct = 'gas' account = SharedReporting.get_first_account_for_group_of_type(equipment.group_id, acct, g.uow) price = g.uow.price_normalizations.get_most_recent_for_account(account['id']) # ensure the price was found if price: price = price.value else: price = 0 return price
def construct_row(syrx_num, component_values, unit): """ Constructs a row for the table :param syrx_num: syrx_num that is being reported on :param component_values: dictionary containing ppsn, sum_value, and sum_hours_in_record :param unit: Unit the result should be in :return: """ equipment_point = g.uow.equipment.get_equipment_point_by_syrx_num(syrx_num) equipment = g.uow.equipment.get_by_id(equipment_point['equipment_id']) component = g.uow.components.get_by_id(equipment_point['component_id']) row_dict = { 'row': { 'equipment_name':equipment.name, 'component_id': component.num, 'description': equipment_point['point_code'], 'units': SharedReporting.get_y_unit_label(unit) }, 'ppsn': component_values['ppsn'], 'hours': component_values['sum_hours_in_record'], 'consumption': component_values['sum_value'], 'component_id': component.id, 'syrx_num': syrx_num, 'conversion_factor': None} return row_dict
def generate_group_text_report(config): return json.dumps(SharedReporting.generate_consumptiontext_report(config, 'groups', g))
def get_total_energy_data(config): # determine the x units x_units = "F" x_axis_label = "Temperature (" + x_units + ")" if config.comparison_type == "dewpt": x_units = "Dewpt" x_axis_label = "Dewpt" elif config.comparison_type == "enthalpy": x_units = "Enthalpy" x_axis_label = "Enthalpy" # get actual y units to send back, and get their equivalent column in the database if config.report_type == "consumption": if config.account_type.lower() == "electric": y_units = config.electric_units y_unit_map = 'sum_btu' title = "Total Energy Usage - Electric" elif config.account_type.lower() == "gas": y_units = config.gas_units y_unit_map = 'sum_btu' title = "Total Energy Usage - Gas" else: y_units = config.btu_units y_unit_map = "sum_btu" title = "Total Energy Usage" y_axis_label = "Average Energy Usage (" + SharedReporting.get_y_unit_label(y_units) + ")" elif config.report_type == "kvar": y_units = "kvar" y_unit_map = "sum_kvar" y_axis_label = "Average Electric Usage (kVar)" title = "kVar" elif config.report_type == "kva": y_units = "kva" y_unit_map = "kva" y_axis_label = "Average Electric Usage (kVa)" title = "kVa" elif config.report_type == "powerfactor": y_units = "pf" y_unit_map = "pf" y_axis_label = "Average Power Factor" title = "Power Factor" else: abort(409) # make sure data exists, otherwise return an empty object if len(config.entity_ids) < 1 or config.entity_ids[0] is None: return_obj = [ { 'consumption-chart': [ { 'name': 'Reported Consumption', 'data': [] }, { 'name': 'Benchmark Consumption', 'data': [] } ], 'difference-chart': [ { 'name': 'Reported Consumption', 'data': [] }, { 'name': 'Benchmark Consumption', 'data': [] } ], 'yunits': y_units, 'y_axis_label': y_axis_label, 'xunits': x_units, 'x_axis_label': x_axis_label, 'title': title } ] return json.dumps(return_obj) # check to see if config is asking for a powerfactor report, as it requires a different function if config.report_type == 'powerfactor': data = get_pf_chart_data_web(config.entity_ids[0], config.report_year, config.benchmark_year, config.comparison_type, config.demand_type, g) else: # we only care about the first entity id since the configuration is being formatted before the request as [entity_id] data = get_total_energy_chart_data_web(config.entity_ids[0], config.report_year, config.benchmark_year, config.account_type, config.comparison_type, config.demand_type, y_units, y_unit_map, g) return_obj = [ { 'consumption-chart': [ { 'name': 'Reported Consumption', 'data': data.reported_consumption }, { 'name': 'Benchmark Consumption', 'data': data.benchmark_consumption } ], 'difference-chart': [ { 'name': 'Reported Consumption', 'data': data.diff }, { 'name': 'Benchmark Consumption', 'data': data.benchmark_diff } ], 'yunits': y_units, 'y_axis_label': y_axis_label, 'xunits': x_units, 'x_axis_label': x_axis_label, 'title': title } ] return json.dumps(return_obj)
def get_comparison_table_data(config, year): """ Gets the rows for the data table after the chart :param config: ComponentReportingComparisonConfiguration :param year: year for the report :return: list of rows """ rows = [] row_dict_list = [] bic_syrx_num = None bic_value = None bic_hours = None bic_ppsn = None syrx_nums_used = set() # get price for reporting group price = get_comparison_price('btu', config.submitted_to) for entity in config.component_ids: # since the application allows for groups, equipment, and equipment points to be selected, we need to get # the syrx nums for whatever the current reporting entity is. # only get the syrx nums which haven't been used yet syrx_nums = get_syrx_nums_from_entity(entity) syrx_nums = list(set(syrx_nums) - syrx_nums_used) # update list of used syrx nums syrx_nums_used |= set(syrx_nums) for syrx_num in syrx_nums: # get PPSN for the entity component_values = g.uow.compiled_point_records.get_ppsn([syrx_num], year) # convert the values units = g.uow.equipment.get_equipment_point_by_syrx_num(syrx_num)['units'] conversion_factor = SharedReporting.get_component_point_conversion(units, config.unit) component_values['sum_value'] *= conversion_factor component_values['ppsn'] *= conversion_factor # add a dictionary of row data to the row_dict row_dict = construct_row(syrx_num, component_values, config.unit) row_dict['conversion_factor'] = conversion_factor # set the bic value if it has not yet been set if not bic_value: bic_syrx_num = syrx_num bic_ppsn = row_dict['ppsn'] bic_value = row_dict['consumption'] bic_hours = row_dict['hours'] elif row_dict['ppsn'] < bic_ppsn: bic_syrx_num = syrx_num bic_ppsn = row_dict['ppsn'] bic_value = row_dict['consumption'] bic_hours = row_dict['hours'] row_dict_list.append(row_dict) # using the bic_syrx_num, find the difference for each other component for row in row_dict_list: new_row = calculate_final_row_values(bic_syrx_num, bic_value, bic_hours, row, price) # update final rows value rows.append(new_row) return rows
def generate_consumptiontext_report(config, submitted_by_user, g): """ Gathers data for consumption text report and generates it's PDF :param config: report configuration :param submitted_by_user: user who submitted the report :param g: g :return: report path """ report_path = DataReports.generate_consumptiontext_report(config.report_year, config.benchmark_year, SharedReporting.generate_consumptiontext_report(config, 'sic', g), submitted_by_user, config.account_type) return report_path
def generate_variance_report(config, y_units, y_unit_map, submitted_by_user, submitted_to, g): """ Gathers data for variance report and generates it's PDF :param config: report configuration :param y_units: y units :param y_unit_map: database column name for y units :param submitted_by_user: user who submitted the report :param submitted_to: group who the report is addressed to :param g: g :return: path to PDF of report """ total_data = [] for code in config.entity_ids: sic_code = g.uow.sic.get_by_code(code) # get all accounts for sic code group_descendants = g.uow.sic.get_group_descendants(code) accounts = [] # check to make sure we should get electric accounts if config.account_type.lower() != 'gas': # get all electric accounts for desc in group_descendants: accounts += SharedReporting.get_accounts_for_group(desc, 'Electric', config.report_year, config.comparison_type, config.demand_type, g) accounts += SharedReporting.get_accounts_for_group(desc, 'Electric', config.benchmark_year, config.comparison_type, config.demand_type, g) # get all month utility, actual, benchmark, plan, variance ($), and variance (%) for every month in the report year electric_data = SharedReporting.get_variance_report_data(accounts, 'electric', config.report_year, config.benchmark_year, config.demand_type, y_units, y_unit_map, g) else: # create blank template so no null errors are thrown later electric_data = {"sitedata": [ {"label": "", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}, {"label": "", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}, {"label": "", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}, {"label": "", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}, {"label": "Variance ($)", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}, {"label": "Variance (%)", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]} ]} accounts = [] if config.account_type.lower() != 'electric': # get all gas accounts for desc in group_descendants: accounts += SharedReporting.get_accounts_for_group(desc, 'Gas', config.report_year, config.comparison_type, config.demand_type, g) accounts += SharedReporting.get_accounts_for_group(desc, 'Gas', config.benchmark_year, config.comparison_type, config.demand_type, g) # get gas data gas_data = SharedReporting.get_variance_report_data(accounts, 'gas', config.report_year, config.benchmark_year, config.demand_type, y_units, y_unit_map, g) else: # create blank template so no null errors are thrown later gas_data = {"sitedata": [ {"label": "", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}, {"label": "", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}, {"label": "", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}, {"label": "", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}, {"label": "Variance ($)", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}, {"label": "Variance (%)", "data": [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]} ]} data = {"entity_name": sic_code["name"], "sitedata": [ {"label": "", "data": []}, {"label": "", "data": []}, {"label": "", "data": []}, {"label": "", "data": []}, {"label": "Variance ($)", "data": []}, {"label": "Variance (%)", "data": []} ]} # determine which site labels to use if config.account_type.lower() != 'electric': labels = [gas_data["sitedata"][0]["label"], gas_data["sitedata"][1]["label"], gas_data["sitedata"][2]["label"], gas_data["sitedata"][3]["label"]] else: labels = [electric_data["sitedata"][0]["label"], electric_data["sitedata"][1]["label"], electric_data["sitedata"][2]["label"], electric_data["sitedata"][3]["label"]] data["sitedata"][0]["label"] = labels[0] data["sitedata"][1]["label"] = labels[1] data["sitedata"][2]["label"] = labels[2] data["sitedata"][3]["label"] = labels[3] # add gas data to electric data utility_list = [a+b for a,b in zip(electric_data["sitedata"][0]["data"], gas_data["sitedata"][0]["data"])] actual_list = [a+b for a,b in zip(electric_data["sitedata"][1]["data"], gas_data["sitedata"][1]["data"])] benchmark_list = [a+b for a,b in zip(electric_data["sitedata"][2]["data"], gas_data["sitedata"][2]["data"])] plan_list = [a+b for a,b in zip(electric_data["sitedata"][3]["data"], gas_data["sitedata"][3]["data"])] cost_variance_list = [a+b for a,b in zip(electric_data["sitedata"][4]["data"], gas_data["sitedata"][4]["data"])] percent_variance_list = [a+b for a,b in zip(electric_data["sitedata"][5]["data"], gas_data["sitedata"][5]["data"])] # format all data to be used in the javascript utility_list = ["{:,d}".format(entry) for entry in utility_list] actual_list = ["{:,d}".format(entry) for entry in actual_list] benchmark_list = ["{:,d}".format(entry) for entry in benchmark_list] plan_list = ["{:,d}".format(entry) for entry in plan_list] percent_variance_list = ["{:,.2f}%".format(entry) for entry in percent_variance_list] locale.setlocale(locale.LC_ALL, '') cost_variance_list = [locale.currency(entry, grouping=True) for entry in cost_variance_list] # set the final data values data["entity_name"] = sic_code["name"] data["sitedata"][0]["data"] = utility_list data["sitedata"][1]["data"] = actual_list data["sitedata"][2]["data"] = benchmark_list data["sitedata"][3]["data"] = plan_list data["sitedata"][4]["data"] = cost_variance_list data["sitedata"][5]["data"] = percent_variance_list total_data.append(data) report_path = DataReports.generate_variance_report(total_data, config.report_year, config.benchmark_year, submitted_by_user, submitted_to) return report_path
def get_equipment_report_table(config): # get the reporting points (that can be converted to btu) equipment_points = g.uow.equipment.get_equipment_reporting_points(config.equipment_id) ret_obj = { 'report_consumption_month': 0, 'benchmark_consumption_month': 0, 'report_consumption_year': 0, 'benchmark_consumption_year': 0, 'difference_month': 0, 'difference_year': 0, 'percent_month': 0, 'percent_year': 0, 'cost_month': 0, 'cost_year': 0 } # get the price for calculating cost savings price = find_price_for_equipment_points('mmbtu', config.equipment_id) # if they are all the same, find the price/unit for equipment_point in equipment_points: ep = g.uow.equipment.get_equipment_point_by_syrx_num(equipment_point['id']) conversion_factor = SharedReporting.get_component_point_conversion(ep['units'].lower(), 'mmbtu') temp_obj = calculate_totals_for_report(config, ep['units'], price, ep, conversion_factor) # update the ret_obj with the values ret_obj['report_consumption_month'] += temp_obj['report_consumption_month'] ret_obj['benchmark_consumption_month'] += temp_obj['benchmark_consumption_month'] ret_obj['report_consumption_year'] += temp_obj['report_consumption_year'] ret_obj['benchmark_consumption_year'] += temp_obj['benchmark_consumption_year'] ret_obj['cost_month'] += temp_obj['cost_month'] ret_obj['cost_year'] += temp_obj['cost_year'] # calculate final difference and percent difference ret_obj['difference_month'] = ret_obj['benchmark_consumption_month'] - ret_obj['report_consumption_month'] ret_obj['difference_year'] = ret_obj['benchmark_consumption_year'] - ret_obj['report_consumption_year'] if ret_obj['benchmark_consumption_month'] == 0: ret_obj['percent_month'] = "{:.2f}".format(0.0) else: ret_obj['percent_month'] = "{:.2f}".format((ret_obj['difference_month'] * 1.0 / ret_obj['benchmark_consumption_month']) * 100.0) if ret_obj['benchmark_consumption_year'] == 0: ret_obj['percent_year'] = "{:.2f}".format(0.0) else: ret_obj['percent_year'] = "{:.2f}".format((ret_obj['difference_year'] * 1.0 / ret_obj['benchmark_consumption_year']) * 100.0) # format the cost savings ret_obj['cost_month'] = "${:,.2f}".format(ret_obj['cost_month']) ret_obj['cost_year'] = "${:,.2f}".format(ret_obj['cost_year']) # format consumption numbers ret_obj['report_consumption_month'] = "{:,.2f}".format(ret_obj['report_consumption_month']) ret_obj['report_consumption_year'] = "{:,.2f}".format(ret_obj['report_consumption_year']) ret_obj['benchmark_consumption_month'] = "{:,.2f}".format(ret_obj['benchmark_consumption_month']) ret_obj['benchmark_consumption_year'] = "{:,.2f}".format(ret_obj['benchmark_consumption_year']) ret_obj['difference_month'] = "{:,.2f}".format(ret_obj['difference_month']) ret_obj['difference_year'] = "{:,.2f}".format(ret_obj['difference_year']) return json.dumps(ret_obj)
def get_total_energy_chart_data_web(sic_code, report_year, benchmark_year, account_type, comparison_type, demand_type, y_units, y_unit_map, g): """ Gets the data for the energy consumption chart :param sic_code: sic code being reported on :param report_year: report year from configuration :param benchmark_year: benchmark year from configuration :param account_type: 'electric'/'gas'/'all' :param comparison_type: 'temp'/'dewpt'/'enthalpy' :param demand_type: 'all'/'peak'/'offpeak' :param y_units: y units used for reporting 'btu, mcf, etc' :param y_unit_map: mapping column for database (often 'sum_btu') :param g: g :return: object containing all necessary information """ # determine if demand will be included in query consider_demand_type = False if demand_type != 'all': consider_demand_type = True same_year = report_year == benchmark_year # get unit factor for the selected y units unit_factor = SharedReporting.get_factor(y_units, y_unit_map) data = TotalEnergyData() # get group descendants of sic code descendants = g.uow.sic.get_group_descendants(sic_code) accounts = [] # get all accounts for each group for the desired year for gr in descendants: accounts += SharedReporting.get_accounts_for_group(gr, account_type, report_year, comparison_type, demand_type, g) if not same_year: accounts += SharedReporting.get_accounts_for_group(gr, account_type, benchmark_year, comparison_type, demand_type, g) if len(accounts) < 1: benchmark_data = [] else: benchmark_data = g.uow.compiled_energy_records.get_compiled_energy_records_for_report(accounts, data_field_name=y_unit_map, consider_demand_type=consider_demand_type) # group the data by value grouped = defaultdict(list) for d in benchmark_data: grouped[d['group']['value']].append(d) reported_consumption = [] diff = [] benchmark_diff = [] benchmark_consumption = [] # get the distinct values for the group grouped_keys = list(grouped.keys()) grouped_keys.sort() # if the report year and benchmark year are the same, it will be handled differently if same_year: for value in grouped_keys: entry = grouped[value] record_value = entry[0]['reduction'][y_unit_map] * unit_factor / entry[0]['reduction']['sum_hours_in_record'] reported_consumption.append([value, round(record_value, 5)]) diff.append([value, 0]) benchmark_consumption.append([value, round(record_value, 5)]) benchmark_diff.append([value, 0]) else: # loop through every distinct value and get all of the records for it for value in grouped_keys: entry = grouped[value] if len(entry) > 1: report_record = 0 benchmark_record = 0 report_avg_size = 0 benchmark_avg_size = 0 benchmark_record_hours = 0 for record in entry: if record['group']['year'] == report_year: report_record_hours = record['reduction']['sum_hours_in_record'] # normalize the values report_record = round(record['reduction'][y_unit_map] * unit_factor / report_record_hours, 5) reported_consumption.append([value, report_record]) report_avg_size = record['reduction']['sum_size_normalization'] * 1.0 / report_record_hours elif record['group']['year'] == benchmark_year: benchmark_record_hours = record['reduction']['sum_hours_in_record'] # get the size and record value to be normalized later benchmark_avg_size = record['reduction']['sum_size_normalization'] * 1.0 / benchmark_record_hours benchmark_record = record['reduction'][y_unit_map] * unit_factor # normalize the benchmark value size_ratio = report_avg_size * 1.0 / benchmark_avg_size benchmark_record *= size_ratio benchmark_record /= benchmark_record_hours # add normalized value to charts benchmark_consumption.append([value, round(benchmark_record, 5)]) benchmark_diff.append([value, 0]) diff.append([value, benchmark_record - report_record]) data.reported_consumption = reported_consumption data.benchmark_consumption = benchmark_consumption data.diff = diff data.benchmark_diff = benchmark_diff return data
def generate_sic_report(config): return json.dumps(SharedReporting.generate_consumptiontext_report(config, 'sic', g))
def get_report(config): report_name = "DefaultReportName" report_path = "" # make sure submitted_to isn't empty if not config.submitted_to: abort(400) submitted_by_user = g.uow.users.get_user_by_id(session["current_user"]["id"]) submitted_to = config.submitted_to # get submitted_by and submitted_to submitted_by_user, submitted_to = SharedReporting.get_submitted_contacts(submitted_by_user, submitted_to, g) total_energy_chart_info = TotalEnergyDataContainer() # determine the x units x_units = "F" total_energy_chart_info.x_axis_label = "Temperature (" + x_units + ")" if config.comparison_type == "dewpt": x_units = "Dewpt" total_energy_chart_info.x_axis_label = "Dewpt" elif config.comparison_type == "enthalpy": x_units = "Enthalpy" total_energy_chart_info.x_axis_label = "Enthalpy" # get actual y units to send back, and get their equivalent column in the database # then call the proper report function determined by config.report_type if config.report_type == "consumption": report_name = "Consumption_Report" if config.account_type.lower() == "electric": y_units = config.electric_units y_unit_map = 'sum_btu' total_energy_chart_info.title = 'Total Energy Usage - Electric' elif config.account_type.lower() == 'gas': y_units = config.gas_units y_unit_map = 'sum_btu' total_energy_chart_info.title = 'Total Energy Usage - Gas' else: y_units = config.btu_units y_unit_map = "sum_btu" total_energy_chart_info.title = 'Total Energy Usage' total_energy_chart_info.y_axis_label = 'Average Energy Usage (' + SharedReporting.get_y_unit_label(y_units) + ')' # generate consumption report report_path = generate_consumption_report(config, y_units, y_unit_map, total_energy_chart_info, submitted_by_user, submitted_to, g) elif config.report_type == "variance": report_name = "Variance Report" if config.account_type == "electric": y_units = config.electric_units elif config.account_type == "gas": y_units = config.gas_units else: y_units = config.btu_units y_unit_map = "sum_btu" report_path = generate_variance_report(config, y_units, y_unit_map, submitted_by_user, submitted_to, g) elif config.report_type == "kvar": report_name = "kVArh" y_units = "kvar" y_unit_map = "sum_kvar" total_energy_chart_info.y_axis_label = "Average Electric Usage (kVar)" total_energy_chart_info.title = "kVar" report_path = generate_kvarh_report(config, y_units, y_unit_map, total_energy_chart_info, submitted_by_user, submitted_to, g) elif config.report_type == "text": report_name = "Consumption Text Report" report_path = generate_consumptiontext_report(config, submitted_by_user, g) elif config.report_type == "kva": report_name = "kVah" y_units = "kva" y_unit_map = "kva" total_energy_chart_info.y_axis_label = "Average Electric Usage (kVa)" total_energy_chart_info.title = "kVa" report_path = generate_kvah_report(config, y_units, y_unit_map, total_energy_chart_info, submitted_by_user, submitted_to, g) elif config.report_type == "powerfactor": report_name = "Power Factor" y_units = "pf" y_unit_map = "pf" total_energy_chart_info.y_axis_label = "Average Power Factor" total_energy_chart_info.title = "Power Factor" report_path = generate_powerfactor_report(config, y_units, y_unit_map, total_energy_chart_info, submitted_by_user, submitted_to, g) elif config.report_type == "peak": report_name = "Peak Report" report_path = generate_peak_report(config, submitted_by_user, submitted_to, g) return send_file(report_path, mimetype='application/pdf', as_attachment=True, attachment_filename=report_name + '.pdf')
def generate_naics_report(config): return json.dumps(SharedReporting.generate_consumptiontext_report(config, 'naics', g))
def calculate_pf_data(account_group, report_year, benchmark_year, same_year): """ Calculates the powerfactor data for the account :param account_group: data for the account grouped by value :param report_year: current year for the report data :param benchmark_year: benchmark year to compare it to :param same_year: boolean value stating whether report_year == benchmark_year :return: TotalEnergyData """ # initialize all variables for this account/year combination reported_consumption = [] diff = [] benchmark_diff = [] benchmark_consumption = [] grouped_keys = list(account_group.keys()) grouped_keys.sort() kwh_unit_factor = SharedReporting.get_factor('kwh', 'sum_btu') # if the benchmark year and current year are the same they will be handled differently if same_year: for value in grouped_keys: entry = account_group[value][0] # calculate powerfactor record_kwh = entry["reduction"]["sum_btu"] * kwh_unit_factor record_kvar = math.sqrt(math.pow(record_kwh, 2) + math.pow(entry['reduction']['sum_kvar'], 2)) record_pf = record_kwh * 1.0 / record_kvar # update lists of data reported_consumption.append([value, round(record_pf, 5)]) diff.append([value, 0]) benchmark_consumption.append([value, round(record_pf, 5)]) benchmark_diff.append([value, 0]) else: # loop through each entry in the keys for value in grouped_keys: entry = account_group[value] # if the data exists for both years if len(entry) > 1: record_pf = 0 reported_avg_size = 0 benchmark_avg_size = 0 benchmark_record_btu_normalized = 0 benchmark_record_kvar_normalized = 0 for record in entry: if record['group']['year'] == report_year: # calculate powerfactor record_kwh = record['reduction']['sum_btu'] * kwh_unit_factor record_kvar = math.sqrt(math.pow(record_kwh, 2) + math.pow(record['reduction']['sum_kvar'], 2)) record_pf = record_kwh * 1.0 / record_kvar report_record_hours = record['reduction']['sum_hours_in_record'] reported_avg_size = record['reduction']['sum_size_normalization'] * 1.0 / report_record_hours # update list reported_consumption.append([value, round(record_pf, 5)]) elif record['group']['year'] == benchmark_year: benchmark_avg_size = record['reduction']['sum_size_normalization'] * 1.0 / record['reduction']['sum_hours_in_record'] benchmark_record_btu_normalized = record['reduction']['sum_btu'] benchmark_record_kvar_normalized = record['reduction']['sum_kvar'] # normalize the btu and kvar to properly calculate pf size_ratio = reported_avg_size * 1.0 / benchmark_avg_size benchmark_record_btu_normalized *= size_ratio benchmark_record_kvar_normalized *= size_ratio benchmark_kwh = benchmark_record_btu_normalized * kwh_unit_factor benchmark_kvar = math.sqrt(math.pow(benchmark_kwh, 2) + math.pow(benchmark_record_kvar_normalized, 2)) benchmark_pf = benchmark_kwh * 1.0 / benchmark_kvar # update lists benchmark_consumption.append([value, round(benchmark_pf, 5)]) benchmark_diff.append([value, 0]) diff.append([value, round(benchmark_pf - record_pf, 5)]) # create a new data object to be returned data = TotalEnergyData() data.reported_consumption = reported_consumption data.benchmark_consumption = benchmark_consumption data.diff = diff data.benchmark_diff = benchmark_diff return data