SHARE
TWEET

Untitled

a guest May 23rd, 2019 72 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import numpy
  2. import random
  3.  
  4.  
  5. class Nodo:
  6.    
  7.    routingTable = {} # <key:destinazione;value:next_hop>
  8.    SPT = {} # <key:destinazione;value:percorso>  
  9.    
  10.    def __init__(self, nome):
  11.       self.nome = nome #stringa
  12.  
  13.    def setGrafo(self, rete):
  14.       self.grafo = rete
  15.  
  16.    def dijkstra(self, grafo):
  17.       visitati = [self]
  18.       nonVisitati = grafo.listaNodi[:]
  19.       nonVisitati.remove(self)
  20.       costi = {}
  21.       self.pred = {}
  22.       vicini = grafo.trovaVicini(self)
  23.       for nodo in grafo.listaNodi:
  24.          if nodo in vicini:
  25.             arco = grafo.trovaArco(self, nodo)
  26.             costi[nodo.nome] = arco.costo
  27.          else:
  28.             costi[nodo.nome] = 1000000000
  29.       costi[self.nome] = 0
  30.       while len(nonVisitati) > 0:
  31.          costoMinimo = 1000000000
  32.          for nodo in visitati:
  33.             costoTmp = costi[nodo.nome]
  34.             vicini = grafo.trovaVicini(nodo)
  35.             for vicino in vicini:
  36.                if vicino not in visitati:
  37.                   arco = grafo.trovaArco(nodo, vicino)
  38.                   if costoTmp + arco.costo < costoMinimo:
  39.                      costoMinimo = costoTmp + arco.costo
  40.                      visitCand = vicino
  41.                      predCand = nodo
  42.          visitati.append(visitCand)
  43.          nonVisitati.remove(visitCand)
  44.          costi[visitCand.nome] = costoMinimo
  45.          self.pred[visitCand.nome] = predCand
  46.          vicini = grafo.trovaVicini(visitCand)
  47.          for vicino in vicini:
  48.             if vicino not in visitati:
  49.                arco = grafo.trovaArco(visitCand, vicino)
  50.                if costoMinimo + arco.costo < costi[vicino.nome]:
  51.                   costi[vicino.nome] = costoMinimo + arco.costo    
  52.    
  53.    def costruisciPercorso(self, destinazione, grafo):
  54.       path = Percorso(self, destinazione)
  55.       path.addNodo(destinazione)
  56.       print ("calcolo percorso da " + self.nome + " a " + destinazione.nome)
  57.       nodoCorrente = destinazione
  58.       while nodoCorrente != self:
  59.          predecessore = self.pred[nodoCorrente.nome]
  60.          arcoCorrente = grafo.trovaArco(predecessore, nodoCorrente)
  61.          path.addLink(arcoCorrente)
  62.          nodoCorrente = predecessore
  63.          path.addNodo(nodoCorrente)
  64.       path.invertiPercorso()
  65.       return path
  66.    
  67.    def scriviRoutingTable(self, grafo):
  68.       for nodo in grafo.listaNodi:
  69.          if nodo != self:
  70.             path = self.costruisciPercorso(nodo, grafo)
  71.             print ("Path da " + self.nome + " a " + nodo.nome)
  72.             path.stampaPercorso()
  73.             print ("Il costo del percorso e' " + str(path.getCosto()))
  74.             print ("Il throughput del percorso e' " + str(path.getThroughput()))
  75.             self.routingTable[nodo.nome] = path.getNextHop().nome
  76.          else:
  77.             self.routingTable[nodo.nome] = "direttamente connesso"
  78.  
  79. class Arco:
  80.    
  81.    def __init__(self, da, a, costo = 1, banda = 100):
  82.       self.da = da
  83.       self.a = a
  84.       self.id = da.nome + "_" + a.nome
  85.       self.costo = costo
  86.       self.banda = banda
  87.    
  88.    def setBanda(self, banda):
  89.       self.banda = banda
  90.  
  91.    def setCosto(self, costo):
  92.       self.costo = costo
  93.  
  94. class Grafo:
  95.    
  96.    listaNodi = []
  97.    listaArchi = []
  98.    TM = numpy.zeros((4,4))
  99.    
  100.    def __init__(self, nome):
  101.       self.nome = nome
  102.      
  103.    
  104.    def addNodo(self, nodo):
  105.       self.listaNodi.append(nodo)
  106.  
  107.    def addArco(self, arco):
  108.       self.listaArchi.append(arco)
  109.    
  110.    def trovaVicini(self, nodo):
  111.       vicini = []
  112.       for arco in self.listaArchi:
  113.          if arco.da == nodo:
  114.             vicini.append(arco.a)
  115.       return vicini
  116.    
  117.    def trovaArco(self, da, a):
  118.       for arco in self.listaArchi:
  119.          if arco.da == da and arco.a == a:
  120.             return arco
  121.  
  122.    def QuantitaTraffico(self,mat,nodo,grafo):
  123.  
  124.       nodo.dijkstra(grafo)
  125.  
  126.       short_path = nodo.costruisciPercorso(self,grafo)
  127.  
  128.       for
  129.      
  130.          
  131.          
  132.       for i in range(len(self.TM)):
  133.          for j in range(len(self.TM[0])):
  134.             if nodo in short_path:
  135.                traffico+=TM[i][j]
  136.       print(traffico)
  137.          
  138.          
  139.  
  140.      
  141.      
  142.  
  143.      
  144.  
  145. class Percorso:
  146.  
  147.    def __init__(self, sorgente, destinazione):
  148.  
  149.       self.pathID = sorgente.nome + "-" + destinazione.nome
  150.       self.sorgente = sorgente
  151.       self.destinazione = destinazione
  152.       self.costo = 0
  153.       self.pathLength = 0
  154.       self.throughput = 0
  155.       self.listaNodi = []
  156.       self.listaArchi = []
  157.    
  158.    def addNodo(self, nodo):
  159.       self.listaNodi.append(nodo)
  160.    
  161.    def addLink(self, arco):
  162.       self.listaArchi.append(arco)
  163.    
  164.    def getCosto(self):
  165.       costo = 0
  166.       for arco in self.listaArchi:
  167.          costo += arco.costo
  168.       self.costo = costo
  169.       return costo
  170.    
  171.    def getThroughput(self):
  172.       throughput = 1000000000
  173.       for arco in self.listaArchi:
  174.          if arco.banda < throughput:
  175.             throughput = arco.banda
  176.       self.throughput = throughput
  177.       return throughput
  178.    
  179.    def getPathLength(self):
  180.       self.pathLength = len(listaNodi)
  181.       return self.pathLength
  182.    
  183.    def invertiPercorso(self):
  184.       self.listaNodi.reverse()
  185.       self.listaArchi.reverse()
  186.    
  187.    def getNextHop(self):
  188.       return self.listaNodi[1]
  189.    
  190.    def stampaPercorso(self):
  191.       stringa = ""
  192.       for nodo in self.listaNodi:
  193.          stringa = stringa + nodo.nome + "->"
  194.       print (stringa[:len(stringa)-2])
  195.  
  196.  
  197. class MatriceTraffico():
  198.  
  199.     def __init__(self,nome,m,n):
  200.         self.nome=nome
  201.         self.righe=m
  202.         self.colonne=n
  203.         TM = numpy.zeros((m,n))
  204.         self.matrix=TM
  205.         print("Matrice di traffico\n")
  206.         print(TM)
  207.  
  208.     def assegna_Unita_Traffico(self,TM):
  209.        for i in range(len(TM)):
  210.          for j in range(len(TM[0])):
  211.             TM[i][j] = random.randint(1,10)
  212.             TM[i][i]=0
  213.             TM[j][j]=0
  214.        print("Matrice di traffico con quantita di traffico tra i nodi\n")
  215.        print(TM)
  216.  
  217.  
  218. if __name__ == "__main__":
  219.    grafo = Grafo("Rete_4_nodi")
  220.    nodoA = Nodo("A")
  221.    grafo.addNodo(nodoA)
  222.    nodoB = Nodo("B")
  223.    grafo.addNodo(nodoB)
  224.    nodoC = Nodo("C")
  225.    grafo.addNodo(nodoC)
  226.    nodoD = Nodo("D")
  227.    grafo.addNodo(nodoD)
  228.    arco1 = Arco(nodoA, nodoB, 10, 100)
  229.    grafo.addArco(arco1)
  230.    arco2 = Arco(nodoA, nodoC, 1, 100)
  231.    grafo.addArco(arco2)
  232.    arco3 = Arco(nodoB, nodoA, 1, 100)
  233.    grafo.addArco(arco3)
  234.    arco4 = Arco(nodoB, nodoD, 1, 100)
  235.    grafo.addArco(arco4)
  236.    arco5 = Arco(nodoC, nodoA, 1, 100)
  237.    grafo.addArco(arco5)
  238.    arco6 = Arco(nodoC, nodoD, 1, 10)
  239.    grafo.addArco(arco6)
  240.    arco7 = Arco(nodoD, nodoB, 1, 100)
  241.    grafo.addArco(arco7)
  242.    arco8 = Arco(nodoD, nodoC, 1, 100)
  243.    grafo.addArco(arco8)
  244.    nodoA.dijkstra(grafo)
  245.    nodoA.scriviRoutingTable(grafo)
  246.    print (nodoA.routingTable)
  247.    nodoB.dijkstra(grafo)
  248.    nodoB.scriviRoutingTable(grafo)
  249.    print (nodoB.routingTable)
  250.    matrice = MatriceTraffico("Matrice MxN",4,4)
  251.    print(matrice.assegna_Unita_Traffico(matrice.matrix))
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top