#######################################################################################################################
# Generation of examples of ds for each cone in the Naruki Fan, and their associated expected and true tropical nodes #
#######################################################################################################################


# We compute examples of parameters d in Q[t] giving Yoshidas whose valuation is the baricenter of each cone in the Naruki fan. We will use them to label the leaves of the tropical lines associated to each extremal curve.
# The examples for the parameters ds are constructed in "ConstructingDsForTheBergmanFan.sage"

# We generate all 135 true and expected nodes. We will use these to label the 27 tropical lines in "../../TropicalConvexHull/Scripts/NodesForAllExtremalCurves.sage"

# All functions used are constructed in "allTropicalNodesPerNarukiConesMacros.sage"


load("allTropicalNodesPerNarukiConesMacros.sage")

# The computation for each cone takes 4 minutes on a 2.4 GHz Intel(R) Core 2 Duo  with 3MB cache and 2GB RAM.

# We need to work with the fraction field of Qt.
Qt = PolynomialRing(QQ,[var("t")])
QtField = FractionField(Qt)

load("../../Yoshida/Scripts/Yoshida.sage")

roots=load("../../Yoshida/Scripts/Input/rootsE6.sobj")
YM = load("../../Yoshida/Output/Yoshida_matrix.sobj")
y_to_d = {Yoshidas[i]: prod([roots[j]^YM[i][j] for j in range(0,36)]) for i in range(0,40)}

# We load the dictionary of 135 Nodes
all135Nodes = load("../../Yoshida/Scripts/Input/all135ClassicalNodes.sobj")

###############################################################
# Produce valid parameters ds for each cone in the Naruki fan #
###############################################################

# We load the functions and the example generators for every vector in 'aa2a3a4' and 'aa2a3b' generated in "ConstructingDsForTheBergmanFan.sage".

load("ConstructingDsForTheBergmanFan.sage")

# The following functions unifies the constructions from "ConstructingDsForTheBergmanFan.sage" to depend on the cone in the Naruki fan we are interested in.

def buildRoots(cone,a,b,c,d):
    if 'b' in cone:
	   return buildRootsFor_aa2a3b(a,b,c,d)
    else:
	   return buildRootsFor_aa2a3a4(a,b,c,d)

def checkLowerFaces(cone, varus,D, a,b,c,d):
    if 'b' in cone:
	   return checkLowerFacesaa2a3b(varus, D, a, b, c, d)
    else:
	   return checkLowerFacesaa2a3a4(varus, D, a, b, c, d)
  

  
# We start with the two maximal cones, and then go to lower faces. As our representative, we choose the baricenter of each cell, in agreement with your choice for "../../ComputeLines/Scripts/ComputationsOfLinesForAllCones.sage".


# NOTE: The values of Yoshidas (rational functions in Q[t]) have been precomputed for choices of (a,b,c,d) that are 0/1 vectors giving the baricenter of each cone. If we wish to change this choice, we simply comment the line
# valYoshidas = load("Input/valYoshidas_aa2a3a4.sobj")
# and uncomment the line
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)



# The entries of all135Nodes[keys] are factorized already.
dictNodes = all135Nodes
pairs = dictNodes.keys() 




#################
# MAXIMAL CONES #
#################


##############
# AAAA Types #
##############

cone  = 'aa2a3a4'
print str(cone)

