def test_001(self):
"""Test 1"""
c = nemo.Context()
c.regions = [regions.nsw, regions.vic, regions.sa]
c.track_exchanges = True
c.verbose = 1
nemo.run(c)
def test_004(self):
"""100 MW fossil plant generates exactly 876,000 MWh."""
ccgt = generators.CCGT(polygons.wildcard, 100)
self.context.generators = [ccgt]
nemo.run(self.context)
self.assertEqual(sum(ccgt.series_power.values()),
self.context.timesteps * 100)
def test_010(self):
"""Running in one region only produces no interstate exchanges."""
import pandas as pd
for rgn in regions.All:
if rgn is regions.snowy:
continue
self.context = nemo.Context()
self.context.track_exchanges = True
self.context.regions = [rgn]
loadpoly = [k for k, v in rgn.polygons.items() if v > 0][0]
nswpoly = [k for k, v in regions.nsw.polygons.items() if v > 0][0]
qldpoly = [k for k, v in regions.qld.polygons.items() if v > 0][0]
sapoly = [k for k, v in regions.sa.polygons.items() if v > 0][0]
taspoly = [k for k, v in regions.tas.polygons.items() if v > 0][0]
vicpoly = [k for k, v in regions.vic.polygons.items() if v > 0][0]
self.context.generators = []
for poly in [nswpoly, qldpoly, sapoly, taspoly, vicpoly]:
self.context.generators.append(generators.OCGT(poly, 100))
nemo.run(self.context, endhour=pd.Timestamp('2010-01-05'))
self.assertEqual((self.context.exchanges[0] > 0).sum(), 1,
'Only one exchange > 0')
# FIXME: we need a numpy array that can be indexed from 1
self.assertTrue(
self.context.exchanges[0, loadpoly - 1, loadpoly - 1] > 0,
'Only rgn->rgn is > 0')
def test_009(self):
"""A NSW generators runs in any set of regions that includes NSW."""
rgnset = []
for rgn in regions.All:
rgnset.append(rgn)
self.context.regions = rgnset
gen = SuperGenerator(None)
self.context.generators = [gen]
nemo.run(self.context)
self.assertEqual(gen.runhours, self.context.timesteps)
def test_003(self):
c = nemo.Context()
# Add 25 DR generators so that the abbreviated legend is used.
for i in range(25):
dr = nemo.generators.DemandResponse(polygons.wildcard, 100, 0)
c.generators += [dr]
print(len(c.generators))
nemo.run(c)
utils.plot(c, filename='foo.png')
os.unlink('foo.png')
def run():
"""Run the evolution."""
if args.verbose and __name__ == '__main__':
print "objective: minimise", eval_func.__doc__
np.random.seed(args.seed)
hof = tools.HallOfFame(1)
stats_fit = tools.Statistics(lambda ind: ind.fitness.values)
stats_hof = tools.Statistics(lambda ignored: hof[0].fitness.values)
mstats = tools.MultiStatistics(fitness=stats_fit, hallfame=stats_hof)
mstats.register("min", np.min)
try:
algorithms.eaGenerateUpdate(toolbox,
ngen=args.generations,
stats=mstats,
halloffame=hof,
verbose=True)
except KeyboardInterrupt: # pragma: no cover
print 'user terminated early'
context.set_capacities(hof[0])
nemo.run(context)
context.verbose = True
print
print context
score, penalty, reason = cost(context)
print 'Score: %.2f $/MWh' % score
constraints_violated = []
if reason > 0:
print 'Penalty: %.2f $/MWh' % penalty
print 'Constraints violated:',
for label, code in reasons.iteritems():
if reason & code:
constraints_violated += [label]
print label,
print
if args.transmission:
np.set_printoptions(precision=5)
x = context.exchanges.max(axis=0)
print np.array_str(x, precision=1, suppress_small=True)
obj = {'exchanges': x.tolist(), 'generators': context}
with open('results.json', 'w') as f:
json.dump(obj, f, cls=nemo.Context.JSONEncoder, indent=True)
with open(args.output, 'w') as f:
bundle = {
'options': vars(args),
'parameters': [max(0, cap) for cap in hof[0]],
'score': score,
'penalty': penalty,
'constraints_violated': constraints_violated
}
json.dump(bundle, f)
print 'Done'
def test_008(self):
"""A NSW generator runs in NSW only."""
for rgn in regions.All:
self.context.regions = [rgn]
gen = SuperGenerator(None)
self.context.generators = [gen]
nemo.run(self.context)
if rgn == regions.nsw:
self.assertEqual(gen.runhours, self.context.timesteps)
else:
self.assertEqual(gen.runhours, 0)
def eval_func(chromosome):
"""Average cost of energy (in $/MWh)."""
context.set_capacities(chromosome)
nemo.run(context)
score, penalty, reason = cost(context)
if args.trace_file is not None:
# write the score and individual to the trace file
with open(args.trace_file, 'a') as csvfile:
writer = csv.writer(csvfile)
writer.writerow([score, penalty, reason] + list(chromosome))
return score + penalty,
def test_012(self):
"""A NSW generator does not run in other regions."""
rgnset = []
# Skip NSW (first in the list).
for rgn in regions.All[1:]:
rgnset.append(rgn)
self.context.regions = rgnset
gen = SuperGenerator(None)
self.context.generators = [gen]
nemo.run(self.context)
self.assertEqual(gen.runhours, 0)
def test_002(self):
"""Test 2"""
c = nemo.Context()
# Make sure there is unserved energy by setting 2nd and
# subsequent generator capacity to 0.
for g in c.generators[1:]:
g.set_capacity(0)
nemo.run(c)
utils.plot(c, filename='foo.png')
os.unlink('foo.png')
utils.plot(c, filename='foo.png', spills=True)
os.unlink('foo.png')
# Test limiting the x-range.
xlim = [datetime(2010, 1, 1), datetime(2010, 1, 10)]
utils.plot(c, filename='foo.png', xlim=xlim)
os.unlink('foo.png')
def test_011(self):
"""Running in two regions only produces limited interstate exchanges."""
for rgn1 in regions.All:
for rgn2 in regions.All:
if rgn1 is rgn2:
continue
self.context.regions = [rgn1, rgn2]
nemo.run(self.context, endhour=1)
self.assertTrue(self.context.exchanges[0, rgn1, rgn1] >= 0)
self.assertTrue(self.context.exchanges[0, rgn2, rgn2] >= 0)
for i in regions.All:
for j in regions.All:
# Check that various elements of the exchanges matrix are 0.
# Ignore: diagonals, [RGN1,RGN2] and [RGN2,RGN1].
if i != j and (i, j) != (rgn1, rgn2) and (i, j) != (
rgn2, rgn1):
self.assertEqual(self.context.exchanges[0, i, j],
0)
def test_007(self):
"""Generation to meet minimum load + 1GW produces some spills."""
self.context.generators = [SuperGenerator(self.minload + 1000)]
nemo.run(self.context)
self.assertTrue(self.context.spill.values.sum() > 0)
def test_006(self):
"""Generation to meet minimum load leads to no spills."""
self.context.generators = [SuperGenerator(self.minload)]
nemo.run(self.context)
self.assertEqual(self.context.spill.values.sum(), 0)
def test_005(self):
"""Super generator runs every hour."""
gen = SuperGenerator(None)
self.context.generators = [gen]
nemo.run(self.context)
self.assertEqual(gen.runhours, self.context.timesteps)
message: discord.Message,
guild: discord.Guild,
event: int,
**_):
role = discord.utils.get(guild.roles, name=f"{config.PARTICIPANT_PREFIX}{event}")
for user in message.mentions:
await user.remove_roles(role)
users = ", ".join([f"<@{user.id}>" for user in message.mentions])
await channel.send(config.KICK_MSG.replace("@User", f"<@{member.id}>").replace("@Invited", users))
@nemo.command("!colab")
@helper.event_command
@helper.auto_delete
async def colab(*,
channel: discord.TextChannel,
member: discord.Member,
message: discord.Message,
guild: discord.Guild,
event: int,
**_):
role = discord.utils.get(guild.roles, name=f"{config.ORGANIZER_PREFIX}{event}")
for user in message.mentions:
await user.add_roles(role)
users = ", ".join([f"<@{user.id}>" for user in message.mentions])
await channel.send(config.COLAB_MSG.replace("@User", f"<@{member.id}>").replace("@Invited", users))
if __name__ == "__main__":
nemo.run(config.TOKEN)
def test_003(self):
"""Power system with no generators meets none of the demand."""
self.context.generators = []
nemo.run(self.context)
self.assertEqual(math.trunc(self.context.unserved_energy()),
math.trunc(self.context.total_demand()))
def test_002(self):
"""Demand equals approx. 204 TWh."""
self.context.generators = []
nemo.run(self.context)
self.assertEqual(math.trunc(self.context.total_demand() / pow(10., 6)),
204)
def test_013(self):
"""Fossil plant records power generation history."""
ccgt = generators.CCGT(polygons.wildcard, 100)
self.context.generators = [ccgt]
nemo.run(self.context)
self.assertTrue(len(self.context.generators[0].series_power) > 0)
"""A stub for profiling tools to run one basic simulation.""" import nemo c = nemo.Context() nemo.run(c)
