def test_AddStation(self):
n = Network()
stationid = "station"
stationid3 = "station3"
companyid = "company"
divisionid = "division"
s = Station(stationid)
s2 = Station(stationid)
n.AddStation(s)
with self.assertRaises(Exception):
n.AddStation(s2)
n.AddStationByDef(stationid3, companyid, divisionid)
self.assertEqual(n.Stations[stationid].ID, stationid)
self.assertEqual(n.Companies[""].Stations[stationid].ID, stationid)
self.assertEqual(n.Companies[""].Divisions[""].Stations[stationid].ID, stationid)
self.assertEqual(s.Company.ID, "")
self.assertEqual(s.Division.ID, "")
self.assertEqual(n.Stations[stationid3].ID, stationid3)
self.assertEqual(n.Companies[companyid].Stations[stationid3].ID, stationid3)
self.assertEqual(n.Companies[companyid].Divisions[divisionid].Stations[stationid3].ID, stationid3)
self.assertEqual(n.Stations[stationid3].Company.ID, companyid)
self.assertEqual(n.Stations[stationid3].Division.ID, divisionid)
return
def test_AddDivision(self):
n = Network()
companyid = "company"
companyid2 = "company2"
companyid3 = "company3"
divisionid = "division"
divisionid2 = "division2"
divisionid3 = "division3"
c = Company(companyid)
c3 = Company(companyid3)
d = Division(divisionid, companyid)
d2 = Division(divisionid2, companyid2)
n.AddCompany(c)
n.AddCompany(c3)
n.AddDivision(d)
n.AddDivision(d2)
n.AddDivisionByDef(divisionid3, companyid3)
n.AddDivisionByDef(divisionid, companyid2)
with self.assertRaises(Exception):
n.AddDivisionByDef(divisionid, companyid)
self.assertEqual(n.Companies[companyid].Divisions[divisionid].ID, divisionid)
self.assertEqual(n.Companies[companyid2].Divisions[divisionid2].ID, divisionid2)
self.assertEqual(n.Companies[companyid3].Divisions[divisionid3].ID, divisionid3)
self.assertEqual(len(n.Companies[companyid2].Divisions), 2)
self.assertEqual(n.Companies[companyid2].Divisions[divisionid].ID, divisionid)
return
def test_FindorAddCompany(self):
n = Network()
companyid = "company"
companyid3 = "company3"
c = Company(companyid)
n.AddCompany(c)
self.assertTrue(n.FindOrAddCompany(companyid).ID, companyid)
self.assertTrue(n.FindOrAddCompany(companyid3).ID, companyid3)
self.assertTrue(n.Companies[companyid3].ID, companyid3)
return
def test_Constructor(self):
n = Network()
self.assertEqual(len(n.Nodes),0)
self.assertEqual(len(n.Stations), 0)
self.assertEqual(len(n.Companies), 0)
return
def test_AddCompany(self):
n = Network()
companyid = "company"
companyid2 = "company"
companyid3 = "company3"
c = Company(companyid)
c2 = Company(companyid2)
n.AddCompany(c)
with self.assertRaises(Exception):
n.AddCompany(c2)
n.AddCompanyByDef(companyid3, False, False)
self.assertEqual(n.Companies[companyid].ID, companyid)
self.assertEqual(n.Companies[companyid3].ID, companyid3)
return
def ImportBidData(self, network: Network):
filename = BidDataCSVStream.DefaultFileName
if FileType.BidData in self.CSVFileNames:
filename = self.CSVFileNames[FileType.BidData]
filename = filename.format(self.MktDay)
propertymap = BidDataCSVStream.DefaultPropertyToFileMap
if FileType.BidData in self.CSVPropertyMaps:
propertymap = self.CSVPropertyMaps[FileType.BidData]
with BidDataCSVStream(filename, propertymap, self.Encoding) as csv:
for udo in csv:
mu = csv.getMktUit()
network.AddMktUnit(mu)
unitoffer = csv.getMktUnitDailyOffer()
unitoffer.MktDay = self.MktDay
network.AddMktUnitDailyOffer(unitoffer)
return
def test_FindOrAddStation(self):
n = Network()
stationid = "station"
stationid3 = "station3"
companyid = "company"
divisionid = "division"
s = Station(stationid)
s2 = Station(stationid)
n.AddStation(s)
self.assertEqual(n.FindOrAddStation(stationid).ID, stationid)
self.assertEqual(n.FindOrAddStation(stationid3,companyid, divisionid).ID, stationid3)
self.assertEqual(n.Stations[stationid3].ID, stationid3)
self.assertEqual(n.Companies[companyid].Stations[stationid3].ID, stationid3)
self.assertEqual(n.Companies[companyid].Divisions[divisionid].Stations[stationid3].ID, stationid3)
self.assertEqual(n.Stations[stationid3].Company.ID, companyid)
self.assertEqual(n.Stations[stationid3].Division.ID, divisionid)
return
def test_AddNode(self):
stname = "station"
kv = "115"
ndid = "AB"
ndid2 = "AB2"
company = "ABC"
n = Network()
s = Station(stname)
n.AddStation(s)
nd = Node(stname, kv, ndid, company)
n.AddNode(nd)
n.AddNodeByDef(stname, kv, ndid2, company, "div")
with self.assertRaises(Exception):
n.AddNodeByDef(stname,kv, ndid, company)
self.assertEqual(n.Nodes[nd.ID].ID, (stname, ndid))
self.assertEqual(n.Stations[stname].Nodes[nd.ID].ID, (stname, ndid))
self.assertEqual(n.Nodes[(stname, ndid2)].ID, (stname, ndid2))
self.assertEqual(n.Stations[stname].Nodes[(stname, ndid2)].ID, (stname, ndid2))
return
def ImportCostCurves(self, network: Network):
filename = CostCurvesCSVStream.DefaultFileName
if FileType.CostCurves in self.CSVFileNames:
filename = self.CSVFileNames[FileType.CostCurves]
filename = filename.format(self.MktDay)
propertymap = CostCurvesCSVStream.DefaultPropertyToFileMap
if FileType.CostCurves in self.CSVPropertyMaps:
propertymap = self.CSVPropertyMaps[FileType.CostCurves]
with CostCurvesCSVStream(filename, propertymap, self.Encoding) as csv:
for uho in csv:
network.AddMktUnitHourlyOffer(csv.getMktUnitHourlyOffer())
return
def ImportDemandBids(self, network: Network):
filename = DemandBidsCSVStream.DefaultFileName
if FileType.DemandBids in self.CSVFileNames:
filename = self.CSVFileNames[FileType.DemandBids]
filename = filename.format(self.MktDay)
propertymap = DemandBidsCSVStream.DefaultPropertyToFileMap
if FileType.DemandBids in self.CSVPropertyMaps:
propertymap = self.CSVPropertyMaps[FileType.DemandBids]
with DemandBidsCSVStream(filename, propertymap, self.Encoding) as csv:
for mb in csv:
network.AddMktBid(csv.getMktBid())
return
def ImportDayAheadLMPs(self, network: Network):
filename = DayAheadLMPsCSVStream.DefaultFileName
if FileType.DayAheadLMPs in self.CSVFileNames:
filename = self.CSVFileNames[FileType.DayAheadLMPs]
filename = filename.format(self.MktDay)
propertymap = DayAheadLMPsCSVStream.DefaultPropertyToFileMap
if FileType.DayAheadLMPs in self.CSVPropertyMaps:
propertymap = self.CSVPropertyMaps[FileType.DayAheadLMPs]
with DayAheadLMPsCSVStream(filename, propertymap,
self.Encoding) as csv:
for pnode in csv:
network.AddPNode(csv.getPNode())
return
def ImportZonalFactors(self, network: Network):
filename = ZonalFactorsCSVStream.DefaultFileName
if FileType.ZonalFactors in self.CSVFileNames:
filename = self.CSVFileNames[FileType.ZonalFactors]
filename = filename.format(self.MktDay)
propertymap = ZonalFactorsCSVStream.DefaultPropertyToFileMap
if FileType.ZonalFactors in self.CSVPropertyMaps:
propertymap = self.CSVPropertyMaps[FileType.ZonalFactors]
with ZonalFactorsCSVStream(filename, propertymap,
self.Encoding) as csv:
for zf in csv:
network.AddPNodeFactor(csv.getCPNodeID(), csv.getPNodeID(),
csv.getFactor())
return
def testNetworkToDEMSimple(self):
st1 = "Home"
st2 = "Grid"
kv = "115"
nd1 = "HomeNode"
nd2 = "GridNode"
sgen = "SolarGen"
ggen = "GridGen"
ld1 = "HomeLoad"
n = Network()
#HOME
n.AddStationByDef(st1)
n.AddNodeByDef(st1, kv, nd1)
sg = Unit(st1, kv, nd1, sgen, "", 10, 0, 0, 0, 1, False, 0)
ld = Load(st1, kv, nd1, ld1, "", 13, 0, 1)
n.AddDevice(sg)
n.AddDevice(ld)
#GRID
n.AddStationByDef(st2)
n.AddNodeByDef(st2, kv, nd2)
gg = Unit(st2, kv, nd2, ggen, "", 1e6, 0, 0, 0, 1, False, 0)
n.AddDevice(gg)
#LINE
br = Branch(st1, kv, nd1, st2, kv, nd2, "Line", "", True, 0, 0, "1",
RatingSet(25, 25, 25), RatingSet(25, 25, 25))
n.AddNodeConnector(br)
gp = NetworkToDEMSimple(n)
gp.init_problem()
gp.problem.solve()
print(gp.results.summary())
def test_FindorAddDivision(self):
n = Network()
companyid = "company"
companyid3 = "company3"
divisionid = "division"
divisionid3 = "division3"
c = Company(companyid)
d = Division(divisionid, companyid)
n.AddCompany(c)
n.AddDivision(d)
self.assertTrue(n.FindOrAddDivision(divisionid, companyid).ID, divisionid)
self.assertTrue(n.FindOrAddDivision(divisionid3, companyid3).ID, divisionid3)
self.assertTrue(n.Companies[companyid3].Divisions[divisionid3].ID, divisionid3)
return
def ImportCompanies(self, network: Network):
filename = CompanyCSVStream.DefaultFileName
if FileType.Company in self.CSVFileNames:
filename = self.CSVFileNames[FileType.Company]
propertymap = CompanyCSVStream.DefaultPropertyToFileMap
if FileType.Company in self.CSVPropertyMaps:
propertymap = self.CSVPropertyMaps[FileType.Company]
with CompanyCSVStream(filename, propertymap, self.Encoding) as csv:
i = 0
d = 0
for company in csv:
network.AddCompanyByDef(csv.getCompanyName(),
csv.getEnforceLosses(), csv.getAWR())
i += 1
while i > ((d + 1) * .10 * len(csv)):
print("", end='.')
d += 1
return
def ImportLines(self, network: Network):
filename = LineCSVStream.DefaultFileName
if FileType.Line in self.CSVFileNames:
filename = self.CSVFileNames[FileType.Line]
propertymap = LineCSVStream.DefaultPropertyToFileMap
if FileType.Line in self.CSVPropertyMaps:
propertymap = self.CSVPropertyMaps[FileType.Line]
with LineCSVStream(filename, propertymap, self.Encoding) as csv:
i = 0
d = 0
for LN in csv:
network.AddNodeConnector(csv.getBranch())
i += 1
while i > ((d + 1) * .10 * len(csv)):
print("", end='.')
d += 1
return
def ImportTransformers(self, network: Network):
filename = TransformerCSVStream.DefaultFileName
if FileType.Transformer in self.CSVFileNames:
filename = self.CSVFileNames[FileType.Transformer]
propertymap = TransformerCSVStream.DefaultPropertyToFileMap
if FileType.Transformer in self.CSVPropertyMaps:
propertymap = self.CSVPropertyMaps[FileType.Transformer]
with TransformerCSVStream(filename, propertymap, self.Encoding) as csv:
i = 0
d = 0
for XF in csv:
network.AddNodeConnector(csv.getTransformer())
i += 1
while i > ((d + 1) * .10 * len(csv)):
print("", end='.')
d += 1
return
def ImportUnits(self, network: Network):
filename = UnitCSVStream.DefaultFileName
if FileType.Unit in self.CSVFileNames:
filename = self.CSVFileNames[FileType.Unit]
propertymap = UnitCSVStream.DefaultPropertyToFileMap
if FileType.Unit in self.CSVPropertyMaps:
propertymap = self.CSVPropertyMaps[FileType.Unit]
with UnitCSVStream(filename, propertymap, self.Encoding) as csv:
i = 0
d = 0
for UN in csv:
network.AddDevice(csv.getUnit())
i += 1
while i > ((d + 1) * .10 * len(csv)):
print("", end='.')
d += 1
return
def ImportNodes(self, network: Network):
filename = NodeCSVStream.DefaultFileName
if FileType.Node in self.CSVFileNames:
filename = self.CSVFileNames[FileType.Node]
propertymap = NodeCSVStream.DefaultPropertyToFileMap
if FileType.Node in self.CSVPropertyMaps:
propertymap = self.CSVPropertyMaps[FileType.Node]
with NodeCSVStream(filename, propertymap, self.Encoding) as csv:
i = 0
d = 0
for Node in csv:
network.AddNodeByDef(csv.getStationName(), csv.getVoltage(),
csv.getNodeName(), csv.getCompanyName())
i += 1
while i > ((d + 1) * .10 * len(csv)):
print("", end='.')
d += 1
return
def ImportDivisions(self, network: Network):
filename = DivisionCSVStream.DefaultFileName
if FileType.Division in self.CSVFileNames:
filename = self.CSVFileNames[FileType.Division]
propertymap = DivisionCSVStream.DefaultPropertyToFileMap
if FileType.Division in self.CSVPropertyMaps:
propertymap = self.CSVPropertyMaps[FileType.Division]
with DivisionCSVStream(filename, propertymap, self.Encoding) as csv:
i = 0
d = 0
for Division in csv:
network.AddDivisionByDef(csv.getDivisionName(),
csv.getCompanyName())
i += 1
while i > ((d + 1) * .10 * len(csv)):
print("", end='.')
d += 1
return
def test_AddPNode(self):
stname = "station"
kv = "115"
ndid = "AB"
ndid2 = "AB2"
company = "ABC"
n = Network()
s = Station(stname)
n.AddStation(s)
nd = Node(stname, kv, ndid, company)
n.AddNode(nd)
n.AddNodeByDef(stname, kv, ndid2, company, "div")
id = 122060565
id2 = 122060564
id3 = 122060562
id4 = 122060563
id5 = 34234234
name = "nodename"
name2 = "nodename2"
name3 = "nodename3"
name4 = "nodename4"
name5 = "nodename5"
ldun = "load1"
sett = True
sett2 = False
rzid = 3
cnd = CPNode(id, name, sett)
cnd2=CPNode(id2,name2,sett2)
pnd3 = PNode(id3, name3)
end4=EPNode(id4, name4,234234,(stname,ndid), ldun, rzid)
end5=EPNode(id5, name5,2634234,("",""), ldun, rzid)
n.AddPNode(cnd)
n.AddPNode(cnd2)
n.AddPNode(pnd3)
n.AddPNode(end4)
with self.assertRaises(Exception):
n.AddPNode(cnd)
with self.assertRaises(Exception):
n.AddPNode(end5)
self.assertEqual(n.PNodes[id].Name, name)
self.assertEqual(n.CPNodes[id].Name, name)
self.assertEqual(n.PNodes[id2].Name, name2)
self.assertEqual(n.CPNodes[id2].Name, name2)
self.assertEqual(n.PNodes[id3].Name, name3)
self.assertEqual(n.PNodes[id4].Name, name4)
self.assertEqual(n.EPNodes[id4].Name, name4)
self.assertEqual(n.EPNodes[id4].Node.ID, nd.ID)
self.assertEqual(n.CPNodes[id].FactorSum, 0)
n.AddPNodeFactor(id, id4, .4)
n.AddPNodeFactor(id, id3, .6)
self.assertEqual(n.CPNodes[id].FactorSum, 1)
self.assertEqual(n.CPNodes[id].PNodes[id4].Name, name4)
self.assertEqual(n.CPNodes[id].PNodeFactors[id3], .6)
with self.assertRaises(Exception):
n.AddPNodeFactor(id, id4, .4)
with self.assertRaises(Exception):
n.AddPNodeFactor(34, id4, .4)
with self.assertRaises(Exception):
n.AddPNodeFactor(id, 45, .4)
return
def test_AddNodeConnector(self):
st1 = "ST1"
st2 = "ST2"
kv115 = "115"
kv365 = "365"
ndid1 = "N1"
ndid2 = "N2"
ndid3 = "N3"
ndid4 = "N4"
cbid1 = "12"
trname = "23"
psname = "ps12"
lnname = "lnname"
cbid2 = "34"
company = "ABC"
n = Network()
#Station #1
s1 = Station(st1)
nd11 = Node(st1, kv115, ndid1, company)
nd12 = Node(st1, kv115, ndid2, company)
nd13 = Node(st1, kv365, ndid3, company)
nd14 = Node(st1, kv365, ndid4, company)
cb11 = CircuitBreaker(st1, kv115, ndid1, ndid2, cbid1, company, CBState.Closed, "CB")
tr11 = Transformer(st1, kv115, ndid2, kv365, ndid3, trname, company, True)
cb12 = CircuitBreaker(st1, kv365, ndid3, ndid4, cbid2, company, CBState.Closed, "CB")
n.AddStation(s1)
#both nodes mising
with self.assertRaises(Exception):
n.AddNodeConnector(cb11)
n.AddNode(nd12)
#from node missing
with self.assertRaises(Exception):
n.AddNodeConnector(cb11)
n.AddNode(nd11)
n.AddNodeConnector(cb11)
#to node missing
with self.assertRaises(Exception):
n.AddNodeConnector(tr11)
#duplicate connector
with self.assertRaises(Exception):
n.AddNodeConnector(cb11)
n.AddNode(nd13)
n.AddNode(nd14)
n.AddNodeConnector(tr11)
n.AddNodeConnector(cb12)
#Station #2
s2 = Station(st2)
n.AddStation(s2)
nd21 = Node(st2, kv115, ndid1, company)
n.AddNode(nd21)
nd22 = Node(st2, kv115, ndid2, company)
n.AddNode(nd22)
ps = PhaseShifter(st2, kv115, ndid1, kv115, ndid2, psname, company, False)
n.AddNodeConnector(ps)
ln = Branch(st1, kv115, ndid1, st2, kv115, ndid1, lnname, company, True)
n.AddNodeConnector(ln)
self.assertEqual(len(n.NodeConnectors), 5)
self.assertEqual(len(n.CircuitBreakers), 2)
self.assertEqual(len(n.Transformers), 1)
self.assertEqual(len(n.PhaseShifters), 1)
self.assertEqual(len(n.Lines), 1)
self.assertEqual(len(nd11.NodeConnectors), 2)
self.assertEqual(len(nd12.NodeConnectors), 2)
self.assertEqual(len(nd13.NodeConnectors), 2)
self.assertEqual(len(nd14.NodeConnectors), 1)
self.assertEqual(len(nd21.NodeConnectors), 2)
self.assertEqual(len(nd22.NodeConnectors), 1)
def get_network(self) -> Network:
return self.network
def __str__(self):
out = [
f" net: {self.network},", f" interface: {self.interface},"
f" metric: {self.metric}"
]
if self.gateway is not None:
out.insert(1, f" gateway: {self.gateway},")
return "".join(out)
if __name__ == "__main__":
net = Network("192.168.1.0", 24)
route = Route(network=net, gateway=None, interface="en0", metric=10)
route2 = Route(Network("0.0.0.0", 0),
gateway=IPv4Address("192.168.0.1"),
interface="en0",
metric=10)
print(route)
print(route2)
# net: 192.168.0.0/24, interface: en0, metric: 10
# net: 0.0.0.0/0, gateway: 192.168.0.1, interface: en0, metric: 10
# class Route {
# public Route(Network network, IPv4Address gateway, String interfaceName, int metric) {}
# public IPv4Address getGateway() {}
# public String getInterfaceName() {}
from Network.Network import Network
from python_mnist.mnist import MNIST
import numpy as np
from Network.NetLib import initWeight, sigmoid, ReLU, sigmoidGrad, ReLUGrad
net = Network()
net.creatLayer(784, "None").creatLayer(400, "ReLU").creatLayer(
400, "ReLU").creatLayer(10, "sigmoid")
net.createWeight()
data = MNIST('python_mnist\data')
t = data.load_training()
net.trainMiniBatch(t, 3, 50, 0.01, 5e-4)
def test_AddDevice(self):
st1 = "ST1"
st2 = "ST2"
kv115 = "115"
kv365 = "365"
ndid1 = "N1"
ndid2 = "N2"
ndid3 = "N3"
ndid4 = "N4"
company = "ABC"
ldid = "LD1"
shid = "SH1"
uid = "U1"
n = Network()
#Station #1
s1 = Station(st1)
nd11 = Node(st1, kv115, ndid1, company)
nd12 = Node(st1, kv115, ndid2, company)
nd13 = Node(st1, kv365, ndid3, company)
nd14 = Node(st1, kv365, ndid4, company)
l1 = Load(st1, kv115, ndid1, ldid, company, 1,1,.97)
sh1 = Shunt(st1, kv115, ndid2, shid, company, 1)
u1 = Unit(st1, kv365, ndid3, uid, company, 10, 10,5,5,.8, False, 7)
with self.assertRaises(Exception):
n.AddDevice(l1)
n.AddStation(s1)
with self.assertRaises(Exception):
n.AddDevice(l1)
n.AddNode(nd12)
n.AddNode(nd11)
n.AddNode(nd13)
n.AddNode(nd14)
n.AddDevice(l1)
n.AddDevice(sh1)
n.AddDevice(u1)
#duplicate device
with self.assertRaises(Exception):
n.AddDevice(l1)
self.assertEqual(len(n.Devices), 3)
self.assertEqual(len(n.Loads), 1)
self.assertEqual(len(n.Units), 1)
self.assertEqual(len(n.Shunts), 1)
self.assertEqual(len(nd11.Devices), 1)
self.assertEqual(len(nd12.Devices), 1)
self.assertEqual(len(nd13.Devices), 1)
return
import numpy
from Network.Layer import Layer
from Network.Network import Network
# a = numpy.array([1])
# b = numpy.array([[1, 2], [3, 4], [5, 6]])
# print(b)
layer1 = Layer(2, 2)
layer2 = Layer(1, 2)
network = Network([layer1, layer2])
training_set = numpy.array([
[0, 0, numpy.array([0])],
[1, 0, numpy.array([1])],
[0, 1, numpy.array([1])],
[1, 1, numpy.array([0])],
],
dtype=object)
network.learning(training_set)
# for layer in network.layers:
# print(layer.weights)
print('###################')
print(network.input([0, 0]))
print(network.input([0, 1]))
print(network.input([1, 0]))
print(network.input([1, 1]))