(a,b,c,d) = (1,1,1,1)
(varusaa2a3a4,D) = buildRoots(cone,a,b,c,d)
varus = varusaa2a3a4  
checkLowerFaces(cone,varus, D, a,b,c,d)
True
vald = computeVald(D,varus)
# print vald
# {d4: -t^5 + 2*t^4 + t + 14, d3: -t^5 + 2*t^4 - 6, d6: -t^5 + 2*t^4 + 17*t + 3, d5: 57*t^8 - t^5 + 2*t^4 - 57*t + 14, d2: 2*t^5 + 2*t^4 + 3, d1: -t^5 + 2*t^4 + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_aa2a3a4.sobj')
valYoshidas = load("Input/valYoshidas_aa2a3a4.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)


##############
# AAAB Types #
##############

cone  = 'aa2a3b'
print str(cone)

(a,b,c,d) = (1,1,1,1)
(varusaa2a3b,D) = buildRoots(cone,a,b,c,d)
varus = varusaa2a3b  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^4 + 2*t^2 + 4*t + 11, d3: -t^4 + 2*t^2 - 6*t, d6: -t^4 + 2*t^2 + 3*t + 17, d5: 57*t^8 - t^4 + 2*t^2 - 54*t + 11, d2: 2*t^4 + 2*t^2 + 3*t, d1: -t^4 + 2*t^2 + 3*t}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_aa2a3b.sobj')
valYoshidas = load("Input/valYoshidas_aa2a3b.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)




###############################
# TWO CONES
###############################


#############
# AAA Types #
#############

cone  = 'aa2a3'
print str(cone)

(a,b,c,d) = (1,1,1,0)
(varusaa2a3,D) = buildRoots(cone,a,b,c,d)
varus = varusaa2a3  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^3 + 2*t^2 + t + 14, d3: -t^3 + 2*t^2 - 6, d6: -t^3 + 2*t^2 + 20, d5: 57*t^6 - t^3 + 2*t^2 - 57*t + 14, d2: 2*t^3 + 2*t^2 + 3, d1: -t^3 + 2*t^2 + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_aa2a3.sobj')
valYoshidas = load("Input/valYoshidas_aa2a3.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 


#######
cone  = 'aa2a4'
print str(cone)

(a,b,c,d) = (1,1,0,1)
(varusaa2a4,D) = buildRoots(cone,a,b,c,d)
varus = varusaa2a4  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^4 + 2*t^3 + 15, d3: -t^4 + 2*t^3 - 6, d6: -t^4 + 2*t^3 + 17*t + 3, d5: 57*t^6 - t^4 + 2*t^3 - 43, d2: 2*t^4 + 2*t^3 + 3, d1: -t^4 + 2*t^3 + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_aa2a4.sobj')
valYoshidas = load("Input/valYoshidas_aa2a4.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)



######
cone  = 'aa3a4'
print str(cone)

(a,b,c,d) = (1,0,1,1)
(varusaa3a4,D) = buildRoots(cone,a,b,c,d)
varus = varusaa3a4  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^4 + 2*t^3 + t + 14, d3: -t^4 + 2*t^3 - 6, d6: -t^4 + 2*t^3 + 17*t + 3, d5: 57*t^6 - t^4 + 2*t^3 - 57*t + 14, d2: 2*t^4 + 2*t^3 + 3, d1: -t^4 + 2*t^3 + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_aa3a4.sobj')
valYoshidas = load("Input/valYoshidas_aa3a4.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)



######
cone  = 'a2a3a4'
print str(cone)

(a,b,c,d) = (0,1,1,1)
(varusa2a3a4,D) = buildRoots(cone,a,b,c,d)
varus = varusa2a3a4  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: t^4 + t + 14, d3: t^4 - 6, d6: t^4 + 17*t + 3, d5: 57*t^6 + t^4 - 57*t + 14, d2: 4*t^4 + 3, d1: t^4 + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_a2a3a4.sobj')
valYoshidas = load("Input/valYoshidas_a2a3a4.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 


#############
# AAB Types #
#############

cone  = 'aa2b'
print str(cone)

(a,b,c,d) = (1,1,0,1)
(varusaa2b,D) = buildRoots(cone,a,b,c,d)
varus = varusaa2b  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^3 + 5*t + 12, d3: -t^3 - 4*t, d6: -t^3 + 5*t + 17, d5: 57*t^6 - t^3 + 5*t - 46, d2: 2*t^3 + 5*t, d1: -t^3 + 5*t}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_aa2b.sobj')
valYoshidas = load("Input/valYoshidas_aa2b.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)



#######
cone  = 'aa3b'
print str(cone)

(a,b,c,d) = (1,0,1,1)
(varusaa3b,D) = buildRoots(cone,a,b,c,d)
varus = varusaa3b  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^3 + 6*t + 11, d3: -t^3 - 4*t, d6: -t^3 + 5*t + 17, d5: 57*t^6 - t^3 - 52*t + 11, d2: 2*t^3 + 5*t, d1: -t^3 + 5*t}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_aa3b.sobj')
valYoshidas = load("Input/valYoshidas_aa3b.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 


######
cone  = 'a2a3b'
print str(cone)

(a,b,c,d) = (0,1,1,1)
(varusa2a3b,D) = buildRoots(cone,a,b,c,d)
varus = varusa2a3b  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^3 + 2*t^2 + 4*t + 11, d3: -t^3 + 2*t^2 - 6*t, d6: -t^3 + 2*t^2 + 3*t + 17, d5: 57*t^6 - t^3 + 2*t^2 - 54*t + 11, d2: 2*t^3 + 2*t^2 + 3*t, d1: -t^3 + 2*t^2 + 3*t}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_a2a3b.sobj')
valYoshidas = load("Input/valYoshidas_a2a3b.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 


###############################
# EDGES
###############################

############
# AA Types #
############

cone  = 'aa2'
print str(cone)

(a,b,c,d) = (1,1,0,0)
(varusaa2,D) = buildRoots(cone,a,b,c,d)
varus = varusaa2  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^2 + 2*t + 15, d3: -t^2 + 2*t - 6, d6: -t^2 + 2*t + 20, d5: 57*t^4 - t^2 + 2*t - 43, d2: 2*t^2 + 2*t + 3, d1: -t^2 + 2*t + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_aa2.sobj')
valYoshidas = load("Input/valYoshidas_aa2.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 


######
cone  = 'aa3'
print str(cone)

(a,b,c,d) = (1,0,1,0)
(varusaa3,D) = buildRoots(cone,a,b,c,d)
varus = varusaa3  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^2 + 3*t + 14, d3: -t^2 + 2*t - 6, d6: -t^2 + 2*t + 20, d5: 57*t^4 - t^2 - 55*t + 14, d2: 2*t^2 + 2*t + 3, d1: -t^2 + 2*t + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_aa3.sobj')
valYoshidas = load("Input/valYoshidas_aa3.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)



######
cone  = 'aa4'
print str(cone)

(a,b,c,d) = (1,0,0,1)
(varusaa4,D) = buildRoots(cone,a,b,c,d)
varus = varusaa4  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^3 + 2*t^2 + 15, d3: -t^3 + 2*t^2 - 6, d6: -t^3 + 2*t^2 + 17*t + 3, d5: 57*t^4 - t^3 + 2*t^2 - 43, d2: 2*t^3 + 2*t^2 + 3, d1: -t^3 + 2*t^2 + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_aa4.sobj')
valYoshidas = load("Input/valYoshidas_aa4.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 


######
cone  = 'a2a3'
print str(cone)

(a,b,c,d) = (0,1,1,0)
(varusa2a3,D) = buildRoots(cone,a,b,c,d)
varus = varusa2a3  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: t^2 + t + 14, d3: t^2 - 6, d6: t^2 + 20, d5: 57*t^4 + t^2 - 57*t + 14, d2: 4*t^2 + 3, d1: t^2 + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_a2a3.sobj')
valYoshidas = load("Input/valYoshidas_a2a3.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 


######
cone  = 'a2a4'
print str(cone)

(a,b,c,d) = (0,1,0,1)
(varusa2a4,D) = buildRoots(cone,a,b,c,d)
varus = varusa2a4  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: t^3 + 15, d3: t^3 - 6, d6: t^3 + 17*t + 3, d5: 57*t^4 + t^3 - 43, d2: 4*t^3 + 3, d1: t^3 + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_a2a4.sobj')
valYoshidas = load("Input/valYoshidas_a2a4.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 


######
cone  = 'a3a4'
print str(cone)

(a,b,c,d) = (0,0,1,1)
(varusa3a4,D) = buildRoots(cone,a,b,c,d)
varus = varusa3a4  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: t^3 + t + 14, d3: t^3 - 6, d6: t^3 + 17*t + 3, d5: 57*t^4 + t^3 - 57*t + 14, d2: 4*t^3 + 3, d1: t^3 + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_a3a4.sobj')
valYoshidas = load("Input/valYoshidas_a3a4.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)



############
# AB Types #
############

cone  = 'ab'
print str(cone)

(a,b,c,d) = (1,0,0,1)
(varusab,D) = buildRoots(cone,a,b,c,d)
varus = varusab  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^2 + 3*t + 14, d3: -t^2 - 6*t + 2, d6: -t^2 + 3*t + 19, d5: 57*t^4 - t^2 + 3*t - 44, d2: 2*t^2 + 3*t + 2, d1: -t^2 + 3*t + 2}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_ab.sobj')
valYoshidas = load("Input/valYoshidas_ab.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 


######
cone  = 'a2b'
print str(cone)

(a,b,c,d) = (0,1,0,1)
(varusa2b,D) = buildRoots(cone,a,b,c,d)
varus = varusa2b  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^2 + 5*t + 12, d3: -t^2 - 4*t, d6: -t^2 + 5*t + 17, d5: 57*t^4 - t^2 + 5*t - 46, d2: 2*t^2 + 5*t, d1: -t^2 + 5*t}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_a2b.sobj')
valYoshidas = load("Input/valYoshidas_a2b.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 


######
cone  = 'a3b'
print str(cone)

(a,b,c,d) = (0,0,1,1)
(varusa3b,D) = buildRoots(cone,a,b,c,d)
varus = varusa3b  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t^2 + 6*t + 11, d3: -t^2 - 4*t, d6: -t^2 + 5*t + 17, d5: 57*t^4 - t^2 - 52*t + 11, d2: 2*t^2 + 5*t, d1: -t^2 + 5*t}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_a3b.sobj')
valYoshidas = load("Input/valYoshidas_a3b.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 



###############################
#  VERTICES
###############################

###########
# A Types #
###########

cone  = 'a'
print str(cone)

(a,b,c,d) = (1,0,0,0)
(varusa,D) = buildRoots(cone,a,b,c,d)
varus = varusa  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: -t + 17, d3: -t - 4, d6: -t + 22, d5: 57*t^2 - t - 41, d2: 2*t + 5, d1: -t + 5}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_a.sobj')
valYoshidas = load("Input/valYoshidas_a.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)

 

######
cone  = 'a2'
print str(cone)

(a,b,c,d) = (0,1,0,0)
(varusa2,D) = buildRoots(cone,a,b,c,d)
varus = varusa2  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: t + 15, d3: t - 6, d6: t + 20, d5: 57*t^2 + t - 43, d2: 4*t + 3, d1: t + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_a2.sobj')
valYoshidas = load("Input/valYoshidas_a2.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 



######
cone  = 'a3'
print str(cone)

(a,b,c,d) = (0,0,1,0)
(varusa3,D) = buildRoots(cone,a,b,c,d)
varus = varusa3  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: 2*t + 14, d3: t - 6, d6: t + 20, d5: 57*t^2 - 56*t + 14, d2: 4*t + 3, d1: t + 3}
# # We compute the Yoshidas given vald where, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_a3.sobj')
valYoshidas = load("Input/valYoshidas_a3.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)



######
cone  = 'a4'
print str(cone)

(a,b,c,d) = (0,0,0,1)
(varusa4,D) = buildRoots(cone,a,b,c,d)
varus = varusa4  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: t^2 + 15, d3: t^2 - 6, d6: t^2 + 17*t + 3, d5: 58*t^2 - 43, d2: 4*t^2 + 3, d1: t^2 + 3}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_a4.sobj')
valYoshidas = load("Input/valYoshidas_a4.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)
 


###########
# B Types #
###########

cone  = 'b'
print str(cone)

(a,b,c,d) = (0,0,0,1)
(varusb,D) = buildRoots(cone,a,b,c,d)
varus = varusb  
checkLowerFaces(cone,varus, D, a,b,c,d)
vald = computeVald(D,varus)
# print vald
# {d4: 2*t + 14, d3: -7*t + 2, d6: 2*t + 19, d5: 57*t^2 + 2*t - 44, d2: 5*t + 2, d1: 2*t + 2}
# # We compute the Yoshidas given vald, store the result and load it.
# valYoshidas =  substituteValdsInYField(vald,Yoshidas)
# save(valYoshidas, 'Input/valYoshidas_b.sobj')
valYoshidas = load("Input/valYoshidas_b.sobj")
generateTrueAndExpectedNodes(cone,a,b,c,d,dictNodes,valYoshidas)


# # We compare the expected and true nodes computed earlier. Some agree, but most don't.

# def compareTE(cone):
#     newExp = load('../../TropicalConvexHulls/Scripts/Input/expectedTNodes_no_nones_' + str(cone) + '.sobj')
#     newTrue = load('../../TropicalConvexHulls/Scripts/Input/trueTNodes_no_nones_' + str(cone) + '.sobj')
#     return newExp == newTrue

# allCompare = dict()
# for cone in AllConeNames:
#     print str(cone)
#     allCompare[cone] = compareTE(cone)

# print allCompare
# {'aa2a3': True, 'ab': False, 'aa2a4': False, 'aa3a4': False, 'a3b': False, 'aa4': False, 'aa2a3a4': False, 'aa3': False, 'aa2': False, 'aa3b': False, 'a2a3': False, 'a3a4': False, 'a2a4': False, 'a3': False, 'a2': False, 'a4': False, 'a': False, 'b': False, 'aa2a3b': True, 'a2b': False, 'a2a3b': False, 'a2a3a4': False, 'aa2b': True}


################################
# Jumps in Valuations of Nodes #
################################

# We start by listing all cones:

AllConeNames = ['aa2a3a4', 'aa2a3b', 'aa2a3', 'aa2a4', 'aa3a4','a2a3a4', 'aa2b', 'aa3b', 'a2a3b', 'aa2','aa3','aa4','a2a3', 'a2a4', 'a3a4', 'ab', 'a2b', 'a3b', 'a', 'a2', 'a3', 'a4','b']

# We record the jumps for each cone and each node as a dictionary of dictionaries with lists of tuples as values. The second entry of each tuple is is the specialization of the expected valuation to the sample point, and the third entry the true valuation coming from the sample point.

jumps = dict()
for cone in AllConeNames:
    print str(cone)
    jumps[cone] = generateJumps(cone,dictNodes)
    
# # We record the jumps as a sage object file:
# save(jumps, '../../Yoshida/Output/valuationJumpsPerConeForCenterOfMass.sobj')

# # We save the output as plain texts in the Output folder of the Yoshida folder:
# f = file('../../Yoshida/Output/valuationJumpsPerConeForCenterOfMass.txt', 'w')
# f.write('Jumps for undertermined valuations of anticanonical coordinates for nodes from sample parameters in Q[t] for each center of mass' + '\n' + '\n')
# for cone in AllConeNames:
#     f.write('Cone '+ str(cone) + '\n')
#     f.write('jumps[ '+ str(cone) + '] = ' + str(jumps[cone]) + '\n')
# f.close()