def test_wiring_graph(self):
meter1 = ElecMeter(metadata={'site_meter': True},
meter_id=ElecMeterID(1,1,'REDD'))
meter2 = ElecMeter(metadata={'submeter_of': 1},
meter_id=ElecMeterID(2,1,'REDD'))
meter3 = ElecMeter(metadata={'submeter_of': 2},
meter_id=ElecMeterID(3,1,'REDD'))
mg = MeterGroup([meter1, meter2, meter3])
wiring_graph = mg.wiring_graph()
self.assertIs(mg.mains(), meter1)
self.assertEqual(mg.meters_directly_downstream_of_mains().meters, [meter2])
self.assertEqual(wiring_graph.nodes(), [meter2, meter3, meter1])
def noise_aggregate_ratio(elec_meter, power_type='active', meterkeys=None, good_sections_only=True):
'''
Computes the noise-to-aggregate ratio (NAR) of an elec metergroup. For more information, see our paper: http://makonin.com/doc/ISGT-NA_2020b.pdf
:param elec_meter: elec of a dataset (see https://raw.githubusercontent.com/nilmtk/writing/master/figures/NILMTK_UML.png)
:param meterkeys: either None or array that contains meter IDs
:param power_type: AC power type, either active or apparent
:param good_sections_only: option to use good sections only (see http://nilmtk.github.io/nilmtk/master/nilmtk.stats.html)
:return: NAR ratio (float), power_type (string), good_sections (Boolean)
'''
mains = elec_meter.mains()
if not meterkeys:
submeters = elec_meter.meters_directly_downstream_of_mains()
else:
submeters = elec_meter.from_list(
[ElecMeterID(elec_meter[m].instance(), elec_meter.building(), elec_meter.dataset()) for m in meterkeys])
if good_sections_only:
good_mains_sections = mains.good_sections()
loader_kwargs = {'sections': good_mains_sections}
else:
loader_kwargs = {}
mains_total_energy = mains.total_energy(**loader_kwargs)
mains_ac_types = mains_total_energy.keys()
proportion = np.float64(0.0)
for meter in submeters.meters:
try:
meter_total_energy = meter.total_energy(**loader_kwargs)
except KeyError:
warn('KeyError at '+str(meter))
return [-1, 'power type: '+ power_type, 'good sections only: ' +str(good_sections_only)]
meter_ac_types = meter_total_energy.keys()
shared_ac_types = set(mains_ac_types).intersection(meter_ac_types)
if len(shared_ac_types) > 1:
proportion += meter_total_energy[power_type] / mains_total_energy[power_type]
continue
elif len(shared_ac_types) == 1 and shared_ac_types.__contains__(power_type):
ac_type = list(shared_ac_types)[0]
proportion += meter_total_energy[ac_type] / mains_total_energy[ac_type]
continue
elif len(shared_ac_types) == 1 and not shared_ac_types.__contains__(power_type):
warn('No matching power types found!')
continue
elif len(shared_ac_types) == 0:
warn('No matching power types found!')
continue
return round(1 - proportion, 2)
def test_proportion_of_energy_submetered(self):
meters = []
for i in [1, 2, 3]:
meter_meta = self.datastore.load_metadata(
'building1')['elec_meters'][i]
meter_id = ElecMeterID(i, 1, 'REDD')
meter = ElecMeter(self.datastore, meter_meta, meter_id)
meters.append(meter)
mains = meters[0]
mg = MeterGroup(meters)
self.assertEqual(mg.proportion_of_energy_submetered(), 1.0)
def test_from_list(self):
meters = []
for i in range(1,6):
meters.append(ElecMeter(meter_id=ElecMeterID(i, 1, None)))
mg = global_meter_group.from_list([
ElecMeterID(1,1,None),
(ElecMeterID(2,1,None),
(ElecMeterID(3,1,None), ElecMeterID(4,1,None), ElecMeterID(5,1,None)))
])
"""
def test_from_list(self):
meters = []
for i in range(1, 6):
meters.append(ElecMeter(meter_id=ElecMeterID(i, 1, None)))
mg = global_meter_group.from_list([
ElecMeterID(1, 1, None),
(ElecMeterID(2, 1,
None), (ElecMeterID(3, 1,
None), ElecMeterID(4, 1, None),
ElecMeterID(5, 1, None)))
])
self.assertEqual(mg.meters[0], meters[0])
self.assertEqual(mg.meters[1].meters[0], meters[1])
self.assertEqual(len(mg.meters[1].meters[1].meters), 3)
self.assertEqual(len(mg.meters), 2)
def test_select_best_ac_type(self):
self.assertEqual(measure.select_best_ac_type(['reactive']), 'reactive')
self.assertEqual(
measure.select_best_ac_type(['active', 'reactive', 'apparent']),
'active')
ElecMeter.meter_devices.update({
'test model': {
'measurements': [{
'physical_quantity': 'power',
'type': 'apparent'
}]
}
})
meter_id = ElecMeterID(1, 1, 'REDD')
meter = ElecMeter(metadata={'device_model': 'test model'},
meter_id=meter_id)
self.assertEqual(
measure.select_best_ac_type(['reactive'],
meter.available_power_ac_types()),
'reactive')
#!/usr/bin/python
from __future__ import print_function, division
import unittest
from os.path import join
import numpy as np
import pandas as pd
from datetime import timedelta
from nilmtk.stats import GoodSections
from nilmtk.stats.goodsectionsresults import GoodSectionsResults
from nilmtk import TimeFrame, ElecMeter, DataSet
from nilmtk.datastore import HDFDataStore
from nilmtk.elecmeter import ElecMeterID
from nilmtk.tests.testingtools import data_dir
METER_ID = ElecMeterID(instance=1, building=1, dataset='REDD')
class TestLocateGoodSections(unittest.TestCase):
@classmethod
def setUpClass(cls):
filename = join(data_dir(), 'energy_complex.h5')
cls.datastore = HDFDataStore(filename)
ElecMeter.load_meter_devices(cls.datastore)
cls.meter_meta = cls.datastore.load_metadata(
'building1')['elec_meters'][METER_ID.instance]
@classmethod
def tearDownClass(cls):
cls.datastore.close()
def test_pipeline(self):
"""Example usage"""
from nilmtk import DataSet
from nilmtk.elecmeter import ElecMeterID
import nilmtk_complexity
import tracebase_complexity
# On REDD dataset using NILMTK API
print("ON REDD")
ds = DataSet('../../Datasets/REDD/redd.h5') # Path to REDD .h5 dataset
elec = ds.buildings[2].elec
meterkeys = [4, 6, 9, 10]
mgroup = elec.from_list([
ElecMeterID(elec[m].instance(), elec.building(), elec.dataset())
for m in meterkeys
])
print(nilmtk_complexity.compute(mgroup))
# On Tracebase dataset
print()
print("ON TRACEBASE")
pathlist = [
'../../Datasets/Tracebase/Complete/Coffeemaker',
'../../Datasets/Tracebase/Complete/Refrigerator',
'../../Datasets/Tracebase/Complete/TV-LCD',
'../../Datasets/Tracebase/Complete/PC-Desktop'
]
print(tracebase_complexity.compute(pathlist))
import unittest
from os.path import join
import pandas as pd
from datetime import timedelta
from nilmtk.tests.testingtools import data_dir, WarningTestMixin
from nilmtk.datastore import HDFDataStore
from nilmtk.elecmeter import ElecMeter, ElecMeterID
from nilmtk.stats.tests.test_totalenergy import check_energy_numbers
METER_ID = ElecMeterID(instance=1, building=1, dataset='REDD')
METER_ID2 = ElecMeterID(instance=2, building=1, dataset='REDD')
METER_ID3 = ElecMeterID(instance=3, building=1, dataset='REDD')
class TestElecMeter(WarningTestMixin, unittest.TestCase):
@classmethod
def setUpClass(cls):
filename = join(data_dir(), 'energy.h5')
cls.datastore = HDFDataStore(filename)
ElecMeter.load_meter_devices(cls.datastore)
cls.meter_meta = cls.datastore.load_metadata(
'building1')['elec_meters'][METER_ID.instance]
@classmethod
def tearDownClass(cls):
cls.datastore.close()
def test_load(self):
meter = ElecMeter(store=self.datastore,
metadata=self.meter_meta,
meter_id=METER_ID)
