def fetchSection1_1_hydroContext(appDbConnStr: str, startDt: dt.datetime,
endDt: dt.datetime) -> ISection_1_1_hydro:
mRepo = MetricsDataRepo(appDbConnStr)
# get hydro mu
hydroMuVals = mRepo.getEntityMetricDailyData("wr", "Hydro(MU)", startDt,
endDt)
cgsHrdroMuVals = mRepo.getEntityMetricDailyData("wr", "CGS Hydro(Mus)",
startDt, endDt)
maxHydroMuObj = hydroMuVals[0]
tot_month_hydro_gen_mu = 0
for h, c in zip(hydroMuVals, cgsHrdroMuVals):
tot_month_hydro_gen_mu += h["data_value"] + c["data_value"]
iterationSum = h["data_value"] + c["data_value"]
if iterationSum > maxHydroMuObj["data_value"]:
maxHydroMuObj["data_value"] = iterationSum
avg_month_hydro_gen_mu = tot_month_hydro_gen_mu / len(hydroMuVals)
max_month_hydro_gen_mu = round(maxHydroMuObj["data_value"], 2)
max_month_hydro_gen_mu_date = dt.datetime.strftime(
maxHydroMuObj["time_stamp"], "%d-%b-%Y")
# get hydro mu for last year
hydroMuLastYrVals = mRepo.getEntityMetricDailyData("wr", "Hydro(MU)",
addMonths(startDt, -12),
addMonths(endDt, -12))
cgsHrdroMuLastYrVals = mRepo.getEntityMetricDailyData(
"wr", "CGS Hydro(Mus)", addMonths(startDt, -12), addMonths(endDt, -12))
tot_last_year_hydro_gen_mu = 0
for h, c in zip(hydroMuLastYrVals, cgsHrdroMuLastYrVals):
tot_last_year_hydro_gen_mu += h["data_value"] + c["data_value"]
tot_last_year_hydro_gen_mu_perc = round(
100 * (tot_month_hydro_gen_mu - tot_last_year_hydro_gen_mu) /
tot_last_year_hydro_gen_mu, 2)
tot_last_year_hydro_gen_mu_perc_str = ""
if tot_last_year_hydro_gen_mu_perc < 0:
tot_last_year_hydro_gen_mu_perc_str = "reduced by {0}%".format(
-1 * tot_last_year_hydro_gen_mu_perc)
else:
tot_last_year_hydro_gen_mu_perc_str = "increased by {0}%".format(
tot_last_year_hydro_gen_mu_perc)
secData: ISection_1_1_hydro = {
"tot_month_hydro_gen_mu": round(tot_month_hydro_gen_mu),
"tot_last_year_hydro_gen_mu": round(tot_last_year_hydro_gen_mu),
"tot_last_year_hydro_gen_mu_perc_str":
tot_last_year_hydro_gen_mu_perc_str,
"avg_month_hydro_gen_mu": round(avg_month_hydro_gen_mu),
"max_month_hydro_gen_mu": round(max_month_hydro_gen_mu),
"max_month_hydro_gen_mu_date": max_month_hydro_gen_mu_date
}
return secData
def fetchSection1_1_4Context(appDbConnStr: str, startDt: dt.datetime,
endDt: dt.datetime) -> ISection_1_1_4:
monthDtObj = dt.datetime(startDt.year, startDt.month, 1)
month_name = dt.datetime.strftime(startDt, "%b %y")
mRepo = MetricsDataRepo(appDbConnStr)
# get WR Unrestricted demand hourly values for this month and prev yr month
wrConMuVals = mRepo.getEntityMetricDailyData('wr', 'Requirement (MU)',
startDt, endDt)
wrConMuDf = pd.DataFrame(wrConMuVals)
wrConMuDf = wrConMuDf.pivot(index='time_stamp',
columns='metric_name',
values='data_value')
lastYrStartDt = addMonths(startDt, -12)
lastYrEndDt = addMonths(endDt, -12)
last_yr_month_name = dt.datetime.strftime(lastYrStartDt, "%b %y")
wrLastYrConMuVals = mRepo.getEntityMetricDailyData('wr',
'Requirement (MU)',
lastYrStartDt,
lastYrEndDt)
wrLastYrConMuDf = pd.DataFrame(wrLastYrConMuVals)
wrLastYrConMuDf = wrLastYrConMuDf.pivot(index='time_stamp',
columns='metric_name',
values='data_value')
wr_tot_req_mu = round(wrConMuDf['Requirement (MU)'].sum())
wr_avg_req_mu = round(wrConMuDf['Requirement (MU)'].mean())
wr_max_req_mu = round(wrConMuDf['Requirement (MU)'].max())
wrMaxConsMuDate = wrConMuDf['Requirement (MU)'].idxmax()
wr_avg_req_mu_last_yr = round(wrLastYrConMuDf['Requirement (MU)'].mean())
wr_max_req_mu_date = "{0}".format(
dt.datetime.strftime(wrMaxConsMuDate, "%d-%b-%y"))
wr_avg_req_mu_perc_inc = round(
100 * (wr_avg_req_mu - wr_avg_req_mu_last_yr) / wr_avg_req_mu_last_yr,
2)
secData: ISection_1_1_4 = {
'wr_tot_req_mu': wr_tot_req_mu,
'wr_avg_req_mu': wr_avg_req_mu,
'wr_max_req_mu': wr_max_req_mu,
'wr_max_req_mu_date': wr_max_req_mu_date,
'wr_avg_req_mu_perc_inc': wr_avg_req_mu_perc_inc,
'wr_avg_req_mu_last_yr': wr_avg_req_mu_last_yr
}
return secData
def fetchSection1_5_1Context(appDbConnStr: str, startDt: dt.datetime, endDt: dt.datetime) -> dict:
# get WR demand from recent Fin year start till this month
# and WR demand from 2 years back fin year to last fin year
# example: For Jan 21, we require data from 1-Apr-2019 to 31-Mar-2020 and 1-Apr-2020 to 31 Jan 21
finYrStart = getFinYrDt(startDt)
prevFinYrStart = getPrevFinYrDt(finYrStart)
finYrName = '{0}-{1}'.format(finYrStart.year, (finYrStart.year+1) % 100)
prevFinYrName = '{0}-{1}'.format(finYrStart.year-1, finYrStart.year % 100)
mRepo = MetricsDataRepo(appDbConnStr)
# get WR hourly demand values for this financial year
wrDemVals = mRepo.getEntityMetricDailyData(
'wr', 'Max Demand(MW)', finYrStart, endDt)
wrPrevFinYrDemVals = mRepo.getEntityMetricDailyData(
'wr', 'Max Demand(MW)', prevFinYrStart, finYrStart-dt.timedelta(days=1))
# create plot image for demands of prev fin year and this fin year
pltDemObjs = [{'MONTH': x["time_stamp"], 'colName': finYrName,
'val': x["data_value"]} for x in wrDemVals]
pltDemObjsLastYear = [{'MONTH': x["time_stamp"],
'colName': prevFinYrName, 'val': x["data_value"]} for x in wrPrevFinYrDemVals]
pltDataObjs = pltDemObjs + pltDemObjsLastYear
pltDataDf = pd.DataFrame(pltDataObjs)
pltDataDf = pltDataDf.pivot(
index='MONTH', columns='colName', values='val')
maxTs = pltDataDf.index.max()
for rIter in range(pltDataDf.shape[0]):
# check if Prev fin Yr data column is not Nan, if yes set this year data column
lastYrDt = pltDataDf.index[rIter].to_pydatetime()
if not pd.isna(pltDataDf[prevFinYrName].iloc[rIter]):
thisYrTs = pd.Timestamp(addMonths(lastYrDt, 12))
if thisYrTs <= maxTs:
thisYrVal = pltDataDf[finYrName].loc[thisYrTs]
pltDataDf.at[pd.Timestamp(lastYrDt), finYrName] = thisYrVal
pltDataDf = pltDataDf[~pltDataDf[prevFinYrName].isna()]
# save plot data as excel
pltDataDf.to_excel("assets/plot_1_5_1.xlsx", index=True)
# derive plot title
pltTitle = 'WR seasonal demand (daily max.) Plot {0} to {1}'.format(
prevFinYrName, finYrName)
# create a plotting area and get the figure, axes handle in return
fig, ax = plt.subplots(figsize=(7.5, 4.8))
# set plot title
ax.set_title(pltTitle)
# set x and y labels
ax.set_xlabel('MONTH')
ax.set_ylabel('MW')
# set x axis locator as month
ax.xaxis.set_major_locator(mdates.MonthLocator())
# set x axis formatter as month name
ax.xaxis.set_major_formatter(mdates.DateFormatter('%b'))
# ax.set_xlim(xmin=finYrStart)
# plot data and get the line artist object in return
laThisYr, = ax.plot(pltDataDf.index.values,
pltDataDf[finYrName].values, color='#ff0000')
laThisYr.set_label(finYrName)
laLastYear, = ax.plot(pltDataDf.index.values,
pltDataDf[prevFinYrName].values, color='#0000ff')
laLastYear.set_label(prevFinYrName)
# enable axis grid lines
ax.yaxis.grid(True)
ax.xaxis.grid(True)
# enable legends
ax.legend(bbox_to_anchor=(0.0, -0.3, 1, 0), loc='lower center',
ncol=2, borderaxespad=0.)
fig.subplots_adjust(bottom=0.25, top=0.8)
fig.savefig('assets/section_1_5_1.png')
secData: dict = {}
return secData
def fetchSection1_1_WindSolarContext(
appDbConnStr: str, startDt: dt.datetime,
endDt: dt.datetime) -> ISection_1_1_wind_solar:
mRepo = MetricsDataRepo(appDbConnStr)
# get solar mu
solarMuVals = mRepo.getEntityMetricDailyData("wr", "Solar(MU)", startDt,
endDt)
cgsSolarMuVals = mRepo.getEntityMetricDailyData("wr", "CGS Solar(Mus)",
startDt, endDt)
tot_month_solar_gen_mu = 0
for s, c in zip(solarMuVals, cgsSolarMuVals):
tot_month_solar_gen_mu += s["data_value"] + c["data_value"]
avg_month_solar_gen_mu = tot_month_solar_gen_mu / len(solarMuVals)
# get solar mu for last year
solarMuLastYrVals = mRepo.getEntityMetricDailyData("wr", "Solar(MU)",
addMonths(startDt, -12),
addMonths(endDt, -12))
cgsSolarMuLastYrVals = mRepo.getEntityMetricDailyData(
"wr", "CGS Solar(Mus)", addMonths(startDt, -12), addMonths(endDt, -12))
tot_last_year_solar_gen_mu = 0
for s, c in zip(solarMuLastYrVals, cgsSolarMuLastYrVals):
tot_last_year_solar_gen_mu += s["data_value"] + c["data_value"]
tot_last_year_solar_gen_mu_perc = round(
100 * (tot_month_solar_gen_mu - tot_last_year_solar_gen_mu) /
tot_last_year_solar_gen_mu, 2)
tot_last_year_solar_gen_mu_perc_str = ""
if tot_last_year_solar_gen_mu_perc < 0:
tot_last_year_solar_gen_mu_perc_str = "reduced by {0}%".format(
-1 * tot_last_year_solar_gen_mu_perc)
else:
tot_last_year_solar_gen_mu_perc_str = "increased by {0}%".format(
tot_last_year_solar_gen_mu_perc)
solarMwVals = mRepo.getEntityMetricHourlyData("wr", "Solar(MW)", startDt,
endDt)
maxSolarMwObj = solarMwVals[0]
for v in solarMwVals:
if v["data_value"] > maxSolarMwObj["data_value"]:
maxSolarMwObj = v
max_month_solar_gen_mw = maxSolarMwObj["data_value"]
max_month_solar_gen_mw_date = '{0} at {1} hrs'.format(
dt.datetime.strftime(maxSolarMwObj["time_stamp"], "%d %b %Y"),
dt.datetime.strftime(maxSolarMwObj["time_stamp"], "%H:%M"))
# get wind mu
windMuVals = mRepo.getEntityMetricDailyData("wr", "Wind(MU)", startDt,
endDt)
cgsWindMuVals = mRepo.getEntityMetricDailyData("wr", "CGS Wind(Mus)",
startDt, endDt)
tot_month_wind_gen_mu = 0
for w, c in zip(windMuVals, cgsWindMuVals):
tot_month_wind_gen_mu += w["data_value"] + c["data_value"]
avg_month_wind_gen_mu = tot_month_wind_gen_mu / len(windMuVals)
# get wind mu for last year
windMuLastYrVals = mRepo.getEntityMetricDailyData("wr", "Wind(MU)",
addMonths(startDt, -12),
addMonths(endDt, -12))
cgsWindMuLastYrVals = mRepo.getEntityMetricDailyData(
"wr", "CGS Wind(Mus)", addMonths(startDt, -12), addMonths(endDt, -12))
tot_last_year_wind_gen_mu = 0
for w, c in zip(windMuLastYrVals, cgsWindMuLastYrVals):
tot_last_year_wind_gen_mu += w["data_value"] + c["data_value"]
tot_last_year_wind_gen_mu_perc = round(
100 * (tot_month_wind_gen_mu - tot_last_year_wind_gen_mu) /
tot_last_year_wind_gen_mu, 2)
tot_last_year_wind_gen_mu_perc_str = ""
if tot_last_year_wind_gen_mu_perc < 0:
tot_last_year_wind_gen_mu_perc_str = "reduced by {0}%".format(
-1 * tot_last_year_wind_gen_mu_perc)
else:
tot_last_year_wind_gen_mu_perc_str = "increased by {0}%".format(
tot_last_year_wind_gen_mu_perc)
windMwVals = mRepo.getEntityMetricHourlyData("wr", "Wind(MW)", startDt,
endDt)
maxWindMwObj = windMwVals[0]
for v in windMwVals:
if v["data_value"] > maxWindMwObj["data_value"]:
maxWindMwObj = v
max_month_wind_gen_mw = maxWindMwObj["data_value"]
max_month_wind_gen_mw_date = '{0} at {1} hrs'.format(
dt.datetime.strftime(maxWindMwObj["time_stamp"], "%d %b %Y"),
dt.datetime.strftime(maxWindMwObj["time_stamp"], "%H:%M"))
# create dataframe for solar and wind addition
resDf = pd.DataFrame(windMwVals + solarMwVals)
resDf = resDf.pivot(index="time_stamp",
columns="metric_name",
values="data_value")
resDf["Renewable"] = resDf["Wind(MW)"] + resDf["Solar(MW)"]
max_month_ren_gen_mw = resDf["Renewable"].max()
maxRenDt = resDf["Renewable"].idxmax().to_pydatetime()
max_month_ren_gen_mw_date = '{0} at {1} hrs'.format(
dt.datetime.strftime(maxRenDt, "%d %b %Y"),
dt.datetime.strftime(maxRenDt, "%H:%M"))
secData: ISection_1_1_wind_solar = {
'tot_month_wind_gen_mu': round(tot_month_wind_gen_mu),
'avg_month_wind_gen_mu': round(avg_month_wind_gen_mu, 1),
'tot_last_year_wind_gen_mu_perc_str':
tot_last_year_wind_gen_mu_perc_str,
'tot_last_year_wind_gen_mu': round(tot_last_year_wind_gen_mu),
'max_month_wind_gen_mw': round(max_month_wind_gen_mw),
'max_month_wind_gen_mw_date': max_month_wind_gen_mw_date,
'tot_month_solar_gen_mu': round(tot_month_solar_gen_mu),
'avg_month_solar_gen_mu': round(avg_month_solar_gen_mu, 1),
'tot_last_year_solar_gen_mu_perc_str':
tot_last_year_solar_gen_mu_perc_str,
'tot_last_year_solar_gen_mu': round(tot_last_year_solar_gen_mu),
'max_month_solar_gen_mw': round(max_month_solar_gen_mw),
'max_month_solar_gen_mw_date': max_month_solar_gen_mw_date,
'max_month_ren_gen_mw': round(max_month_ren_gen_mw),
'max_month_ren_gen_mw_date': max_month_ren_gen_mw_date
}
return secData
def fetchSection1_11_windPLF(appDbConnStr: str, startDt: dt.datetime,
endDt: dt.datetime) -> ISection_1_11_PLFCUF:
constituentsInfos = getREConstituentsMappings()
mRepo = MetricsDataRepo(appDbConnStr)
numOfDays = (endDt - startDt).days + 1
soFarHighestAllEntityGenVals = mRepo.getSoFarHighestAllEntityData(
'soFarHighestWindGen', addMonths(startDt, -1))
soFarHighestGenLookUp = {}
for v in soFarHighestAllEntityGenVals:
soFarHighestGenLookUp[v['constituent']] = {
'value': v['data_value'],
'ts': v['data_time']
}
dispRows: List[IPLFCUFDataRow] = []
for cIter in range(len(constituentsInfos)):
constInfo = constituentsInfos[cIter]
if (math.isnan(constInfo['windCapacity'])):
continue
maxGenData = mRepo.getEntityMetricHourlyData(constInfo["entity_tag"],
"Wind(MW)", startDt,
endDt)
if constInfo['entity_tag'] == 'central':
windEnerConsumption = mRepo.getEntityMetricDailyData(
'wr', 'CGS Wind(Mus)', startDt, endDt)
elif constInfo['entity_tag'] == 'wr':
windEnerConsumption = mRepo.getEntityMetricDailyData(
'wr', "Wind(MU)", startDt, endDt)
cgsWindEnerConsumption = mRepo.getEntityMetricDailyData(
'wr', 'CGS Wind(Mus)', startDt, endDt)
for w, c in zip(windEnerConsumption, cgsWindEnerConsumption):
w["data_value"] += c["data_value"]
else:
windEnerConsumption = mRepo.getEntityMetricDailyData(
constInfo['entity_tag'], 'Wind(MU)', startDt, endDt)
energyConsumption = mRepo.getEntityMetricDailyData(
constInfo['entity_tag'], 'Consumption(MU)', startDt, endDt)
maxGenDf = pd.DataFrame(maxGenData)
maxGenDf = maxGenDf.pivot(index='time_stamp',
columns='metric_name',
values='data_value')
windEnerConsumptionSum = pd.DataFrame(windEnerConsumption).groupby(
'entity_tag').sum().iloc[0]['data_value']
if (len(energyConsumption) == 0):
# This is for central sector as we dont have consumption data
# calculate mu from mw
# df = pd.DataFrame(maxGenData)
# average = df.groupby('entity_tag').mean()
# windEnerConsumptionSumDf = average * 0.024 * numOfDays #To Calculate Avg MU from MW
# windEnerConsumptionSum = windEnerConsumptionSumDf.iloc[0]['data_value']
EnerConsumptionSum = 0
penetrationLevel = 0
else:
EnerConsumptionSum = pd.DataFrame(energyConsumption).groupby(
'entity_tag').sum().iloc[0]['data_value']
penetrationLevel = round(
(windEnerConsumptionSum / EnerConsumptionSum) * 100, 2)
maxWind = maxGenDf["Wind(MW)"].max()
maxWindDt = maxGenDf["Wind(MW)"].idxmax()
plf = (windEnerConsumptionSum *
1000) / (int(constInfo['windCapacity']) * 24 * numOfDays)
cuf = maxWind * 100 / (int(constInfo['windCapacity']))
prevHighestWindObj = soFarHighestGenLookUp[constInfo["entity_tag"]]
newHighestWind = maxWind
newHighestWindTime = maxWindDt.to_pydatetime()
if newHighestWind < prevHighestWindObj["value"]:
newHighestWind = prevHighestWindObj["value"]
newHighestWindTime = prevHighestWindObj["ts"]
mRepo.insertSoFarHighest(constInfo['entity_tag'],
"soFarHighestWindGen", startDt,
newHighestWind, newHighestWindTime)
# soFarHighestAllEntityGenVals = mRepo.getSoFarHighestAllEntityData(
# 'soFarHighestWindGen', startDt)
# soFarHighestGenLookUp = {}
# for v in soFarHighestAllEntityGenVals:
# soFarHighestGenLookUp[v['constituent']] = {
# 'value': v['data_value'], 'ts': v['data_time']}
so_far_high_gen_str = str(
round(newHighestWind)) + ' on ' + dt.datetime.strftime(
newHighestWindTime,
'%d-%b-%Y') + ' at ' + dt.datetime.strftime(
newHighestWindTime, '%H:%S')
const_display_row: IPLFCUFDataRow = {
'entity': constInfo['display_name'],
'capacityMW': round(constInfo['windCapacity']),
'maxgenerationMW': round(maxWind),
'soFarHighestGenMW': so_far_high_gen_str,
'energyGeneration': round(windEnerConsumptionSum),
'energyConsumption': round(EnerConsumptionSum),
'penetration': penetrationLevel,
'plf': round(plf * 100),
'cuf': round(cuf)
}
dispRows.append(const_display_row)
secData: ISection_1_11_PLFCUF = {"so_far_hig_win_gen_plf": dispRows}
return secData
def fetchSection1_5_3Context(appDbConnStr: str, startDt: dt.datetime,
endDt: dt.datetime) -> ISection_1_5_3:
monthName = dt.datetime.strftime(startDt, "%b %y")
mRepo = MetricsDataRepo(appDbConnStr)
# get WR consumption Daily values for this month and prev yr month
wrConVals = mRepo.getEntityMetricDailyData('wr', 'Consumption(MU)',
startDt, endDt)
conVals = [x['data_value'] for x in wrConVals]
wr_max_con = max(conVals)
wrMaxConDt = wrConVals[conVals.index(wr_max_con)]['time_stamp']
wr_max_con_date_str = dt.datetime.strftime(wrMaxConDt, "%d-%b-%y")
wr_avg_con = sum(conVals) / len(conVals)
# wrMaxDemTimestampStr = dt.datetime.strftime(
# wrMaxConDt, "%d-%b-%y %H:%M")+" hrs"
lastYrStartDt = addMonths(startDt, -12)
lastYrEndDt = addMonths(endDt, -12)
monthNameLastYear = dt.datetime.strftime(lastYrStartDt, "%b %y")
wrLastYrConVals = mRepo.getEntityMetricDailyData('wr', 'Consumption(MU)',
lastYrStartDt,
lastYrEndDt)
conVals = [x['data_value'] for x in wrLastYrConVals]
wr_max_con_last_year = max(conVals)
wr_max_con_date_str_last_year = dt.datetime.strftime(
wrLastYrConVals[conVals.index(wr_max_con_last_year)]['time_stamp'],
"%d-%b-%y")
wr_avg_con_last_year = sum(conVals) / len(conVals)
wr_avg_con_perc_change_last_year = round(
100 * (wr_avg_con - wr_avg_con_last_year) / wr_avg_con_last_year, 2)
wr_max_con_perc_change_last_year = round(
100 * (wr_max_con - wr_max_con_last_year) / wr_max_con_last_year, 2)
prevMonthStartDt = addMonths(startDt, -1)
prevMonthEndDt = addMonths(endDt, -1)
prev_month_name = dt.datetime.strftime(prevMonthStartDt, "%b %y")
wrPrevMonthDemVals = mRepo.getEntityMetricDailyData(
'wr', 'Consumption(MU)', prevMonthStartDt, prevMonthEndDt)
conVals = [x['data_value'] for x in wrPrevMonthDemVals]
wr_max_con_prev_month = max(conVals)
wr_max_con_date_str_prev_month = dt.datetime.strftime(
wrPrevMonthDemVals[conVals.index(wr_max_con_prev_month)]['time_stamp'],
"%d-%b-%y")
wr_avg_con_prev_month = sum(conVals) / len(conVals)
wr_avg_con_perc_change_prev_month = round(
100 * (wr_avg_con - wr_avg_con_prev_month) / wr_avg_con_prev_month, 2)
wr_max_con_perc_change_prev_month = round(
100 * (wr_max_con - wr_max_con_prev_month) / wr_max_con_prev_month, 2)
# create plot image for demands of prev yr, prev month, this month
pltDemObjs = [{
'Date': convertDtToDayNum(x["time_stamp"]),
'colName': monthName,
'val': x["data_value"]
} for x in wrConVals]
pltDemObjsLastYear = [{
'Date': convertDtToDayNum(x["time_stamp"]),
'colName': monthNameLastYear,
'val': x["data_value"]
} for x in wrLastYrConVals]
pltDemObjsPrevMonth = [{
'Date': convertDtToDayNum(x["time_stamp"]),
'colName': prev_month_name,
'val': x["data_value"]
} for x in wrPrevMonthDemVals]
pltDataObjs = pltDemObjs + pltDemObjsLastYear + pltDemObjsPrevMonth
pltDataDf = pd.DataFrame(pltDataObjs)
pltDataDf = pltDataDf.pivot(index='Date', columns='colName', values='val')
pltDataDf.reset_index(inplace=True)
pltDataDf["Date"] = [math.floor(x) for x in pltDataDf["Date"]]
# pltDataDf = pltDataDf.groupby(by="Date").max()
# save plot data as excel
pltDataDf.to_excel("assets/plot_1_5_3.xlsx", index=True)
# derive plot title
pltTitle = 'Energy Cons-{0}, {1} & {2} \n Max- {3}MUs, {4}MUs and {5}MUs'.format(
monthName, prev_month_name, monthNameLastYear, round(wr_max_con),
round(wr_max_con_prev_month), round(wr_max_con_last_year))
# create a plotting area and get the figure, axes handle in return
fig, ax = plt.subplots(figsize=(7.5, 4.5))
# set plot title
ax.set_title(pltTitle)
# set x and y labels
ax.set_xlabel('Date')
ax.set_ylabel('MUs')
# plot data and get the line artist object in return
laThisMonth, = ax.plot(pltDataDf.index.values,
pltDataDf[monthName].values,
color='#ff0000')
laThisMonth.set_label(monthName)
laLastYear, = ax.plot(pltDataDf.index.values,
pltDataDf[monthNameLastYear].values,
color='#00ff00')
laLastYear.set_label(monthNameLastYear)
laPrevMonth, = ax.plot(pltDataDf.index.values,
pltDataDf[prev_month_name].values,
color='#A52A2A')
laPrevMonth.set_label(prev_month_name)
# enable y axis grid lines
ax.yaxis.grid(True)
ax.set_xlim((1, 31), auto=True)
# enable legends
ax.legend(bbox_to_anchor=(0.0, -0.3, 1, 0),
loc='lower center',
ncol=3,
mode="expand",
borderaxespad=0.)
fig.subplots_adjust(bottom=0.25, top=0.8)
fig.savefig('assets/section_1_5_3.png')
secData: ISection_1_5_3 = {
'prev_month_name': prev_month_name,
'wr_max_con': round(wr_max_con),
'wr_max_con_date_str': wr_max_con_date_str,
'wr_avg_con': round(wr_avg_con),
'wr_max_con_last_year': round(wr_max_con_last_year),
'wr_max_con_date_str_last_year': wr_max_con_date_str_last_year,
'wr_avg_con_last_year': round(wr_avg_con_last_year),
'wr_avg_con_perc_change_last_year': wr_avg_con_perc_change_last_year,
'wr_max_con_perc_change_last_year': wr_max_con_perc_change_last_year,
'wr_max_con_prev_month': round(wr_max_con_prev_month),
'wr_max_con_date_str_prev_month': wr_max_con_date_str_prev_month,
'wr_avg_con_prev_month': round(wr_avg_con_prev_month),
'wr_avg_con_perc_change_prev_month': wr_avg_con_perc_change_prev_month,
'wr_max_con_perc_change_prev_month': wr_max_con_perc_change_prev_month
}
return secData
def fetchSection1_11_Solar_A(appDbConnStr: str, startDt: dt.datetime,
endDt: dt.datetime) -> dict:
constituentsInfos = getREConstituentsMappings()
mRepo = MetricsDataRepo(appDbConnStr)
solarDataObj: list = []
for cIter in range(len(constituentsInfos)):
constInfo = constituentsInfos[cIter]
if (math.isnan(constInfo['solarCapacity'])):
continue
if (constInfo['entity_tag'] == 'wr'):
solarEnerGeneration = mRepo.getEntityMetricDailyData(
constInfo['entity_tag'], 'Solar(MU)', startDt, endDt)
cgsSolarGeneration = mRepo.getEntityMetricDailyData(
constInfo['entity_tag'], 'CGS Solar(Mus)', startDt, endDt)
for s, c in zip(solarEnerGeneration, cgsSolarGeneration):
s['data_value'] += c['data_value']
elif constInfo['entity_tag'] == 'central':
solarEnerGeneration = mRepo.getEntityMetricDailyData(
'wr', 'CGS Solar(Mus)', startDt, endDt)
for c in solarEnerGeneration:
c['entity_tag'] = 'central'
else:
solarEnerGeneration = mRepo.getEntityMetricDailyData(
constInfo['entity_tag'], 'Solar(MU)', startDt, endDt)
solarDataObj.append(solarEnerGeneration)
if (len(solarDataObj) > 0):
pltDataObj: list = []
for temp in range(len(solarDataObj)):
pltDataObj = pltDataObj + [{
'Date': x["time_stamp"],
'colName': x['entity_tag'],
'val': x["data_value"]
} for x in solarDataObj[temp]]
pltDataDf = pd.DataFrame(pltDataObj)
pltDataDf = pltDataDf.pivot(index='Date',
columns='colName',
values='val')
pltDataDf.reset_index(inplace=True)
pltDataDf.to_excel("assets/plot_1_11_solar_1.xlsx", index=True)
pltTitle = 'Total Solar Generation (MUs) {0} '.format(
startDt.strftime('%b-%y'))
fig, ax = plt.subplots(figsize=(7.5, 5.5))
ax.set_title(pltTitle)
ax.set_ylabel('Mus')
ax.set_xlabel('Date')
# ax.set_facecolor("#ffffdc")
fig.patch.set_facecolor("#ffffdc")
ax.xaxis.set_major_locator(mdates.DayLocator(interval=2))
ax.xaxis.set_major_formatter(mdates.DateFormatter('%d-%b-%Y'))
clr = [
'#00ccff', '#ff8533', '#ff0000', '#9900ff', '#ff3300', '#44ff66'
]
for col in range(1, len(pltDataDf.columns)):
ax.plot(pltDataDf['Date'],
pltDataDf[pltDataDf.columns[col]],
color=clr[col - 1],
label=pltDataDf.columns[col])
ax.yaxis.grid(True)
ax.legend(loc='best', ncol=4, borderaxespad=0.)
plt.xticks(rotation=90)
ax.set_xlim(xmin=startDt, xmax=endDt)
fig.subplots_adjust(bottom=0.25, top=0.8)
fig.savefig('assets/section_1_11_solar_1.png')
# plt.show()
# plt.close()
secData: dict = {}
return secData
