# coding: utf-8

# In[25]:

#from pylab import *

import math

import random as rd

import numpy as np

import networkx as nx

from scipy import stats as st

from numpy import array

from scipy.integrate import ode

from scipy.stats import pareto

import csv

def sistema_nodo(nodo): # genera las ecuaciones (derivada de cada P)

return resultado

def dP_dt2_nodo(t,P,alpha,expresion,nodo):

return resultado

def actualizacion2_nodo(g,Tg,nodo):

g.node[nodo]['theta'] = list(array(solver.y))[0]

def sistema_nodo_vecinos(nodo): # genera las ecuaciones (derivada de cada P)

return resultado

def dP_dt2_nodo_vecinos(t,P,alpha,expresion,nodo):

return resultado

def actualizacion2_nodo_vecinos(g,Tg,nodo):

g.node[i]['theta'] = list(array(solver.y))[candidatos.index(i)]

#########

def nuevo_nodo2(i): #Se selecciona un nodo y se le conecta a un nodo nuevo. Se perturba la posición del primero.

return nuevo #devuelve el valor del nodo al que se ha conectado el nodo recien creado

def nuevo_enlace2(i): #Se selecciona un nodo y se le conecta a otro cercano. Se perturba la posición del primero.

return i

def update2():

lista_roturas.append(rotura)

def registro_datos():

lista_distancia_enlace_euclidiana_media_componente_gigante.append(float('nan'))

#############################################################

#############################################################

#PARAMETROS

#############################################################

#Parámetros generales

tmax = 20

p = 0.5 # parametro para ajustar la proporcion de nodos o enlaces nuevos que introducimos en cada paso

incluye_vecinos = True #J: Parámetro para elegir si actualizar también las fases de los vecinos o no

#a = 0.001; # limiting factor

#b = 2.0 #Pareto parameter # QUITAMOS vecindad con distribución de Pareto. Ahora es FIJA. JMP 19/01/18

rad0= 0.1 #Quitamos Pareto y dejamos distancia fija rad0

c = 2.0 #factor distancia nuevo hijo (por ahora no se mueren)

gamma = 2.0 #exponente de Pareto

exp_Levy = 1.5 #exponente de Levy-Flights

delta_omega = 0.2

delta_theta = 0.1*math.pi #máxima desviación de la fase del hijo

delta_c = 0.1*c ##máxima desviación de la posición de un nodo al inicio de un nuevo instante de tiempo

#############################################################

#Umbrales

umbral = 0.3 #sincronización mínima que se exige en los extremos de un enlace

p_rotura = 0.0 #probabilidad de rotura de un enlace que está a distancia menor o igual que 1

#############################################################

#Integración numérica

Tg = 3.0 #duración de la integración numérica de las ecuaciones diferenciales

alpha = 1.0 # coupling strength

csvfile = 'out_Ag_Dif_neigh_FAST_nn_p5rp1c2u3t20.txt' #nombre del fichero txt de salida con los datos de las series temporales

path_graph = 'out_Ag_Dif_neigh_FAST_nn_p5rp1c2u3t20.gpickle' #nombre del fichero gpickle de salida con el grafo

lista_cant_nodos = []

lista_cant_enlaces = []

#lista_escisiones = []

lista_roturas = []

lista_media_sin = []

lista_media_cos = []

lista_orden = []

lista_cant_subgrafos = []

lista_cantidad_nodos_componente_gigante = [] #A: Almacena la variable que indica el nombre

lista_diametro_componente_gigante = [] #A: Almacena la variable que indica el nombre

tiempo = []

microtiempo = [] #Almacena el valor de (macro)tiempo de cada instante de microtiempo

lista_clustering_medio_componente_gigante = [] #A: Almacena la variable que indica el nombre

lista_camino_corto_medio_componente_gigante = [] #A: Almacena la variable que indica el nombre

lista_distancia_enlace_euclidiana_media_componente_gigante = [] #A: Almacena la variable que indica el nombre

################################################## Semilla

g = nx.Graph()

nuevo_nodo2(0)

#g_max = g.copy()

#n_max = len(g_max.nodes())

t = 1

tiempo.append(0)

lista_cant_nodos.append(1)

lista_cant_enlaces.append(0.0)

#lista_escisiones.append(0.0)

lista_roturas.append(0.0)

lista_cant_subgrafos.append(1.0)

lista_media_sin.append(np.sin(g.node[0]['theta']))

lista_media_cos.append(np.cos(g.node[0]['theta']))

lista_orden.append(1.0)

lista_cantidad_nodos_componente_gigante.append(1.0)

lista_diametro_componente_gigante.append(float('nan'))

microtiempo.append(0)

lista_clustering_medio_componente_gigante.append(float('nan'))

lista_camino_corto_medio_componente_gigante.append(float('nan'))

lista_distancia_enlace_euclidiana_media_componente_gigante.append(float('nan'))

################################

################################

## Comienzo del bucle

################################

cons = 0

while t < tmax+1:

dt=0

cons = 0

while dt < 1.0:

cons += 1

if cons % 1000 == 0:

print('cons=',cons)

microtiempo.append(t)

dt += 1./len(g.nodes())

#print('t:',t,'; n_nodes=',len(g.nodes()),'; dt: ',dt)

update2() #J: A continuación habría que meter lo que se calcula en cada actualización

registro_datos() #Esta función registra los datos en los instante de macro tiempo

tiempo.append(t)

t += 1

#J: Uso la actualización de tiempos de SAYAMA

#J: Aquí habría que meter lo que se calcula para cada MACROTIEMPO

if t%1==0:

print(t)

res = [lista_cant_nodos,lista_cant_enlaces,lista_roturas,lista_media_sin,lista_media_cos,lista_orden, lista_cant_subgrafos,lista_cantidad_nodos_componente_gigante,lista_diametro_componente_gigante,tiempo, microtiempo,lista_clustering_medio_componente_gigante,lista_camino_corto_medio_componente_gigante, lista_distancia_enlace_euclidiana_media_componente_gigante]

with open(csvfile, "w") as output:

writer = csv.writer(output, lineterminator='\n')

writer.writerows(res)

nx.write_gpickle(g, path_graph)

#Salvado final, tras completar la ejecución del programa

res = [lista_cant_nodos,lista_cant_enlaces,lista_roturas,lista_media_sin,lista_media_cos,lista_orden, lista_cant_subgrafos,lista_cantidad_nodos_componente_gigante,lista_diametro_componente_gigante,tiempo, microtiempo,lista_clustering_medio_componente_gigante,lista_camino_corto_medio_componente_gigante, lista_distancia_enlace_euclidiana_media_componente_gigante]

with open(csvfile, "w") as output:

writer = csv.writer(output, lineterminator='\n')

writer.writerows(res)

nx.write_gpickle(g, path_graph)

# In[21]:

print(nx.neighbors(g,4))