JNLS_plotScripts/ClassifyMin.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+# print(sys.executable)
+# from subprocess import Popen, PIPE
+
+
+# --------------------------------------------------
+# 'classifyMin' classifies Minimizers by utilizing the result of
+# Lemma1.6
+#
+#
+#
+#
+# 'classifyMin_ana': (Special-Case : Lemma1.4)
+# ..additionally assumes Poisson-ratio=0 => q12==0
+#
+#
+#
+# Output : MinimizingMatrix, Angle, Type, Curvature
+def determinant(q1,q2,q3,q12):                                  # TODO General:Matrix
+    return q1*q2 - (q3**2 + 2*q3*q12 + q12**2)
+
+
+
+
+def harmonicMean(mu_1, beta, theta):
+    return mu_1*(beta/(theta+((1-theta)*beta)))
+
+
+def arithmeticMean(mu_1, beta, theta):
+    return mu_1*((1-theta)+theta*beta)
+
+
+def prestrain_b1(rho_1, beta, alpha, theta):
+    return (3.0*rho_1/2.0)*(1-(theta*(1+alpha)))
+    # return (3.0*rho_1/2.0)*beta*(1-(theta*(1+alpha)))
+
+
+def prestrain_b2(rho_1, beta, alpha, theta):
+    return (3.0*rho_1/(2.0*((1.0-theta) + theta*beta)))*(1-theta*(1+beta*alpha))
+    # return (3.0*rho_1/(4.0*((1.0-theta) + theta*beta)))*(1-theta*(1+beta*alpha))
+
+
+# Define function to be minimized
+def f(a1, a2, q1, q2, q3, q12, b1, b2):
+    A = np.array([[q1, q3 + q12/2.0], [q3 + q12/2.0, q2]])
+    B = np.array([-2.0*q1*b1-q12*b2, -2.0*q2*b2-q12*b1])
+    a = np.array([a1, a2])
+    tmp = np.dot(A, a)
+    tmp2 = np.dot(a, tmp)
+    tmpB = np.dot(B, a)
+    return tmp2 + tmpB + q1*(b1**2) + q2*(b2**2) + q12*b1*b2
+
+# ---- Alternative Version using alpha,beta,theta ,mu_1,rho_1
+def classifyMin_ana(alpha,beta,theta,q3,mu_1,rho_1,print_Cases=False, print_Output=False):
+
+    # Assumption of Classification-Lemma1.6:
+    #  1. [b3 == 0]
+    #  2. Q is orthotropic i.e. q13 = q31 = q23 = q32 == 0
+    # 3. This additionally assumes that Poisson-Ratio = 0 => q12 == 0
+    q12 = 0.0
+
+    q1 = (1.0/6.0)*harmonicMean(mu_1, beta, theta)
+    q2 = (1.0/6.0)*arithmeticMean(mu_1, beta, theta)
+    # print('q1: ', q1)
+    # print('q2: ', q2)
+    b1 = prestrain_b1(rho_1, beta, alpha,theta)
+    b2 = prestrain_b2(rho_1, beta, alpha,theta)
+
+    # print('alpha:',alpha)
+    # print('beta:',beta)
+    # print('theta:',theta)
+
+    return classifyMin(q1, q2, q3, q12,  b1, b2,  print_Cases, print_Output)
+
+
+
+# Matrix Version that just gets matrices Q & B
+def classifyMin_mat(Q,B,print_Cases=False, print_Output=False):
+    q1 = Q[0][0]
+    q2 = Q[1][1]
+    q3 = Q[2][2]
+    q12 = Q[0][1]
+    b1 = B[0]
+    b2 = B[1]
+    b3 = B[2]
+    return classifyMin(q1, q2, q3, q12,  b1, b2,  print_Cases, print_Output)
+
+
+# --------------------------------------------------------------------
+# Classify Type of minimizer  1 = R1 , 2 = R2 , 3 = R3                          # before : destinction between which axis.. (4Types )
+# where
+# R1 : unique local (global) minimizer which is not axial
+# R2 : continuum of local (global) minimizers which are not axial
+# R3 : one or two local (global) minimizers which are axial
+# Partition given by
+# R1 = E1
+# R2 = P1.2
+# R3 = E2 U E3 U P1.1 U P2 U H
+# -------------------------------------------------------------------
+def classifyMin(q1, q2, q3, q12, b1, b2,  print_Cases=False, print_Output=False):   #ClassifyMin_hom?
+    # Assumption of Classification-Lemma1.6:
+    #  1. [b3 == 0]
+    #  2. Q is orthotropic i.e. q13 = q31 = q23 = q32 == 0
+
+    # TODO: check if Q is orthotropic here - assert()
+
+
+    if print_Output: print("Run ClassifyMin...")
+    CaseCount = 0
+    epsilon = sys.float_info.epsilon #Machine epsilon
+
+    B = np.array([-2.0*q1*b1-q12*b2, -2.0*q2*b2-q12*b1])
+    A = np.array([[q1, q3 + q12/2.0], [q3 + q12/2.0, q2]])
+    # print('Matrix A:',  A)
+    # print('Matrix B:', B)
+    # print('Matrix rank of A:', np.linalg.matrix_rank(A))
+    # print('shape of A:', A.shape)
+    # print('shape of B:', B.shape)
+    # print('Matrix [A,B]:', np.c_[A, B])
+    # print('Matrix rank of [A,B]:', np.linalg.matrix_rank(np.c_[A, B]))
+    # print('shape of [A,B]:', C.shape)
+    #
+    # x = np.linalg.solve(A, B)     # works only if A is not singular!!
+    # print("Solution LGS:", x)
+    # # print("sym Matrix", sym.Matrix(([A],[B])))
+    #
+    # # Test
+    # C = np.array([[1, 0], [0, 0]])
+    # d = np.array([5, 0])
+    # y = np.linalg.lstsq(C, d)[0]
+    # print("Solution LGS:", y)
+    # T = np.c_[C, d]
+    # print('T:', T)
+    # Trref = sym.Matrix(T).rref()[0]
+    # Out = np.array(Trref, dtype=float)
+    # print('rref:', Out)
+
+    determinant = q1*q2 - (q3**2 + 2*q3*q12 + q12**2)
+    if print_Cases: print("determinant:", determinant)
+
+    # Define values for axial-Solutions (b1*,0) & (0,b2*)
+    b1_star = (2.0*q1*b1 + b2*q12)/(2*q1)
+    b2_star = (2.0*q2*b2 + b1*q12)/(2*q2)
+
+    # ------------------------------------ Parabolic Case -----------------------------------
+    if abs(determinant) < epsilon:
+        if print_Cases: print('P : parabolic case (determinant equal zero)')
+        print('P : parabolic case (determinant equal zero)')
+        # if print_Cases: print('P : parabolic case (determinant equal zero)')
+
+        # check if B is in range of A
+        # check if rank(A) == rank([A,B])
+        # OK this way? (or use Sympy?)
+        if np.linalg.matrix_rank(A) == np.linalg.matrix_rank(np.c_[A, B]):
+            if print_Cases: print('P1 (B is in the range of A)')
+
+            if (q12+q3)/2.0 <= -1.0*epsilon:
+                print('should not happen(not compatible with det = 0)')
+
+            if (abs(B[0]) < epsilon and abs(B[1]) < epsilon) and (q12+q3)/2.0 >= epsilon:
+                if print_Cases: print('P1.1')
+                a1 = 0.0
+                a2 = 0.0
+                type = 3
+                CaseCount += 1
+
+            if (abs(B[0]) >= epsilon or abs(B[1]) >= epsilon) and (q12+q3)/2.0 >= epsilon:
+                # Continuum of minimizers located along a line of negative slope in Lambda
+                if print_Cases: print('P1.2 (Continuum of minimizers located along a line of negative slope in Lambda) ')
+
+                # Just solve Aa* = b (alternatively using SymPy ?)
+                # we know that A is singular (det A = 0 ) here..
+                # & we know that there are either infinitely many solutions or a unique solution ...
+                # ---- determine one via Least Squares
+                # "If A is square and of full rank, then x (but for round-off error)
+                # is the “exact” solution of the equation. Else, x minimizes the
+                # Euclidean 2-norm || b-Ax ||. If there are multiple minimizing solutions,
+                # the one with the smallest 2-norm  is returned. ""
+
+                # a = np.linalg.lstsq(A, B)[0]                            # TODO check is this Ok ?
+                a = np.linalg.lstsq(A, -B/2)[0]                            # TODO check is this Ok ? (UPDATE 13-10-21)
+                print("Solution LGS: a =", a)
+                a1 = a[0]
+                a2 = a[1]
+
+                type = 2
+                CaseCount += 1
+        else:
+            if print_Cases: print('P2 (B is not in the range of A)')
+            # local Minimizers occur on the boundary of Lambda...
+            # There are at most two local minima and they are either
+            # (b1_star, 0) or (0, b2_star)
+            # could also outsource this to another function..
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) < f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                a1 = b1_star
+                a2 = 0.0
+                type = 3  # 1
+                CaseCount += 1
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) > f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                a1 = 0
+                a2 = b2_star
+                type = 3  # 2
+                CaseCount += 1
+            # TODO Problem: angle depends on how you choose... THE angle is not defined for this case
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) == f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                # Two Minimizers pick one
+                a1 = b1_star
+                a2 = 0.0
+                type = 3  # 4
+                CaseCount += 1
+
+    # ------------------------------------ Elliptic Case -----------------------------------
+    if determinant >= epsilon:
+        if print_Cases: print('E : elliptic case (determinant greater zero)')
+        a1_star = (b1*(q12**2) + 2*b1*q3*q12 - 4*b1*q1*q2 + 4*b2*q2*q3) / \
+            (4*(q3**2) + 4*q3*q12 + (q12**2) - 4*q1*q2)
+        a2_star = (b2*(q12**2) + 2*b2*q3*q12 + 4*b1*q1*q3 - 4*b2*q1*q2) / \
+            (4*(q3**2) + 4*q3*q12 + (q12**2) - 4*q1*q2)
+        prod = a1_star*a2_star
+
+        if prod >= epsilon:
+            if print_Cases: print('(E1) - inside Lambda ')
+            a1 = a1_star
+            a2 = a2_star
+            type = 1  # non-axial Minimizer
+            CaseCount += 1
+        if abs(prod) < epsilon:   # same as prod = 0 ? or better use <=epsilon ?
+            if print_Cases: print('(E2) - on the boundary of Lambda ')
+            a1 = a1_star
+            a2 = a2_star
+            type = 3  # could check which axis: if a1_star or a2_star close to zero.. ?
+            CaseCount += 1
+
+        if prod <= -1.0*epsilon:
+            if print_Cases: print('(E3) - Outside Lambda ')
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) < f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                a1 = b1_star
+                a2 = 0.0
+                type = 3  # 1
+                CaseCount += 1
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) > f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                a1 = 0
+                a2 = b2_star
+                type = 3  # 2
+                CaseCount += 1
+
+            # TODO Problem: angle depends on how you choose... THE angle is not defined for this case
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) == f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                # Two Minimizers pick one
+                a1 = b1_star
+                a2 = 0.0
+                type = 3  # 4
+                CaseCount += 1
+
+    # ------------------------------------ Hyperbolic Case -----------------------------------
+    if determinant <= -1.0*epsilon:
+        if print_Cases: print('H : hyperbolic case (determinant smaller zero)')
+        # One or two minimizers wich are axial
+        type = 3 # (always type 3)
+        if f(b1_star, 0, q1, q2, q3, q12, b1, b2) < f(0, b2_star, q1, q2, q3, q12, b1, b2):
+            a1 = b1_star
+            a2 = 0.0
+            # type = 3  # 1
+            CaseCount += 1
+        if f(b1_star, 0, q1, q2, q3, q12, b1, b2) > f(0, b2_star, q1, q2, q3, q12, b1, b2):
+            a1 = 0
+            a2 = b2_star
+            # type = 3  # 2
+            CaseCount += 1
+        # TODO can add this case to first or second ..
+        if f(b1_star, 0, q1, q2, q3, q12, b1, b2) == f(0, b2_star, q1, q2, q3, q12, b1, b2):
+            # Two Minimizers pick one
+            a1 = b1_star
+            a2 = 0.0
+            # type = 3  # 4
+            CaseCount += 1
+    # ---------------------------------------------------------------------------------------
+
+    if (CaseCount > 1):
+        print('Error: More than one Case happened!')
+
+    # compute a3
+    # a3 = math.sqrt(2.0*a1*a2)   # never needed?
+
+    # print('a1:', a1)
+    # print('a2:', a2)
+
+    # compute the angle <(e,e_1) where Minimizer = kappa* (e (x) e)
+    # e = [math.sqrt((a1/(a1+a2))), math.sqrt((a2/(a1+a2)))]
+    e = [((a1/(a1+a2)))**0.5, ((a2/(a1+a2)))**0.5]
+    angle = math.atan2(e[1], e[0])
+
+    # compute kappa
+    kappa = (a1 + a2)
+
+    # Minimizer G
+    # Minimizer = np.array([[a1, math.sqrt(a1*a2)], [math.sqrt(a1*a2), a2]],dtype=object)
+    Minimizer = np.array([[a1, (a1*a2)**0.5], [(a1*a2)**0.5, a2]],dtype=object)
+    # Minimizer = np.array([[a1, math.sqrt(a1*a2)], [math.sqrt(a1*a2), a2]])
+
+    # MinimizerVec = np.array([a1, a2],dtype=object)
+    MinimizerVec = np.array([a1, a2])
+
+    if print_Output:
+        print('--- Output ClassifyMin ---')
+        print("Minimizing Matrix G:")
+        print(Minimizer)
+        print("angle = ", angle)
+        print("type: ", type)
+        print("kappa = ", kappa)
+
+    return Minimizer, angle, type, kappa
+    # return MinimizerVec, angle, type, kappa    #return Minimizer Vector instead
+# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+
+# ---------------------------------------------- Main ---------------------
+
+# --- Input Parameters ----
+# mu_1 = 1.0
+# rho_1 = 1.0
+# alpha = 9.0
+# beta = 2.0
+# theta = 1.0/8.0
+
+# # define q1, q2 , mu_gamma, q12
+# # 1. read from Cell-Output
+# # 2. define values from analytic formulas (expect for mu_gamma)
+# q1 = (1.0/6.0)*harmonicMean(mu_1, beta, theta)
+# q2 = (1.0/6.0)*arithmeticMean(mu_1, beta, theta)
+# # TEST
+# q12 = 0.0  # (analytical example)
+# # q12 = 12.0  # (analytical example)
+
+# set mu_gamma  to value or read from Cell-Output
+# mu_gamma = q1   # TODO read from Cell-Output
+# b1 = prestrain_b1(rho_1, beta, alpha, theta)
+# b2 = prestrain_b2(rho_1, beta, alpha, theta)
+
+
+# print('---- Input parameters: -----')
+# print('mu_1: ', mu_1)
+# print('rho_1: ', rho_1)
+# print('alpha: ', alpha)
+# print('beta: ', beta)
+# print('theta: ', theta)
+# print("q1: ", q1)
+# print("q2: ", q2)
+# print("mu_gamma: ", mu_gamma)
+# print("q12: ", q12)
+# print("b1: ", b1)
+# print("b2: ", b2)
+# print('----------------------------')
+# # print("machine epsilon", sys.float_info.epsilon)
+#
+#
+# # ------- Options --------
+# print_Cases = True
+# print_Output = True
+
+# G, angle, type, kappa = classifyMin(q1, q2, mu_gamma, q12,  b1, b2, print_Cases, print_Output)
+#
+# G, angle, type, kappa = classifyMin_ana(alpha, beta, theta, mu_gamma, q12, print_Cases, print_Output)
+#
+# Out = classifyMin_ana(alpha, beta, theta, mu_gamma, q12, print_Cases, print_Output)
+
+# print('TEST:')
+# Out = classifyMin_ana(alpha, beta, theta)
+
+# print('Out[0]', Out[0])
+# print('Out[1]', Out[1])
+# print('Out[2]', Out[2])
+# print('Out[3]', Out[3])
+
+
+# #supress certain Outout..
+# _,_,T,_ = classifyMin_ana(alpha, beta, theta, mu_gamma, q12, print_Cases, print_Output)
+# print('Output only type..:', T)
+
+# Test = f(1,2 ,q1,q2,mu_gamma,q12,b1,b2)
+# print("Test", Test)
+
+# -----------------------------------------------------------------------------------------------------------------------------------------------------------------

JNLS_plotScripts/ClassifyMinVec.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+# print(sys.executable)
+# from subprocess import Popen, PIPE
+
+
+# --------------------------------------------------
+# 'classifyMin' classifies Minimizers by utilizing the result of
+# Lemma1.6
+#
+#
+#
+#
+# 'classifyMin_ana': (Special-Case : Lemma1.4)
+# ..additionally assumes Poisson-ratio=0 => q12==0
+#
+#
+#
+# Output : MinimizingMatrix, Angle, Type, Curvature
+def determinant(q1,q2,q3,q12):                                  # TODO General:Matrix
+    return q1*q2 - (q3**2 + 2*q3*q12 + q12**2)
+
+
+
+
+def harmonicMean(mu_1, beta, theta):
+    return mu_1*(beta/(theta+(1-theta)*beta))
+
+
+def arithmeticMean(mu_1, beta, theta):
+    return mu_1*((1-theta)+theta*beta)
+
+
+def prestrain_b1(rho_1, beta, alpha, theta):
+    return (3.0*rho_1/2.0)*(1-(theta*(1+alpha)))
+    # return (3.0*rho_1/2.0)*beta*(1-(theta*(1+alpha)))
+
+
+def prestrain_b2(rho_1, beta, alpha, theta):
+    return (3.0*rho_1/(2.0*((1.0-theta) + theta*beta)))*(1-theta*(1+beta*alpha))
+    # return (3.0*rho_1/(4.0*((1.0-theta) + theta*beta)))*(1-theta*(1+beta*alpha))
+
+
+# Define function to be minimized
+def f(a1, a2, q1, q2, q3, q12, b1, b2):
+    A = np.array([[q1, q3 + q12/2.0], [q3 + q12/2.0, q2]])
+    B = np.array([-2.0*q1*b1-q12*b2, -2.0*q2*b2-q12*b1])
+    a = np.array([a1, a2])
+    tmp = np.dot(A, a)
+    tmp2 = np.dot(a, tmp)
+    tmpB = np.dot(B, a)
+    return tmp2 + tmpB + q1*(b1**2) + q2*(b2**2) + q12*b1*b2
+
+# ---- Alternative Version using alpha,beta,theta ,mu_1,rho_1
+def classifyMin_ana(alpha,beta,theta,q3,mu_1,rho_1,print_Cases=False, print_Output=False):
+
+    # Assumption of Classification-Lemma1.6:
+    #  1. [b3 == 0]
+    #  2. Q is orthotropic i.e. q13 = q31 = q23 = q32 == 0
+    # 3. This additionally assumes that Poisson-Ratio = 0 => q12 == 0
+    q12 = 0.0
+
+    q1 = (1.0/6.0)*harmonicMean(mu_1, beta, theta)
+    q2 = (1.0/6.0)*arithmeticMean(mu_1, beta, theta)
+    # print('q1: ', q1)
+    # print('q2: ', q2)
+    b1 = prestrain_b1(rho_1, beta, alpha,theta)
+    b2 = prestrain_b2(rho_1, beta, alpha,theta)
+    return classifyMin(q1, q2, q3, q12,  b1, b2,  print_Cases, print_Output)
+
+
+
+# Matrix Version that just gets matrices Q & B
+def classifyMin_mat(Q,B,print_Cases=False, print_Output=False):
+    q1 = Q[0][0]
+    q2 = Q[1][1]
+    q3 = Q[2][2]
+    q12 = Q[0][1]
+    b1 = B[0]
+    b2 = B[1]
+    b3 = B[2]
+    return classifyMin(q1, q2, q3, q12,  b1, b2,  print_Cases, print_Output)
+
+
+# --------------------------------------------------------------------
+# Classify Type of minimizer  1 = R1 , 2 = R2 , 3 = R3                          # before : destinction between which axis.. (4Types )
+# where
+# R1 : unique local (global) minimizer which is not axial
+# R2 : continuum of local (global) minimizers which are not axial
+# R3 : one or two local (global) minimizers which are axial
+# Partition given by
+# R1 = E1
+# R2 = P1.2
+# R3 = E2 U E3 U P1.1 U P2 U H
+# -------------------------------------------------------------------
+def classifyMin(q1, q2, q3, q12, b1, b2,  print_Cases=False, print_Output=False):   #ClassifyMin_hom?
+    # Assumption of Classification-Lemma1.6:
+    #  1. [b3 == 0]
+    #  2. Q is orthotropic i.e. q13 = q31 = q23 = q32 == 0
+
+    # TODO: check if Q is orthotropic here - assert()
+
+
+    if print_Output: print("Run ClassifyMin...")
+    CaseCount = 0
+    epsilon = sys.float_info.epsilon #Machine epsilon
+
+    B = np.array([-2.0*q1*b1-q12*b2, -2.0*q2*b2-q12*b1])
+    A = np.array([[q1, q3 + q12/2.0], [q3 + q12/2.0, q2]])
+    # print('Matrix A:',  A)
+    # print('Matrix B:', B)
+    # print('Matrix rank of A:', np.linalg.matrix_rank(A))
+    # print('shape of A:', A.shape)
+    # print('shape of B:', B.shape)
+    # print('Matrix [A,B]:', np.c_[A, B])
+    # print('Matrix rank of [A,B]:', np.linalg.matrix_rank(np.c_[A, B]))
+    # print('shape of [A,B]:', C.shape)
+    #
+    # x = np.linalg.solve(A, B)     # works only if A is not singular!!
+    # print("Solution LGS:", x)
+    # # print("sym Matrix", sym.Matrix(([A],[B])))
+    #
+    # # Test
+    # C = np.array([[1, 0], [0, 0]])
+    # d = np.array([5, 0])
+    # y = np.linalg.lstsq(C, d)[0]
+    # print("Solution LGS:", y)
+    # T = np.c_[C, d]
+    # print('T:', T)
+    # Trref = sym.Matrix(T).rref()[0]
+    # Out = np.array(Trref, dtype=float)
+    # print('rref:', Out)
+
+    determinant = q1*q2 - (q3**2 + 2*q3*q12 + q12**2)
+    if print_Cases: print("determinant:", determinant)
+
+    # Define values for axial-Solutions (b1*,0) & (0,b2*)
+    b1_star = (2.0*q1*b1 + b2*q12)/(2*q1)
+    b2_star = (2.0*q2*b2 + b1*q12)/(2*q2)
+
+    # ------------------------------------ Parabolic Case -----------------------------------
+    if abs(determinant) < epsilon:
+        if print_Cases: print('P : parabolic case (determinant equal zero)')
+        # if print_Cases: print('P : parabolic case (determinant equal zero)')
+
+        # check if B is in range of A
+        # check if rank(A) == rank([A,B])
+        # OK this way? (or use Sympy?)
+        if np.linalg.matrix_rank(A) == np.linalg.matrix_rank(np.c_[A, B]):
+            if print_Cases: print('P1 (B is in the range of A)')
+
+            if (q12+q3)/2.0 <= -1.0*epsilon:
+                print('should not happen(not compatible with det = 0)')
+
+            if (abs(B[0]) < epsilon and abs(B[1]) < epsilon) and (q12+q3)/2.0 >= epsilon:
+                if print_Cases: print('P1.1')
+                a1 = 0.0
+                a2 = 0.0
+                type = 3
+                CaseCount += 1
+
+            if (abs(B[0]) >= epsilon or abs(B[1]) >= epsilon) and (q12+q3)/2.0 >= epsilon:
+                # Continuum of minimizers located along a line of negative slope in Lambda
+                if print_Cases: print('P1.2 (Continuum of minimizers located along a line of negative slope in Lambda) ')
+
+                # Just solve Aa* = b (alternatively using SymPy ?)
+                # we know that A is singular (det A = 0 ) here..
+                # & we know that there are either infinitely many solutions or a unique solution ...
+                # ---- determine one via Least Squares
+                # "If A is square and of full rank, then x (but for round-off error)
+                # is the “exact” solution of the equation. Else, x minimizes the
+                # Euclidean 2-norm || b-Ax ||. If there are multiple minimizing solutions,
+                # the one with the smallest 2-norm  is returned. ""
+                a = np.linalg.lstsq(A, B)[0]                            # TODO check is this Ok ?
+                print("Solution LGS: a =", a)
+                a1 = a[0]
+                a2 = a[1]
+
+                type = 2
+                CaseCount += 1
+        else:
+            if print_Cases: print('P2 (B is not in the range of A)')
+            # local Minimizers occur on the boundary of Lambda...
+            # There are at most two local minima and they are either
+            # (b1_star, 0) or (0, b2_star)
+            # could also outsource this to another function..
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) < f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                a1 = b1_star
+                a2 = 0.0
+                type = 3  # 1
+                CaseCount += 1
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) > f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                a1 = 0
+                a2 = b2_star
+                type = 3  # 2
+                CaseCount += 1
+            # TODO Problem: angle depends on how you choose... THE angle is not defined for this case
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) == f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                # Two Minimizers pick one
+                a1 = b1_star
+                a2 = 0.0
+                type = 3  # 4
+                CaseCount += 1
+
+    # ------------------------------------ Elliptic Case -----------------------------------
+    if determinant >= epsilon:
+        if print_Cases: print('E : elliptic case (determinant greater zero)')
+        a1_star = -(2*(b1*(q12**2) + 2*b1*q3*q12 - 4*b1*q1*q2 + 4*b2*q2*q3)) / \
+            (4*(q3**2) + 4*q3*q12 + (q12**2) - 4*q1*q2)
+        a2_star = -(2*(b2*(q12**2) + 2*b2*q3*q12 + 4*b1*q1*q3 - 4*b2*q1*q2)) / \
+            (4*(q3**2) + 4*q3*q12 + (q12**2) - 4*q1*q2)
+        prod = a1_star*a2_star
+
+        if prod >= epsilon:
+            if print_Cases: print('(E1) - inside Lambda ')
+            a1 = a1_star
+            a2 = a2_star
+            type = 1  # non-axial Minimizer
+            CaseCount += 1
+        if abs(prod) < epsilon:   # same as prod = 0 ? or better use <=epsilon ?
+            if print_Cases: print('(E2) - on the boundary of Lambda ')
+            a1 = a1_star
+            a2 = a2_star
+            type = 3  # could check which axis: if a1_star or a2_star close to zero.. ?
+            CaseCount += 1
+
+        if prod <= -1.0*epsilon:
+            if print_Cases: print('(E3) - Outside Lambda ')
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) < f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                a1 = b1_star
+                a2 = 0.0
+                type = 3  # 1
+                CaseCount += 1
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) > f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                a1 = 0
+                a2 = b2_star
+                type = 3  # 2
+                CaseCount += 1
+
+            # TODO Problem: angle depends on how you choose... THE angle is not defined for this case
+            if f(b1_star, 0, q1, q2, q3, q12, b1, b2) == f(0, b2_star, q1, q2, q3, q12, b1, b2):
+                # Two Minimizers pick one
+                a1 = b1_star
+                a2 = 0.0
+                type = 3  # 4
+                CaseCount += 1
+
+    # ------------------------------------ Hyperbolic Case -----------------------------------
+    if determinant <= -1.0*epsilon:
+        if print_Cases: print('H : hyperbolic case (determinant smaller zero)')
+        # One or two minimizers wich are axial
+        type = 3 # (always type 3)
+        if f(b1_star, 0, q1, q2, q3, q12, b1, b2) < f(0, b2_star, q1, q2, q3, q12, b1, b2):
+            a1 = b1_star
+            a2 = 0.0
+            # type = 3  # 1
+            CaseCount += 1
+        if f(b1_star, 0, q1, q2, q3, q12, b1, b2) > f(0, b2_star, q1, q2, q3, q12, b1, b2):
+            a1 = 0
+            a2 = b2_star
+            # type = 3  # 2
+            CaseCount += 1
+        # TODO can add this case to first or second ..
+        if f(b1_star, 0, q1, q2, q3, q12, b1, b2) == f(0, b2_star, q1, q2, q3, q12, b1, b2):
+            # Two Minimizers pick one
+            a1 = b1_star
+            a2 = 0.0
+            # type = 3  # 4
+            CaseCount += 1
+    # ---------------------------------------------------------------------------------------
+
+    if (CaseCount > 1):
+        print('Error: More than one Case happened!')
+
+    # compute a3
+    # a3 = math.sqrt(2.0*a1*a2)   # never needed?
+
+    # compute the angle <(e,e_1) where Minimizer = kappa* (e (x) e)
+    e = [math.sqrt((a1/(a1+a2))), math.sqrt((a2/(a1+a2)))]
+    angle = math.atan2(e[1], e[0])
+
+    # compute kappa
+    kappa = (a1 + a2)
+
+    # Minimizer G
+    Minimizer = np.array([[a1, math.sqrt(a1*a2)], [math.sqrt(a1*a2), a2]],dtype=object)
+
+    MinimizerVec = np.array([a1, a2],dtype=object)
+    # Minimizer = np.array([[a1, math.sqrt(a1*a2)], [math.sqrt(a1*a2), a2]])
+
+    if print_Output:
+        print('--- Output ClassifyMin ---')
+        print("Minimizing Matrix G:")
+        print(Minimizer)
+        print("angle = ", angle)
+        print("type: ", type)
+        print("kappa = ", kappa)
+
+    return MinimizerVec, angle, type, kappa
+# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+
+# ---------------------------------------------- Main ---------------------
+
+# --- Input Parameters ----
+# mu_1 = 1.0
+# rho_1 = 1.0
+# alpha = 9.0
+# beta = 2.0
+# theta = 1.0/8.0
+
+# # define q1, q2 , mu_gamma, q12
+# # 1. read from Cell-Output
+# # 2. define values from analytic formulas (expect for mu_gamma)
+# q1 = (1.0/6.0)*harmonicMean(mu_1, beta, theta)
+# q2 = (1.0/6.0)*arithmeticMean(mu_1, beta, theta)
+# # TEST
+# q12 = 0.0  # (analytical example)
+# # q12 = 12.0  # (analytical example)
+
+# set mu_gamma  to value or read from Cell-Output
+# mu_gamma = q1   # TODO read from Cell-Output
+# b1 = prestrain_b1(rho_1, beta, alpha, theta)
+# b2 = prestrain_b2(rho_1, beta, alpha, theta)
+
+
+# print('---- Input parameters: -----')
+# print('mu_1: ', mu_1)
+# print('rho_1: ', rho_1)
+# print('alpha: ', alpha)
+# print('beta: ', beta)
+# print('theta: ', theta)
+# print("q1: ", q1)
+# print("q2: ", q2)
+# print("mu_gamma: ", mu_gamma)
+# print("q12: ", q12)
+# print("b1: ", b1)
+# print("b2: ", b2)
+# print('----------------------------')
+# # print("machine epsilon", sys.float_info.epsilon)
+#
+#
+# # ------- Options --------
+# print_Cases = True
+# print_Output = True
+
+# G, angle, type, kappa = classifyMin(q1, q2, mu_gamma, q12,  b1, b2, print_Cases, print_Output)
+#
+# G, angle, type, kappa = classifyMin_ana(alpha, beta, theta, mu_gamma, q12, print_Cases, print_Output)
+#
+# Out = classifyMin_ana(alpha, beta, theta, mu_gamma, q12, print_Cases, print_Output)
+
+# print('TEST:')
+# Out = classifyMin_ana(alpha, beta, theta)
+
+# print('Out[0]', Out[0])
+# print('Out[1]', Out[1])
+# print('Out[2]', Out[2])
+# print('Out[3]', Out[3])
+
+
+# #supress certain Outout..
+# _,_,T,_ = classifyMin_ana(alpha, beta, theta, mu_gamma, q12, print_Cases, print_Output)
+# print('Output only type..:', T)
+
+# Test = f(1,2 ,q1,q2,mu_gamma,q12,b1,b2)
+# print("Test", Test)
+
+# -----------------------------------------------------------------------------------------------------------------------------------------------------------------

JNLS_plotScripts/ClassifyMin_New.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+# print(sys.executable)
+# from subprocess import Popen, PIPE
+
+
+# --------------------------------------------------
+# 'classifyMin' classifies Minimizers by utilizing the result of
+# Lemma1.6
+#
+#
+#
+#
+# 'classifyMin_ana': (Special-Case : Lemma1.4)
+# ..additionally assumes Poisson-ratio=0 => q12==0
+#
+#
+#
+# Output : MinimizingMatrix, Angle, Type, Curvature
+
+
+
+def get_gstar(q1,q2,q12,q3,b1,b2):
+
+    # a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,q12/2], [q12/2,q2] ])
+    # print('det(H)=', np.linalg.det(H))
+    # check if g* is in G^*_R^2
+    tmp = A.dot(b)
+    ## compute inverse of H :
+    inv_H = np.linalg.inv(H)
+    g_star = 2*inv_H.dot(tmp)
+    # print('g_star=', g_star)
+
+    return g_star
+
+
+def determine_b(q1,q2,q12,q3,g_star):
+    ##
+    # Input: g_star
+    # Output : b  such that g_star is minimizer, i.e A*b = (1/2)*H*g_star
+    # q1=1;
+    # q2=2;
+    # q12=1/2;
+    # q3=((4*q1*q2)**0.5-q12)/2;
+    # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    abar = np.array([q12+2*q3, 2*q2])
+    rhs = (1/2)*H.dot(g_star)
+    print('rhs:', rhs)
+    b = np.linalg.lstsq(A, rhs)[0]
+    print('b',b)
+    b1=b[0]
+    b2=b[1]
+
+    return b
+    ## ---------------
+
+
+def get_minimizer(q1,q2,q3,b1,b2):
+
+    # In the case if q12 == 0:
+    quotient = (q1*q2-q3**2)
+    g_star = np.array([(q1*q2*b1-q3*q2*b2)/quotient, (q1*q2*b2-q3*q1*b1)/quotient])
+    print('g_star=', g_star)
+    return g_star
+
+
+def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+
+
+    a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+
+
+    tmp = H.dot(a)
+
+    # print('H',H)
+    # print('A',A)
+    # print('b',b)
+    # print('a',a)
+    # print('tmp',tmp)
+
+    tmp = (1/2)*a.dot(tmp)
+    # print('tmp',tmp)
+
+    tmp2 = A.dot(b)
+    # print('tmp2',tmp2)
+    tmp2 = 2*a.dot(tmp2)
+
+    # print('tmp2',tmp2)
+    energy = tmp - tmp2
+    # print('energy',energy)
+
+
+    # energy_axial1.append(energy_1)
+
+    return energy
+
+
+
+
+
+
+
+
+def determinant(q1,q2,q3,q12):                                  # TODO General:Matrix
+    return q1*q2 - (q3**2 + 2*q3*q12 + q12**2)
+
+
+
+
+def harmonicMean(mu_1, beta, theta):
+    return mu_1*(beta/(theta+((1-theta)*beta)))
+
+
+def arithmeticMean(mu_1, beta, theta):
+    return mu_1*((1-theta)+theta*beta)
+
+
+def prestrain_b1(rho_1, beta, alpha, theta):
+    return (3.0*rho_1/2.0)*(1-(theta*(1+alpha)))
+    # return (3.0*rho_1/2.0)*beta*(1-(theta*(1+alpha)))
+
+
+def prestrain_b2(rho_1, beta, alpha, theta):
+    return (3.0*rho_1/(2.0*((1.0-theta) + theta*beta)))*(1-theta*(1+beta*alpha))
+    # return (3.0*rho_1/(4.0*((1.0-theta) + theta*beta)))*(1-theta*(1+beta*alpha))
+
+
+# Define function to be minimized
+def f(a1, a2, q1, q2, q3, q12, b1, b2):
+    A = np.array([[q1, q3 + q12/2.0], [q3 + q12/2.0, q2]])
+    B = np.array([-2.0*q1*b1-q12*b2, -2.0*q2*b2-q12*b1])
+    a = np.array([a1, a2])
+    tmp = np.dot(A, a)
+    tmp2 = np.dot(a, tmp)
+    tmpB = np.dot(B, a)
+    return tmp2 + tmpB + q1*(b1**2) + q2*(b2**2) + q12*b1*b2
+
+# ---- Alternative Version using alpha,beta,theta ,mu_1,rho_1
+def classifyMin_ana(alpha,beta,theta,q3,mu_1,rho_1,print_Cases=False, print_Output=False):
+
+    # Assumption of Classification-Lemma1.6:
+    #  1. [b3 == 0]
+    #  2. Q is orthotropic i.e. q13 = q31 = q23 = q32 == 0
+    # 3. This additionally assumes that Poisson-Ratio = 0 => q12 == 0
+    q12 = 0.0
+
+    q1 = (1.0/6.0)*harmonicMean(mu_1, beta, theta)
+    q2 = (1.0/6.0)*arithmeticMean(mu_1, beta, theta)
+    # print('q1: ', q1)
+    # print('q2: ', q2)
+    b1 = prestrain_b1(rho_1, beta, alpha,theta)
+    b2 = prestrain_b2(rho_1, beta, alpha,theta)
+
+    # print('alpha:',alpha)
+    # print('beta:',beta)
+    # print('theta:',theta)
+
+    return classifyMin(q1, q2, q3, q12,  b1, b2,  print_Cases, print_Output)
+
+
+
+# Matrix Version that just gets matrices Q & B
+def classifyMin_mat(Q,B,print_Cases=False, print_Output=False):
+    q1 = Q[0][0]
+    q2 = Q[1][1]
+    q3 = Q[2][2]
+    q12 = Q[0][1]
+    b1 = B[0]
+    b2 = B[1]
+    b3 = B[2]
+    return classifyMin(q1, q2, q3, q12,  b1, b2,  print_Cases, print_Output)
+
+
+# --------------------------------------------------------------------
+# Classify Type of minimizer  1 = R1 , 2 = R2 , 3 = R3                          # before : destinction between which axis.. (4Types )
+# where
+# R1 : unique local (global) minimizer which is not axial
+# R2 : continuum of local (global) minimizers which are not axial
+# R3 : one or two local (global) minimizers which are axial
+# Partition given by
+# R1 = E1
+# R2 = P1.2
+# R3 = E2 U E3 U P1.1 U P2 U H
+# -------------------------------------------------------------------
+def classifyMin(q1, q2, q3, q12, b1, b2,  print_Cases=False, print_Output=False):   #ClassifyMin_hom?
+    # Assumption of Classification-Lemma1.6:
+    #  1. [b3 == 0]
+    #  2. Q is orthotropic i.e. q13 = q31 = q23 = q32 == 0
+
+    # TODO: check if Q is orthotropic here - assert()
+
+
+    if print_Output: print("Run ClassifyMin_NEW...")
+    CaseCount = 0
+    epsilon = sys.float_info.epsilon #Machine epsilon
+    # print('epsilon:',epsilon)
+
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,q12/2], [q12/2,q2] ])
+
+    # B = np.array([-2.0*q1*b1-q12*b2, -2.0*q2*b2-q12*b1])
+    # A = np.array([[q1, q3 + q12/2.0], [q3 + q12/2.0, q2]])
+
+    determinant = np.linalg.det(H)
+    # print('determinant:',determinant)
+    # determinant = q1*q2 - (q3**2 + 2*q3*q12 + q12**2)
+    if print_Cases: print("determinant:", determinant)
+
+    # Define values for axial-Solutions (b1*,0) & (0,b2*)
+    # b1_star = (2.0*q1*b1 + b2*q12)/(2*q1)
+    # b2_star = (2.0*q2*b2 + b1*q12)/(2*q2)
+
+    # ------------------------------------ Parabolic Case -----------------------------------
+    # if abs(determinant) < epsilon:
+    if abs(determinant) < epsilon:
+        if print_Cases: print('P : parabolic case (determinant equal zero)')
+        print('P : PARABOLIC CASE (determinant equal zero)')
+
+    # ------------------------------------ Elliptic Case -----------------------------------
+    if determinant >= epsilon:
+        if print_Cases: print('E : elliptic case (determinant greater zero)')
+
+        g_star = get_gstar(q1,q2,q12,q3,b1,b2)
+
+        # a1_star = (b1*(q12**2) + 2*b1*q3*q12 - 4*b1*q1*q2 + 4*b2*q2*q3) / \
+        #     (4*(q3**2) + 4*q3*q12 + (q12**2) - 4*q1*q2)
+        # a2_star = (b2*(q12**2) + 2*b2*q3*q12 + 4*b1*q1*q3 - 4*b2*q1*q2) / \
+        #     (4*(q3**2) + 4*q3*q12 + (q12**2) - 4*q1*q2)
+        # prod = a1_star*a2_star
+
+        prod = g_star[0]*g_star[1]
+
+        if prod >= epsilon:
+            if print_Cases: print('(E1) - inside Lambda ')
+            # a1 = a1_star
+            # a2 = a2_star
+            # type = 1  # non-axial Minimizer
+            # CaseCount += 1
+            a1 = g_star[0]
+            a2 = g_star[1]
+            CaseCount += 1
+        if prod < epsilon:   # same as prod = 0 ? or better use <=epsilon ?
+            if abs(((b2**2)/q1 - (b1**2)/q2)) < epsilon :
+                print('((b2**2)/q1 - (b1**2)/q2)', ((b2**2)/q1 - (b1**2)/q2))
+                print('two minimizers')
+                a1 = b1
+                a2 = 0.0
+                # type = 3  # 1
+                CaseCount += 1
+            else:
+                #compare energy values
+                if energy(b1, 0, q1, q2, q3, q12, b1, b2) > energy(0, b2, q1, q2, q3, q12, b1, b2):
+                    a1 = 0
+                    a2 = b2
+                    CaseCount += 1
+                else :
+                    a1 = b1
+                    a2 = 0
+                    CaseCount += 1
+    else :
+        # g_star = get_gstar(q1,q2,q12,q3,b1,b2)
+        # prod = g_star[0]*g_star[1]
+
+        if abs((b2**2)/q1 - (b1**2)/q2) < epsilon :
+            print('two minimizers')
+            a1 = b1
+            a2 = 0.0
+            # type = 3  # 1
+            CaseCount += 1
+        else:
+            #compare energy values
+            if energy(b1, 0, q1, q2, q3, q12, b1, b2) > energy(0, b2, q1, q2, q3, q12, b1, b2):
+                a1 = 0
+                a2 = b2
+                CaseCount += 1
+            else :
+                a1 = b1
+                a2 = 0
+                CaseCount += 1
+
+        #
+        #     if print_Cases: print('(E2) - on the boundary of Lambda ')
+        #     a1 = a1_star
+        #     a2 = a2_star
+        #     type = 3  # could check which axis: if a1_star or a2_star close to zero.. ?
+        #     CaseCount += 1
+        #
+        # if prod <= -1.0*epsilon:
+        #     if print_Cases: print('(E3) - Outside Lambda ')
+        #     if f(b1_star, 0, q1, q2, q3, q12, b1, b2) < f(0, b2_star, q1, q2, q3, q12, b1, b2):
+        #         a1 = b1_star
+        #         a2 = 0.0
+        #         type = 3  # 1
+        #         CaseCount += 1
+        #     if f(b1_star, 0, q1, q2, q3, q12, b1, b2) > f(0, b2_star, q1, q2, q3, q12, b1, b2):
+        #         a1 = 0
+        #         a2 = b2_star
+        #         type = 3  # 2
+        #         CaseCount += 1
+        #
+        #     # TODO Problem: angle depends on how you choose... THE angle is not defined for this case
+        #     if f(b1_star, 0, q1, q2, q3, q12, b1, b2) == f(0, b2_star, q1, q2, q3, q12, b1, b2):
+        #         # Two Minimizers pick one
+        #         a1 = b1_star
+        #         a2 = 0.0
+        #         type = 3  # 4
+        #         CaseCount += 1
+
+    # ------------------------------------ Hyperbolic Case -----------------------------------
+    # if determinant <= -1.0*epsilon:
+    #     if print_Cases: print('H : hyperbolic case (determinant smaller zero)')
+    #     # One or two minimizers wich are axial
+    #     type = 3 # (always type 3)
+    #     if f(b1_star, 0, q1, q2, q3, q12, b1, b2) < f(0, b2_star, q1, q2, q3, q12, b1, b2):
+    #         a1 = b1_star
+    #         a2 = 0.0
+    #         # type = 3  # 1
+    #         CaseCount += 1
+    #     if f(b1_star, 0, q1, q2, q3, q12, b1, b2) > f(0, b2_star, q1, q2, q3, q12, b1, b2):
+    #         a1 = 0
+    #         a2 = b2_star
+    #         # type = 3  # 2
+    #         CaseCount += 1
+    #     # TODO can add this case to first or second ..
+    #     if f(b1_star, 0, q1, q2, q3, q12, b1, b2) == f(0, b2_star, q1, q2, q3, q12, b1, b2):
+    #         # Two Minimizers pick one
+    #         a1 = b1_star
+    #         a2 = 0.0
+    #         # type = 3  # 4
+    #         CaseCount += 1
+    # ---------------------------------------------------------------------------------------
+
+    if (CaseCount > 1):
+        print('Error: More than one Case happened!')
+
+    # compute a3
+    # a3 = math.sqrt(2.0*a1*a2)   # never needed?
+
+    # print('a1:', a1)
+    # print('a2:', a2)
+
+    # compute the angle <(e,e_1) where Minimizer = kappa* (e (x) e)
+    # e = [math.sqrt((a1/(a1+a2))), math.sqrt((a2/(a1+a2)))]
+    e = [((a1/(a1+a2)))**0.5, ((a2/(a1+a2)))**0.5]
+    angle = math.atan2(e[1], e[0])
+
+    type = 1 # ToDO..
+
+    # compute kappa
+    kappa = (a1 + a2)
+
+    # Minimizer G
+    # Minimizer = np.array([[a1, math.sqrt(a1*a2)], [math.sqrt(a1*a2), a2]],dtype=object)
+    Minimizer = np.array([[a1, (a1*a2)**0.5], [(a1*a2)**0.5, a2]],dtype=object)
+    # Minimizer = np.array([[a1, math.sqrt(a1*a2)], [math.sqrt(a1*a2), a2]])
+
+    # MinimizerVec = np.array([a1, a2],dtype=object)
+    MinimizerVec = np.array([a1, a2])
+
+    if print_Output:
+        print('--- Output ClassifyMin ---')
+        print("Minimizing Matrix G:")
+        print(Minimizer)
+        print("angle = ", angle)
+        print("type: ", type)
+        print("kappa = ", kappa)
+
+    return Minimizer, angle, type, kappa
+    # return MinimizerVec, angle, type, kappa    #return Minimizer Vector instead
+# ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+
+# ---------------------------------------------- Main ---------------------
+
+# --- Input Parameters ----
+# mu_1 = 1.0
+# rho_1 = 1.0
+# alpha = 9.0
+# beta = 2.0
+# theta = 1.0/8.0
+
+# # define q1, q2 , mu_gamma, q12
+# # 1. read from Cell-Output
+# # 2. define values from analytic formulas (expect for mu_gamma)
+# q1 = (1.0/6.0)*harmonicMean(mu_1, beta, theta)
+# q2 = (1.0/6.0)*arithmeticMean(mu_1, beta, theta)
+# # TEST
+# q12 = 0.0  # (analytical example)
+# # q12 = 12.0  # (analytical example)
+
+# set mu_gamma  to value or read from Cell-Output
+# mu_gamma = q1   # TODO read from Cell-Output
+# b1 = prestrain_b1(rho_1, beta, alpha, theta)
+# b2 = prestrain_b2(rho_1, beta, alpha, theta)
+
+
+# print('---- Input parameters: -----')
+# print('mu_1: ', mu_1)
+# print('rho_1: ', rho_1)
+# print('alpha: ', alpha)
+# print('beta: ', beta)
+# print('theta: ', theta)
+# print("q1: ", q1)
+# print("q2: ", q2)
+# print("mu_gamma: ", mu_gamma)
+# print("q12: ", q12)
+# print("b1: ", b1)
+# print("b2: ", b2)
+# print('----------------------------')
+# # print("machine epsilon", sys.float_info.epsilon)
+#
+#
+# # ------- Options --------
+# print_Cases = True
+# print_Output = True
+
+# G, angle, type, kappa = classifyMin(q1, q2, mu_gamma, q12,  b1, b2, print_Cases, print_Output)
+#
+# G, angle, type, kappa = classifyMin_ana(alpha, beta, theta, mu_gamma, q12, print_Cases, print_Output)
+#
+# Out = classifyMin_ana(alpha, beta, theta, mu_gamma, q12, print_Cases, print_Output)
+
+# print('TEST:')
+# Out = classifyMin_ana(alpha, beta, theta)
+
+# print('Out[0]', Out[0])
+# print('Out[1]', Out[1])
+# print('Out[2]', Out[2])
+# print('Out[3]', Out[3])
+
+
+# #supress certain Outout..
+# _,_,T,_ = classifyMin_ana(alpha, beta, theta, mu_gamma, q12, print_Cases, print_Output)
+# print('Output only type..:', T)
+
+# Test = f(1,2 ,q1,q2,mu_gamma,q12,b1,b2)
+# print("Test", Test)
+
+# -----------------------------------------------------------------------------------------------------------------------------------------------------------------

JNLS_plotScripts/CylindricalMinimizer-Plot.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import matplotlib.ticker as tickers
+import matplotlib as mpl
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+from mpl_toolkits.mplot3d import Axes3D
+import pandas as pd
+import matplotlib.colors as mcolors
+from matplotlib import cm
+
+from mpl_toolkits.mplot3d.proj3d import proj_transform
+# from mpl_toolkits.mplot3d.axes3d import Axes3D
+from matplotlib.text import Annotation
+from matplotlib.patches import FancyArrowPatch
+
+# Extra packages :
+# from HelperFunctions import *
+# from ClassifyMin import *
+# from subprocess import Popen, PIPE
+#import sys
+
+###################### Documentation #########################
+
+#..... add description here
+
+###########################################################
+
+
+def rot(v,alpha):
+
+#rotate about axis v with degree deg in radians:
+
+
+    tmp = np.array([ [v[0]**2*(1-np.cos(alpha))+np.cos(alpha), v[0]*v[1]*(1-np.cos(alpha))-v[2]*np.sin(alpha), v[0]*v[2]*(1-np.cos(alpha))+ v[1]*np.sin(alpha) ],
+         [v[0]*v[1]*(1-np.cos(alpha))+v[2]*np.sin(alpha), v[1]**2*(1-np.cos(alpha))+np.cos(alpha), v[1]*v[2]*(1-np.cos(alpha))+v[0]*np.sin(alpha) ],
+         [v[2]*v[0]*(1-np.cos(alpha))-v[1]*np.sin(alpha), v[2]*v[1]*(1-np.cos(alpha))+v[0]*np.sin(alpha) , v[2]**2*(1-np.cos(alpha))+np.cos(alpha) ] ])
+
+    return tmp
+
+
+
+def rotate_data(X, R):
+#rotate about axis v with degree deg in radians:
+# X : DataSet
+# R : RotationMatrix
+    print('ROTATE DATA FUNCTION ---------------')
+
+    rot_matrix = R
+    # print('rot_matrix:', rot_matrix)
+    # print('rot_matrix.shape:', rot_matrix.shape)
+    # print('X', X)
+    # print('shape of X[0]', X.shape[0])
+    B = np.dot(rot_matrix, X.reshape(rot_matrix.shape[1],-1))
+    # print('shape of B', B.shape)
+    # print('B',B)
+    # print('B[0,:]', B[0,:])
+    # print('B[0,:].shape', B[0,:].shape)
+    Out = np.array([B[0,:].reshape(X.shape[1],X.shape[2]), B[1,:].reshape(X.shape[1],X.shape[2]), B[2,:].reshape(X.shape[1],X.shape[2])])
+    print('shape of Out', Out.shape)
+
+    return Out
+
+# def rotate_data(X, v,alpha): #(Old Version)
+# #rotate about axis v with degree deg in radians:
+# # X : DataSet
+#     print('ROTATE DATA FUNCTION ---------------')
+#     # v = np.array([1,0,0])
+#     # rotM = rot(v,np.pi/2)
+#     # print('rotM:', rotM)
+#     rot_matrix = rot(v,alpha)
+#     # print('rot_matrix:', rot_matrix)
+#     # print('rot_matrix.shape:', rot_matrix.shape)
+#
+#     # print('X', X)
+#     # print('shape of X[0]', X.shape[0])
+#     B = np.dot(rot_matrix, X.reshape(rot_matrix.shape[1],-1))
+#
+#     # print('shape of B', B.shape)
+#     # print('B',B)
+#     # print('B[0,:]', B[0,:])
+#     # print('B[0,:].shape', B[0,:].shape)
+#     Out = np.array([B[0,:].reshape(X.shape[1],X.shape[2]), B[1,:].reshape(X.shape[1],X.shape[2]), B[2,:].reshape(X.shape[1],X.shape[2])])
+#     print('shape of Out', Out.shape)
+#
+#     return Out
+
+
+# def translate_data(X, v):  ...
+# #rotate about axis v with degree deg in radians:
+# # X : DataSet
+#     print('ROTATE DATA FUNCTION ---------------')
+#     # v = np.array([1,0,0])
+#     # rotM = rot(v,np.pi/2)
+#     # print('rotM:', rotM)
+#
+#     print('X', X)
+#     print('shape of X[0]', X.shape[0])
+#
+#     Out = X + v
+#     return Out
+
+
+def u(x,kappa,e):
+
+    tmp = (x.dot(e))*kappa
+    # print('tmp for u',tmp)
+    if kappa == 0 :
+        tmp = np.array([0*x[0],  x[0]*e[0] + x[1]*e[1], x[1]*e[0] - x[0]*e[1] ])
+    else :
+        tmp = np.array([-(1/kappa)*np.cos(tmp)+(1/kappa),  (1/kappa)*np.sin(tmp), -x[0]*e[1]+x[1]*e[0] ])
+    return tmp
+
+
+
+
+def grad_u(x,kappa,e):
+
+    tmp = (x.dot(e))*kappa
+    # print('tmp',tmp)
+
+    grad_u = np.array([ [np.sin(tmp)*e[0], np.sin(tmp)*e[1]], [np.cos(tmp)*e[0], np.cos(tmp)*e[1]], [-e[1], e[0]] ])
+    # print('produkt', grad_u.dot(e) )
+    mapped_e = grad_u.dot(e)
+    # print('mapped_e:', mapped_e)
+    # print('siize of mapped_e', mapped_e.shape)
+    # mapped_e = mapped_e.transpose()
+    # print('mapped_e:', mapped_e)
+    # print('siize of mapped_e', mapped_e.shape)
+    return mapped_e
+
+def compute_normal(x,kappa,e):
+    tmp = (x.dot(e))*kappa
+    partial1_u = np.array([ np.sin(tmp)*e[0] ,np.cos(tmp)*e[0], -e[1] ])
+    partial2_u = np.array([ np.sin(tmp)*e[1], np.cos(tmp)*e[1], e[0]      ])
+    normal = np.cross(partial1_u,partial2_u)
+    # print('normal=',normal)
+    return normal
+
+
+
+class Annotation3D(Annotation):
+    def __init__(self, text, xyz, *args, **kwargs):
+        super().__init__(text, xy=(0, 0), *args, **kwargs)
+        self._xyz = xyz
+
+    def draw(self, renderer):
+        x2, y2, z2 = proj_transform(*self._xyz, self.axes.M)
+        self.xy = (x2, y2)
+        super().draw(renderer)
+
+def _annotate3D(ax, text, xyz, *args, **kwargs):
+    '''Add anotation `text` to an `Axes3d` instance.'''
+
+    annotation = Annotation3D(text, xyz, *args, **kwargs)
+    ax.add_artist(annotation)
+
+setattr(Axes3D, 'annotate3D', _annotate3D)
+
+class Arrow3D(FancyArrowPatch):
+
+    def __init__(self, x, y, z, dx, dy, dz, *args, **kwargs):
+        super().__init__((0, 0), (0, 0), *args, **kwargs)
+        self._xyz = (x, y, z)
+        self._dxdydz = (dx, dy, dz)
+
+    def draw(self, renderer):
+        x1, y1, z1 = self._xyz
+        dx, dy, dz = self._dxdydz
+        x2, y2, z2 = (x1 + dx, y1 + dy, z1 + dz)
+
+        xs, ys, zs = proj_transform((x1, x2), (y1, y2), (z1, z2), self.axes.M)
+        self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
+        super().draw(renderer)
+
+
+def _arrow3D(ax, x, y, z, dx, dy, dz, *args, **kwargs):
+    '''Add an 3d arrow to an `Axes3D` instance.'''
+
+    arrow = Arrow3D(x, y, z, dx, dy, dz, *args, **kwargs)
+    ax.add_artist(arrow)
+
+setattr(Axes3D, 'arrow3D', _arrow3D)
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+
+############################################################################################################################################
+####################################################################### KAPPA NEGATIVE ####################################################
+############################################################################################################################################
+kappa = -2
+num_Points = 200
+num_Points = 100
+
+
+e = np.array([1,0])
+# e = np.array([0,1])
+e = np.array([1/np.sqrt(2),1/np.sqrt(2)])
+# e = np.array([1/2,np.sqrt(3)/2])
+# e = np.array([np.sqrt(3)/2,1/2])
+# e = np.array([-1,0])
+# e = np.array([0,-1])
+
+# Creating dataset
+# x = np.linspace(-1.5,1.5,num_Points)
+x = np.linspace(-1,1,num_Points)
+y = np.linspace(-1/2,1/2,num_Points)
+
+print('type of x', type(x))
+print('max of x:', max(x))
+print('max of y:', max(y))
+# print('x:', x)
+
+x1, x2 = np.meshgrid(x,y)
+zero = 0*x1
+
+if kappa == 0 :
+    u1 = 0*x1
+    u2 = x1*e[0] + x2*e[1]
+    u3 = x2*e[0] - x1*e[1]
+
+else :
+    u1 = -(1/kappa)*np.cos(kappa*(x1*e[0]+x2*e[1])) + (1/kappa)
+    u2 = (1/kappa)*np.sin(kappa*(x1*e[0]+x2*e[1]))
+    u3 = x2*e[0] -x1*e[1]
+
+# print('np.size(u1)',np.size(u1))
+# print('u1.shape',u1.shape)
+# colorfunction=(u1**2+u2**2)
+# print('colofunction',colorfunction)
+
+# print('u1.size:',np.size(u1))
+# tmp = np.ones(np.size(u1))*kappa
+# print('np.size(tmp)',np.size(tmp))
+B = np.full_like(u1, 1)
+# colorfunction=(u3)                                              # TODO Color by angle
+# colorfunction=(np.ones(np.size(u1))*kappa)
+colorfunction=(B*kappa)
+# print('colofunction',colorfunction)
+norm=mcolors.Normalize(colorfunction.min(),colorfunction.max())
+
+
+# -----------------------------------------------------
+# Display the mesh
+fig = plt.figure()
+
+
+width = 6.28 *0.5
+# width = 6.28
+height = width / 1.618
+
+
+
+
+ax = plt.axes(projection ='3d', adjustable='box')
+
+
+###---TEST MAP e-vectprs!
+# e1 = np.array([1,0])
+# e2 = np.array([0,1])
+# e3 = np.array([1/np.sqrt(2),1/np.sqrt(2)])
+# e1 = np.array([0,1])
+# e2 = np.array([-1,0])
+# e3 = np.array([-1/np.sqrt(2),1/np.sqrt(2)])
+# e1_mapped = u(e1,kappa,e1)
+# e2_mapped = u(e2,kappa,e2)
+# e3_mapped = u(e3,kappa,e3)
+# print('e1 mapped:',e1_mapped)
+# print('e2 mapped:',e2_mapped)
+# print('e3 mapped:',e3_mapped)
+### -----------------------------------
+
+#--e1 :
+# Rotation_angle = -np.pi/2
+# Rotation_vector = np.array([0,1,0])
+
+#--e2:
+Rotation_angle = np.pi/2
+Rotation_vector = np.array([1,0,0])
+
+###--e = np.array([1/np.sqrt(2),1/np.sqrt(2)])
+# Rotation_angle = -np.pi/2
+# Rotation_vector = np.array([1,0,0])
+# #2te rotation :
+# Rotation_angle = np.pi/4
+# Rotation_vector = np.array([0,0,1])
+
+
+
+Rotation_angle = -np.pi/2
+Rotation_angle = 0
+# Rotation_angle = np.pi/2
+Rotation_vector = np.array([0,1,0])
+Rotation_vector = np.array([1,0,0])
+
+# rot(np.array([0,1,0]),np.pi/2)
+
+# ZERO ROTATION
+Rotation = rot(np.array([0,1,0]),0)
+
+
+
+# TEST :
+
+#DETERMINE ANGLE:
+angle = math.atan2(e[1], e[0])
+print('angle:', angle)
+
+## GENERAL TRANSFORMATION / ROTATION:
+Rotation = rot(np.array([0,0,1]),angle).dot(rot(np.array([0,1,0]),-np.pi/2))
+
+Rotation = rot(np.array([0,0,1]),+np.pi/4).dot(Rotation)
+Rotation = rot(np.array([0,0,1]),+np.pi/16).dot(Rotation)
+
+
+
+### if e1:
+# Rotation = rot(np.array([0,0,1]),-np.pi/4).dot(Rotation)
+# Rotation = rot(np.array([0,0,1]),+np.pi/16).dot(Rotation)
+
+# Add another rotation around z-axis:
+# Rotation = rot(np.array([0,0,1]),+np.pi).dot(Rotation)
+# Rotation = rot(np.array([0,0,1]),+np.pi/4).dot(Rotation)
+
+
+# Rotation = rot(np.array([0,0,1]),+np.pi/8).dot(Rotation)
+
+#e3 :
+# Rotation = rot(np.array([0,1,0]),-np.pi/2)
+# Rotation = rot(np.array([0,0,1]),np.pi/4).dot(rot(np.array([0,1,0]),-np.pi/2))
+
+# Rotation = rot(np.array([0,0,1]),np.pi/4)
+# Rotation = rot(np.array([1,0,0]),np.pi/4)
+#### if e1 :
+# Rotation = rot(np.array([0,1,0]),-np.pi/2)
+#### if e2:
+# Rotation = rot(np.array([0,1,0]),-np.pi/2).dot(rot(np.array([1,0,0]),-np.pi/2))
+# # #### if e3 :
+# zufall dass np.pi/4 genau dem Winkel angle alpha entspricht?:
+# (würde) bei e_2 keinen Unterschied machen um z achse zu rotieren?!
+
+# Rotation = rot(np.array([0,0,1]),np.pi/4).dot(rot(np.array([0,1,0]),-np.pi/2).dot(rot(np.array([1,0,0]),-np.pi/2)))
+# Rotation = rot(np.array([0,0,1]),np.pi/2).dot(rot(np.array([0,1,0]),-np.pi/2).dot(rot(np.array([1,0,0]),-np.pi/2)))
+
+# Rotation = rot(np.array([1,0,0]),np.pi/2)
+
+# Rotation_vector = e3_mapped  #TEST
+# Rotation_vector = np.array([-1/np.sqrt(2),1/np.sqrt(2)])
+# Rotation_vector = np.array([0,0,1])
+
+# v = np.array([1,0,0])
+# X = np.array([u1,u2,u3])
+
+
+
+
+# T = rotate_data(np.array([u1,u2,u3]),Rotation_vector,Rotation_angle)
+T = rotate_data(np.array([u1,u2,u3]),Rotation)
+
+# ax.plot_surface(T[0], T[1], T[2], color = 'w', rstride = 2, cstride = 2, facecolors=cm.brg(colorfunction), alpha=.4, zorder=4)
+# ax.plot_surface(T[0], T[1], T[2], color = 'w', rstride = 1, cstride = 1, facecolors=cm.viridis(colorfunction), alpha=.4, zorder=4)
+ax.plot_surface(T[0], T[1], T[2], color = 'w', rstride = 1, cstride = 1, facecolors=cm.Spectral_r(colorfunction), alpha=.4, zorder=4)
+
+###---- PLOT PARAMETER-PLANE:
+# ax.plot_surface(x1,x2,zero,color = 'w', rstride = 1, cstride = 1 )
+
+
+print('------------------ Kappa : ', kappa)
+
+#midpoint:
+midpoint = np.array([(max(x)+min(x))/2,(max(y)+min(y))/2])
+print('midpoint',midpoint)
+
+# Map midpoint:
+midpoint_mapped = u(midpoint,kappa,e)
+print('mapped midpoint', midpoint_mapped)
+
+#map origin
+origin = np.array([0,0])
+origin_mapped = u(origin,kappa,e)
+
+
+mapped_e = grad_u(midpoint,kappa,e)
+normal = compute_normal(midpoint,kappa,e)
+
+print('mapped_e', mapped_e)
+print('normal',normal )
+
+#
+# mapped_e = Rotation.dot(mapped_e)
+# normal = Rotation.dot(normal)
+
+
+# Plot Mapped_midPoint
+ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],    # data
+marker='o',     # each marker will be rendered as a circle
+markersize=4,   # marker size
+markerfacecolor='orange',   # marker facecolor
+markeredgecolor='black',  # marker edgecolor
+markeredgewidth=1,       # marker edge width
+linewidth=1,
+zorder=4)          # line width
+
+# ax.quiver([midpoint_mapped[0]], [midpoint_mapped[1]], [midpoint_mapped[2]], [mapped_e[0]], [mapped_e[1]], [mapped_e[2]], color="red")
+# ax.quiver([midpoint_mapped[0]], [midpoint_mapped[1]], [midpoint_mapped[2]], [normal[0]], [normal[1]], [normal[2]], color="blue")
+
+# ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+#            mapped_e[0],mapped_e[1],mapped_e[2],
+#            mutation_scale=15,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='green',
+#            lw = 2,
+#            ec ='green',
+#            zorder=3)
+#
+# ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+#            normal[0],normal[1],normal[2],
+#            mutation_scale=15,
+#             lw = 2,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='blue',
+#            ec ='blue',
+#            zorder = 3)
+
+
+###-- TEST Rotation :
+# v = np.array([1,0,0])
+# t = np.array([0,1,0])
+#
+# ax.arrow3D(0,0,0,
+#            t[0],t[1],t[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='blue',
+#            ec ='blue')
+#
+# # e_extend
+#
+# rotM = rot(v,np.pi/2)
+#
+# print('rotM:', rotM)
+#
+# rot_t = rotM.dot(t)
+#
+# print('rot_t:', rot_t)
+#
+# ax.arrow3D(0,0,0,
+#            rot_t[0],rot_t[1],rot_t[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='blue',
+#            ec ='blue')
+
+### -------------------------------------------
+
+############################################################################################################################################
+####################################################################### KAPPA POSITIVE  ####################################################
+############################################################################################################################################
+
+kappa = (-1)*kappa
+
+if kappa == 0 :
+    u1 = 0*x1
+    u2 = x1*e[0] + x2*e[1]
+    u3 = x2*e[0] - x1*e[1]
+else :
+    u1 = -(1/kappa)*np.cos(kappa*(x1*e[0]+x2*e[1])) + (1/kappa)
+    u2 = (1/kappa)*np.sin(kappa*(x1*e[0]+x2*e[1]))
+    u3 = x2*e[0] -x1*e[1]
+# ax.plot_surface(u1, u2, u3, color = 'w', rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.3)  ##This one!
+
+
+# T = rotate_data(X,Rotation_vector,Rotation_angle)
+
+T = rotate_data(np.array([u1,u2,u3]),Rotation)
+# T = rotate_data(T,np.array([0,1,0]),Rotation_angle)
+# T = rotate_data(T,np.array([0,0,1]),-1*Rotation_angle/2)
+
+
+cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","orange"])
+
+# ax.plot_surface(T[0], T[1], T[2], rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4, antialiased=False)
+# ax.plot_surface(T[0], T[1], T[2], rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4, antialiased=True)
+ax.plot_surface(T[0], T[1], T[2], rstride = 2, cstride = 2, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4)
+# ax.plot_surface(T[0], T[1], T[2], rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4, shade=True)
+# ax.plot_surface(T[0], T[1], T[2], color = 'w', rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=0.8, zorder=4)
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=1, zorde5r=5)
+
+# midpoint = np.array([(max(x)+min(x))/2,(max(y)+min(y))/2])
+# print('midpoint',midpoint)
+print('------------------ Kappa : ', kappa)
+# Map midpoint:
+midpoint_mapped = u(midpoint,kappa,e)
+print('mapped midpoint', midpoint_mapped)
+
+#map origin
+origin = np.array([0,0])
+origin_mapped = u(origin,kappa,e)
+
+
+mapped_e = grad_u(midpoint,kappa,e)
+normal = compute_normal(midpoint,kappa,e)
+
+print('mapped_e', mapped_e)
+print('normal',normal )
+
+
+#
+mapped_e = Rotation.dot(mapped_e)
+normal = Rotation.dot(normal)
+
+
+# ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2], color='black', markersize=10,marker='o',  zorder=5)
+ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],    # data
+marker='o',     # each marker will be rendered as a circle
+markersize=4,   # marker size
+markerfacecolor='orange',   # marker facecolor
+markeredgecolor='black',  # marker edgecolor
+markeredgewidth=1,       # marker edge width
+linewidth=1,
+zorder=5)          # line width
+# ax.scatter3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2], color='black', s=100,  zorder=5)
+
+
+# mapped_e = grad_u(midpoint,kappa,e)
+# normal = compute_normal(midpoint,kappa,e)
+
+
+ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+           mapped_e[0],mapped_e[1],mapped_e[2],
+           mutation_scale=15,
+           arrowstyle="-|>",
+           linestyle='dashed',fc='limegreen',
+           # linestyle='dashed',fc='green',
+           lw = 1.5,
+           ec ='limegreen',
+           zorder=5)
+
+ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+           normal[0],normal[1],normal[2],
+           mutation_scale=15,
+            lw = 1.5,
+           arrowstyle="-|>",
+           linestyle='dashed',fc='royalblue',
+           # linestyle='dashed',fc='yellow',
+           ec ='royalblue',
+           # ec ='orange',
+           zorder = 5)
+
+
+############################################################################################################################################
+####################################################################### KAPPA ZERO #########################################################
+############################################################################################################################################
+kappa = 0
+
+if kappa == 0 :
+    u1 = 0*x1
+    u2 = x1*e[0] + x2*e[1]
+    u3 = x2*e[0] - x1*e[1]
+else :
+    u1 = -(1/kappa)*np.cos(kappa*(x1*e[0]+x2*e[1])) + (1/kappa)
+    u2 = (1/kappa)*np.sin(kappa*(x1*e[0]+x2*e[1]))
+    u3 = x2*e[0] -x1*e[1]
+# ax.plot_surface(u1, u2, u3,  rstride = 1, cstride = 1, color = 'white', alpha=0.85)
+
+# T = rotate_data(np.array([u1,u2,u3]),Rotation_vector,Rotation_angle)
+
+T = rotate_data(np.array([u1,u2,u3]),Rotation)
+# T = rotate_data(T,np.array([0,1,0]),Rotation_angle)
+# T = rotate_data(T,np.array([0,0,1]),-1*Rotation_angle/2)
+
+
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, color = 'white', alpha=0.55, zorder=2, antialiased=True)
+# ax.plot_surface(T[0], T[1], T[2],  rstride =1 , cstride = 1, color = 'white', alpha=0.55, zorder=3)
+
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, color = 'white', alpha=0.55, zorder=2)
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, color = 'white', alpha=0.5, zorder=2, antialiased=True)
+ax.plot_surface(T[0], T[1], T[2],  rstride = 10, cstride = 10, color = 'white', alpha=0.55, zorder=2)
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 20, cstride = 20, color = 'gray', alpha=0.35, zorder=1, shade=True)
+# ax.plot_surface(T[0], T[1], T[2], color = 'white', alpha=0.55, zorder=2)
+
+# midpoint = np.array([(max(x)+min(x))/2,(max(y)+min(y))/2])
+mapped_e = grad_u(midpoint,kappa,e)
+normal_zeroCurv = compute_normal(midpoint,kappa,e)
+
+# Map midpoint:
+midpoint_mapped = u(midpoint,kappa,e)
+print('mapped midpoint', midpoint_mapped)
+
+##-----  PLOT MAPPED MIDPOINT :::
+
+ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],    # data
+marker='o',     # each marker will be rendered as a circle
+markersize=4,   # marker size
+markerfacecolor='orange',   # marker facecolor
+markeredgecolor='black',  # marker edgecolor
+markeredgewidth=1,       # marker edge width
+# linestyle='--',            # line style will be dash line
+linewidth=1,
+zorder=5)
+
+# ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+#            mapped_e[0],mapped_e[1],mapped_e[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='red',
+#            ec ='red')
+#
+# ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+#            normal_zeroCurv[0],normal_zeroCurv[1],normal_zeroCurv[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='blue',
+#            ec ='blue')
+
+
+##----------  PLOT MAPPED ORIGIN :::
+# origin = np.array([0,0])
+# origin_mapped = u(origin,kappa,e)
+# print('origin_mapped', origin_mapped)
+#
+# ax.plot(origin_mapped[0],origin_mapped[1],origin_mapped[2],    # data
+# marker='o',     # each marker will be rendered as a circle
+# markersize=4,   # marker size
+# markerfacecolor='green',   # marker facecolor
+# markeredgecolor='black',  # marker edgecolor
+# markeredgewidth=1,       # marker edge width
+# linewidth=1,
+# zorder=5)          # line width
+#
+# # rotate mapped origin
+# # v = np.array([1,0,0])
+# # alpha  = Rotation_angle
+#
+# rotM = rot(Rotation_vector,Rotation_angle)
+# # origin_mRot = rotate_data(origin_mapped,v,alpha)
+# origin_mRot = rotM.dot(origin_mapped)
+# print('origin_mapped Rotated', origin_mRot)
+#
+# # --- Compute Distance to Origin 3D
+# origin_3D=np.array([0,0,0])
+# distance = origin_mapped-origin_3D
+# print('distance', distance)
+
+## --------------------------------------------------------
+
+# COMPUTE ANGLE WITH Z AXIS
+z = np.array([0,0,1])
+print('test', normal_zeroCurv*z)
+angle_z = np.arccos(normal_zeroCurv.dot(z) /( (np.linalg.norm(z)*np.linalg.norm(normal_zeroCurv) ) ))
+print('angle between normal and z-axis', angle_z)
+
+## unfinished...
+
+
+
+
+###-------------------------------------  PLOT :
+plt.axis('off')
+# plt.axis('tight')
+
+# ADD colorbar
+# scamap = plt.cm.ScalarMappable(cmap='inferno')
+# fig.colorbar(scamap)
+
+# ax.colorbar()
+# ax.axis('auto')
+# ax.set_title(r'Cylindrical minimizer_$\kappa$='+ str(kappa)+ '_$e$=' +  str(e))
+# ax.set_title(r'Cylindrical minimizer' + '_$e$=' +  str(e))
+ax.set_xlabel(r"x-axis")
+ax.set_ylabel(r"y-axis")
+ax.set_zlabel(r"z-axis")
+
+# TEST :
+# ax.annotate3D('point 1', (0, 0, 0), xytext=(3, 3), textcoords='offset points')
+# ax.annotate3D('point 2', (0, 1, 0),
+#               xytext=(-30, -30),
+#               textcoords='offset points',
+#               arrowprops=dict(ec='black', fc='white', shrink=2.5))
+# ax.annotate3D('point 3', (0, 0, 1),
+#               xytext=(30, -30),
+#               textcoords='offset points',
+#               bbox=dict(boxstyle="round", fc="lightyellow"),
+#               arrowprops=dict(arrowstyle="-|>", ec='black', fc='white', lw=5))
+
+#######################################################################################################################
+
+u1 = T[0]
+u2 = T[1]
+u3 = T[2]
+
+max_range = np.array([u1.max()-u1.min(), u2.max()-u2.min(), u3.max()-u3.min()]).max() /3
+# max_range = np.array([u1.max()-u1.min(), u2.max()-u2.min(), u3.max()-u3.min()]).max() /2
+mid_u1 = (u1.max()+u1.min()) * 0.5
+mid_u2 = (u2.max()+u2.min()) * 0.5
+mid_u3 = (u3.max()+u3.min()) * 0.5
+
+
+ax.set_xlim(mid_u1 - max_range, mid_u1 + max_range)
+ax.set_ylim(mid_u2 - max_range, mid_u2 + max_range)
+ax.set_zlim(mid_u3 - max_range, mid_u3 + max_range)
+
+
+
+
+
+
+
+
+##----- CHANGE CAMERA POSITION:
+# ax.view_init(elev=10., azim=0)
+# ax.view_init(elev=38, azim=90)
+# ax.view_init(elev=38, azim=120)
+# ax.view_init(elev=38)
+
+# if e1 ::
+# ax.view_init(elev=44)
+# ax.view_init(elev=38, azim=-90)
+# ax.view_init(elev=38, azim=0)
+
+
+# if e3 ::
+ax.view_init(elev=25)
+
+# ax.set_xlim3d(-2, 2)
+# ax.set_ylim3d(-1.0,3.0)
+# ax.set_zlim3d(-1.5,2.5)
+
+# ax.set_ylim3d(-10,10)
+# ax.set_xlim(mid_u1 - max_range-0.2, mid_u1 + max_range+0.2)
+# ax.set_zlim(mid_u3 - max_range-0.2, mid_u3 + max_range+0.2)
+# ax.set_ylim(mid_u2 - max_range-0.2, mid_u2 + max_range+0.2)
+
+# width = 6.28 *0.5
+# height = width / 1.618
+# # height = width / 2.5
+# fig.set_size_inches(width, height)
+# fig.savefig('Test-Cylindrical.pdf')
+
+# Figurename = r'Cylindrical minimizer_$\kappa$='+ str(kappa)+ '_$e$=' +  str(e)
+Figurename = r'Cylindrical minimizer' + '_$e$=' +  str(e)
+# plt.savefig("test.png", bbox_inches='tight')
+# plt.figure().set_size_inches(width, height)
+# plt.set_size_inches(width, height)
+
+
+# fig.set_size_inches(width, height)
+# fig.savefig(Figurename+".pdf")
+
+plt.savefig(Figurename+".png", bbox_inches='tight')
+# plt.savefig(Figurename+".png")
+plt.show()
+
+
+
+# #---------------------------------------------------------------

JNLS_plotScripts/CylindricalMinimizer-Plot_newColors.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import matplotlib.ticker as tickers
+import matplotlib as mpl
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+from mpl_toolkits.mplot3d import Axes3D
+import pandas as pd
+import matplotlib.colors as mcolors
+from matplotlib import cm
+
+from mpl_toolkits.mplot3d.proj3d import proj_transform
+# from mpl_toolkits.mplot3d.axes3d import Axes3D
+from matplotlib.text import Annotation
+from matplotlib.patches import FancyArrowPatch
+
+import matplotlib as mpl
+import seaborn as sns
+import matplotlib.colors as mcolors
+
+# Extra packages :
+# from HelperFunctions import *
+# from ClassifyMin import *
+# from subprocess import Popen, PIPE
+#import sys
+
+###################### Documentation #########################
+
+#..... add description here
+
+###########################################################
+
+
+def rot(v,alpha):
+
+#rotate about axis v with degree deg in radians:
+
+
+    tmp = np.array([ [v[0]**2*(1-np.cos(alpha))+np.cos(alpha), v[0]*v[1]*(1-np.cos(alpha))-v[2]*np.sin(alpha), v[0]*v[2]*(1-np.cos(alpha))+ v[1]*np.sin(alpha) ],
+         [v[0]*v[1]*(1-np.cos(alpha))+v[2]*np.sin(alpha), v[1]**2*(1-np.cos(alpha))+np.cos(alpha), v[1]*v[2]*(1-np.cos(alpha))+v[0]*np.sin(alpha) ],
+         [v[2]*v[0]*(1-np.cos(alpha))-v[1]*np.sin(alpha), v[2]*v[1]*(1-np.cos(alpha))+v[0]*np.sin(alpha) , v[2]**2*(1-np.cos(alpha))+np.cos(alpha) ] ])
+
+    return tmp
+
+
+
+def rotate_data(X, R):
+#rotate about axis v with degree deg in radians:
+# X : DataSet
+# R : RotationMatrix
+    print('ROTATE DATA FUNCTION ---------------')
+
+    rot_matrix = R
+    # print('rot_matrix:', rot_matrix)
+    # print('rot_matrix.shape:', rot_matrix.shape)
+    # print('X', X)
+    # print('shape of X[0]', X.shape[0])
+    B = np.dot(rot_matrix, X.reshape(rot_matrix.shape[1],-1))
+    # print('shape of B', B.shape)
+    # print('B',B)
+    # print('B[0,:]', B[0,:])
+    # print('B[0,:].shape', B[0,:].shape)
+    Out = np.array([B[0,:].reshape(X.shape[1],X.shape[2]), B[1,:].reshape(X.shape[1],X.shape[2]), B[2,:].reshape(X.shape[1],X.shape[2])])
+    print('shape of Out', Out.shape)
+
+    return Out
+
+# def rotate_data(X, v,alpha): #(Old Version)
+# #rotate about axis v with degree deg in radians:
+# # X : DataSet
+#     print('ROTATE DATA FUNCTION ---------------')
+#     # v = np.array([1,0,0])
+#     # rotM = rot(v,np.pi/2)
+#     # print('rotM:', rotM)
+#     rot_matrix = rot(v,alpha)
+#     # print('rot_matrix:', rot_matrix)
+#     # print('rot_matrix.shape:', rot_matrix.shape)
+#
+#     # print('X', X)
+#     # print('shape of X[0]', X.shape[0])
+#     B = np.dot(rot_matrix, X.reshape(rot_matrix.shape[1],-1))
+#
+#     # print('shape of B', B.shape)
+#     # print('B',B)
+#     # print('B[0,:]', B[0,:])
+#     # print('B[0,:].shape', B[0,:].shape)
+#     Out = np.array([B[0,:].reshape(X.shape[1],X.shape[2]), B[1,:].reshape(X.shape[1],X.shape[2]), B[2,:].reshape(X.shape[1],X.shape[2])])
+#     print('shape of Out', Out.shape)
+#
+#     return Out
+
+
+# def translate_data(X, v):  ...
+# #rotate about axis v with degree deg in radians:
+# # X : DataSet
+#     print('ROTATE DATA FUNCTION ---------------')
+#     # v = np.array([1,0,0])
+#     # rotM = rot(v,np.pi/2)
+#     # print('rotM:', rotM)
+#
+#     print('X', X)
+#     print('shape of X[0]', X.shape[0])
+#
+#     Out = X + v
+#     return Out
+
+
+def u(x,kappa,e):
+
+    tmp = (x.dot(e))*kappa
+    # print('tmp for u',tmp)
+    if kappa == 0 :
+        tmp = np.array([0*x[0],  x[0]*e[0] + x[1]*e[1], x[1]*e[0] - x[0]*e[1] ])
+    else :
+        tmp = np.array([-(1/kappa)*np.cos(tmp)+(1/kappa),  (1/kappa)*np.sin(tmp), -x[0]*e[1]+x[1]*e[0] ])
+    return tmp
+
+
+
+
+def grad_u(x,kappa,e):
+
+    tmp = (x.dot(e))*kappa
+    # print('tmp',tmp)
+
+    grad_u = np.array([ [np.sin(tmp)*e[0], np.sin(tmp)*e[1]], [np.cos(tmp)*e[0], np.cos(tmp)*e[1]], [-e[1], e[0]] ])
+    # print('produkt', grad_u.dot(e) )
+    mapped_e = grad_u.dot(e)
+    # print('mapped_e:', mapped_e)
+    # print('siize of mapped_e', mapped_e.shape)
+    # mapped_e = mapped_e.transpose()
+    # print('mapped_e:', mapped_e)
+    # print('siize of mapped_e', mapped_e.shape)
+    return mapped_e
+
+def compute_normal(x,kappa,e):
+    tmp = (x.dot(e))*kappa
+    partial1_u = np.array([ np.sin(tmp)*e[0] ,np.cos(tmp)*e[0], -e[1] ])
+    partial2_u = np.array([ np.sin(tmp)*e[1], np.cos(tmp)*e[1], e[0]      ])
+    normal = np.cross(partial1_u,partial2_u)
+    # print('normal=',normal)
+    return normal
+
+
+
+class Annotation3D(Annotation):
+    def __init__(self, text, xyz, *args, **kwargs):
+        super().__init__(text, xy=(0, 0), *args, **kwargs)
+        self._xyz = xyz
+
+    def draw(self, renderer):
+        x2, y2, z2 = proj_transform(*self._xyz, self.axes.M)
+        self.xy = (x2, y2)
+        super().draw(renderer)
+
+def _annotate3D(ax, text, xyz, *args, **kwargs):
+    '''Add anotation `text` to an `Axes3d` instance.'''
+
+    annotation = Annotation3D(text, xyz, *args, **kwargs)
+    ax.add_artist(annotation)
+
+setattr(Axes3D, 'annotate3D', _annotate3D)
+
+class Arrow3D(FancyArrowPatch):
+
+    def __init__(self, x, y, z, dx, dy, dz, *args, **kwargs):
+        super().__init__((0, 0), (0, 0), *args, **kwargs)
+        self._xyz = (x, y, z)
+        self._dxdydz = (dx, dy, dz)
+
+    def draw(self, renderer):
+        x1, y1, z1 = self._xyz
+        dx, dy, dz = self._dxdydz
+        x2, y2, z2 = (x1 + dx, y1 + dy, z1 + dz)
+
+        xs, ys, zs = proj_transform((x1, x2), (y1, y2), (z1, z2), self.axes.M)
+        self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
+        super().draw(renderer)
+
+
+def _arrow3D(ax, x, y, z, dx, dy, dz, *args, **kwargs):
+    '''Add an 3d arrow to an `Axes3D` instance.'''
+
+    arrow = Arrow3D(x, y, z, dx, dy, dz, *args, **kwargs)
+    ax.add_artist(arrow)
+
+setattr(Axes3D, 'arrow3D', _arrow3D)
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+
+############################################################################################################################################
+####################################################################### KAPPA NEGATIVE ####################################################
+############################################################################################################################################
+kappa = -2
+num_Points = 200
+# num_Points = 100
+
+
+e = np.array([1,0])
+# e = np.array([0,1])
+# e = np.array([1/np.sqrt(2),1/np.sqrt(2)])
+# e = np.array([1/2,np.sqrt(3)/2])
+# e = np.array([np.sqrt(3)/2,1/2])
+# e = np.array([-1,0])
+# e = np.array([0,-1])
+
+# Creating dataset
+# x = np.linspace(-1.5,1.5,num_Points)
+x = np.linspace(-1,1,num_Points)
+y = np.linspace(-1/2,1/2,num_Points)
+
+print('type of x', type(x))
+print('max of x:', max(x))
+print('max of y:', max(y))
+# print('x:', x)
+
+x1, x2 = np.meshgrid(x,y)
+zero = 0*x1
+
+if kappa == 0 :
+    u1 = 0*x1
+    u2 = x1*e[0] + x2*e[1]
+    u3 = x2*e[0] - x1*e[1]
+
+else :
+    u1 = -(1/kappa)*np.cos(kappa*(x1*e[0]+x2*e[1])) + (1/kappa)
+    u2 = (1/kappa)*np.sin(kappa*(x1*e[0]+x2*e[1]))
+    u3 = x2*e[0] -x1*e[1]
+
+# print('np.size(u1)',np.size(u1))
+# print('u1.shape',u1.shape)
+# colorfunction=(u1**2+u2**2)
+# print('colofunction',colorfunction)
+
+# print('u1.size:',np.size(u1))
+# tmp = np.ones(np.size(u1))*kappa
+# print('np.size(tmp)',np.size(tmp))
+B = np.full_like(u1, 1)
+# colorfunction=(u3)                                              # TODO Color by angle
+# colorfunction=(np.ones(np.size(u1))*kappa)
+colorfunction=(B*kappa)
+# print('colofunction',colorfunction)
+norm=mcolors.Normalize(colorfunction.min(),colorfunction.max())
+
+
+# -----------------------------------------------------
+# Display the mesh
+fig = plt.figure()
+
+
+width = 6.28 *0.5
+# width = 6.28
+height = width / 1.618
+
+
+
+
+ax = plt.axes(projection ='3d', adjustable='box')
+
+
+###---TEST MAP e-vectprs!
+# e1 = np.array([1,0])
+# e2 = np.array([0,1])
+# e3 = np.array([1/np.sqrt(2),1/np.sqrt(2)])
+# e1 = np.array([0,1])
+# e2 = np.array([-1,0])
+# e3 = np.array([-1/np.sqrt(2),1/np.sqrt(2)])
+# e1_mapped = u(e1,kappa,e1)
+# e2_mapped = u(e2,kappa,e2)
+# e3_mapped = u(e3,kappa,e3)
+# print('e1 mapped:',e1_mapped)
+# print('e2 mapped:',e2_mapped)
+# print('e3 mapped:',e3_mapped)
+### -----------------------------------
+
+#--e1 :
+# Rotation_angle = -np.pi/2
+# Rotation_vector = np.array([0,1,0])
+
+#--e2:
+Rotation_angle = np.pi/2
+Rotation_vector = np.array([1,0,0])
+
+###--e = np.array([1/np.sqrt(2),1/np.sqrt(2)])
+# Rotation_angle = -np.pi/2
+# Rotation_vector = np.array([1,0,0])
+# #2te rotation :
+# Rotation_angle = np.pi/4
+# Rotation_vector = np.array([0,0,1])
+
+
+
+Rotation_angle = -np.pi/2
+Rotation_angle = 0
+# Rotation_angle = np.pi/2
+Rotation_vector = np.array([0,1,0])
+Rotation_vector = np.array([1,0,0])
+
+# rot(np.array([0,1,0]),np.pi/2)
+
+# ZERO ROTATION
+Rotation = rot(np.array([0,1,0]),0)
+
+
+
+# TEST :
+
+#DETERMINE ANGLE:
+angle = math.atan2(e[1], e[0])
+print('angle:', angle)
+
+## GENERAL TRANSFORMATION / ROTATION:
+Rotation = rot(np.array([0,0,1]),angle).dot(rot(np.array([0,1,0]),-np.pi/2))
+
+# Rotation = rot(np.array([0,0,1]),+np.pi/4).dot(Rotation)
+# Rotation = rot(np.array([0,0,1]),+np.pi/16).dot(Rotation)
+
+
+
+### if e1:
+Rotation = rot(np.array([0,0,1]),-np.pi/4).dot(Rotation)
+Rotation = rot(np.array([0,0,1]),+np.pi/16).dot(Rotation)
+
+# Add another rotation around z-axis:
+# Rotation = rot(np.array([0,0,1]),+np.pi).dot(Rotation)
+# Rotation = rot(np.array([0,0,1]),+np.pi/4).dot(Rotation)
+
+
+# Rotation = rot(np.array([0,0,1]),+np.pi/8).dot(Rotation)
+
+#e3 :
+# Rotation = rot(np.array([0,1,0]),-np.pi/2)
+# Rotation = rot(np.array([0,0,1]),np.pi/4).dot(rot(np.array([0,1,0]),-np.pi/2))
+
+# Rotation = rot(np.array([0,0,1]),np.pi/4)
+# Rotation = rot(np.array([1,0,0]),np.pi/4)
+#### if e1 :
+# Rotation = rot(np.array([0,1,0]),-np.pi/2)
+#### if e2:
+# Rotation = rot(np.array([0,1,0]),-np.pi/2).dot(rot(np.array([1,0,0]),-np.pi/2))
+# # #### if e3 :
+# zufall dass np.pi/4 genau dem Winkel angle alpha entspricht?:
+# (würde) bei e_2 keinen Unterschied machen um z achse zu rotieren?!
+
+# Rotation = rot(np.array([0,0,1]),np.pi/4).dot(rot(np.array([0,1,0]),-np.pi/2).dot(rot(np.array([1,0,0]),-np.pi/2)))
+# Rotation = rot(np.array([0,0,1]),np.pi/2).dot(rot(np.array([0,1,0]),-np.pi/2).dot(rot(np.array([1,0,0]),-np.pi/2)))
+
+# Rotation = rot(np.array([1,0,0]),np.pi/2)
+
+# Rotation_vector = e3_mapped  #TEST
+# Rotation_vector = np.array([-1/np.sqrt(2),1/np.sqrt(2)])
+# Rotation_vector = np.array([0,0,1])
+
+# v = np.array([1,0,0])
+# X = np.array([u1,u2,u3])
+
+
+
+
+# T = rotate_data(np.array([u1,u2,u3]),Rotation_vector,Rotation_angle)
+T = rotate_data(np.array([u1,u2,u3]),Rotation)
+
+# ax.plot_surface(T[0], T[1], T[2], color = 'w', rstride = 2, cstride = 2, facecolors=cm.brg(colorfunction), alpha=.4, zorder=4)
+# ax.plot_surface(T[0], T[1], T[2], color = 'w', rstride = 1, cstride = 1, facecolors=cm.viridis(colorfunction), alpha=.4, zorder=4)
+ax.plot_surface(T[0], T[1], T[2], color = 'w', rstride = 1, cstride = 1, facecolors=cm.Spectral_r(colorfunction), alpha=.4, zorder=4)
+
+###---- PLOT PARAMETER-PLANE:
+# ax.plot_surface(x1,x2,zero,color = 'w', rstride = 1, cstride = 1 )
+
+
+print('------------------ Kappa : ', kappa)
+
+#midpoint:
+midpoint = np.array([(max(x)+min(x))/2,(max(y)+min(y))/2])
+print('midpoint',midpoint)
+
+# Map midpoint:
+midpoint_mapped = u(midpoint,kappa,e)
+print('mapped midpoint', midpoint_mapped)
+
+#map origin
+origin = np.array([0,0])
+origin_mapped = u(origin,kappa,e)
+
+
+mapped_e = grad_u(midpoint,kappa,e)
+normal = compute_normal(midpoint,kappa,e)
+
+print('mapped_e', mapped_e)
+print('normal',normal )
+
+#
+# mapped_e = Rotation.dot(mapped_e)
+# normal = Rotation.dot(normal)
+
+
+# Plot Mapped_midPoint
+ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],    # data
+marker='o',     # each marker will be rendered as a circle
+markersize=4,   # marker size
+markerfacecolor='orange',   # marker facecolor
+markeredgecolor='black',  # marker edgecolor
+markeredgewidth=1,       # marker edge width
+linewidth=1,
+zorder=4)          # line width
+
+# ax.quiver([midpoint_mapped[0]], [midpoint_mapped[1]], [midpoint_mapped[2]], [mapped_e[0]], [mapped_e[1]], [mapped_e[2]], color="red")
+# ax.quiver([midpoint_mapped[0]], [midpoint_mapped[1]], [midpoint_mapped[2]], [normal[0]], [normal[1]], [normal[2]], color="blue")
+
+# ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+#            mapped_e[0],mapped_e[1],mapped_e[2],
+#            mutation_scale=15,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='green',
+#            lw = 2,
+#            ec ='green',
+#            zorder=3)
+#
+# ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+#            normal[0],normal[1],normal[2],
+#            mutation_scale=15,
+#             lw = 2,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='blue',
+#            ec ='blue',
+#            zorder = 3)
+
+
+###-- TEST Rotation :
+# v = np.array([1,0,0])
+# t = np.array([0,1,0])
+#
+# ax.arrow3D(0,0,0,
+#            t[0],t[1],t[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='blue',
+#            ec ='blue')
+#
+# # e_extend
+#
+# rotM = rot(v,np.pi/2)
+#
+# print('rotM:', rotM)
+#
+# rot_t = rotM.dot(t)
+#
+# print('rot_t:', rot_t)
+#
+# ax.arrow3D(0,0,0,
+#            rot_t[0],rot_t[1],rot_t[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='blue',
+#            ec ='blue')
+
+### -------------------------------------------
+
+############################################################################################################################################
+####################################################################### KAPPA POSITIVE  ####################################################
+############################################################################################################################################
+
+kappa = (-1)*kappa
+
+if kappa == 0 :
+    u1 = 0*x1
+    u2 = x1*e[0] + x2*e[1]
+    u3 = x2*e[0] - x1*e[1]
+else :
+    u1 = -(1/kappa)*np.cos(kappa*(x1*e[0]+x2*e[1])) + (1/kappa)
+    u2 = (1/kappa)*np.sin(kappa*(x1*e[0]+x2*e[1]))
+    u3 = x2*e[0] -x1*e[1]
+# ax.plot_surface(u1, u2, u3, color = 'w', rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.3)  ##This one!
+
+
+# T = rotate_data(X,Rotation_vector,Rotation_angle)
+
+T = rotate_data(np.array([u1,u2,u3]),Rotation)
+# T = rotate_data(T,np.array([0,1,0]),Rotation_angle)
+# T = rotate_data(T,np.array([0,0,1]),-1*Rotation_angle/2)
+
+
+
+## GET COLORS :
+# deep_colors = sns.color_palette("pastel")
+# print('deep_colors.as_hex():',deep_colors.as_hex())
+#
+#
+# diverging_colors = sns.color_palette("RdBu", 10)
+# print('diverging_colors.as_hex():',diverging_colors.as_hex())
+#
+# pal = sns.color_palette("Blues")
+# pal = sns.color_palette()
+# print(pal.as_hex())
+#
+# # flatui = ["#9b59b6", "#3498db", "#95a5a6", "#e74c3c", "#34495e", "#2ecc71"]
+# flatui = ["coral","white", "cornflowerblue"]
+# flatui = ["cornflowerblue", "coral"]
+# # flatui = ['#4c72b0','white', '#c44e52']
+# # flatui = ['#4c72b0','white', '#8de5a1']
+# # flatui = ['#a1c9f4', '#ffb482','#ff9f9b'] #Test colors
+# # flatui = ['#4c72b0','white', '#ffb482']
+# # flatui = ['#4c72b0','white', '#ff9f9b']
+# # flatui = ['#4c72b0','white', '#ab162a']
+#
+# # flatui = ['#4c72b0','white', '#eb9172']
+# # flatui = ['#4c72b0','white', '#64b5cd']
+# # cmap = mpl.colors.ListedColormap(sns.color_palette(flatui).as_hex())
+# # cmap = mpl.colors.ListedColormap(sns.color_palette(flatui).as_hex())
+# # cmap = mpl.colors.ListedColormap(sns.color_palette("RdBu_r", 10).as_hex())
+# # cmap = mpl.colors.ListedColormap(sns.color_palette("coolwarm", 10).as_hex())  #Discrete CMAP
+# # cmap = sns.color_palette("coolwarm", as_cmap=True)
+# # cmap = sns.color_palette("RdBu_r", as_cmap=True)
+#
+# # cmap=plt.cm.gnuplot
+# # cmap = sns.color_palette("vlag", as_cmap=True)
+# # cmap = sns.color_palette("icefire", as_cmap=True)   ## THIS !
+# # cmap = sns.color_palette("Spectral_r", as_cmap=True)
+# # cmap = sns.color_palette("cubehelix", as_cmap=True)
+#
+# # cmap = sns.color_palette("flare_r", as_cmap=True)
+# cmap = sns.color_palette("gnuplot", as_cmap=True)
+# cmap = sns.color_palette("plasma", as_cmap=True)
+# cmap = sns.diverging_palette(220, 20, as_cmap=True)
+# cmap = sns.diverging_palette(250, 30, l=65, center="dark", as_cmap=True)
+# cmap = mpl.colors.ListedColormap(sns.color_palette().as_hex())
+# # cmap = mpl.colors.LinearSegmentedColormap.from_list("", sns.color_palette(flatui).as_hex())
+# cmap = mpl.colors.ListedColormap("", sns.color_palette(flatui).as_hex())
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["orange"])
+
+
+
+
+
+# cmaps = cmap(colorfunction)
+
+# cmap = plt.cm.Spectral(colorfunction)
+# # cmap = plt.cm.coolwarm(colorfunction)
+# cmap = plt.cm.coolwarm_r(colorfunction)
+cmap = plt.cm.bwr_r(colorfunction)
+# cmap = plt.cm.PiYG(colorfunction)
+# cmap = plt.cm.seismic_r(colorfunction)
+# cmap = plt.cm.hsv(colorfunction)
+
+# ax.plot_surface(T[0], T[1], T[2], rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4, antialiased=False)
+# ax.plot_surface(T[0], T[1], T[2], rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4, antialiased=True)
+# ax.plot_surface(T[0], T[1], T[2], rstride = 2, cstride = 2, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4)
+ax.plot_surface(T[0], T[1], T[2], rstride = 2, cstride = 2, facecolors=cmap, alpha=.4, zorder=4)
+# ax.plot_surface(T[0], T[1], T[2], rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4, shade=True)
+# ax.plot_surface(T[0], T[1], T[2], color = 'w', rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=0.8, zorder=4)
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=1, zorde5r=5)
+
+# midpoint = np.array([(max(x)+min(x))/2,(max(y)+min(y))/2])
+# print('midpoint',midpoint)
+print('------------------ Kappa : ', kappa)
+# Map midpoint:
+midpoint_mapped = u(midpoint,kappa,e)
+print('mapped midpoint', midpoint_mapped)
+
+#map origin
+origin = np.array([0,0])
+origin_mapped = u(origin,kappa,e)
+
+
+mapped_e = grad_u(midpoint,kappa,e)
+normal = compute_normal(midpoint,kappa,e)
+
+print('mapped_e', mapped_e)
+print('normal',normal )
+
+
+#
+mapped_e = Rotation.dot(mapped_e)
+normal = Rotation.dot(normal)
+
+
+# ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2], color='black', markersize=10,marker='o',  zorder=5)
+ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],    # data
+marker='o',     # each marker will be rendered as a circle
+markersize=4,   # marker size
+markerfacecolor='orange',   # marker facecolor
+markeredgecolor='black',  # marker edgecolor
+markeredgewidth=1,       # marker edge width
+linewidth=1,
+zorder=5)          # line width
+# ax.scatter3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2], color='black', s=100,  zorder=5)
+
+
+# mapped_e = grad_u(midpoint,kappa,e)
+# normal = compute_normal(midpoint,kappa,e)
+
+
+ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+           mapped_e[0],mapped_e[1],mapped_e[2],
+           mutation_scale=15,
+           arrowstyle="-|>",
+           linestyle='dashed',fc='limegreen',
+           # linestyle='dashed',fc='green',
+           lw = 1.5,
+           ec ='limegreen',
+           zorder=5)
+
+ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+           normal[0],normal[1],normal[2],
+           mutation_scale=15,
+            lw = 1.5,
+           arrowstyle="-|>",
+           linestyle='dashed',fc='royalblue',
+           # linestyle='dashed',fc='yellow',
+           ec ='royalblue',
+           # ec ='orange',
+           zorder = 5)
+
+
+############################################################################################################################################
+####################################################################### KAPPA ZERO #########################################################
+############################################################################################################################################
+kappa = 0
+
+if kappa == 0 :
+    u1 = 0*x1
+    u2 = x1*e[0] + x2*e[1]
+    u3 = x2*e[0] - x1*e[1]
+else :
+    u1 = -(1/kappa)*np.cos(kappa*(x1*e[0]+x2*e[1])) + (1/kappa)
+    u2 = (1/kappa)*np.sin(kappa*(x1*e[0]+x2*e[1]))
+    u3 = x2*e[0] -x1*e[1]
+# ax.plot_surface(u1, u2, u3,  rstride = 1, cstride = 1, color = 'white', alpha=0.85)
+
+# T = rotate_data(np.array([u1,u2,u3]),Rotation_vector,Rotation_angle)
+
+T = rotate_data(np.array([u1,u2,u3]),Rotation)
+# T = rotate_data(T,np.array([0,1,0]),Rotation_angle)
+# T = rotate_data(T,np.array([0,0,1]),-1*Rotation_angle/2)
+
+
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, color = 'white', alpha=0.55, zorder=2, antialiased=True)
+# ax.plot_surface(T[0], T[1], T[2],  rstride =1 , cstride = 1, color = 'white', alpha=0.55, zorder=3)
+
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, color = 'white', alpha=0.55, zorder=2)
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, color = 'white', alpha=0.5, zorder=2, antialiased=True)
+ax.plot_surface(T[0], T[1], T[2],  rstride = 10, cstride = 10, color = 'white', alpha=0.55, zorder=2)
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 20, cstride = 20, color = 'gray', alpha=0.35, zorder=1, shade=True)
+# ax.plot_surface(T[0], T[1], T[2], color = 'white', alpha=0.55, zorder=2)
+
+# midpoint = np.array([(max(x)+min(x))/2,(max(y)+min(y))/2])
+mapped_e = grad_u(midpoint,kappa,e)
+normal_zeroCurv = compute_normal(midpoint,kappa,e)
+
+# Map midpoint:
+midpoint_mapped = u(midpoint,kappa,e)
+print('mapped midpoint', midpoint_mapped)
+
+##-----  PLOT MAPPED MIDPOINT :::
+
+ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],    # data
+marker='o',     # each marker will be rendered as a circle
+markersize=4,   # marker size
+markerfacecolor='orange',   # marker facecolor
+markeredgecolor='black',  # marker edgecolor
+markeredgewidth=1,       # marker edge width
+# linestyle='--',            # line style will be dash line
+linewidth=1,
+zorder=5)
+
+# ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+#            mapped_e[0],mapped_e[1],mapped_e[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='red',
+#            ec ='red')
+#
+# ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+#            normal_zeroCurv[0],normal_zeroCurv[1],normal_zeroCurv[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='blue',
+#            ec ='blue')
+
+
+##----------  PLOT MAPPED ORIGIN :::
+# origin = np.array([0,0])
+# origin_mapped = u(origin,kappa,e)
+# print('origin_mapped', origin_mapped)
+#
+# ax.plot(origin_mapped[0],origin_mapped[1],origin_mapped[2],    # data
+# marker='o',     # each marker will be rendered as a circle
+# markersize=4,   # marker size
+# markerfacecolor='green',   # marker facecolor
+# markeredgecolor='black',  # marker edgecolor
+# markeredgewidth=1,       # marker edge width
+# linewidth=1,
+# zorder=5)          # line width
+#
+# # rotate mapped origin
+# # v = np.array([1,0,0])
+# # alpha  = Rotation_angle
+#
+# rotM = rot(Rotation_vector,Rotation_angle)
+# # origin_mRot = rotate_data(origin_mapped,v,alpha)
+# origin_mRot = rotM.dot(origin_mapped)
+# print('origin_mapped Rotated', origin_mRot)
+#
+# # --- Compute Distance to Origin 3D
+# origin_3D=np.array([0,0,0])
+# distance = origin_mapped-origin_3D
+# print('distance', distance)
+
+## --------------------------------------------------------
+
+# COMPUTE ANGLE WITH Z AXIS
+z = np.array([0,0,1])
+print('test', normal_zeroCurv*z)
+angle_z = np.arccos(normal_zeroCurv.dot(z) /( (np.linalg.norm(z)*np.linalg.norm(normal_zeroCurv) ) ))
+print('angle between normal and z-axis', angle_z)
+
+## unfinished...
+
+
+
+
+###-------------------------------------  PLOT :
+plt.axis('off')
+# plt.axis('tight')
+
+# ADD colorbar
+# scamap = plt.cm.ScalarMappable(cmap='inferno')
+# fig.colorbar(scamap)
+
+# ax.colorbar()
+# ax.axis('auto')
+# ax.set_title(r'Cylindrical minimizer_$\kappa$='+ str(kappa)+ '_$e$=' +  str(e))
+# ax.set_title(r'Cylindrical minimizer' + '_$e$=' +  str(e))
+ax.set_xlabel(r"x-axis")
+ax.set_ylabel(r"y-axis")
+ax.set_zlabel(r"z-axis")
+
+# TEST :
+# ax.annotate3D('point 1', (0, 0, 0), xytext=(3, 3), textcoords='offset points')
+# ax.annotate3D('point 2', (0, 1, 0),
+#               xytext=(-30, -30),
+#               textcoords='offset points',
+#               arrowprops=dict(ec='black', fc='white', shrink=2.5))
+# ax.annotate3D('point 3', (0, 0, 1),
+#               xytext=(30, -30),
+#               textcoords='offset points',
+#               bbox=dict(boxstyle="round", fc="lightyellow"),
+#               arrowprops=dict(arrowstyle="-|>", ec='black', fc='white', lw=5))
+
+#######################################################################################################################
+
+u1 = T[0]
+u2 = T[1]
+u3 = T[2]
+
+max_range = np.array([u1.max()-u1.min(), u2.max()-u2.min(), u3.max()-u3.min()]).max() /3
+# max_range = np.array([u1.max()-u1.min(), u2.max()-u2.min(), u3.max()-u3.min()]).max() /2
+mid_u1 = (u1.max()+u1.min()) * 0.5
+mid_u2 = (u2.max()+u2.min()) * 0.5
+mid_u3 = (u3.max()+u3.min()) * 0.5
+
+
+ax.set_xlim(mid_u1 - max_range, mid_u1 + max_range)
+ax.set_ylim(mid_u2 - max_range, mid_u2 + max_range)
+ax.set_zlim(mid_u3 - max_range, mid_u3 + max_range)
+
+
+
+
+
+
+
+
+##----- CHANGE CAMERA POSITION:
+# ax.view_init(elev=10., azim=0)
+# ax.view_init(elev=38, azim=90)
+# ax.view_init(elev=38, azim=120)
+# ax.view_init(elev=38)
+
+# if e1 ::
+# ax.view_init(elev=44)
+# ax.view_init(elev=38, azim=-90)
+# ax.view_init(elev=38, azim=0)
+
+
+# if e3 ::
+ax.view_init(elev=25)
+
+# ax.set_xlim3d(-2, 2)
+# ax.set_ylim3d(-1.0,3.0)
+# ax.set_zlim3d(-1.5,2.5)
+
+# ax.set_ylim3d(-10,10)
+# ax.set_xlim(mid_u1 - max_range-0.2, mid_u1 + max_range+0.2)
+# ax.set_zlim(mid_u3 - max_range-0.2, mid_u3 + max_range+0.2)
+# ax.set_ylim(mid_u2 - max_range-0.2, mid_u2 + max_range+0.2)
+
+# width = 6.28 *0.5
+# height = width / 1.618
+# # height = width / 2.5
+# fig.set_size_inches(width, height)
+# fig.savefig('Test-Cylindrical.pdf')
+
+# Figurename = r'Cylindrical minimizer_$\kappa$='+ str(kappa)+ '_$e$=' +  str(e)
+Figurename = r'Cylindrical minimizer' + '_$e$=' +  str(e)
+# plt.savefig("test.png", bbox_inches='tight')
+# plt.figure().set_size_inches(width, height)
+# plt.set_size_inches(width, height)
+
+
+# fig.set_size_inches(width, height)
+# fig.savefig(Figurename+".pdf")
+
+plt.savefig(Figurename+".png", bbox_inches='tight')
+# plt.savefig(Figurename+".png")
+plt.show()
+
+
+
+# #---------------------------------------------------------------

JNLS_plotScripts/CylindricalMinimizer-Plot_v2.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import matplotlib.ticker as tickers
+import matplotlib as mpl
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+from mpl_toolkits.mplot3d import Axes3D
+import pandas as pd
+import matplotlib.colors as mcolors
+from matplotlib import cm
+
+from mpl_toolkits.mplot3d.proj3d import proj_transform
+# from mpl_toolkits.mplot3d.axes3d import Axes3D
+from matplotlib.text import Annotation
+from matplotlib.patches import FancyArrowPatch
+
+# Extra packages :
+# from HelperFunctions import *
+# from ClassifyMin import *
+# from subprocess import Popen, PIPE
+#import sys
+
+###################### Documentation #########################
+
+#..... add description here
+
+###########################################################
+
+
+def rot(v,alpha):
+
+#rotate about axis v with degree deg in radians:
+
+
+    tmp = np.array([ [v[0]**2*(1-np.cos(alpha))+np.cos(alpha), v[0]*v[1]*(1-np.cos(alpha))-v[2]*np.sin(alpha), v[0]*v[2]*(1-np.cos(alpha))+ v[1]*np.sin(alpha) ],
+         [v[0]*v[1]*(1-np.cos(alpha))+v[2]*np.sin(alpha), v[1]**2*(1-np.cos(alpha))+np.cos(alpha), v[1]*v[2]*(1-np.cos(alpha))+v[0]*np.sin(alpha) ],
+         [v[2]*v[0]*(1-np.cos(alpha))-v[1]*np.sin(alpha), v[2]*v[1]*(1-np.cos(alpha))+v[0]*np.sin(alpha) , v[2]**2*(1-np.cos(alpha))+np.cos(alpha) ] ])
+
+    return tmp
+
+
+
+def rotate_data(X, R):
+#rotate about axis v with degree deg in radians:
+# X : DataSet
+# R : RotationMatrix
+    print('ROTATE DATA FUNCTION ---------------')
+
+    rot_matrix = R
+    # print('rot_matrix:', rot_matrix)
+    # print('rot_matrix.shape:', rot_matrix.shape)
+    # print('X', X)
+    # print('shape of X[0]', X.shape[0])
+    B = np.dot(rot_matrix, X.reshape(rot_matrix.shape[1],-1))
+    # print('shape of B', B.shape)
+    # print('B',B)
+    # print('B[0,:]', B[0,:])
+    # print('B[0,:].shape', B[0,:].shape)
+    Out = np.array([B[0,:].reshape(X.shape[1],X.shape[2]), B[1,:].reshape(X.shape[1],X.shape[2]), B[2,:].reshape(X.shape[1],X.shape[2])])
+    print('shape of Out', Out.shape)
+
+    return Out
+
+# def rotate_data(X, v,alpha): #(Old Version)
+# #rotate about axis v with degree deg in radians:
+# # X : DataSet
+#     print('ROTATE DATA FUNCTION ---------------')
+#     # v = np.array([1,0,0])
+#     # rotM = rot(v,np.pi/2)
+#     # print('rotM:', rotM)
+#     rot_matrix = rot(v,alpha)
+#     # print('rot_matrix:', rot_matrix)
+#     # print('rot_matrix.shape:', rot_matrix.shape)
+#
+#     # print('X', X)
+#     # print('shape of X[0]', X.shape[0])
+#     B = np.dot(rot_matrix, X.reshape(rot_matrix.shape[1],-1))
+#
+#     # print('shape of B', B.shape)
+#     # print('B',B)
+#     # print('B[0,:]', B[0,:])
+#     # print('B[0,:].shape', B[0,:].shape)
+#     Out = np.array([B[0,:].reshape(X.shape[1],X.shape[2]), B[1,:].reshape(X.shape[1],X.shape[2]), B[2,:].reshape(X.shape[1],X.shape[2])])
+#     print('shape of Out', Out.shape)
+#
+#     return Out
+
+
+# def translate_data(X, v):  ...
+# #rotate about axis v with degree deg in radians:
+# # X : DataSet
+#     print('ROTATE DATA FUNCTION ---------------')
+#     # v = np.array([1,0,0])
+#     # rotM = rot(v,np.pi/2)
+#     # print('rotM:', rotM)
+#
+#     print('X', X)
+#     print('shape of X[0]', X.shape[0])
+#
+#     Out = X + v
+#     return Out
+
+
+# def u(x,kappa,e):
+#
+#     tmp = (x.dot(e))*kappa
+#     # print('tmp for u',tmp)
+#     if kappa == 0 :
+#         tmp = np.array([0*x[0],  x[0]*e[0] + x[1]*e[1], x[1]*e[0] - x[0]*e[1] ])
+#     else :
+#         tmp = np.array([-(1/kappa)*np.cos(tmp)+(1/kappa),  (1/kappa)*np.sin(tmp), -x[0]*e[1]+x[1]*e[0] ])
+#     return tmp
+
+def u(x,kappa,e):
+
+    tmp = (x.dot(e))*((-1)*kappa)
+    # print('tmp for u',tmp)
+    if kappa == 0 :
+        tmp = np.array([x[0]*e[0] + x[1]*e[1], x[1]*e[0] - x[0]*e[1], 0*x[0]  ])
+    else :
+        tmp = np.array([ -(1/kappa)*np.sin(tmp), -x[0]*e[1]+x[1]*e[0], (1/kappa)*np.cos(tmp)-(1/kappa)   ])
+    return tmp
+
+
+
+# def grad_u(x,kappa,e):
+#
+#     tmp = (x.dot(e))*kappa
+#     # print('tmp',tmp)
+#
+#     grad_u = np.array([ [np.sin(tmp)*e[0], np.sin(tmp)*e[1]], [np.cos(tmp)*e[0], np.cos(tmp)*e[1]], [-e[1], e[0]] ])
+#     # print('produkt', grad_u.dot(e) )
+#     mapped_e = grad_u.dot(e)
+#     # print('mapped_e:', mapped_e)
+#     # print('siize of mapped_e', mapped_e.shape)
+#     # mapped_e = mapped_e.transpose()
+#     # print('mapped_e:', mapped_e)
+#     # print('siize of mapped_e', mapped_e.shape)
+#     return mapped_e
+#
+
+
+def grad_u(x,kappa,e):
+
+    tmp = (x.dot(e))*(-1)*kappa
+    # print('tmp',tmp)
+
+    grad_u = np.array([  [np.cos(tmp)*e[0], np.cos(tmp)*e[1]], [-e[1], e[0]], [np.sin(tmp)*e[0], np.sin(tmp)*e[1]] ])
+    # print('produkt', grad_u.dot(e) )
+    mapped_e = grad_u.dot(e)
+    # print('mapped_e:', mapped_e)
+    # print('siize of mapped_e', mapped_e.shape)
+    # mapped_e = mapped_e.transpose()
+    # print('mapped_e:', mapped_e)
+    # print('siize of mapped_e', mapped_e.shape)
+    return mapped_e
+
+
+def compute_normal(x,kappa,e):
+    tmp = (x.dot(e))*(-1)*kappa
+    partial1_u = np.array([ np.cos(tmp)*e[0], -e[1],np.sin(tmp)*e[0]  ])
+    partial2_u = np.array([ np.cos(tmp)*e[1], e[0], np.sin(tmp)*e[1]  ])
+    normal = np.cross(partial1_u,partial2_u)
+    # print('normal=',normal)
+    return normal
+
+
+
+class Annotation3D(Annotation):
+    def __init__(self, text, xyz, *args, **kwargs):
+        super().__init__(text, xy=(0, 0), *args, **kwargs)
+        self._xyz = xyz
+
+    def draw(self, renderer):
+        x2, y2, z2 = proj_transform(*self._xyz, self.axes.M)
+        self.xy = (x2, y2)
+        super().draw(renderer)
+
+def _annotate3D(ax, text, xyz, *args, **kwargs):
+    '''Add anotation `text` to an `Axes3d` instance.'''
+
+    annotation = Annotation3D(text, xyz, *args, **kwargs)
+    ax.add_artist(annotation)
+
+setattr(Axes3D, 'annotate3D', _annotate3D)
+
+class Arrow3D(FancyArrowPatch):
+
+    def __init__(self, x, y, z, dx, dy, dz, *args, **kwargs):
+        super().__init__((0, 0), (0, 0), *args, **kwargs)
+        self._xyz = (x, y, z)
+        self._dxdydz = (dx, dy, dz)
+
+    def draw(self, renderer):
+        x1, y1, z1 = self._xyz
+        dx, dy, dz = self._dxdydz
+        x2, y2, z2 = (x1 + dx, y1 + dy, z1 + dz)
+
+        xs, ys, zs = proj_transform((x1, x2), (y1, y2), (z1, z2), self.axes.M)
+        self.set_positions((xs[0], ys[0]), (xs[1], ys[1]))
+        super().draw(renderer)
+
+
+def _arrow3D(ax, x, y, z, dx, dy, dz, *args, **kwargs):
+    '''Add an 3d arrow to an `Axes3D` instance.'''
+
+    arrow = Arrow3D(x, y, z, dx, dy, dz, *args, **kwargs)
+    ax.add_artist(arrow)
+
+setattr(Axes3D, 'arrow3D', _arrow3D)
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+
+############################################################################################################################################
+####################################################################### KAPPA NEGATIVE ####################################################
+############################################################################################################################################
+kappa = -2
+num_Points = 200
+num_Points = 100
+
+
+e = np.array([1,0])
+# e = np.array([0,1])
+# e = np.array([1/np.sqrt(2),1/np.sqrt(2)])
+# e = np.array([1/2,np.sqrt(3)/2])
+# e = np.array([np.sqrt(3)/2,1/2])
+# e = np.array([-1,0])
+# e = np.array([0,-1])
+
+# Creating dataset
+# x = np.linspace(-1.5,1.5,num_Points)
+x = np.linspace(-1,1,num_Points)
+y = np.linspace(-1/2,1/2,num_Points)
+
+print('type of x', type(x))
+print('max of x:', max(x))
+print('max of y:', max(y))
+# print('x:', x)
+
+x1, x2 = np.meshgrid(x,y)
+zero = 0*x1
+
+if kappa == 0 :
+    # u1 = 0*x1
+    # u2 = x1*e[0] + x2*e[1]
+    # u3 = x2*e[0] - x1*e[1]
+    u1 = x1*e[0] + x2*e[1]
+    u2 = x2*e[0] - x1*e[1]
+    u3 = 0*x1
+
+else :
+    # u1 = -(1/kappa)*np.cos(kappa*(x1*e[0]+x2*e[1])) + (1/kappa)
+    # u2 = (1/kappa)*np.sin(kappa*(x1*e[0]+x2*e[1]))
+    # u3 = x2*e[0] -x1*e[1]
+    u1 = -(1/kappa)*np.sin((-1)*kappa*(x1*e[0]+x2*e[1]))
+    u2 =  x2*e[0] -x1*e[1]
+    u3 = (1/kappa)*np.cos((-1)*kappa*(x1*e[0]+x2*e[1]))-(1/kappa)
+
+
+
+# print('np.size(u1)',np.size(u1))
+# print('u1.shape',u1.shape)
+# colorfunction=(u1**2+u2**2)
+# print('colofunction',colorfunction)
+
+# print('u1.size:',np.size(u1))
+# tmp = np.ones(np.size(u1))*kappa
+# print('np.size(tmp)',np.size(tmp))
+B = np.full_like(u1, 1)
+# colorfunction=(u3)                                              # TODO Color by angle
+# colorfunction=(np.ones(np.size(u1))*kappa)
+colorfunction=(B*kappa)
+# print('colofunction',colorfunction)
+norm=mcolors.Normalize(colorfunction.min(),colorfunction.max())
+
+
+# -----------------------------------------------------
+# Display the mesh
+fig = plt.figure()
+
+
+width = 6.28 *0.5
+# width = 6.28
+height = width / 1.618
+
+
+
+
+ax = plt.axes(projection ='3d', adjustable='box')
+
+
+###---TEST MAP e-vectprs!
+# e1 = np.array([1,0])
+# e2 = np.array([0,1])
+# e3 = np.array([1/np.sqrt(2),1/np.sqrt(2)])
+# e1 = np.array([0,1])
+# e2 = np.array([-1,0])
+# e3 = np.array([-1/np.sqrt(2),1/np.sqrt(2)])
+# e1_mapped = u(e1,kappa,e1)
+# e2_mapped = u(e2,kappa,e2)
+# e3_mapped = u(e3,kappa,e3)
+# print('e1 mapped:',e1_mapped)
+# print('e2 mapped:',e2_mapped)
+# print('e3 mapped:',e3_mapped)
+### -----------------------------------
+
+#--e1 :
+# Rotation_angle = -np.pi/2
+# Rotation_vector = np.array([0,1,0])
+
+#--e2:
+Rotation_angle = np.pi/2
+Rotation_vector = np.array([1,0,0])
+
+###--e = np.array([1/np.sqrt(2),1/np.sqrt(2)])
+# Rotation_angle = -np.pi/2
+# Rotation_vector = np.array([1,0,0])
+# #2te rotation :
+# Rotation_angle = np.pi/4
+# Rotation_vector = np.array([0,0,1])
+
+
+
+# Rotation_angle = -np.pi/2
+# Rotation_angle = 0
+# # Rotation_angle = np.pi/2
+# Rotation_vector = np.array([0,1,0])
+# Rotation_vector = np.array([1,0,0])
+
+# rot(np.array([0,1,0]),np.pi/2)
+
+# ZERO ROTATION
+Rotation = rot(np.array([0,1,0]),0)
+
+
+
+# TEST :
+
+#DETERMINE ANGLE:
+angle = math.atan2(e[1], e[0])
+print('angle:', angle)
+
+## GENERAL TRANSFORMATION / ROTATION:
+# Rotation = rot(np.array([0,0,1]),angle).dot(rot(np.array([0,1,0]),-np.pi/2))
+
+# Rotation = rot(np.array([0,0,1]),+np.pi/4).dot(Rotation)
+# Rotation = rot(np.array([0,0,1]),+np.pi/16).dot(Rotation)
+
+
+
+### if e1:
+# Rotation = rot(np.array([0,0,1]),-np.pi/4).dot(Rotation)
+# Rotation = rot(np.array([0,0,1]),+np.pi/16).dot(Rotation)
+
+# Add another rotation around z-axis:
+# Rotation = rot(np.array([0,0,1]),+np.pi).dot(Rotation)
+# Rotation = rot(np.array([0,0,1]),+np.pi/4).dot(Rotation)
+
+
+# Rotation = rot(np.array([0,0,1]),+np.pi/8).dot(Rotation)
+
+#e3 :
+# Rotation = rot(np.array([0,1,0]),-np.pi/2)
+# Rotation = rot(np.array([0,0,1]),np.pi/4).dot(rot(np.array([0,1,0]),-np.pi/2))
+
+# Rotation = rot(np.array([0,0,1]),np.pi/4)
+# Rotation = rot(np.array([1,0,0]),np.pi/4)
+#### if e1 :
+# Rotation = rot(np.array([0,1,0]),-np.pi/2)
+#### if e2:
+# Rotation = rot(np.array([0,1,0]),-np.pi/2).dot(rot(np.array([1,0,0]),-np.pi/2))
+# # #### if e3 :
+# zufall dass np.pi/4 genau dem Winkel angle alpha entspricht?:
+# (würde) bei e_2 keinen Unterschied machen um z achse zu rotieren?!
+
+# Rotation = rot(np.array([0,0,1]),np.pi/4).dot(rot(np.array([0,1,0]),-np.pi/2).dot(rot(np.array([1,0,0]),-np.pi/2)))
+# Rotation = rot(np.array([0,0,1]),np.pi/2).dot(rot(np.array([0,1,0]),-np.pi/2).dot(rot(np.array([1,0,0]),-np.pi/2)))
+
+# Rotation = rot(np.array([1,0,0]),np.pi/2)
+
+# Rotation_vector = e3_mapped  #TEST
+# Rotation_vector = np.array([-1/np.sqrt(2),1/np.sqrt(2)])
+# Rotation_vector = np.array([0,0,1])
+
+# v = np.array([1,0,0])
+# X = np.array([u1,u2,u3])
+
+
+
+
+# T = rotate_data(np.array([u1,u2,u3]),Rotation_vector,Rotation_angle)
+T = rotate_data(np.array([u1,u2,u3]),Rotation)
+
+# ax.plot_surface(T[0], T[1], T[2], color = 'w', rstride = 2, cstride = 2, facecolors=cm.brg(colorfunction), alpha=.4, zorder=4)
+ax.plot_surface(T[0], T[1], T[2], color = 'w', rstride = 1, cstride = 1, facecolors=cm.Blues(colorfunction), alpha=.4, zorder=4)
+
+
+###---- PLOT PARAMETER-PLANE:
+# ax.plot_surface(x1,x2,zero,color = 'w', rstride = 1, cstride = 1 )
+
+
+print('------------------ Kappa : ', kappa)
+
+#midpoint:
+midpoint = np.array([(max(x)+min(x))/2,(max(y)+min(y))/2])
+print('midpoint',midpoint)
+
+# Map midpoint:
+midpoint_mapped = u(midpoint,kappa,e)
+print('mapped midpoint', midpoint_mapped)
+
+#map origin
+origin = np.array([0,0])
+origin_mapped = u(origin,kappa,e)
+
+
+mapped_e = grad_u(midpoint,kappa,e)
+normal = compute_normal(midpoint,kappa,e)
+
+print('mapped_e', mapped_e)
+print('normal',normal )
+
+#
+# mapped_e = Rotation.dot(mapped_e)
+# normal = Rotation.dot(normal)
+
+
+# Plot Mapped_midPoint
+ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],    # data
+marker='o',     # each marker will be rendered as a circle
+markersize=4,   # marker size
+markerfacecolor='orange',   # marker facecolor
+markeredgecolor='black',  # marker edgecolor
+markeredgewidth=1,       # marker edge width
+linewidth=1,
+zorder=4)          # line width
+
+# ax.quiver([midpoint_mapped[0]], [midpoint_mapped[1]], [midpoint_mapped[2]], [mapped_e[0]], [mapped_e[1]], [mapped_e[2]], color="red")
+# ax.quiver([midpoint_mapped[0]], [midpoint_mapped[1]], [midpoint_mapped[2]], [normal[0]], [normal[1]], [normal[2]], color="blue")
+
+ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+           mapped_e[0],mapped_e[1],mapped_e[2],
+           mutation_scale=15,
+           arrowstyle="-|>",
+           linestyle='dashed',fc='green',
+           lw = 2,
+           ec ='green',
+           zorder=3)
+
+ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+           normal[0],normal[1],normal[2],
+           mutation_scale=15,
+            lw = 2,
+           arrowstyle="-|>",
+           linestyle='dashed',fc='blue',
+           ec ='blue',
+           zorder = 3)
+
+
+###-- TEST Rotation :
+# v = np.array([1,0,0])
+# t = np.array([0,1,0])
+#
+# ax.arrow3D(0,0,0,
+#            t[0],t[1],t[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='blue',
+#            ec ='blue')
+#
+# # e_extend
+#
+# rotM = rot(v,np.pi/2)
+#
+# print('rotM:', rotM)
+#
+# rot_t = rotM.dot(t)
+#
+# print('rot_t:', rot_t)
+#
+# ax.arrow3D(0,0,0,
+#            rot_t[0],rot_t[1],rot_t[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='blue',
+#            ec ='blue')
+
+### -------------------------------------------
+
+############################################################################################################################################
+####################################################################### KAPPA POSITIVE  ####################################################
+############################################################################################################################################
+
+kappa = (-1)*kappa
+
+# if kappa == 0 :
+#     u1 = 0*x1
+#     u2 = x1*e[0] + x2*e[1]
+#     u3 = x2*e[0] - x1*e[1]
+# else :
+#     u1 = -(1/kappa)*np.cos(kappa*(x1*e[0]+x2*e[1])) + (1/kappa)
+#     u2 = (1/kappa)*np.sin(kappa*(x1*e[0]+x2*e[1]))
+#     u3 = x2*e[0] -x1*e[1]
+
+
+if kappa == 0 :
+    # u1 = 0*x1
+    # u2 = x1*e[0] + x2*e[1]
+    # u3 = x2*e[0] - x1*e[1]
+    u1 = x1*e[0] + x2*e[1]
+    u2 = x2*e[0] - x1*e[1]
+    u3 = 0*x1
+
+else :
+    # u1 = -(1/kappa)*np.cos(kappa*(x1*e[0]+x2*e[1])) + (1/kappa)
+    # u2 = (1/kappa)*np.sin(kappa*(x1*e[0]+x2*e[1]))
+    # u3 = x2*e[0] -x1*e[1]
+    u1 = -(1/kappa)*np.sin((-1)*kappa*(x1*e[0]+x2*e[1]))
+    u2 =  x2*e[0] -x1*e[1]
+    u3 = (1/kappa)*np.cos((-1)*kappa*(x1*e[0]+x2*e[1]))-(1/kappa)
+# ax.plot_surface(u1, u2, u3, color = 'w', rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.3)  ##This one!
+
+
+# T = rotate_data(X,Rotation_vector,Rotation_angle)
+
+T = rotate_data(np.array([u1,u2,u3]),Rotation)
+# T = rotate_data(T,np.array([0,1,0]),Rotation_angle)
+# T = rotate_data(T,np.array([0,0,1]),-1*Rotation_angle/2)
+
+# ax.plot_surface(T[0], T[1], T[2], rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4, antialiased=False)
+# ax.plot_surface(T[0], T[1], T[2], rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4, antialiased=True)
+ax.plot_surface(T[0], T[1], T[2], rstride = 2, cstride = 2, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4)
+# ax.plot_surface(T[0], T[1], T[2], rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=.4, zorder=4, shade=True)
+# ax.plot_surface(T[0], T[1], T[2], color = 'w', rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=0.8, zorder=4)
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, facecolors=cm.autumn(colorfunction), alpha=1, zorde5r=5)
+
+# midpoint = np.array([(max(x)+min(x))/2,(max(y)+min(y))/2])
+# print('midpoint',midpoint)
+print('------------------ Kappa : ', kappa)
+# Map midpoint:
+midpoint_mapped = u(midpoint,kappa,e)
+print('mapped midpoint', midpoint_mapped)
+
+#map origin
+origin = np.array([0,0])
+origin_mapped = u(origin,kappa,e)
+
+
+mapped_e = grad_u(midpoint,kappa,e)
+normal = compute_normal(midpoint,kappa,e)
+
+print('mapped_e', mapped_e)
+print('normal',normal )
+
+
+#
+# mapped_e = Rotation.dot(mapped_e)
+# normal = Rotation.dot(normal)
+
+
+# ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2], color='black', markersize=10,marker='o',  zorder=5)
+ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],    # data
+marker='o',     # each marker will be rendered as a circle
+markersize=4,   # marker size
+markerfacecolor='orange',   # marker facecolor
+markeredgecolor='black',  # marker edgecolor
+markeredgewidth=1,       # marker edge width
+linewidth=1,
+zorder=5)          # line width
+# ax.scatter3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2], color='black', s=100,  zorder=5)
+
+
+# mapped_e = grad_u(midpoint,kappa,e)
+# normal = compute_normal(midpoint,kappa,e)
+
+
+ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+           mapped_e[0],mapped_e[1],mapped_e[2],
+           mutation_scale=15,
+           arrowstyle="-|>",
+           linestyle='dashed',fc='green',
+           lw = 1.5,
+           ec ='green',
+           zorder=5)
+
+ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+           normal[0],normal[1],normal[2],
+           mutation_scale=15,
+            lw = 1.5,
+           arrowstyle="-|>",
+           linestyle='dashed',fc='blue',
+           ec ='blue',
+           zorder = 5)
+
+
+############################################################################################################################################
+####################################################################### KAPPA ZERO #########################################################
+############################################################################################################################################
+kappa = 0
+
+# if kappa == 0 :
+#     u1 = 0*x1
+#     u2 = x1*e[0] + x2*e[1]
+#     u3 = x2*e[0] - x1*e[1]
+# else :
+#     u1 = -(1/kappa)*np.cos(kappa*(x1*e[0]+x2*e[1])) + (1/kappa)
+#     u2 = (1/kappa)*np.sin(kappa*(x1*e[0]+x2*e[1]))
+#     u3 = x2*e[0] -x1*e[1]
+
+if kappa == 0 :
+    # u1 = 0*x1
+    # u2 = x1*e[0] + x2*e[1]
+    # u3 = x2*e[0] - x1*e[1]
+    u1 = x1*e[0] + x2*e[1]
+    u2 = x2*e[0] - x1*e[1]
+    u3 = 0*x1
+
+else :
+    # u1 = -(1/kappa)*np.cos(kappa*(x1*e[0]+x2*e[1])) + (1/kappa)
+    # u2 = (1/kappa)*np.sin(kappa*(x1*e[0]+x2*e[1]))
+    # u3 = x2*e[0] -x1*e[1]
+    u1 = -(1/kappa)*np.sin((-1)*kappa*(x1*e[0]+x2*e[1]))
+    u2 =  x2*e[0] -x1*e[1]
+    u3 = (1/kappa)*np.cos((-1)*kappa*(x1*e[0]+x2*e[1]))-(1/kappa)
+# ax.plot_surface(u1, u2, u3,  rstride = 1, cstride = 1, color = 'white', alpha=0.85)
+
+# T = rotate_data(np.array([u1,u2,u3]),Rotation_vector,Rotation_angle)
+
+T = rotate_data(np.array([u1,u2,u3]),Rotation)
+# T = rotate_data(T,np.array([0,1,0]),Rotation_angle)
+# T = rotate_data(T,np.array([0,0,1]),-1*Rotation_angle/2)
+
+
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, color = 'white', alpha=0.55, zorder=2, antialiased=True)
+# ax.plot_surface(T[0], T[1], T[2],  rstride =1 , cstride = 1, color = 'white', alpha=0.55, zorder=3)
+
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, color = 'white', alpha=0.55, zorder=2)
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 1, cstride = 1, color = 'white', alpha=0.5, zorder=2, antialiased=True)
+ax.plot_surface(T[0], T[1], T[2],  rstride = 10, cstride = 10, color = 'white', alpha=0.55, zorder=2)
+# ax.plot_surface(T[0], T[1], T[2],  rstride = 20, cstride = 20, color = 'gray', alpha=0.35, zorder=1, shade=True)
+# ax.plot_surface(T[0], T[1], T[2], color = 'white', alpha=0.55, zorder=2)
+
+# midpoint = np.array([(max(x)+min(x))/2,(max(y)+min(y))/2])
+mapped_e = grad_u(midpoint,kappa,e)
+normal_zeroCurv = compute_normal(midpoint,kappa,e)
+
+# Map midpoint:
+midpoint_mapped = u(midpoint,kappa,e)
+print('mapped midpoint', midpoint_mapped)
+
+##-----  PLOT MAPPED MIDPOINT :::
+
+ax.plot(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],    # data
+marker='o',     # each marker will be rendered as a circle
+markersize=4,   # marker size
+markerfacecolor='orange',   # marker facecolor
+markeredgecolor='black',  # marker edgecolor
+markeredgewidth=1,       # marker edge width
+# linestyle='--',            # line style will be dash line
+linewidth=1,
+zorder=5)
+
+# ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+#            mapped_e[0],mapped_e[1],mapped_e[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='red',
+#            ec ='red')
+#
+# ax.arrow3D(midpoint_mapped[0],midpoint_mapped[1],midpoint_mapped[2],
+#            normal_zeroCurv[0],normal_zeroCurv[1],normal_zeroCurv[2],
+#            mutation_scale=10,
+#            arrowstyle="-|>",
+#            linestyle='dashed',fc='blue',
+#            ec ='blue')
+
+
+##----------  PLOT MAPPED ORIGIN :::
+# origin = np.array([0,0])
+# origin_mapped = u(origin,kappa,e)
+# print('origin_mapped', origin_mapped)
+#
+# ax.plot(origin_mapped[0],origin_mapped[1],origin_mapped[2],    # data
+# marker='o',     # each marker will be rendered as a circle
+# markersize=4,   # marker size
+# markerfacecolor='green',   # marker facecolor
+# markeredgecolor='black',  # marker edgecolor
+# markeredgewidth=1,       # marker edge width
+# linewidth=1,
+# zorder=5)          # line width
+#
+# # rotate mapped origin
+# # v = np.array([1,0,0])
+# # alpha  = Rotation_angle
+#
+# rotM = rot(Rotation_vector,Rotation_angle)
+# # origin_mRot = rotate_data(origin_mapped,v,alpha)
+# origin_mRot = rotM.dot(origin_mapped)
+# print('origin_mapped Rotated', origin_mRot)
+#
+# # --- Compute Distance to Origin 3D
+# origin_3D=np.array([0,0,0])
+# distance = origin_mapped-origin_3D
+# print('distance', distance)
+
+## --------------------------------------------------------
+
+# COMPUTE ANGLE WITH Z AXIS
+z = np.array([0,0,1])
+print('test', normal_zeroCurv*z)
+angle_z = np.arccos(normal_zeroCurv.dot(z) /( (np.linalg.norm(z)*np.linalg.norm(normal_zeroCurv) ) ))
+print('angle between normal and z-axis', angle_z)
+
+## unfinished...
+
+
+
+
+###-------------------------------------  PLOT :
+plt.axis('off')
+# plt.axis('tight')
+
+# ADD colorbar
+# scamap = plt.cm.ScalarMappable(cmap='inferno')
+# fig.colorbar(scamap)
+
+# ax.colorbar()
+# ax.axis('auto')
+# ax.set_title(r'Cylindrical minimizer_$\kappa$='+ str(kappa)+ '_$e$=' +  str(e))
+# ax.set_title(r'Cylindrical minimizer' + '_$e$=' +  str(e))
+ax.set_xlabel(r"x-axis")
+ax.set_ylabel(r"y-axis")
+ax.set_zlabel(r"z-axis")
+
+# TEST :
+# ax.annotate3D('point 1', (0, 0, 0), xytext=(3, 3), textcoords='offset points')
+# ax.annotate3D('point 2', (0, 1, 0),
+#               xytext=(-30, -30),
+#               textcoords='offset points',
+#               arrowprops=dict(ec='black', fc='white', shrink=2.5))
+# ax.annotate3D('point 3', (0, 0, 1),
+#               xytext=(30, -30),
+#               textcoords='offset points',
+#               bbox=dict(boxstyle="round", fc="lightyellow"),
+#               arrowprops=dict(arrowstyle="-|>", ec='black', fc='white', lw=5))
+
+#######################################################################################################################
+
+u1 = T[0]
+u2 = T[1]
+u3 = T[2]
+
+max_range = np.array([u1.max()-u1.min(), u2.max()-u2.min(), u3.max()-u3.min()]).max() /3
+# max_range = np.array([u1.max()-u1.min(), u2.max()-u2.min(), u3.max()-u3.min()]).max() /2
+mid_u1 = (u1.max()+u1.min()) * 0.5
+mid_u2 = (u2.max()+u2.min()) * 0.5
+mid_u3 = (u3.max()+u3.min()) * 0.5
+
+
+ax.set_xlim(mid_u1 - max_range, mid_u1 + max_range)
+ax.set_ylim(mid_u2 - max_range, mid_u2 + max_range)
+ax.set_zlim(mid_u3 - max_range, mid_u3 + max_range)
+
+
+
+
+
+
+
+
+##----- CHANGE CAMERA POSITION:
+# ax.view_init(elev=10., azim=0)
+# ax.view_init(elev=38, azim=90)
+# ax.view_init(elev=38, azim=120)
+# ax.view_init(elev=38)
+
+# if e1 ::
+# ax.view_init(elev=44)
+# ax.view_init(elev=38, azim=-90)
+# ax.view_init(elev=38, azim=0)
+
+
+# if e3 ::
+ax.view_init(elev=25)
+
+# ax.set_xlim3d(-2, 2)
+# ax.set_ylim3d(-1.0,3.0)
+# ax.set_zlim3d(-1.5,2.5)
+
+# ax.set_ylim3d(-10,10)
+# ax.set_xlim(mid_u1 - max_range-0.2, mid_u1 + max_range+0.2)
+# ax.set_zlim(mid_u3 - max_range-0.2, mid_u3 + max_range+0.2)
+# ax.set_ylim(mid_u2 - max_range-0.2, mid_u2 + max_range+0.2)
+
+# width = 6.28 *0.5
+# height = width / 1.618
+# # height = width / 2.5
+# fig.set_size_inches(width, height)
+# fig.savefig('Test-Cylindrical.pdf')
+
+# Figurename = r'Cylindrical minimizer_$\kappa$='+ str(kappa)+ '_$e$=' +  str(e)
+Figurename = r'Cylindrical minimizer' + '_$e$=' +  str(e)
+# plt.savefig("test.png", bbox_inches='tight')
+# plt.figure().set_size_inches(width, height)
+# plt.set_size_inches(width, height)
+
+
+# fig.set_size_inches(width, height)
+# fig.savefig(Figurename+".pdf")
+
+plt.savefig(Figurename+".png", bbox_inches='tight')
+# plt.savefig(Figurename+".png")
+plt.show()
+
+
+
+# #---------------------------------------------------------------

JNLS_plotScripts/Energy_ContourG+.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+from ClassifyMin import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+import time
+import matplotlib.ticker as ticker
+
+import matplotlib as mpl
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+import pandas as pd
+
+import seaborn as sns
+import matplotlib.colors as mcolors
+# from matplotlib import rc
+# rc('text', usetex=True) # Use LaTeX font
+#
+# import seaborn as sns
+# sns.set(color_codes=True)
+
+# set the colormap and centre the colorbar
+class MidpointNormalize(mcolors.Normalize):
+	"""
+	Normalise the colorbar so that diverging bars work there way either side from a prescribed midpoint value)
+
+	e.g. im=ax1.imshow(array, norm=MidpointNormalize(midpoint=0.,vmin=-100, vmax=100))
+	"""
+	def __init__(self, vmin=None, vmax=None, midpoint=None, clip=False):
+		self.midpoint = midpoint
+		mcolors.Normalize.__init__(self, vmin, vmax, clip)
+
+	def __call__(self, value, clip=None):
+		# I'm ignoring masked values and all kinds of edge cases to make a
+		# simple example...
+		x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
+		return np.ma.masked_array(np.interp(value, x, y), np.isnan(value))
+
+
+
+def format_func(value, tick_number):
+    # find number of multiples of pi/2
+    # N = int(np.round(2 * value / np.pi))
+    # if N == 0:
+    #     return "0"
+    # elif N == 1:
+    #     return r"$\pi/2$"
+    # elif N == -1:
+    #     return r"$-\pi/2$"
+    # elif N == 2:
+    #     return r"$\pi$"
+    # elif N % 2 > 0:
+    #     return r"${0}\pi/2$".format(N)
+    # else:
+    #     return r"${0}\pi$".format(N // 2)
+    ##find number of multiples of pi/2
+    N = int(np.round(4 * value / np.pi))
+    if N == 0:
+        return "0"
+    elif N == 1:
+        return r"$\pi/4$"
+    elif N == -1:
+        return r"$-\pi/4$"
+    elif N == 2:
+        return r"$\pi/2$"
+    elif N == -2:
+        return r"$-\pi/2$"
+    elif N % 2 > 0:
+        return r"${0}\pi/2$".format(N)
+    else:
+        return r"${0}\pi$".format(N // 2)
+
+
+
+def find_nearest(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return array[idx]
+
+
+def find_nearestIdx(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return idx
+
+
+
+def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+
+
+    a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+
+
+    tmp = H.dot(a)
+
+    # print('H',H)
+    # print('A',A)
+    # print('b',b)
+    # print('a',a)
+    # print('tmp',tmp)
+
+    tmp = (1/2)*a.dot(tmp)
+    # print('tmp',tmp)
+
+    tmp2 = A.dot(b)
+    # print('tmp2',tmp2)
+    tmp2 = 2*a.dot(tmp2)
+
+    # print('tmp2',tmp2)
+    energy = tmp - tmp2
+    # print('energy',energy)
+
+
+    # energy_axial1.append(energy_1)
+
+    return energy
+
+
+
+# def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+#
+#
+#     b = np.array([b1,b2])
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a',a)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy = tmp - tmp2
+#     print('energy',energy)
+#
+#
+#     # energy_axial1.append(energy_1)
+#
+#     return energy
+#
+
+
+
+
+
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+print('---- Input parameters: -----')
+
+# q1=1;
+# q2=2;
+# q12=1/2;
+# q3=((4*q1*q2)**0.5-q12)/2;
+# # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+#
+# H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+# A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+# abar = np.array([q12+2*q3, 2*q2])
+# abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+#
+# print('abar:',abar)
+#
+# b = np.linalg.lstsq(A, abar)[0]
+# print('b',b)
+#
+#
+# # print('abar:',np.shape(abar))
+# # print('np.transpose(abar):',np.shape(np.transpose(abar)))
+# sstar = (1/(q1+q2))*abar.dot(A.dot(b))
+# # sstar = (1/(q1+q2))*abar.dot(tmp)
+# print('sstar', sstar)
+# abarperp= np.array([abar[1],-abar[0]])
+# print('abarperp:',abarperp)
+
+
+# -------------------------- Input Parameters --------------------
+
+mu1 = 1.0
+rho1 = 1.0
+alpha = 5.0
+theta = 1.0/2
+# theta= 0.1
+beta = 5.0
+
+
+
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+
+
+#Figure3:
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/8
+# # theta= 0.1
+# beta = 2.0
+
+
+# alpha= -5
+
+
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+gamma = '0'
+gamma = 'infinity'
+
+
+lambda1 = 0.0
+
+
+print('---- Input parameters: -----')
+print('mu1: ', mu1)
+print('rho1: ', rho1)
+# print('alpha: ', alpha)
+print('beta: ', beta)
+# print('theta: ', theta)
+print('gamma:', gamma)
+
+print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+print('----------------------------')
+
+# ----------------------------------------------------------------
+
+
+
+
+
+
+q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta)
+q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta)
+q12 = 0.0
+q3 = GetMuGamma(beta, theta,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+b1 = prestrain_b1(rho1,beta, alpha, theta )
+b2 = prestrain_b2(rho1,beta, alpha, theta )
+
+
+# 1-ParameterFamilyCase:
+
+q1=1;
+q2=2;
+q12=1/2;
+q3=((4*q1*q2)**0.5-q12)/2;
+# H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+
+H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+abar = np.array([q12+2*q3, 2*q2])
+abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+
+print('abar:',abar)
+
+b = np.linalg.lstsq(A, abar)[0]
+print('b',b)
+
+b1=b[0]
+b2=b[1]
+
+
+
+
+
+print('q1 = ', q1)
+print('q2 = ', q2)
+print('q3 = ', q3)
+print('q12 = ', q12)
+print('b1 = ', b1)
+print('b2 = ', b2)
+
+num_Points = 400
+# num_Points = 20
+
+
+# Creating dataset
+x = np.linspace(-5,5,num_Points)
+y = np.linspace(-5,5,num_Points)
+
+x = np.linspace(-20,20,num_Points)
+y = np.linspace(-20,20,num_Points)
+
+# x = np.linspace(-10,10,num_Points)
+# y = np.linspace(-10,10,num_Points)
+
+# x = np.linspace(-60,60,num_Points)
+# y = np.linspace(-60,60,num_Points)
+#
+#
+# x = np.linspace(-40,40,num_Points)
+# y = np.linspace(-40,40,num_Points)
+
+
+a1, a2 = np.meshgrid(x,y)
+
+geyser = sns.load_dataset("geyser")
+print('type of geyser:', type(geyser))
+print('geyser:',geyser)
+
+ContourRange=20
+
+x_in = np.linspace(-ContourRange,ContourRange,num_Points)
+y_in = np.linspace(-ContourRange,ContourRange,num_Points)
+a1_in, a2_in = np.meshgrid(x_in,y_in)
+
+print('a1:', a1)
+print('a2:',a2 )
+
+print('a1.shape', a1.shape)
+
+#-- FILTER OUT VALUES for G+ :
+
+# tmp1 = a1[np.where(a1*a2 >= 0)]
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+
+# np.take(a, np.where(a>100)[0], axis=0)
+# tmp1 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+
+# tmp1 = a1[a1*a2 >= 0]
+# tmp2 = a2[a1*a2 >= 0]
+
+
+# tmp1_pos = a1[np.where(a1*a2 >= 0) ]
+# tmp2_pos = a2[np.where(a1*a2 >= 0) ]
+# tmp1_pos = tmp1_pos[np.where(tmp1_pos  >= 0)]
+# tmp2_pos = tmp2_pos[np.where(tmp2_pos  >= 0)]
+
+# tmp1_neg = a1[a1*a2 >= 0 ]
+# tmp2_neg = a2[a1*a2 >= 0 ]
+# tmp1_neg = tmp1_neg[tmp1_neg  < 0]
+# tmp2_neg = tmp2_neg[tmp2_neg  < 0]
+# a1 = tmp1
+# a2 = tmp2
+#
+# a1 = a1.reshape(-1,5)
+# a2 = a2.reshape(-1,5)
+
+# tmp1_pos = tmp1_pos.reshape(-1,5)
+# tmp2_pos = tmp2_pos.reshape(-1,5)
+# tmp1_neg = tmp1_neg.reshape(-1,5)
+# tmp2_neg = tmp2_neg.reshape(-1,5)
+
+
+print('a1:', a1)
+print('a2:',a2 )
+print('a1.shape', a1.shape)
+
+
+
+
+
+energyVec = np.vectorize(energy)
+
+# Z = energyVec(np.array([a1,a2]),q1,q2,q12,q3,b1,b2)
+Z = energyVec(a1,a2,q1,q2,q12,q3,b1,b2)
+
+Z_in = energyVec(a1_in,a2_in,q1,q2,q12,q3,b1,b2)
+
+
+print('Z:', Z)
+
+print('any', np.any(Z<0))
+
+#
+
+
+# negZ_a1 = a1[np.where(Z<0)]
+# negZ_a2 = a2[np.where(Z<0)]
+# negativeValues = Z[np.where(Z<0)]
+# print('negativeValues:',negativeValues)
+#
+# print('negZ_a1',negZ_a1)
+# print('negZ_a2',negZ_a2)
+#
+#
+# negZ_a1 = negZ_a1.reshape(-1,5)
+# negZ_a2 = negZ_a2.reshape(-1,5)
+# negativeValues = negativeValues.reshape(-1,5)
+#
+# Z_pos =  energyVec(tmp1_pos,tmp2_pos,q1,q2,q12,q3,b1,b2)
+# Z_neg = energyVec(tmp1_neg,tmp2_neg,q1,q2,q12,q3,b1,b2)
+
+
+
+
+
+# print('Test energy:' , energy(np.array([1,1]),q1,q2,q12,q3,b1,b2))
+
+
+
+
+# print('Z_pos.shape', Z_pos.shape)
+
+
+
+
+
+
+
+## -- PLOT :
+mpl.rcParams['text.usetex'] = True
+mpl.rcParams["font.family"] = "serif"
+mpl.rcParams["font.size"] = "9"
+
+label_size = 8
+mpl.rcParams['xtick.labelsize'] = label_size
+mpl.rcParams['ytick.labelsize'] = label_size
+
+# plt.style.use('seaborn')
+plt.style.use('seaborn-whitegrid')
+# sns.set()
+# plt.style.use('seaborn-whitegrid')
+
+label_size = 9
+mpl.rcParams['xtick.labelsize'] = label_size
+mpl.rcParams['ytick.labelsize'] = label_size
+
+width = 6.28 *0.5
+# width = 6.28
+height = width / 1.618
+fig = plt.figure()
+
+# ax = plt.axes(projection ='3d', adjustable='box')
+ax = plt.axes((0.17,0.21 ,0.75,0.75))
+# ax = plt.axes((0.15,0.18,0.8,0.8))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+ax.grid(True,which='major',axis='both',alpha=0.3)
+
+# colorfunction=(B*kappa)
+# print('colofunction',colorfunction)
+
+#translate Data
+# Z = Z - (Z.max()-Z.min())/2
+# Z = Z - 50
+# Z = Z - 500
+#
+# Z = Z.T
+
+
+# Substract constant:
+c = (b1**2)*q1+b1*b2*q12+(b2**2)*q2
+Z = Z-c
+
+print('Value of c:', c)
+
+
+
+print('Z.min()', Z.min())
+print('Z.max()', Z.max())
+norm=mcolors.Normalize(Z.min(),Z.max())
+# facecolors=cm.brg(norm)
+
+
+print('norm:', norm)
+print('type of norm', type(norm))
+print('norm(0):', norm(0))
+print('norm(Z):', norm(Z))
+
+# ax.plot(theta_rho, theta_values, 'royalblue', zorder=3, )
+
+# ax.scatter(a1,a2, s=0.5)
+
+# ax.scatter(tmp1_pos,tmp2_pos, s=0.5)
+# ax.scatter(tmp1_neg,tmp2_neg, s=0.5)
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, levels=100 )
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot,  levels=20 )
+
+
+# sns.kdeplot(np.array([a1, a2, Z]))
+# sns.kdeplot(tmp1_pos,tmp2_pos,Z_pos)
+
+# levels = [-5.0, -4, -3, 0.0, 1.5, 2.5, 3.5]
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, corner_mask=True,levels=levels)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot(norm(Z)), corner_mask=True)
+# CS = ax.contour(a1, a2, Z, cm.brg(norm(Z)), levels=20)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot, levels=20)
+# CS = ax.contour(a1, a2, Z, colors='k', levels=14,  linewidths=(0.5,))
+# CS = ax.contour(a1, a2, Z, colors='k', levels=18,  linewidths=(0.5,))
+
+# ax.contour(negZ_a1, negZ_a2, negativeValues, colors='k',  linewidths=(0.5,))
+CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(0.5,))
+
+
+
+# df = pd.DataFrame(data=Z_in, columns=a1_in, index=a2_in)
+# df2 = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
+#                    columns=['a', 'b', 'c'])
+
+
+
+
+# sns.kdeplot(data=df2, x="waiting", y="duration")
+# sns.kdeplot(data=df2)
+
+# CS = ax.contour(a1, a2, Z, colors='k',   linewidths=(0.5,))
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k', extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k')
+#
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, levels=10 )
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, corner_mask=True)
+#
+# CS = ax.contour(a1, a2, Z,10,  colors = 'k')
+ax.clabel(CS, inline=True, fontsize=4)
+
+
+# cmap = cm.brg(norm(Z))
+#
+# C_map = cm.inferno(norm(Z))
+
+# ax.imshow(Z, cmap=C_map, extent=[-20, 20, -20, 20], origin='lower', alpha=0.5)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20], origin='lower',
+#                   cmap='bwr', alpha=0.8)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', vmin=Z.min(), vmax=Z.max(),
+#                   cmap='bwr', alpha=0.6)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+
+cmap=mpl.cm.RdBu_r
+# cmap=mpl.cm.viridis_r
+cmap=mpl.cm.bwr
+# cmap=mpl.cm.coolwarm
+cmap=mpl.cm.gnuplot
+
+# cmap = cm.brg(Z)
+divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap='coolwarm', alpha=0.6)
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+# divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+# plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+                  cmap=cmap, alpha=0.6)
+
+
+
+
+# COLORBAR :
+# cbar = plt.colorbar()
+# cbar.ax.tick_params(labelsize=8)
+
+
+
+
+##----- ADD RECTANGLE TO COVER QUADRANT :
+epsilon = 0.4
+epsilon = 0.1
+# ax.axvspan(0, x.max(), y.min(), 0, alpha=1, color='yellow', zorder=5)#yellow
+# ax.fill_between([0, x.max()], y.min(), 0, alpha=0.3, color='yellow', zorder=5)#yellow
+# ax.fill_between([x.min(), 0], 0, y.max(), alpha=0.3, color='yellow', zorder=5)#yellow
+ax.fill_between([0+epsilon, x.max()], y.min(), 0-epsilon, alpha=0.7, color='gray', zorder=5)#yellow
+ax.fill_between([x.min(), 0-epsilon], 0+epsilon, y.max(), alpha=0.7, color='gray', zorder=5)#yellow
+
+
+# ax.plot_surface(a1,a2, Z, cmap=cm.coolwarm,
+#                        linewidth=0, antialiased=False)
+
+
+
+# ax.plot(theta_rho, energy_axial1, 'royalblue', zorder=3, label=r"axialMin1")
+# ax.plot(theta_rho, energy_axial2, 'forestgreen', zorder=3, label=r"axialMin2")
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )
+
+
+
+
+# lg = ax.legend(bbox_to_anchor=(0.0, 0.75), loc='upper left')
+
+
+
+### PLot x and y- Axes
+ax.plot(ax.get_xlim(),[0,0],'k--', linewidth=0.5)
+ax.plot([0,0],ax.get_ylim(), 'k--', linewidth=0.5)
+
+
+
+ax.set_xlabel(r"$a_1$", fontsize=10 ,labelpad=0)
+ax.set_ylabel(r"$a_2$", fontsize=10 ,labelpad=0)
+# ax.set_ylabel(r"energy")
+
+
+# ax.set_xticks([-np.pi/2, -np.pi/4  ,0,  np.pi/4,  np.pi/2 ])
+# labels = ['$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$']
+# ax.set_yticklabels(labels)
+
+
+
+
+
+# ax.legend(loc='upper right')
+
+
+
+fig.set_size_inches(width, height)
+fig.savefig('Energy_ContourG+.pdf')
+
+plt.show()
+
+
+#
+#
+#
+# # Curve parametrised by \theta_rho = alpha in parameter space
+# N=100;
+# theta_rho = np.linspace(1, 3, num=N)
+# print('theta_rho:', theta_rho)
+#
+#
+# theta_values = []
+#
+#
+# for t in theta_rho:
+#
+#         s = (1.0/10.0)*t+0.1
+#         theta_values.append(s)
+#
+#
+#
+#
+#
+# theta_rho = np.array(theta_rho)
+# theta_values = np.array(theta_values)
+#
+# betas_ = 2.0
+#
+
+# alphas, betas, thetas = np.meshgrid(theta_rho, betas_, theta_values, indexing='ij')
+#
+#
+# harmonicMeanVec = np.vectorize(harmonicMean)
+# arithmeticMeanVec = np.vectorize(arithmeticMean)
+# prestrain_b1Vec = np.vectorize(prestrain_b1)
+# prestrain_b2Vec = np.vectorize(prestrain_b2)
+#
+# GetMuGammaVec = np.vectorize(GetMuGamma)
+# muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#
+# q1_vec = harmonicMeanVec(mu1, betas, thetas)
+# q2_vec = arithmeticMeanVec(mu1, betas, thetas)
+#
+# b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+# b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+
+# special case: q12 == 0!! .. braucht eigentlich nur b1 & b2 ...
+
+# print('type b1_values:', type(b1_values))
+
+
+
+# print('size(q1)',q1.shape)
+#
+#
+# energy_axial1 = []
+# energy_axial2 = []
+#
+# # for b1 in b1_values:
+# for i in range(len(theta_rho)):
+#     print('index i:', i)
+#
+#     print('theta_rho[i]',theta_rho[i])
+#     print('theta_values[i]',theta_values[i])
+#
+#     q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta_values[i])
+#     q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta_values[i])
+#     q12 = 0.0
+#     q3 = GetMuGamma(beta, theta_values[i],gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#     b1 = prestrain_b1(rho1,beta, theta_rho[i],theta_values[i] )
+#     b2 = prestrain_b2(rho1,beta, theta_rho[i],theta_values[i] )
+#
+#
+#     # q2_vec = arithmeticMean(mu1, betas, thetas)
+#     #
+#     # b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+#     # b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+#     print('q1[i]',q1)
+#     print('q2[i]',q2)
+#     print('q3[i]',q3)
+#     print('b1[i]',b1)
+#     print('b2[i]',b2)
+#     # print('q1[i]',q1[0][i])
+#     # print('q2[i]',q2[i])
+#     # print('b1[i]',b1[i])
+#     # print('b2[i]',b2[i])
+#     #compute axial energy #1 ...
+#
+#     a_axial1 = np.array([b1,0])
+#     a_axial2 = np.array([0,b2])
+#     b = np.array([b1,b2])
+#
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a_axial1)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial1',a_axial1)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial1.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial1.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_1 = tmp - tmp2
+#     print('energy_1',energy_1)
+#
+#
+#     energy_axial1.append(energy_1)
+#
+#
+#     tmp = H.dot(a_axial2)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial2',a_axial2)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial2.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial2.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_2 = tmp - tmp2
+#     print('energy_2',energy_2)
+#
+#
+#     energy_axial2.append(energy_2)
+#
+#
+#
+#
+#
+# print('theta_values', theta_values)
+#
+#
+#
+
+
+#
+#
+#
+#
+# kappas = []
+# alphas = []
+# # G.append(float(s[0]))
+#
+#
+#
+#
+# for t in T :
+#
+#     abar_current = sstar*abar+t*abarperp;
+#     # print('abar_current', abar_current)
+#     abar_current[abar_current < 1e-10] = 0
+#     # print('abar_current', abar_current)
+#
+#     # G = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     G = [abar_current[0], abar_current[1] , (2*abar_current[0]*abar_current[1])**0.5 ]
+#
+#     e = [(abar_current[0]/(abar_current[0]+abar_current[1]))**0.5, (abar_current[1]/(abar_current[0]+abar_current[1]))**0.5]
+#     kappa = abar_current[0]+abar_current[1]
+#     alpha = math.atan2(e[1], e[0])
+#
+#     print('angle current:', alpha)
+#
+#     kappas.append(kappa)
+#     alphas.append(alpha)
+#
+#
+#
+# alphas = np.array(alphas)
+# kappas = np.array(kappas)
+#
+#
+# print('kappas:',kappas)
+# print('alphas:',alphas)
+# print('min alpha:', min(alphas))
+# print('min kappa:', min(kappas))
+#
+# mpl.rcParams['text.usetex'] = True
+# mpl.rcParams["font.family"] = "serif"
+# mpl.rcParams["font.size"] = "9"
+# width = 6.28 *0.5
+# height = width / 1.618
+# fig = plt.figure()
+# # ax = plt.axes((0.15,0.21 ,0.75,0.75))
+# ax = plt.axes((0.15,0.21 ,0.8,0.75))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# # ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# # ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# # ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# # ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+# ax.grid(True,which='major',axis='both',alpha=0.3)
+#
+#
+#
+#
+# ax.plot(alphas, kappas, 'royalblue', zorder=3, )
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )

JNLS_plotScripts/Energy_ContourG+_plotly.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+from ClassifyMin import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+import time
+import matplotlib.ticker as ticker
+
+import matplotlib as mpl
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+import pandas as pd
+
+import seaborn as sns
+import matplotlib.colors as mcolors
+
+from chart_studio import plotly
+import plotly.graph_objs as go
+from plotly.subplots import make_subplots
+import plotly.io as pio
+# from matplotlib import rc
+# rc('text', usetex=True) # Use LaTeX font
+#
+# import seaborn as sns
+# sns.set(color_codes=True)
+
+
+def show(fig):
+    import io
+    import plotly.io as pio
+    from PIL import Image
+    buf = io.BytesIO()
+    pio.write_image(fig, buf)
+    img = Image.open(buf)
+    img.show()
+
+
+def set_size(width, fraction=1):
+    """Set figure dimensions to avoid scaling in LaTeX.
+
+    Parameters
+    ----------
+    width: float
+            Document textwidth or columnwidth in pts
+    fraction: float, optional
+            Fraction of the width which you wish the figure to occupy
+
+    Returns
+    -------
+    fig_dim: tuple
+            Dimensions of figure in inches
+    """
+    # Width of figure (in pts)
+    fig_width_pt = width * fraction
+
+    # Convert from pt to inches
+    inches_per_pt = 1 / 72.27
+
+    # Golden ratio to set aesthetic figure height
+    # https://disq.us/p/2940ij3
+    golden_ratio = (5**.5 - 1) / 2
+
+    # Figure width in inches
+    fig_width_in = fig_width_pt * inches_per_pt
+    # Figure height in inches
+    fig_height_in = fig_width_in * golden_ratio
+
+    fig_dim = (fig_width_in, fig_height_in)
+
+    return fig_dim
+
+
+
+
+# set the colormap and centre the colorbar
+class MidpointNormalize(mcolors.Normalize):
+	"""
+	Normalise the colorbar so that diverging bars work there way either side from a prescribed midpoint value)
+
+	e.g. im=ax1.imshow(array, norm=MidpointNormalize(midpoint=0.,vmin=-100, vmax=100))
+	"""
+	def __init__(self, vmin=None, vmax=None, midpoint=None, clip=False):
+		self.midpoint = midpoint
+		mcolors.Normalize.__init__(self, vmin, vmax, clip)
+
+	def __call__(self, value, clip=None):
+		# I'm ignoring masked values and all kinds of edge cases to make a
+		# simple example...
+		x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
+		return np.ma.masked_array(np.interp(value, x, y), np.isnan(value))
+
+
+
+def format_func(value, tick_number):
+    # find number of multiples of pi/2
+    # N = int(np.round(2 * value / np.pi))
+    # if N == 0:
+    #     return "0"
+    # elif N == 1:
+    #     return r"$\pi/2$"
+    # elif N == -1:
+    #     return r"$-\pi/2$"
+    # elif N == 2:
+    #     return r"$\pi$"
+    # elif N % 2 > 0:
+    #     return r"${0}\pi/2$".format(N)
+    # else:
+    #     return r"${0}\pi$".format(N // 2)
+    ##find number of multiples of pi/2
+    N = int(np.round(4 * value / np.pi))
+    if N == 0:
+        return "0"
+    elif N == 1:
+        return r"$\pi/4$"
+    elif N == -1:
+        return r"$-\pi/4$"
+    elif N == 2:
+        return r"$\pi/2$"
+    elif N == -2:
+        return r"$-\pi/2$"
+    elif N % 2 > 0:
+        return r"${0}\pi/2$".format(N)
+    else:
+        return r"${0}\pi$".format(N // 2)
+
+
+
+def find_nearest(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return array[idx]
+
+
+def find_nearestIdx(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return idx
+
+
+
+def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+
+
+    a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+
+
+    tmp = H.dot(a)
+
+    # print('H',H)
+    # print('A',A)
+    # print('b',b)
+    # print('a',a)
+    # print('tmp',tmp)
+
+    tmp = (1/2)*a.dot(tmp)
+    # print('tmp',tmp)
+
+    tmp2 = A.dot(b)
+    # print('tmp2',tmp2)
+    tmp2 = 2*a.dot(tmp2)
+
+    # print('tmp2',tmp2)
+    energy = tmp - tmp2
+    # print('energy',energy)
+
+
+    # energy_axial1.append(energy_1)
+
+    return energy
+
+
+
+# def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+#
+#
+#     b = np.array([b1,b2])
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a',a)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy = tmp - tmp2
+#     print('energy',energy)
+#
+#
+#     # energy_axial1.append(energy_1)
+#
+#     return energy
+#
+
+
+
+
+
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+print('---- Input parameters: -----')
+
+# q1=1;
+# q2=2;
+# q12=1/2;
+# q3=((4*q1*q2)**0.5-q12)/2;
+# # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+#
+# H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+# A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+# abar = np.array([q12+2*q3, 2*q2])
+# abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+#
+# print('abar:',abar)
+#
+# b = np.linalg.lstsq(A, abar)[0]
+# print('b',b)
+#
+#
+# # print('abar:',np.shape(abar))
+# # print('np.transpose(abar):',np.shape(np.transpose(abar)))
+# sstar = (1/(q1+q2))*abar.dot(A.dot(b))
+# # sstar = (1/(q1+q2))*abar.dot(tmp)
+# print('sstar', sstar)
+# abarperp= np.array([abar[1],-abar[0]])
+# print('abarperp:',abarperp)
+
+
+# -------------------------- Input Parameters --------------------
+
+mu1 = 1.0
+rho1 = 1.0
+alpha = 5.0
+theta = 1.0/2
+# theta= 0.1
+beta = 5.0
+
+
+
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+
+
+#Figure3:
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/8
+# # theta= 0.1
+# beta = 2.0
+
+
+# alpha= -5
+
+
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+gamma = '0'
+gamma = 'infinity'
+
+
+lambda1 = 0.0
+
+
+print('---- Input parameters: -----')
+print('mu1: ', mu1)
+print('rho1: ', rho1)
+# print('alpha: ', alpha)
+print('beta: ', beta)
+# print('theta: ', theta)
+print('gamma:', gamma)
+
+print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+print('----------------------------')
+
+# ----------------------------------------------------------------
+
+
+
+
+
+
+q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta)
+q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta)
+q12 = 0.0
+q3 = GetMuGamma(beta, theta,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+b1 = prestrain_b1(rho1,beta, alpha, theta )
+b2 = prestrain_b2(rho1,beta, alpha, theta )
+
+
+# 1-ParameterFamilyCase:
+
+q1=1;
+q2=2;
+q12=1/2;
+q3=((4*q1*q2)**0.5-q12)/2;
+# H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+
+H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+abar = np.array([q12+2*q3, 2*q2])
+abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+
+print('abar:',abar)
+
+b = np.linalg.lstsq(A, abar)[0]
+print('b',b)
+
+b1=b[0]
+b2=b[1]
+
+
+
+
+
+print('q1 = ', q1)
+print('q2 = ', q2)
+print('q3 = ', q3)
+print('q12 = ', q12)
+print('b1 = ', b1)
+print('b2 = ', b2)
+
+# num_Points = 400
+num_Points = 100
+# num_Points = 20
+
+
+# Creating dataset
+x = np.linspace(-5,5,num_Points)
+y = np.linspace(-5,5,num_Points)
+
+x = np.linspace(-20,20,num_Points)
+y = np.linspace(-20,20,num_Points)
+
+# x = np.linspace(-10,10,num_Points)
+# y = np.linspace(-10,10,num_Points)
+
+# x = np.linspace(-60,60,num_Points)
+# y = np.linspace(-60,60,num_Points)
+#
+#
+# x = np.linspace(-40,40,num_Points)
+# y = np.linspace(-40,40,num_Points)
+
+
+a1, a2 = np.meshgrid(x,y)
+
+geyser = sns.load_dataset("geyser")
+print('type of geyser:', type(geyser))
+print('geyser:',geyser)
+
+ContourRange=20
+
+x_in = np.linspace(-ContourRange,ContourRange,num_Points)
+y_in = np.linspace(-ContourRange,ContourRange,num_Points)
+a1_in, a2_in = np.meshgrid(x_in,y_in)
+
+print('a1:', a1)
+print('a2:',a2 )
+
+print('a1.shape', a1.shape)
+
+#-- FILTER OUT VALUES for G+ :
+
+# tmp1 = a1[np.where(a1*a2 >= 0)]
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+#
+# np.take(a, np.where(a>100)[0], axis=0)
+# tmp1 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+
+tmp1 = a1[a1*a2 >= 0]
+tmp2 = a2[a1*a2 >= 0]
+tmp1 = tmp1.reshape(-1,5)
+tmp2 = tmp2.reshape(-1,5)
+
+
+# tmp1_pos = a1[np.where(a1*a2 >= 0) ]
+# tmp2_pos = a2[np.where(a1*a2 >= 0) ]
+# tmp1_pos = tmp1_pos[np.where(tmp1_pos  >= 0)]
+# tmp2_pos = tmp2_pos[np.where(tmp2_pos  >= 0)]
+#
+# tmp1_neg = a1[a1*a2 >= 0 ]
+# tmp2_neg = a2[a1*a2 >= 0 ]
+# tmp1_neg = tmp1_neg[tmp1_neg  < 0]
+# tmp2_neg = tmp2_neg[tmp2_neg  < 0]
+# a1 = tmp1
+# a2 = tmp2
+#
+# a1 = a1.reshape(-1,5)
+# a2 = a2.reshape(-1,5)
+#
+# tmp1_pos = tmp1_pos.reshape(-1,5)
+# tmp2_pos = tmp2_pos.reshape(-1,5)
+# tmp1_neg = tmp1_neg.reshape(-1,5)
+# tmp2_neg = tmp2_neg.reshape(-1,5)
+
+
+print('a1:', a1)
+print('a2:',a2 )
+print('a1.shape', a1.shape)
+
+
+
+
+
+energyVec = np.vectorize(energy)
+
+# Z = energyVec(np.array([a1,a2]),q1,q2,q12,q3,b1,b2)
+Z = energyVec(a1,a2,q1,q2,q12,q3,b1,b2)
+
+Z_in = energyVec(a1_in,a2_in,q1,q2,q12,q3,b1,b2)
+
+
+
+
+print('Z:', Z)
+
+print('any', np.any(Z<0))
+
+#
+
+
+# negZ_a1 = a1[np.where(Z<0)]
+# negZ_a2 = a2[np.where(Z<0)]
+# negativeValues = Z[np.where(Z<0)]
+# print('negativeValues:',negativeValues)
+#
+# print('negZ_a1',negZ_a1)
+# print('negZ_a2',negZ_a2)
+#
+#
+# negZ_a1 = negZ_a1.reshape(-1,5)
+# negZ_a2 = negZ_a2.reshape(-1,5)
+# negativeValues = negativeValues.reshape(-1,5)
+#
+# Z_pos =  energyVec(tmp1_pos,tmp2_pos,q1,q2,q12,q3,b1,b2)
+# Z_neg = energyVec(tmp1_neg,tmp2_neg,q1,q2,q12,q3,b1,b2)
+
+
+
+
+
+# print('Test energy:' , energy(np.array([1,1]),q1,q2,q12,q3,b1,b2))
+
+
+
+
+# print('Z_pos.shape', Z_pos.shape)
+
+
+
+
+
+
+
+## -- PLOT :
+mpl.rcParams['text.usetex'] = True
+mpl.rcParams["font.family"] = "serif"
+mpl.rcParams["font.size"] = "9"
+
+label_size = 8
+mpl.rcParams['xtick.labelsize'] = label_size
+mpl.rcParams['ytick.labelsize'] = label_size
+
+# plt.style.use('seaborn')
+# plt.style.use('seaborn-whitegrid')
+# sns.set()
+# plt.style.use('seaborn-whitegrid')
+
+label_size = 9
+mpl.rcParams['xtick.labelsize'] = label_size
+mpl.rcParams['ytick.labelsize'] = label_size
+
+width = 6.28 *0.5
+width = 6.28 *0.33
+# width = 6.28
+height = width / 1.618
+height = width
+fig = plt.figure()
+
+# ax = plt.axes(projection ='3d', adjustable='box')
+ax = plt.axes((0.17,0.21 ,0.75,0.75))
+# ax = plt.axes((0.15,0.18,0.8,0.8))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+# ax.grid(True,which='major',axis='both',alpha=0.3)
+
+# colorfunction=(B*kappa)
+# print('colofunction',colorfunction)
+
+#translate Data
+# Z = Z - (Z.max()-Z.min())/2
+# Z = Z - 50
+# Z = Z - 500
+#
+# Z = Z.T
+
+
+# Substract constant:
+c = (b1**2)*q1+b1*b2*q12+(b2**2)*q2
+Z = Z-c
+
+print('Value of c:', c)
+
+
+
+print('Z.min()', Z.min())
+print('Z.max()', Z.max())
+norm=mcolors.Normalize(Z.min(),Z.max())
+# facecolors=cm.brg(norm)
+
+
+print('norm:', norm)
+print('type of norm', type(norm))
+print('norm(0):', norm(0))
+print('norm(Z):', norm(Z))
+
+# ax.plot(theta_rho, theta_values, 'royalblue', zorder=3, )
+
+# ax.scatter(a1,a2, s=0.5)
+
+# ax.scatter(tmp1_pos,tmp2_pos, s=0.5)
+# ax.scatter(tmp1_neg,tmp2_neg, s=0.5)
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, levels=100 )
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot,  levels=20 )
+
+
+# sns.kdeplot(np.array([a1, a2, Z]))
+# sns.kdeplot(tmp1_pos,tmp2_pos,Z_pos)
+
+# levels = [-5.0, -4, -3, 0.0, 1.5, 2.5, 3.5]
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, corner_mask=True,levels=levels)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot(norm(Z)), corner_mask=True)
+# CS = ax.contour(a1, a2, Z, cm.brg(norm(Z)), levels=20)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot, levels=20)
+# CS = ax.contour(a1, a2, Z, colors='k', levels=14,  linewidths=(0.5,))
+# CS = ax.contour(a1, a2, Z, colors='k', levels=18,  linewidths=(0.5,))
+
+# ax.contour(negZ_a1, negZ_a2, negativeValues, colors='k',  linewidths=(0.5,))
+CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(0.5,),zorder=5)
+
+
+## PLOTLY:
+
+fig = make_subplots(specs=[[{"secondary_y": True}]])
+
+
+data1 = go.Contour(x = x_in, y = y_in, z = Z_in,
+		# colorscale='Electric',
+		colorscale='agsunset',
+		contours=dict(
+            coloring ='heatmap',
+            showlabels = True, # show labels on contours
+            labelfont = dict( # label font properties
+                size = 14,
+                color = 'white',
+            )
+		), line_width=2 ,line_smoothing=0.85,
+		# colorbar=dict(
+        #     title='Color bar title', # title here
+        #     titleside='right',
+        #     titlefont=dict(
+        #         size=14,
+        #         family='Arial, sans-serif')
+		# )
+
+
+		)
+epsilon = 0.4
+epsilon = 0.1
+# data2 = go.Scatter(x=[0+epsilon,x.max(),x.max(), 0+epsilon], y=[0-epsilon,0-epsilon,y.min(),y.min()], fill="toself")
+data2 = go.Scatter(x=[0+epsilon,x.max(),x.max(), 0+epsilon], y=[0-epsilon,0-epsilon,y.min(),y.min()])
+
+# data_tmp = [data1,data2]
+data_tmp = [data1]
+
+fig = go.Figure(data = data_tmp)
+
+# ADD RECTANGLES:
+fig.add_shape(type="rect",
+    x0=0+epsilon, y0=0-epsilon, x1=x.max(), y1=y.min(),
+    line=dict(
+        color="White",
+        width=1,
+    ),
+    fillcolor="White",
+    opacity=0.75
+)
+fig.add_shape(type="rect",
+    x0=x.min(), y0=0+epsilon, x1=0-epsilon, y1=y.max(),
+    line=dict(
+        color="White",
+        width=1
+    ),
+    fillcolor="White",
+    opacity=0.75
+)
+
+
+# ADD COORDINATE LINES
+
+fig.add_shape(type="line",
+    x0=x.min(), y0=0, x1=x.max(), y1=0,
+    line=dict(
+        color="black",
+        width=2,
+        dash="dash",
+    )
+)
+
+fig.add_shape(type="line",
+    x0=0, y0=y.min(), x1=0, y1=y.max(),
+    line=dict(
+        color="black",
+        width=2,
+        dash="dash",
+    )
+)
+
+# fig = go.Figure(data = go.Contour(Z_in, a1_in, a2_in))
+# fig = go.Figure(data = go.Contour(x = x_in, y = y_in, z = Z_in,
+# 		# colorscale='Electric',
+# 		colorscale='agsunset',
+# 		contours=dict(
+#             coloring ='heatmap',
+#             showlabels = True, # show labels on contours
+#             labelfont = dict( # label font properties
+#                 size = 12,
+#                 color = 'white',
+#             )
+# 		), line_width=2 ,line_smoothing=0.85,
+# 		# colorbar=dict(
+#         #     title='Color bar title', # title here
+#         #     titleside='right',
+#         #     titlefont=dict(
+#         #         size=14,
+#         #         family='Arial, sans-serif')
+# 		# )
+# 		)
+#         )
+
+epsilon = 0.4
+epsilon = 0.1
+# ax.axvspan(0, x.max(), y.min(), 0, alpha=1, color='yellow', zorder=5)#yellow
+# ax.fill_between([0, x.max()], y.min(), 0, alpha=0.3, color='yellow', zorder=5)#yellow
+# ax.fill_between([x.min(), 0], 0, y.max(), alpha=0.3, color='yellow', zorder=5)#yellow
+
+# fillcolor = 'white'
+# ax.fill_between([0+epsilon, x.max()], y.min(), 0-epsilon, alpha=0.7, color=fillcolor, zorder=4)#yellow
+# ax.fill_between([x.min(), 0-epsilon], 0+epsilon, y.max(), alpha=0.7, color=fillcolor, zorder=4)#yellow
+
+
+# trace2 = go.Figure(go.Scatter(x=[0+epsilon,x.max(),x.max(), 0+epsilon], y=[0-epsilon,0-epsilon,y.min(),y.min()], fill="toself"))
+# fig.add_trace(trace1)
+
+# fig.add_trace(trace1)
+# fig.add_trace(trace2.data[0],secondary_y=True)
+
+fig.update_layout(
+    autosize=False,
+    # width=500,
+    # height=500,
+    width=300,
+    height=300,
+    # margin=dict(
+    #     l=50,
+    #     r=50,
+    #     b=100,
+    #     t=100,
+    #     pad=4
+    # ),
+    # paper_bgcolor="LightSteelBlue",
+)
+
+width = 452.9579/2
+size= set_size(width, fraction=0.5)
+print('set_size(width, fraction=0.5)', set_size(width, fraction=0.5))
+print('size[0]',size[0])
+
+
+
+# fig.show()
+# show(fig)
+# fig.write_image("Plotly-fig1.png",  width=width, height=height, scale=1)
+fig.write_image("Plotly-fig1.png")
+# pio.write_image(fig, "test.svg", width=6.28 *0.33*300, height=6.28 *0.33*300, scale=1)
+# pio.write_image(fig, "test.png", width=6.28*0.33*300, height=6.28*0.33*300)
+pio.write_image(fig, "test.pdf", width=6.28*0.33*300, height=6.28*0.33*300)
+# pio.write_image(fig, "test.pdf", width=width, height=width)
+# df = pd.DataFrame(data=Z_in, columns=a1_in, index=a2_in)
+# df2 = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
+#                    columns=['a', 'b', 'c'])
+
+
+
+
+# sns.kdeplot(data=df2, x="waiting", y="duration")
+# sns.kdeplot(data=df2)
+
+# CS = ax.contour(a1, a2, Z, colors='k',   linewidths=(0.5,))
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k', extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k')
+#
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, levels=10 )
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, corner_mask=True)
+#
+# CS = ax.contour(a1, a2, Z,10,  colors = 'k')
+ax.clabel(CS, inline=True, fontsize=4)
+
+
+# cmap = cm.brg(norm(Z))
+#
+# C_map = cm.inferno(norm(Z))
+
+# ax.imshow(Z, cmap=C_map, extent=[-20, 20, -20, 20], origin='lower', alpha=0.5)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20], origin='lower',
+#                   cmap='bwr', alpha=0.8)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', vmin=Z.min(), vmax=Z.max(),
+#                   cmap='bwr', alpha=0.6)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+
+cmap=mpl.cm.RdBu_r
+# cmap=mpl.cm.viridis_r
+cmap=mpl.cm.bwr
+# cmap=mpl.cm.coolwarm
+cmap=mpl.cm.gnuplot
+
+# cmap = cm.brg(Z)
+divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap='coolwarm', alpha=0.6)
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+# divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+# plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+                  cmap=cmap, alpha=0.6)
+
+
+
+
+
+# COLORBAR :
+cbar = plt.colorbar()
+cbar.ax.tick_params(labelsize=8)
+
+
+
+
+##----- ADD RECTANGLE TO COVER QUADRANT :
+epsilon = 0.4
+epsilon = 0.1
+# ax.axvspan(0, x.max(), y.min(), 0, alpha=1, color='yellow', zorder=5)#yellow
+# ax.fill_between([0, x.max()], y.min(), 0, alpha=0.3, color='yellow', zorder=5)#yellow
+# ax.fill_between([x.min(), 0], 0, y.max(), alpha=0.3, color='yellow', zorder=5)#yellow
+
+fillcolor = 'white'
+ax.fill_between([0+epsilon, x.max()], y.min(), 0-epsilon, alpha=0.7, color=fillcolor, zorder=4)#yellow
+ax.fill_between([x.min(), 0-epsilon], 0+epsilon, y.max(), alpha=0.7, color=fillcolor, zorder=4)#yellow
+
+
+# ax.plot_surface(a1,a2, Z, cmap=cm.coolwarm,
+#                        linewidth=0, antialiased=False)
+
+
+
+# ax.plot(theta_rho, energy_axial1, 'royalblue', zorder=3, label=r"axialMin1")
+# ax.plot(theta_rho, energy_axial2, 'forestgreen', zorder=3, label=r"axialMin2")
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )
+
+
+
+
+# lg = ax.legend(bbox_to_anchor=(0.0, 0.75), loc='upper left')
+
+
+
+### PLot x and y- Axes
+ax.plot(ax.get_xlim(),[0,0],'k--', linewidth=0.5)
+ax.plot([0,0],ax.get_ylim(), 'k--', linewidth=0.5)
+
+
+
+ax.set_xlabel(r"$a_1$", fontsize=10 ,labelpad=0)
+ax.set_ylabel(r"$a_2$", fontsize=10 ,labelpad=0)
+# ax.set_ylabel(r"energy")
+
+
+# ax.set_xticks([-np.pi/2, -np.pi/4  ,0,  np.pi/4,  np.pi/2 ])
+# labels = ['$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$']
+# ax.set_yticklabels(labels)
+
+
+
+
+
+# ax.legend(loc='upper right')
+
+
+
+fig.set_size_inches(width, height)
+fig.savefig('Energy_ContourG+.pdf')
+
+plt.show()
+
+
+#
+#
+#
+# # Curve parametrised by \theta_rho = alpha in parameter space
+# N=100;
+# theta_rho = np.linspace(1, 3, num=N)
+# print('theta_rho:', theta_rho)
+#
+#
+# theta_values = []
+#
+#
+# for t in theta_rho:
+#
+#         s = (1.0/10.0)*t+0.1
+#         theta_values.append(s)
+#
+#
+#
+#
+#
+# theta_rho = np.array(theta_rho)
+# theta_values = np.array(theta_values)
+#
+# betas_ = 2.0
+#
+
+# alphas, betas, thetas = np.meshgrid(theta_rho, betas_, theta_values, indexing='ij')
+#
+#
+# harmonicMeanVec = np.vectorize(harmonicMean)
+# arithmeticMeanVec = np.vectorize(arithmeticMean)
+# prestrain_b1Vec = np.vectorize(prestrain_b1)
+# prestrain_b2Vec = np.vectorize(prestrain_b2)
+#
+# GetMuGammaVec = np.vectorize(GetMuGamma)
+# muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#
+# q1_vec = harmonicMeanVec(mu1, betas, thetas)
+# q2_vec = arithmeticMeanVec(mu1, betas, thetas)
+#
+# b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+# b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+
+# special case: q12 == 0!! .. braucht eigentlich nur b1 & b2 ...
+
+# print('type b1_values:', type(b1_values))
+
+
+
+# print('size(q1)',q1.shape)
+#
+#
+# energy_axial1 = []
+# energy_axial2 = []
+#
+# # for b1 in b1_values:
+# for i in range(len(theta_rho)):
+#     print('index i:', i)
+#
+#     print('theta_rho[i]',theta_rho[i])
+#     print('theta_values[i]',theta_values[i])
+#
+#     q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta_values[i])
+#     q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta_values[i])
+#     q12 = 0.0
+#     q3 = GetMuGamma(beta, theta_values[i],gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#     b1 = prestrain_b1(rho1,beta, theta_rho[i],theta_values[i] )
+#     b2 = prestrain_b2(rho1,beta, theta_rho[i],theta_values[i] )
+#
+#
+#     # q2_vec = arithmeticMean(mu1, betas, thetas)
+#     #
+#     # b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+#     # b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+#     print('q1[i]',q1)
+#     print('q2[i]',q2)
+#     print('q3[i]',q3)
+#     print('b1[i]',b1)
+#     print('b2[i]',b2)
+#     # print('q1[i]',q1[0][i])
+#     # print('q2[i]',q2[i])
+#     # print('b1[i]',b1[i])
+#     # print('b2[i]',b2[i])
+#     #compute axial energy #1 ...
+#
+#     a_axial1 = np.array([b1,0])
+#     a_axial2 = np.array([0,b2])
+#     b = np.array([b1,b2])
+#
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a_axial1)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial1',a_axial1)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial1.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial1.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_1 = tmp - tmp2
+#     print('energy_1',energy_1)
+#
+#
+#     energy_axial1.append(energy_1)
+#
+#
+#     tmp = H.dot(a_axial2)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial2',a_axial2)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial2.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial2.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_2 = tmp - tmp2
+#     print('energy_2',energy_2)
+#
+#
+#     energy_axial2.append(energy_2)
+#
+#
+#
+#
+#
+# print('theta_values', theta_values)
+#
+#
+#
+
+
+#
+#
+#
+#
+# kappas = []
+# alphas = []
+# # G.append(float(s[0]))
+#
+#
+#
+#
+# for t in T :
+#
+#     abar_current = sstar*abar+t*abarperp;
+#     # print('abar_current', abar_current)
+#     abar_current[abar_current < 1e-10] = 0
+#     # print('abar_current', abar_current)
+#
+#     # G = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     G = [abar_current[0], abar_current[1] , (2*abar_current[0]*abar_current[1])**0.5 ]
+#
+#     e = [(abar_current[0]/(abar_current[0]+abar_current[1]))**0.5, (abar_current[1]/(abar_current[0]+abar_current[1]))**0.5]
+#     kappa = abar_current[0]+abar_current[1]
+#     alpha = math.atan2(e[1], e[0])
+#
+#     print('angle current:', alpha)
+#
+#     kappas.append(kappa)
+#     alphas.append(alpha)
+#
+#
+#
+# alphas = np.array(alphas)
+# kappas = np.array(kappas)
+#
+#
+# print('kappas:',kappas)
+# print('alphas:',alphas)
+# print('min alpha:', min(alphas))
+# print('min kappa:', min(kappas))
+#
+# mpl.rcParams['text.usetex'] = True
+# mpl.rcParams["font.family"] = "serif"
+# mpl.rcParams["font.size"] = "9"
+# width = 6.28 *0.5
+# height = width / 1.618
+# fig = plt.figure()
+# # ax = plt.axes((0.15,0.21 ,0.75,0.75))
+# ax = plt.axes((0.15,0.21 ,0.8,0.75))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# # ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# # ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# # ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# # ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+# ax.grid(True,which='major',axis='both',alpha=0.3)
+#
+#
+#
+#
+# ax.plot(alphas, kappas, 'royalblue', zorder=3, )
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )

JNLS_plotScripts/Energy_ContourG+_v2.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+from ClassifyMin import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+import time
+import matplotlib.ticker as ticker
+
+import matplotlib as mpl
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+import pandas as pd
+
+import seaborn as sns
+import matplotlib.colors as mcolors
+
+from chart_studio import plotly
+import plotly.graph_objs as go
+import plotly.express as px
+import plotly.colors
+# from matplotlib import rc
+# rc('text', usetex=True) # Use LaTeX font
+#
+# import seaborn as sns
+# sns.set(color_codes=True)
+
+
+def show(fig):
+    import io
+    import plotly.io as pio
+    from PIL import Image
+    buf = io.BytesIO()
+    pio.write_image(fig, buf)
+    img = Image.open(buf)
+    img.show()
+
+
+
+
+# set the colormap and centre the colorbar
+class MidpointNormalize(mcolors.Normalize):
+	"""
+	Normalise the colorbar so that diverging bars work there way either side from a prescribed midpoint value)
+
+	e.g. im=ax1.imshow(array, norm=MidpointNormalize(midpoint=0.,vmin=-100, vmax=100))
+	"""
+	def __init__(self, vmin=None, vmax=None, midpoint=None, clip=False):
+		self.midpoint = midpoint
+		mcolors.Normalize.__init__(self, vmin, vmax, clip)
+
+	def __call__(self, value, clip=None):
+		# I'm ignoring masked values and all kinds of edge cases to make a
+		# simple example...
+		x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
+		return np.ma.masked_array(np.interp(value, x, y), np.isnan(value))
+
+
+
+def set_size(width, fraction=1):
+    """Set figure dimensions to avoid scaling in LaTeX.
+
+    Parameters
+    ----------
+    width: float
+            Document textwidth or columnwidth in pts
+    fraction: float, optional
+            Fraction of the width which you wish the figure to occupy
+
+    Returns
+    -------
+    fig_dim: tuple
+            Dimensions of figure in inches
+    """
+    # Width of figure (in pts)
+    fig_width_pt = width * fraction
+
+    # Convert from pt to inches
+    inches_per_pt = 1 / 72.27
+
+    # Golden ratio to set aesthetic figure height
+    # https://disq.us/p/2940ij3
+    golden_ratio = (5**.5 - 1) / 2
+
+    # Figure width in inches
+    fig_width_in = fig_width_pt * inches_per_pt
+    # Figure height in inches
+    fig_height_in = fig_width_in * golden_ratio
+
+    fig_dim = (fig_width_in, fig_height_in)
+
+    return fig_dim
+
+
+
+def format_func(value, tick_number):
+    # find number of multiples of pi/2
+    # N = int(np.round(2 * value / np.pi))
+    # if N == 0:
+    #     return "0"
+    # elif N == 1:
+    #     return r"$\pi/2$"
+    # elif N == -1:
+    #     return r"$-\pi/2$"
+    # elif N == 2:
+    #     return r"$\pi$"
+    # elif N % 2 > 0:
+    #     return r"${0}\pi/2$".format(N)
+    # else:
+    #     return r"${0}\pi$".format(N // 2)
+    ##find number of multiples of pi/2
+    N = int(np.round(4 * value / np.pi))
+    if N == 0:
+        return "0"
+    elif N == 1:
+        return r"$\pi/4$"
+    elif N == -1:
+        return r"$-\pi/4$"
+    elif N == 2:
+        return r"$\pi/2$"
+    elif N == -2:
+        return r"$-\pi/2$"
+    elif N % 2 > 0:
+        return r"${0}\pi/2$".format(N)
+    else:
+        return r"${0}\pi$".format(N // 2)
+
+
+
+def find_nearest(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return array[idx]
+
+
+def find_nearestIdx(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return idx
+
+
+
+
+def check_case(q1,q2,q12,q3,b1,b2):
+
+    # a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+
+
+    print('det(H)=', np.linalg.det(H))
+
+    # check if g* is in G^*_R^2
+    tmp = A.dot(b)
+
+    ## compute inverse of H :
+    inv_H = np.linalg.inv(H)
+
+    g_star = inv_H.dot(tmp)
+
+    print('g_star=', g_star)
+
+
+    return g_star
+
+
+def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+
+
+    a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+
+
+    tmp = H.dot(a)
+
+    # print('H',H)
+    # print('A',A)
+    # print('b',b)
+    # print('a',a)
+    # print('tmp',tmp)
+
+    tmp = (1/2)*a.dot(tmp)
+    # print('tmp',tmp)
+
+    tmp2 = A.dot(b)
+    # print('tmp2',tmp2)
+    tmp2 = 2*a.dot(tmp2)
+
+    # print('tmp2',tmp2)
+    energy = tmp - tmp2
+    # print('energy',energy)
+
+
+    # energy_axial1.append(energy_1)
+
+    return energy
+
+
+
+# def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+#
+#
+#     b = np.array([b1,b2])
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a',a)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy = tmp - tmp2
+#     print('energy',energy)
+#
+#
+#     # energy_axial1.append(energy_1)
+#
+#     return energy
+#
+
+
+
+
+
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+print('---- Input parameters: -----')
+
+# q1=1;
+# q2=2;
+# q12=1/2;
+# q3=((4*q1*q2)**0.5-q12)/2;
+# # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+#
+# H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+# A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+# abar = np.array([q12+2*q3, 2*q2])
+# abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+#
+# print('abar:',abar)
+#
+# b = np.linalg.lstsq(A, abar)[0]
+# print('b',b)
+#
+#
+# # print('abar:',np.shape(abar))
+# # print('np.transpose(abar):',np.shape(np.transpose(abar)))
+# sstar = (1/(q1+q2))*abar.dot(A.dot(b))
+# # sstar = (1/(q1+q2))*abar.dot(tmp)
+# print('sstar', sstar)
+# abarperp= np.array([abar[1],-abar[0]])
+# print('abarperp:',abarperp)
+
+
+# -------------------------- Input Parameters --------------------
+
+mu1 = 1.0
+rho1 = 1.0
+alpha = 5.0
+theta = 1.0/2
+# theta= 0.1
+beta = 5.0
+
+
+
+
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = -0.75
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+
+
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+
+
+#Figure3:
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/8
+# # theta= 0.1
+# beta = 2.0
+
+
+# alpha= -5
+
+
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+gamma = '0'
+# gamma = 'infinity'
+
+
+lambda1 = 0.0
+
+
+print('---- Input parameters: -----')
+print('mu1: ', mu1)
+print('rho1: ', rho1)
+# print('alpha: ', alpha)
+print('beta: ', beta)
+# print('theta: ', theta)
+print('gamma:', gamma)
+
+print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+print('----------------------------')
+
+# ----------------------------------------------------------------
+
+
+
+
+
+
+q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta)
+q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta)
+q12 = 0.0
+q3 = GetMuGamma(beta, theta,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+b1 = prestrain_b1(rho1,beta, alpha, theta )
+b2 = prestrain_b2(rho1,beta, alpha, theta )
+
+
+## ---- 1-ParameterFamilyCase:
+# q1=1;
+# q2=2;
+# q12=1/2;
+# q3=((4*q1*q2)**0.5-q12)/2;
+# # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+# H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+# A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+# abar = np.array([q12+2*q3, 2*q2])
+# abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+# print('abar:',abar)
+# b = np.linalg.lstsq(A, abar)[0]
+# print('b',b)
+# b1=b[0]
+# b2=b[1]
+## ---------------
+
+
+
+
+print('q1 = ', q1)
+print('q2 = ', q2)
+print('q3 = ', q3)
+print('q12 = ', q12)
+print('b1 = ', b1)
+print('b2 = ', b2)
+
+## --- CHECK CASE ---
+
+
+g_star = check_case(q1,q2,q12,q3,b1,b2)
+
+
+
+
+
+
+## -------------------------------------
+
+num_Points = 400
+num_Points = 200
+# num_Points = 20
+
+
+# Creating dataset
+x = np.linspace(-5,5,num_Points)
+y = np.linspace(-5,5,num_Points)
+
+x = np.linspace(-20,20,num_Points)
+y = np.linspace(-20,20,num_Points)
+
+
+x = np.linspace(-2,2,num_Points)
+y = np.linspace(-2,2,num_Points)
+# x = np.linspace(-10,10,num_Points)
+# y = np.linspace(-10,10,num_Points)
+
+# x = np.linspace(-60,60,num_Points)
+# y = np.linspace(-60,60,num_Points)
+#
+#
+# x = np.linspace(-40,40,num_Points)
+# y = np.linspace(-40,40,num_Points)
+
+
+a1, a2 = np.meshgrid(x,y)
+
+# geyser = sns.load_dataset("geyser")
+# print('type of geyser:', type(geyser))
+# print('geyser:',geyser)
+
+# ContourRange=20
+ContourRange=2
+
+x_in = np.linspace(-ContourRange,ContourRange,num_Points)
+y_in = np.linspace(-ContourRange,ContourRange,num_Points)
+a1_in, a2_in = np.meshgrid(x_in,y_in)
+
+print('a1:', a1)
+print('a2:',a2 )
+
+print('a1.shape', a1.shape)
+
+#-- FILTER OUT VALUES for G+ :
+
+# tmp1 = a1[np.where(a1*a2 >= 0)]
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+#
+# np.take(a, np.where(a>100)[0], axis=0)
+# tmp1 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+
+tmp1 = a1[a1*a2 >= 0]
+tmp2 = a2[a1*a2 >= 0]
+tmp1 = tmp1.reshape(-1,5)
+tmp2 = tmp2.reshape(-1,5)
+
+
+# tmp1_pos = a1[np.where(a1*a2 >= 0) ]
+# tmp2_pos = a2[np.where(a1*a2 >= 0) ]
+# tmp1_pos = tmp1_pos[np.where(tmp1_pos  >= 0)]
+# tmp2_pos = tmp2_pos[np.where(tmp2_pos  >= 0)]
+#
+# tmp1_neg = a1[a1*a2 >= 0 ]
+# tmp2_neg = a2[a1*a2 >= 0 ]
+# tmp1_neg = tmp1_neg[tmp1_neg  < 0]
+# tmp2_neg = tmp2_neg[tmp2_neg  < 0]
+# a1 = tmp1
+# a2 = tmp2
+#
+# a1 = a1.reshape(-1,5)
+# a2 = a2.reshape(-1,5)
+#
+# tmp1_pos = tmp1_pos.reshape(-1,5)
+# tmp2_pos = tmp2_pos.reshape(-1,5)
+# tmp1_neg = tmp1_neg.reshape(-1,5)
+# tmp2_neg = tmp2_neg.reshape(-1,5)
+
+
+# print('a1:', a1)
+# print('a2:',a2 )
+# print('a1.shape', a1.shape)
+
+
+
+
+
+energyVec = np.vectorize(energy)
+
+# Z = energyVec(np.array([a1,a2]),q1,q2,q12,q3,b1,b2)
+Z = energyVec(a1,a2,q1,q2,q12,q3,b1,b2)
+
+Z_in = energyVec(a1_in,a2_in,q1,q2,q12,q3,b1,b2)
+
+
+
+
+print('Z:', Z)
+print('any', np.any(Z<0))
+
+#
+
+
+# negZ_a1 = a1[np.where(Z<0)]
+# negZ_a2 = a2[np.where(Z<0)]
+# negativeValues = Z[np.where(Z<0)]
+# print('negativeValues:',negativeValues)
+#
+# print('negZ_a1',negZ_a1)
+# print('negZ_a2',negZ_a2)
+#
+#
+# negZ_a1 = negZ_a1.reshape(-1,5)
+# negZ_a2 = negZ_a2.reshape(-1,5)
+# negativeValues = negativeValues.reshape(-1,5)
+#
+# Z_pos =  energyVec(tmp1_pos,tmp2_pos,q1,q2,q12,q3,b1,b2)
+# Z_neg = energyVec(tmp1_neg,tmp2_neg,q1,q2,q12,q3,b1,b2)
+
+
+
+
+
+# print('Test energy:' , energy(np.array([1,1]),q1,q2,q12,q3,b1,b2))
+
+
+
+
+# print('Z_pos.shape', Z_pos.shape)
+
+
+
+
+
+
+
+## -- PLOT :
+mpl.rcParams['text.usetex'] = True
+mpl.rcParams["font.family"] = "serif"
+mpl.rcParams["font.size"] = "9"
+
+label_size = 8
+mpl.rcParams['xtick.labelsize'] = label_size
+mpl.rcParams['ytick.labelsize'] = label_size
+
+# plt.style.use('seaborn')
+# plt.style.use('seaborn-whitegrid')
+# sns.set()
+# plt.style.use('seaborn-whitegrid')
+
+label_size = 9
+mpl.rcParams['xtick.labelsize'] = label_size
+mpl.rcParams['ytick.labelsize'] = label_size
+
+width = 6.28 *0.5
+# width = 6.28 *0.33
+# width = 6.28
+height = width #/ 1.618
+
+# width = 452.9579/2
+# size= set_size(width, fraction=0.5)
+# print('set_size(width, fraction=0.5)', set_size(width, fraction=1))
+# print('size[0]',size[0])
+
+f_size = 8
+# fig= plt.figure()
+fig, ax = plt.subplots()
+# fig.set_size_inches(width, height)
+# fig.set_size_inches(set_size(width, fraction=0.5))
+# ax = plt.axes(projection ='3d', adjustable='box')
+# ax = plt.axes((0.17,0.21 ,0.75,0.75))
+
+# ax = plt.axes((0.17,0.23 ,0.7,0.7))
+# ax = plt.axes((0.17,0.23 ,1.0,1.0))
+# ax=plt.axes()
+# ax = plt.axes((0.15,0.18,0.8,0.8))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+# ax.grid(True,which='major',axis='both',alpha=0.3)
+
+# colorfunction=(B*kappa)
+# print('colofunction',colorfunction)
+
+#translate Data
+# Z = Z - (Z.max()-Z.min())/2
+# Z = Z - 50
+# Z = Z - 500
+#
+# Z = Z.T
+
+
+# Substract constant:
+# c = (b1**2)*q1+b1*b2*q12+(b2**2)*q2
+# Z = Z-c
+#
+# print('Value of c:', c)
+
+
+
+print('Z.min()', Z.min())
+print('Z.max()', Z.max())
+norm=mcolors.Normalize(Z.min(),Z.max())
+# facecolors=cm.brg(norm)
+
+
+print('norm:', norm)
+print('type of norm', type(norm))
+print('norm(0):', norm(0))
+print('norm(Z):', norm(Z))
+
+# ax.plot(theta_rho, theta_values, 'royalblue', zorder=3, )
+
+# ax.scatter(a1,a2, s=0.5)
+
+# ax.scatter(tmp1_pos,tmp2_pos, s=0.5)
+# ax.scatter(tmp1_neg,tmp2_neg, s=0.5)
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, levels=100 )
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot,  levels=20 )
+
+
+# sns.kdeplot(np.array([a1, a2, Z]))
+# sns.kdeplot(tmp1_pos,tmp2_pos,Z_pos)
+
+# levels = [-5.0, -4, -3, 0.0, 1.5, 2.5, 3.5]
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, corner_mask=True,levels=levels)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot(norm(Z)), corner_mask=True)
+# CS = ax.contour(a1, a2, Z, cm.brg(norm(Z)), levels=20)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot, levels=20)
+# CS = ax.contour(a1, a2, Z, colors='k', levels=14,  linewidths=(0.5,))
+# CS = ax.contour(a1, a2, Z, colors='k', levels=18,  linewidths=(0.5,))
+
+# ax.contour(negZ_a1, negZ_a2, negativeValues, colors='k',  linewidths=(0.5,))
+# CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(0.75) ,zorder=5)
+
+
+step = (-1)*Z.min()
+
+
+levels = np.arange(Z.min(),Z.max()/2,step)
+levels = np.arange(Z.min(),Z.max()/12,step)
+# levels = np.arange(0,Z.max()/2,200)
+# CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(0.75), levels=levels ,zorder=5)
+
+# CS =  ax.contour(a1, a2, Z, colors='k',  linewidths=(0.75), levels=levels ,zorder=5)
+
+CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(1) , vmin= Z.min()+0.04, zorder=5)
+
+# df = pd.DataFrame(data=Z_in, columns=a1_in, index=a2_in)
+# df2 = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
+#                    columns=['a', 'b', 'c'])
+
+# sns.kdeplot(data=df2, x="waiting", y="duration")
+# sns.kdeplot(data=df2)
+
+# CS = ax.contour(a1, a2, Z, colors='k',   linewidths=(0.5,))
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k', extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k')
+#
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, levels=10 )
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, corner_mask=True)
+#
+# CS = ax.contour(a1, a2, Z,10,  colors = 'k')
+# ax.clabel(CS, inline=True, fontsize=4)
+
+# ax.clabel(CS, inline=True,  fontsize=4)
+
+
+# 1- ParameterFAMILY CASE :
+# manual_locations = [
+#                 (1, 1), (-5, -5), (-10, -10 ),(-12.5,-12.5),(-14,-14), (-15,-15),
+#                 (5, 5), (10, 10 ),(12.5,12.5), (15,15), (17,17)]
+
+
+
+# GAMMA = inf
+manual_locations = [
+                (1, 1), (-5, -5), (-10, -10 ), (-15,-15),
+                (5, 5), (10, 10 ),(12.5,12.5), (15,15), (17,17)]
+
+#
+#
+# # GAMMA = 0
+# manual_locations = [
+#                 (1, 1), (-5, -5), (-10, -10 ), (-15,-15), (-15,7),
+#                 (5, 5), (10, 10 ), (15,15), (17,17)]
+
+# ax.clabel(CS, inline=True, fontsize=f_size, colors='black', manual=manual_locations)
+ax.clabel(CS, inline=True, fontsize=f_size, colors='black')
+
+# cmap = cm.brg(norm(Z))
+#
+# C_map = cm.inferno(norm(Z))
+
+# ax.imshow(Z, cmap=C_map, extent=[-20, 20, -20, 20], origin='lower', alpha=0.5)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20], origin='lower',
+#                   cmap='bwr', alpha=0.8)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', vmin=Z.min(), vmax=Z.max(),
+#                   cmap='bwr', alpha=0.6)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+
+cmap=mpl.cm.RdBu_r
+cmap=mpl.cm.viridis_r
+# cmap=mpl.cm.bwr
+cmap=mpl.cm.coolwarm
+# cmap=mpl.cm.gnuplot
+cmap=mpl.cm.magma_r
+# cmap=mpl.cm.inferno_r
+# cmap=mpl.cm.plasma
+# cmap=mpl.cm.plasma_r
+# cmap=mpl.cm.cividis_r
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","violet","red"])
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","orange"])
+
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", [(0,"red"), (.1,"violet"), (.5, "blue"), (1.0, "green")])
+# make a colormap that has land and ocean clearly delineated and of the
+# same length (256 + 256)
+#
+# colors_undersea = plt.cm.terrain(np.linspace(0, 0.17, 256))
+# colors_land = plt.cm.terrain(np.linspace(0.25, 1, 256))
+# all_colors = np.vstack((colors_undersea, colors_land))
+# # cmap = mcolors.LinearSegmentedColormap.from_list(
+# #     'terrain_map', all_colors)
+
+
+# cmap = px.colors.sequential.agsunset
+# cmap = plotly.colors.PLOTLY_SCALES["Viridis"]
+
+
+
+
+
+# cmap = cm.brg(Z)
+divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=(Z.max()+Z.min())/2, vmax=Z.max())
+# divnorm=mcolors.TwoSlopeNorm(vmin=-500, vcenter=0, vmax=Z.max())
+
+# divnorm=mcolors.TwoSlopeNorm(vmin=-10, vcenter=0. ,vmax=10)
+# divnorm=mcolors.TwoSlopeNorm(vmin=-10, vcenter=0., vmax=Z.max())
+
+# divnorm=mcolors.LogNorm(vmin=Z.min(),  vmax=Z.max())  #Test LogNorm
+
+# cmap = cm.brg(divnorm(Z))
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap='coolwarm', alpha=0.6)
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+# divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+# plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+#                   cmap=cmap, alpha=0.6)
+plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+                  cmap=cmap, alpha=0.9)
+# plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+#                   cmap=cmap, alpha=0.6)
+
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower',
+                  # cmap=cmap, alpha=0.6)
+
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = mcolors.CenteredNorm(),
+#                   cmap=cmap, alpha=0.6)
+
+
+
+# COLORBAR :
+# cbar = plt.colorbar()
+# cbar.ax.tick_params(labelsize=f_size)
+# fig.colorbar(I)
+
+
+
+##----- ADD RECTANGLE TO COVER QUADRANT :
+epsilon = 0.4
+epsilon = 0.2
+# ax.axvspan(0, x.max(), y.min(), 0, alpha=1, color='yellow', zorder=5)#yellow
+# ax.fill_between([0, x.max()], y.min(), 0, alpha=0.3, color='yellow', zorder=5)#yellow
+# ax.fill_between([x.min(), 0], 0, y.max(), alpha=0.3, color='yellow', zorder=5)#yellow
+
+fillcolor = 'white'
+# ax.fill_between([0+epsilon, x.max()], y.min(), 0-epsilon, alpha=0.7, color=fillcolor, zorder=4)#yellow
+# ax.fill_between([x.min(), 0-epsilon], 0+epsilon, y.max(), alpha=0.7, color=fillcolor, zorder=4)#yellow
+ax.fill_between([0+epsilon, x.max()], y.min(), 0-epsilon, alpha=1.0, color=fillcolor, zorder=4)#yellow
+ax.fill_between([x.min(), 0-epsilon], 0+epsilon, y.max(), alpha=1.0, color=fillcolor, zorder=4)#yellow
+
+# ax.plot_surface(a1,a2, Z, cmap=cm.coolwarm,
+#                        linewidth=0, antialiased=False)
+
+
+
+# ax.plot(theta_rho, energy_axial1, 'royalblue', zorder=3, label=r"axialMin1")
+# ax.plot(theta_rho, energy_axial2, 'forestgreen', zorder=3, label=r"axialMin2")
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )
+
+
+
+
+# lg = ax.legend(bbox_to_anchor=(0.0, 0.75), loc='upper left')
+
+
+
+### PLot x and y- Axes
+ax.plot(ax.get_xlim(),[0,0],'k--', linewidth=0.5)
+ax.plot([0,0],ax.get_ylim(), 'k--', linewidth=0.5)
+
+
+
+
+ax.scatter(g_star[0],g_star[1], s=20, zorder=5)
+ax.text(g_star[0]+1,g_star[1]-1, r"$g_*$", color='royalblue', size=15, zorder = 5)
+
+
+ax.set_xlabel(r"$a_1$", fontsize=f_size ,labelpad=0)
+ax.set_ylabel(r"$a_2$", fontsize=f_size ,labelpad=0)
+# ax.set_ylabel(r"energy")
+ax.tick_params(axis='both', which='major', labelsize=f_size)
+ax.tick_params(axis='both', which='minor', labelsize=f_size)
+
+
+
+# ax.set_xticks([-np.pi/2, -np.pi/4  ,0,  np.pi/4,  np.pi/2 ])
+# labels = ['$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$']
+# ax.set_yticklabels(labels)
+
+
+
+
+
+# ax.legend(loc='upper right')
+
+
+
+fig.set_size_inches(width, height)
+# fig.set_size_inches(set_size(width, fraction=0.33))
+fig.savefig('Energy_ContourG+.pdf')
+
+plt.show()
+
+
+#
+#
+#
+# # Curve parametrised by \theta_rho = alpha in parameter space
+# N=100;
+# theta_rho = np.linspace(1, 3, num=N)
+# print('theta_rho:', theta_rho)
+#
+#
+# theta_values = []
+#
+#
+# for t in theta_rho:
+#
+#         s = (1.0/10.0)*t+0.1
+#         theta_values.append(s)
+#
+#
+#
+#
+#
+# theta_rho = np.array(theta_rho)
+# theta_values = np.array(theta_values)
+#
+# betas_ = 2.0
+#
+
+# alphas, betas, thetas = np.meshgrid(theta_rho, betas_, theta_values, indexing='ij')
+#
+#
+# harmonicMeanVec = np.vectorize(harmonicMean)
+# arithmeticMeanVec = np.vectorize(arithmeticMean)
+# prestrain_b1Vec = np.vectorize(prestrain_b1)
+# prestrain_b2Vec = np.vectorize(prestrain_b2)
+#
+# GetMuGammaVec = np.vectorize(GetMuGamma)
+# muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#
+# q1_vec = harmonicMeanVec(mu1, betas, thetas)
+# q2_vec = arithmeticMeanVec(mu1, betas, thetas)
+#
+# b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+# b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+
+# special case: q12 == 0!! .. braucht eigentlich nur b1 & b2 ...
+
+# print('type b1_values:', type(b1_values))
+
+
+
+# print('size(q1)',q1.shape)
+#
+#
+# energy_axial1 = []
+# energy_axial2 = []
+#
+# # for b1 in b1_values:
+# for i in range(len(theta_rho)):
+#     print('index i:', i)
+#
+#     print('theta_rho[i]',theta_rho[i])
+#     print('theta_values[i]',theta_values[i])
+#
+#     q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta_values[i])
+#     q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta_values[i])
+#     q12 = 0.0
+#     q3 = GetMuGamma(beta, theta_values[i],gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#     b1 = prestrain_b1(rho1,beta, theta_rho[i],theta_values[i] )
+#     b2 = prestrain_b2(rho1,beta, theta_rho[i],theta_values[i] )
+#
+#
+#     # q2_vec = arithmeticMean(mu1, betas, thetas)
+#     #
+#     # b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+#     # b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+#     print('q1[i]',q1)
+#     print('q2[i]',q2)
+#     print('q3[i]',q3)
+#     print('b1[i]',b1)
+#     print('b2[i]',b2)
+#     # print('q1[i]',q1[0][i])
+#     # print('q2[i]',q2[i])
+#     # print('b1[i]',b1[i])
+#     # print('b2[i]',b2[i])
+#     #compute axial energy #1 ...
+#
+#     a_axial1 = np.array([b1,0])
+#     a_axial2 = np.array([0,b2])
+#     b = np.array([b1,b2])
+#
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a_axial1)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial1',a_axial1)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial1.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial1.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_1 = tmp - tmp2
+#     print('energy_1',energy_1)
+#
+#
+#     energy_axial1.append(energy_1)
+#
+#
+#     tmp = H.dot(a_axial2)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial2',a_axial2)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial2.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial2.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_2 = tmp - tmp2
+#     print('energy_2',energy_2)
+#
+#
+#     energy_axial2.append(energy_2)
+#
+#
+#
+#
+#
+# print('theta_values', theta_values)
+#
+#
+#
+
+
+#
+#
+#
+#
+# kappas = []
+# alphas = []
+# # G.append(float(s[0]))
+#
+#
+#
+#
+# for t in T :
+#
+#     abar_current = sstar*abar+t*abarperp;
+#     # print('abar_current', abar_current)
+#     abar_current[abar_current < 1e-10] = 0
+#     # print('abar_current', abar_current)
+#
+#     # G = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     G = [abar_current[0], abar_current[1] , (2*abar_current[0]*abar_current[1])**0.5 ]
+#
+#     e = [(abar_current[0]/(abar_current[0]+abar_current[1]))**0.5, (abar_current[1]/(abar_current[0]+abar_current[1]))**0.5]
+#     kappa = abar_current[0]+abar_current[1]
+#     alpha = math.atan2(e[1], e[0])
+#
+#     print('angle current:', alpha)
+#
+#     kappas.append(kappa)
+#     alphas.append(alpha)
+#
+#
+#
+# alphas = np.array(alphas)
+# kappas = np.array(kappas)
+#
+#
+# print('kappas:',kappas)
+# print('alphas:',alphas)
+# print('min alpha:', min(alphas))
+# print('min kappa:', min(kappas))
+#
+# mpl.rcParams['text.usetex'] = True
+# mpl.rcParams["font.family"] = "serif"
+# mpl.rcParams["font.size"] = "9"
+# width = 6.28 *0.5
+# height = width / 1.618
+# fig = plt.figure()
+# # ax = plt.axes((0.15,0.21 ,0.75,0.75))
+# ax = plt.axes((0.15,0.21 ,0.8,0.75))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# # ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# # ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# # ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# # ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+# ax.grid(True,which='major',axis='both',alpha=0.3)
+#
+#
+#
+#
+# ax.plot(alphas, kappas, 'royalblue', zorder=3, )
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )

JNLS_plotScripts/Energy_ContourG+_v3.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+from ClassifyMin import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+import time
+import matplotlib.ticker as ticker
+
+import matplotlib as mpl
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+import pandas as pd
+
+import seaborn as sns
+import matplotlib.colors as mcolors
+
+from chart_studio import plotly
+import plotly.graph_objs as go
+import plotly.express as px
+import plotly.colors
+# from matplotlib import rc
+# rc('text', usetex=True) # Use LaTeX font
+#
+# import seaborn as sns
+# sns.set(color_codes=True)
+
+
+def show(fig):
+    import io
+    import plotly.io as pio
+    from PIL import Image
+    buf = io.BytesIO()
+    pio.write_image(fig, buf)
+    img = Image.open(buf)
+    img.show()
+
+
+
+
+# set the colormap and centre the colorbar
+class MidpointNormalize(mcolors.Normalize):
+	"""
+	Normalise the colorbar so that diverging bars work there way either side from a prescribed midpoint value)
+
+	e.g. im=ax1.imshow(array, norm=MidpointNormalize(midpoint=0.,vmin=-100, vmax=100))
+	"""
+	def __init__(self, vmin=None, vmax=None, midpoint=None, clip=False):
+		self.midpoint = midpoint
+		mcolors.Normalize.__init__(self, vmin, vmax, clip)
+
+	def __call__(self, value, clip=None):
+		# I'm ignoring masked values and all kinds of edge cases to make a
+		# simple example...
+		x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
+		return np.ma.masked_array(np.interp(value, x, y), np.isnan(value))
+
+
+
+def set_size(width, fraction=1):
+    """Set figure dimensions to avoid scaling in LaTeX.
+
+    Parameters
+    ----------
+    width: float
+            Document textwidth or columnwidth in pts
+    fraction: float, optional
+            Fraction of the width which you wish the figure to occupy
+
+    Returns
+    -------
+    fig_dim: tuple
+            Dimensions of figure in inches
+    """
+    # Width of figure (in pts)
+    fig_width_pt = width * fraction
+
+    # Convert from pt to inches
+    inches_per_pt = 1 / 72.27
+
+    # Golden ratio to set aesthetic figure height
+    # https://disq.us/p/2940ij3
+    golden_ratio = (5**.5 - 1) / 2
+
+    # Figure width in inches
+    fig_width_in = fig_width_pt * inches_per_pt
+    # Figure height in inches
+    fig_height_in = fig_width_in * golden_ratio
+
+    fig_dim = (fig_width_in, fig_height_in)
+
+    return fig_dim
+
+
+
+def format_func(value, tick_number):
+    # find number of multiples of pi/2
+    # N = int(np.round(2 * value / np.pi))
+    # if N == 0:
+    #     return "0"
+    # elif N == 1:
+    #     return r"$\pi/2$"
+    # elif N == -1:
+    #     return r"$-\pi/2$"
+    # elif N == 2:
+    #     return r"$\pi$"
+    # elif N % 2 > 0:
+    #     return r"${0}\pi/2$".format(N)
+    # else:
+    #     return r"${0}\pi$".format(N // 2)
+    ##find number of multiples of pi/2
+    N = int(np.round(4 * value / np.pi))
+    if N == 0:
+        return "0"
+    elif N == 1:
+        return r"$\pi/4$"
+    elif N == -1:
+        return r"$-\pi/4$"
+    elif N == 2:
+        return r"$\pi/2$"
+    elif N == -2:
+        return r"$-\pi/2$"
+    elif N % 2 > 0:
+        return r"${0}\pi/2$".format(N)
+    else:
+        return r"${0}\pi$".format(N // 2)
+
+
+
+def find_nearest(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return array[idx]
+
+
+def find_nearestIdx(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return idx
+
+
+
+
+def check_case(q1,q2,q12,q3,b1,b2):
+
+    # a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+
+
+    print('det(H)=', np.linalg.det(H))
+
+    # check if g* is in G^*_R^2
+    tmp = A.dot(b)
+
+    ## compute inverse of H :
+    inv_H = np.linalg.inv(H)
+
+    g_star = 2*inv_H.dot(tmp)
+
+    print('g_star=', g_star)
+
+
+    return g_star
+
+
+def get_gstar(q1,q2,q12,q3,b1,b2):
+
+    # a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    print('det(H)=', np.linalg.det(H))
+    # check if g* is in G^*_R^2
+    tmp = A.dot(b)
+    ## compute inverse of H :
+    inv_H = np.linalg.inv(H)
+    g_star = 2*inv_H.dot(tmp)
+    # print('g_star=', g_star)
+
+    return g_star
+
+
+def determine_b(q1,q2,q12,q3,g_star):
+    ##
+    # Input: g_star
+    # Output : b  such that g_star is minimizer, i.e A*b = (1/2)*H*g_star
+    # q1=1;
+    # q2=2;
+    # q12=1/2;
+    # q3=((4*q1*q2)**0.5-q12)/2;
+    # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+
+
+
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    abar = np.array([q12+2*q3, 2*q2])
+    rhs = (1/2)*H.dot(g_star)
+    print('rhs:', rhs)
+    b = np.linalg.lstsq(A, rhs)[0]
+    print('b',b)
+    b1=b[0]
+    b2=b[1]
+
+    return b
+    ## ---------------
+
+
+def get_minimizer(q1,q2,q3,b1,b2):
+
+    # In the case if q12 == 0:
+    quotient = (q1*q2-q3**2)
+    g_star = np.array([(q1*q2*b1-q3*q2*b2)/quotient, (q1*q2*b2-q3*q1*b1)/quotient])
+    print('g_star=', g_star)
+    return g_star
+
+
+def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+
+
+    a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+
+
+    tmp = H.dot(a)
+
+    # print('H',H)
+    # print('A',A)
+    # print('b',b)
+    # print('a',a)
+    # print('tmp',tmp)
+
+    tmp = (1/2)*a.dot(tmp)
+    # print('tmp',tmp)
+
+    tmp2 = A.dot(b)
+    # print('tmp2',tmp2)
+    tmp2 = 2*a.dot(tmp2)
+
+    # print('tmp2',tmp2)
+    energy = tmp - tmp2
+    # print('energy',energy)
+
+
+    # energy_axial1.append(energy_1)
+
+    return energy
+
+
+
+# def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+#
+#
+#     b = np.array([b1,b2])
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a',a)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy = tmp - tmp2
+#     print('energy',energy)
+#
+#
+#     # energy_axial1.append(energy_1)
+#
+#     return energy
+#
+
+
+def draw_1ParameterLine(q1,q2,q12,q3):
+
+    # q1=1;
+    # q2=2;
+    # q12=1/2;
+    # q3=((4*q1*q2)**0.5-q12)/2;
+    # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    abar = np.array([q12+2*q3, 2*q2])
+    abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+
+    print('abar:',abar)
+
+    b = np.linalg.lstsq(A, abar)[0]
+    print('b',b)
+
+    b1=b[0]
+    b2=b[1]
+
+
+    # print('abar:',np.shape(abar))
+    # print('np.transpose(abar):',np.shape(np.transpose(abar)))
+    sstar = (1/(q1+q2))*abar.dot(A.dot(b))
+    # sstar = (1/(q1+q2))*abar.dot(tmp)
+    print('sstar', sstar)
+    abarperp= np.array([abar[1],-abar[0]])
+    print('abarperp:',abarperp)
+
+    N=500;
+    scale_domain = 5
+    translate_startpoint = -1.8
+    scale_domain = 4.65
+    translate_startpoint = -1.85
+    # --- FUll LINE:
+    scale_domain = 4.5
+    translate_startpoint = -1.4
+    T_line = np.linspace(-sstar*(q12+2*q3)/(2*q2)*scale_domain + translate_startpoint, sstar*(2*q2)/(q12+2*q3)*scale_domain , num=N)
+    line_values = []
+    for t in T_line :
+        print('sstar*abar+t*abarperp', sstar*abar+t*abarperp)
+        line_values.append(sstar*abar+t*abarperp)
+    # ------
+
+
+    T = np.linspace(-sstar*(q12+2*q3)/(2*q2), sstar*(2*q2)/(q12+2*q3), num=N)
+    # T = np.linspace(-sstar*(q12+2*q3)/(2*q2)*scale_domain + translate_startpoint, sstar*(2*q2)/(q12+2*q3)*scale_domain , num=N)
+    # T = np.linspace(-2,2, num=N)
+    # print('T:', T)
+
+    print('T.min():', T.min())
+    print('T.max():', T.max())
+
+    kappas = []
+    alphas = []
+    # G.append(float(s[0]))
+
+    G_container = []
+    abar_container = []
+
+
+    abar_tmp = abar
+
+    for t in T :
+        abar_current = sstar*abar+t*abarperp;
+        abar_current[abar_current < 1e-10] = 0 # Project to x-y-axis!!
+        current_energy = energy(abar_current[0],abar_current[1],q1,q2,q12,q3,b1,b2)
+        print('energy along line:', current_energy )
+        G = [abar_current[0], abar_current[1] , (2*abar_current[0]*abar_current[1])**0.5 ]
+        G_container.append(G)
+        abar_container.append(abar_current)
+        e = [(abar_current[0]/(abar_current[0]+abar_current[1]))**0.5, (abar_current[1]/(abar_current[0]+abar_current[1]))**0.5]
+        kappa = abar_current[0]+abar_current[1]
+        alpha = math.atan2(e[1], e[0])
+        kappas.append(kappa)
+        alphas.append(alpha)
+
+
+    alphas = np.array(alphas)
+    kappas = np.array(kappas)
+
+    # print('G_container', G_container)
+    G = np.array(G_container)
+    abar = np.array(abar_container)
+
+    # print('G', G)
+    # print('abar', abar)
+    # print('abar.shape',abar.shape)
+    line = ax.plot(abar[:,0],abar[:,1], linewidth=2, color='royalblue', linestyle='-', zorder=4)
+
+    # Plot 1-Parameter Line
+    line_values= np.array(line_values)
+    ax.plot(line_values[:,0],line_values[:,1],'k--', linewidth=1,color='royalblue',alpha=0.8,zorder=4)
+
+    return line
+
+
+
+
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+print('---- Input parameters: -----')
+
+# q1=1;
+# q2=2;
+# q12=1/2;
+# q3=((4*q1*q2)**0.5-q12)/2;
+# # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+#
+# H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+# A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+# abar = np.array([q12+2*q3, 2*q2])
+# abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+#
+# print('abar:',abar)
+#
+# b = np.linalg.lstsq(A, abar)[0]
+# print('b',b)
+#
+#
+# # print('abar:',np.shape(abar))
+# # print('np.transpose(abar):',np.shape(np.transpose(abar)))
+# sstar = (1/(q1+q2))*abar.dot(A.dot(b))
+# # sstar = (1/(q1+q2))*abar.dot(tmp)
+# print('sstar', sstar)
+# abarperp= np.array([abar[1],-abar[0]])
+# print('abarperp:',abarperp)
+
+
+# -------------------------- Input Parameters --------------------
+#
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 5.0
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+#
+
+
+
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = -0.75
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+
+
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+
+
+#Figure3:
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/8
+# # theta= 0.1
+# beta = 2.0
+
+
+# alpha= -5
+
+
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+# gamma = '0'
+# # gamma = 'infinity'
+#
+#
+# lambda1 = 0.0
+
+
+print('---- Input parameters: -----')
+# print('mu1: ', mu1)
+# print('rho1: ', rho1)
+# # print('alpha: ', alpha)
+# print('beta: ', beta)
+# # print('theta: ', theta)
+# print('gamma:', gamma)
+#
+# print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+print('----------------------------')
+
+# ----------------------------------------------------------------
+
+
+
+
+
+
+# q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta)
+# q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta)
+# q12 = 0.0
+# q3 = GetMuGamma(beta, theta,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+# b1 = prestrain_b1(rho1,beta, alpha, theta )
+# b2 = prestrain_b2(rho1,beta, alpha, theta )
+#
+
+
+case = 'a'
+case = 'b'
+case = 'c'
+
+
+
+if case == 'a':
+    print('---- CASE (a) ----')
+    q1 = 1
+    q2 = 2
+    q12 = 0
+    q3 = 1
+    g_star = np.array([0,1])
+    g_star = np.array([-1,1])
+    # ToDO
+    b = determine_b(q1,q2,q12,q3, g_star)
+    b1 = b[0]
+    b2 = b[1]
+
+
+if case == 'b':
+    print('---- CASE (b) ----')
+    q1 = 1
+    q2 = 2
+    q12 = 0
+    q3 = 1
+    g_star = np.array([1,1])
+    # ToDO
+    b = determine_b(q1,q2,q12,q3, g_star)
+    b1 = b[0]
+    b2 = b[1]
+
+
+if case == 'c':
+    print('---- CASE (c) ----')
+    ## ---- 1-ParameterFamilyCase:
+    q1=1;
+    q2=2;
+    q12=1/2;
+    q3=((4*q1*q2)**0.5-q12)/2;
+    # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    abar = np.array([q12+2*q3, 2*q2])
+    abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+    print('abar:',abar)
+    b = np.linalg.lstsq(A, abar)[0]
+    print('b',b)
+    b1=b[0]
+    b2=b[1]
+    ## ---------------
+
+
+
+
+print('q1 = ', q1)
+print('q2 = ', q2)
+print('q3 = ', q3)
+print('q12 = ', q12)
+print('b1 = ', b1)
+print('b2 = ', b2)
+
+## --- CHECK CASE ---
+
+
+if case == 'a':
+    # Check Minimizers:
+    vec1 = np.array([(2*q1*b1+q12*b2)/(2*q1), 0])
+    vec2 = np.array([0, (2*q12*b1+q2*b2)/(2*q2)])
+    print('vec1:',vec1)
+    print('vec2:',vec2)
+    energy_1 = energy(vec1[0],vec1[1],q1,q2,q12,q3,b1,b2)
+    energy_2 = energy(vec2[0],vec2[1],q1,q2,q12,q3,b1,b2)
+    print('energy_1:',energy_1)
+    print('energy_2:',energy_2)
+    if energy_1 >= energy_2:
+        minvec = vec2
+    else:
+        minvec = vec1
+    print('minvec:', minvec)
+
+
+
+
+check_case(q1,q2,q12,q3,b1,b2)
+
+g_star = get_gstar(q1,q2,q12,q3,b1,b2)
+print('g_star:',g_star)
+
+# TEST
+print('special case g_star:')
+get_minimizer(q1,q2,q3,b1,b2)
+
+
+
+
+## -------------------------------------
+
+num_Points = 400
+# num_Points = 600
+# num_Points = 200
+# num_Points = 100
+# num_Points = 20
+
+
+# Creating dataset
+x = np.linspace(-5,5,num_Points)
+y = np.linspace(-5,5,num_Points)
+
+x = np.linspace(-20,20,num_Points)
+y = np.linspace(-20,20,num_Points)
+
+
+x = np.linspace(-2,2,num_Points)
+y = np.linspace(-2,2,num_Points)
+# x = np.linspace(-10,10,num_Points)
+# y = np.linspace(-10,10,num_Points)
+
+# x = np.linspace(-60,60,num_Points)
+# y = np.linspace(-60,60,num_Points)
+#
+#
+# x = np.linspace(-40,40,num_Points)
+# y = np.linspace(-40,40,num_Points)
+
+
+a1, a2 = np.meshgrid(x,y)
+
+# geyser = sns.load_dataset("geyser")
+# print('type of geyser:', type(geyser))
+# print('geyser:',geyser)
+
+# ContourRange=20
+ContourRange=2
+
+# x_in = np.linspace(-ContourRange,ContourRange,num_Points)
+# y_in = np.linspace(-ContourRange,ContourRange,num_Points)
+# a1_in, a2_in = np.meshgrid(x_in,y_in)
+
+print('a1:', a1)
+print('a2:',a2 )
+print('a1.shape', a1.shape)
+
+#-- FILTER OUT VALUES for G+ :
+
+# tmp1 = a1[np.where(a1*a2 >= 0)]
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+#
+# np.take(a, np.where(a>100)[0], axis=0)
+# tmp1 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+
+tmp1 = a1[a1*a2 >= 0]
+tmp2 = a2[a1*a2 >= 0]
+tmp1 = tmp1.reshape(-1,5)
+tmp2 = tmp2.reshape(-1,5)
+
+
+# tmp1_pos = a1[np.where(a1*a2 >= 0) ]
+# tmp2_pos = a2[np.where(a1*a2 >= 0) ]
+# tmp1_pos = tmp1_pos[np.where(tmp1_pos  >= 0)]
+# tmp2_pos = tmp2_pos[np.where(tmp2_pos  >= 0)]
+#
+# tmp1_neg = a1[a1*a2 >= 0 ]
+# tmp2_neg = a2[a1*a2 >= 0 ]
+# tmp1_neg = tmp1_neg[tmp1_neg  < 0]
+# tmp2_neg = tmp2_neg[tmp2_neg  < 0]
+# a1 = tmp1
+# a2 = tmp2
+#
+# a1 = a1.reshape(-1,5)
+# a2 = a2.reshape(-1,5)
+#
+# tmp1_pos = tmp1_pos.reshape(-1,5)
+# tmp2_pos = tmp2_pos.reshape(-1,5)
+# tmp1_neg = tmp1_neg.reshape(-1,5)
+# tmp2_neg = tmp2_neg.reshape(-1,5)
+
+
+# print('a1:', a1)
+# print('a2:',a2 )
+# print('a1.shape', a1.shape)
+
+
+
+
+
+energyVec = np.vectorize(energy)
+
+# Z = energyVec(np.array([a1,a2]),q1,q2,q12,q3,b1,b2)
+Z = energyVec(a1,a2,q1,q2,q12,q3,b1,b2)
+
+# Z_in = energyVec(a1_in,a2_in,q1,q2,q12,q3,b1,b2)
+
+
+
+
+print('Z:', Z)
+print('any', np.any(Z<0))
+
+
+
+
+
+
+
+# negZ_a1 = a1[np.where(Z<0)]
+# negZ_a2 = a2[np.where(Z<0)]
+# negativeValues = Z[np.where(Z<0)]
+# print('negativeValues:',negativeValues)
+#
+# print('negZ_a1',negZ_a1)
+# print('negZ_a2',negZ_a2)
+#
+#
+# negZ_a1 = negZ_a1.reshape(-1,5)
+# negZ_a2 = negZ_a2.reshape(-1,5)
+# negativeValues = negativeValues.reshape(-1,5)
+#
+# Z_pos =  energyVec(tmp1_pos,tmp2_pos,q1,q2,q12,q3,b1,b2)
+# Z_neg = energyVec(tmp1_neg,tmp2_neg,q1,q2,q12,q3,b1,b2)
+
+
+
+
+
+# print('Test energy:' , energy(np.array([1,1]),q1,q2,q12,q3,b1,b2))
+
+
+
+
+# print('Z_pos.shape', Z_pos.shape)
+
+
+
+
+
+
+
+## -- PLOT :
+mpl.rcParams['text.usetex'] = True
+mpl.rcParams["font.family"] = "serif"
+mpl.rcParams["font.size"] = "9"
+
+label_size = 8
+mpl.rcParams['xtick.labelsize'] = label_size
+mpl.rcParams['ytick.labelsize'] = label_size
+
+# plt.style.use('seaborn')
+# plt.style.use('seaborn-whitegrid')
+# sns.set()
+# plt.style.use('seaborn-whitegrid')
+
+label_size = 9
+mpl.rcParams['xtick.labelsize'] = label_size
+mpl.rcParams['ytick.labelsize'] = label_size
+
+width = 6.28 *0.5
+# width = 6.28 *0.33
+# width = 6.28
+height = width #/ 1.618
+
+# width = 452.9579/2
+# size= set_size(width, fraction=0.5)
+# print('set_size(width, fraction=0.5)', set_size(width, fraction=1))
+# print('size[0]',size[0])
+
+f_size = 10
+# fig= plt.figure()
+fig, ax = plt.subplots()
+# fig.set_size_inches(width, height)
+# fig.set_size_inches(set_size(width, fraction=0.5))
+# ax = plt.axes(projection ='3d', adjustable='box')
+# ax = plt.axes((0.17,0.21 ,0.75,0.75))
+
+# ax = plt.axes((0.17,0.23 ,0.7,0.7))
+# ax = plt.axes((0.17,0.23 ,1.0,1.0))
+# ax=plt.axes()
+# ax = plt.axes((0.15,0.18,0.8,0.8))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+# ax.grid(True,which='major',axis='both',alpha=0.3)
+
+# colorfunction=(B*kappa)
+# print('colofunction',colorfunction)
+
+#translate Data
+# Z = Z - (Z.max()-Z.min())/2
+# Z = Z - 50
+# Z = Z - 500
+#
+# Z = Z.T
+
+
+# Substract constant:
+# c = (b1**2)*q1+b1*b2*q12+(b2**2)*q2
+# Z = Z-c
+#
+# print('Value of c:', c)
+
+
+
+print('Z.min()', Z.min())
+print('Z.max()', Z.max())
+norm=mcolors.Normalize(Z.min(),Z.max())
+# facecolors=cm.brg(norm)
+
+
+
+print('norm:', norm)
+print('type of norm', type(norm))
+print('norm(0):', norm(0))
+print('norm(Z):', norm(Z))
+
+# ax.plot(theta_rho, theta_values, 'royalblue', zorder=3, )
+
+# ax.scatter(a1,a2, s=0.5)
+
+# ax.scatter(tmp1_pos,tmp2_pos, s=0.5)
+# ax.scatter(tmp1_neg,tmp2_neg, s=0.5)
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, levels=100 )
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot,  levels=20 )
+
+
+# sns.kdeplot(np.array([a1, a2, Z]))
+# sns.kdeplot(tmp1_pos,tmp2_pos,Z_pos)
+
+# levels = [-5.0, -4, -3, 0.0, 1.5, 2.5, 3.5]
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, corner_mask=True,levels=levels)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot(norm(Z)), corner_mask=True)
+# CS = ax.contour(a1, a2, Z, cm.brg(norm(Z)), levels=20)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot, levels=20)
+# CS = ax.contour(a1, a2, Z, colors='k', levels=14,  linewidths=(0.5,))
+# CS = ax.contour(a1, a2, Z, colors='k', levels=18,  linewidths=(0.5,))
+
+# ax.contour(negZ_a1, negZ_a2, negativeValues, colors='k',  linewidths=(0.5,))
+# CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(0.75) ,zorder=5)
+
+
+step = (-1)*Z.min()
+# step = 3.0
+
+levels = np.arange(Z.min(),Z.max()/2,step)
+# evels = np.arange(-4, 25, 4)
+# levels = np.arange(-3, 23, 4)
+
+# levels = np.arange(Z.min(),Z.max()/12,step)
+# levels = np.arange(Z.min(),Z.max(),step)
+# levels = np.arange(0,Z.max()/2,200)
+# CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(0.75), levels=levels ,zorder=5)
+
+# CS =  ax.contour(a1, a2, Z, colors='k',  linewidths=(0.75), levels=levels ,zorder=5)
+# CS =  ax.contour(a1, a2, Z,5,  colors='k',  linewidths=(0.75) ,zorder=5, vmin=Z.min(), vmax=1)
+
+# CS =  ax.contour(a1, a2, Z,5,  colors='k',  linewidths=(0.75) ,zorder=5, vmin=Z.min(), vmax=1)
+
+if case == 'b':
+    levels = np.arange(-4, 25, 4)
+
+
+if case == 'a':
+    levels = np.arange(-1, 25, 5)  # if g_star = [0 1]
+    levels = np.arange(0, 24, 4)  # if g_star = [-1 1]
+if case == 'c':
+    levels = np.arange(0, 25, 4)
+
+CS =  ax.contour(a1, a2, Z,levels,  colors='k',linewidths=(0.75), extent=(-2, 2, -2, 2), zorder=5)
+
+
+# CS =  ax.contour(a1 , a2 , Z, colors='k',  linewidths=(0.75), zorder=5)
+# CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(1) , vmin= Z.min()+0.04, zorder=5)
+# CS =  ax.contour(a1, a2, Z, colors='k',  linewidths=(1) , vmin= Z.min()+0.04, zorder=5)
+
+
+
+# df = pd.DataFrame(data=Z_in, columns=a1_in, index=a2_in)
+# df2 = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
+#                    columns=['a', 'b', 'c'])
+
+# sns.kdeplot(data=df2, x="waiting", y="duration")
+# sns.kdeplot(data=df2)
+
+# CS = ax.contour(a1, a2, Z, colors='k',   linewidths=(0.5,))
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k', extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k')
+#
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, levels=10 )
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, corner_mask=True)
+#
+# CS = ax.contour(a1, a2, Z,10,  colors = 'k')
+# ax.clabel(CS, inline=True, fontsize=4)
+
+# ax.clabel(CS, inline=True,  fontsize=4)
+
+
+# 1- ParameterFAMILY CASE :
+# manual_locations = [
+#                 (1, 1), (-5, -5), (-10, -10 ),(-12.5,-12.5),(-14,-14), (-15,-15),
+#                 (5, 5), (10, 10 ),(12.5,12.5), (15,15), (17,17)]
+
+
+if case == 'c':
+    manual_locations = [
+                    (1, 1), (0.5, 0.5),(1.5,1.5),(1.75,1.75),(-0.2,0.2), (-0.5,-0.5),
+                    (-1,-1),(-1.25,-1.25), (-1.5,-1.5)]
+    ax.clabel(CS, inline=True, fontsize=9, colors='black', manual=manual_locations)
+else :
+    ax.clabel(CS, inline=True, fontsize=9, colors='black', zorder=5)
+
+# GAMMA = inf
+# manual_locations = [
+#                 (1, 1), (-5, -5), (-10, -10 ), (-15,-15),
+#                 (5, 5), (10, 10 ),(12.5,12.5), (15,15), (17,17)]
+
+#
+#
+# # GAMMA = 0
+# manual_locations = [
+#                 (1, 1), (-5, -5), (-10, -10 ), (-15,-15), (-15,7),
+#                 (5, 5), (10, 10 ), (15,15), (17,17)]
+
+
+# ax.clabel(CS, inline=True, fontsize=f_size, colors='black')
+# ax.clabel(CS, inline=True, fontsize=9, colors='black', zorder=5)
+
+# cmap = cm.brg(norm(Z))
+#
+# C_map = cm.inferno(norm(Z))
+
+# ax.imshow(Z, cmap=C_map, extent=[-20, 20, -20, 20], origin='lower', alpha=0.5)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20], origin='lower',
+#                   cmap='bwr', alpha=0.8)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', vmin=Z.min(), vmax=Z.max(),
+#                   cmap='bwr', alpha=0.6)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+
+cmap=mpl.cm.RdBu_r
+cmap=mpl.cm.viridis_r
+# cmap=mpl.cm.bwr
+cmap=mpl.cm.coolwarm
+# cmap=mpl.cm.gnuplot
+cmap=mpl.cm.magma_r
+# cmap=mpl.cm.inferno_r
+# cmap=mpl.cm.plasma
+# cmap=mpl.cm.plasma_r
+# cmap=mpl.cm.cividis_r
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","violet","red"])
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","orange"])
+
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", [(0,"red"), (.1,"violet"), (.5, "blue"), (1.0, "green")])
+# make a colormap that has land and ocean clearly delineated and of the
+# same length (256 + 256)
+#
+# colors_undersea = plt.cm.terrain(np.linspace(0, 0.17, 256))
+# colors_land = plt.cm.terrain(np.linspace(0.25, 1, 256))
+# all_colors = np.vstack((colors_undersea, colors_land))
+# # cmap = mcolors.LinearSegmentedColormap.from_list(
+# #     'terrain_map', all_colors)
+
+
+# cmap = px.colors.sequential.agsunset
+# cmap = plotly.colors.PLOTLY_SCALES["Viridis"]
+
+
+
+
+
+# cmap = cm.brg(Z)
+divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=(Z.max()+Z.min())/2, vmax=Z.max())
+# divnorm=mcolors.TwoSlopeNorm(vmin=-500, vcenter=0, vmax=Z.max())
+
+# divnorm=mcolors.TwoSlopeNorm(vmin=-10, vcenter=0. ,vmax=10)
+# divnorm=mcolors.TwoSlopeNorm(vmin=-10, vcenter=0., vmax=Z.max())
+
+# divnorm=mcolors.LogNorm(vmin=Z.min(),  vmax=Z.max())  #Test LogNorm
+
+# cmap = cm.brg(divnorm(Z))
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap='coolwarm', alpha=0.6)
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+# divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+# plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+#                   cmap=cmap, alpha=0.6)
+plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+                  cmap=cmap, alpha=0.9)
+# plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+#                   cmap=cmap, alpha=0.6)
+
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower',
+                  # cmap=cmap, alpha=0.6)
+
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = mcolors.CenteredNorm(),
+#                   cmap=cmap, alpha=0.6)
+
+
+
+# COLORBAR :
+# cbar = plt.colorbar()
+# cbar.ax.tick_params(labelsize=f_size)
+# fig.colorbar(I)
+
+
+
+##----- ADD RECTANGLE TO COVER QUADRANT :
+epsilon = 0.4
+epsilon = 0.2
+epsilon = 0.005
+epsilon = 0.01
+# ax.axvspan(0, x.max(), y.min(), 0, alpha=1, color='yellow', zorder=5)#yellow
+# ax.fill_between([0, x.max()], y.min(), 0, alpha=0.3, color='yellow', zorder=5)#yellow
+# ax.fill_between([x.min(), 0], 0, y.max(), alpha=0.3, color='yellow', zorder=5)#yellow
+
+fillcolor = 'white'
+# ax.fill_between([0+epsilon, x.max()], y.min(), 0-epsilon, alpha=0.7, color=fillcolor, zorder=4)#yellow
+# ax.fill_between([x.min(), 0-epsilon], 0+epsilon, y.max(), alpha=0.7, color=fillcolor, zorder=4)#yellow
+ax.fill_between([0+epsilon, x.max()-epsilon], y.min()+epsilon, 0-epsilon, alpha=1.0, color=fillcolor, zorder=4)#yellow
+ax.fill_between([x.min()+epsilon, 0-epsilon], 0+epsilon, y.max()-epsilon, alpha=1.0, color=fillcolor, zorder=4)#yellow
+
+# ax.plot_surface(a1,a2, Z, cmap=cm.coolwarm,
+#                        linewidth=0, antialiased=False)
+
+
+
+# ax.plot(theta_rho, energy_axial1, 'royalblue', zorder=3, label=r"axialMin1")
+# ax.plot(theta_rho, energy_axial2, 'forestgreen', zorder=3, label=r"axialMin2")
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )
+
+if case == 'a':
+    # PLOT MINIMIZER g*:
+    # ax.scatter(g_star[0],g_star[1], s=20, zorder=5)
+    # ax.scatter(g_star[0],g_star[1], marker = 'x', s=20, zorder=5)
+    # ax.text(g_star[0]+0.1,g_star[1]-0.1, r"$g_*$", color='royalblue', size=15, zorder = 5)
+    ax.scatter(g_star[0],g_star[1], marker = 'x', s=40, color='gray', zorder=4)
+    ax.text(g_star[0]+0.15,g_star[1]-0.15, r"$g_*$", color='gray', size=12, alpha=0.8, zorder = 5)
+if case == 'b':
+    # PLOT MINIMIZER g*:
+    ax.scatter(g_star[0],g_star[1], s=20, color='royalblue', zorder=5)
+    ax.scatter(g_star[0],g_star[1], marker = 'x', s=40, color='gray', zorder=4)
+    ax.text(g_star[0]+0.15,g_star[1]-0.15, r"$g_*$", color='gray', size=12, alpha=0.8, zorder = 5)
+if case == 'c':
+    print('draw Line')
+    line = draw_1ParameterLine(q1,q2,q12,q3)
+
+
+# lg = ax.legend(bbox_to_anchor=(0.0, 0.75), loc='upper left')
+
+if case == 'c':
+    # draw MINIMAL VALUES
+    print('np.where(Z == Z.min())',np.where(np.round(Z,6) == np.round(Z.min(),6)))
+    tmp_x = a1[np.where(np.round(Z,6) == np.round(Z.min(),6))]
+    tmp_y = a2[np.where(np.round(Z,6) == np.round(Z.min(),6))]
+    # ax.scatter(tmp_x,tmp_y,color='red', zorder=5, s=1)
+    # ax.plot(tmp_x,tmp_y,color='forestgreen', zorder=5)
+
+# print('np.where(Z == Z.min())',np.where(np.round(Z,8) == np.round(Z.min(),8)))
+
+
+if case == 'a':
+    ax.scatter(minvec[0],minvec[1],color='royalblue',zorder=5, s=20)
+
+
+### PLot x and y- Axes
+ax.plot(ax.get_xlim(),[0,0],'k--', linewidth=0.5, zorder=4)
+ax.plot([0,0],ax.get_ylim(), 'k--', linewidth=0.5, zorder=4)
+
+
+
+
+
+
+ax.set_xlabel(r"$a_1$", fontsize=f_size ,labelpad=0)
+ax.set_ylabel(r"$a_2$", fontsize=f_size ,labelpad=0)
+# ax.set_xlabel(r"$a_1$", fontsize=f_size )
+# ax.set_ylabel(r"$a_2$", fontsize=f_size )
+
+# ax.set_ylabel(r"energy")
+ax.tick_params(axis='both', which='major', labelsize=f_size)
+ax.tick_params(axis='both', which='minor', labelsize=f_size)
+
+
+
+# ax.set_xticks([-np.pi/2, -np.pi/4  ,0,  np.pi/4,  np.pi/2 ])
+# labels = ['$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$']
+# ax.set_yticklabels(labels)
+
+
+# plt.subplots_adjust(left = 0.25 )
+
+
+# ax.legend(loc='upper right')
+
+fig.subplots_adjust(left=.18, bottom=.12, right=.90, top=.97)
+
+fig.set_size_inches(width, height)
+# fig.set_size_inches(set_size(width, fraction=0.33))
+Outputname = 'Energy_ContourG+_case'+ str(case) + '.pdf'
+fig.savefig(Outputname)
+
+plt.show()
+
+
+#
+#
+#
+# # Curve parametrised by \theta_rho = alpha in parameter space
+# N=100;
+# theta_rho = np.linspace(1, 3, num=N)
+# print('theta_rho:', theta_rho)
+#
+#
+# theta_values = []
+#
+#
+# for t in theta_rho:
+#
+#         s = (1.0/10.0)*t+0.1
+#         theta_values.append(s)
+#
+#
+#
+#
+#
+# theta_rho = np.array(theta_rho)
+# theta_values = np.array(theta_values)
+#
+# betas_ = 2.0
+#
+
+# alphas, betas, thetas = np.meshgrid(theta_rho, betas_, theta_values, indexing='ij')
+#
+#
+# harmonicMeanVec = np.vectorize(harmonicMean)
+# arithmeticMeanVec = np.vectorize(arithmeticMean)
+# prestrain_b1Vec = np.vectorize(prestrain_b1)
+# prestrain_b2Vec = np.vectorize(prestrain_b2)
+#
+# GetMuGammaVec = np.vectorize(GetMuGamma)
+# muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#
+# q1_vec = harmonicMeanVec(mu1, betas, thetas)
+# q2_vec = arithmeticMeanVec(mu1, betas, thetas)
+#
+# b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+# b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+
+# special case: q12 == 0!! .. braucht eigentlich nur b1 & b2 ...
+
+# print('type b1_values:', type(b1_values))
+
+
+
+# print('size(q1)',q1.shape)
+#
+#
+# energy_axial1 = []
+# energy_axial2 = []
+#
+# # for b1 in b1_values:
+# for i in range(len(theta_rho)):
+#     print('index i:', i)
+#
+#     print('theta_rho[i]',theta_rho[i])
+#     print('theta_values[i]',theta_values[i])
+#
+#     q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta_values[i])
+#     q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta_values[i])
+#     q12 = 0.0
+#     q3 = GetMuGamma(beta, theta_values[i],gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#     b1 = prestrain_b1(rho1,beta, theta_rho[i],theta_values[i] )
+#     b2 = prestrain_b2(rho1,beta, theta_rho[i],theta_values[i] )
+#
+#
+#     # q2_vec = arithmeticMean(mu1, betas, thetas)
+#     #
+#     # b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+#     # b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+#     print('q1[i]',q1)
+#     print('q2[i]',q2)
+#     print('q3[i]',q3)
+#     print('b1[i]',b1)
+#     print('b2[i]',b2)
+#     # print('q1[i]',q1[0][i])
+#     # print('q2[i]',q2[i])
+#     # print('b1[i]',b1[i])
+#     # print('b2[i]',b2[i])
+#     #compute axial energy #1 ...
+#
+#     a_axial1 = np.array([b1,0])
+#     a_axial2 = np.array([0,b2])
+#     b = np.array([b1,b2])
+#
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a_axial1)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial1',a_axial1)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial1.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial1.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_1 = tmp - tmp2
+#     print('energy_1',energy_1)
+#
+#
+#     energy_axial1.append(energy_1)
+#
+#
+#     tmp = H.dot(a_axial2)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial2',a_axial2)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial2.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial2.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_2 = tmp - tmp2
+#     print('energy_2',energy_2)
+#
+#
+#     energy_axial2.append(energy_2)
+#
+#
+#
+#
+#
+# print('theta_values', theta_values)
+#
+#
+#
+
+
+#
+#
+#
+#
+# kappas = []
+# alphas = []
+# # G.append(float(s[0]))
+#
+#
+#
+#
+# for t in T :
+#
+#     abar_current = sstar*abar+t*abarperp;
+#     # print('abar_current', abar_current)
+#     abar_current[abar_current < 1e-10] = 0
+#     # print('abar_current', abar_current)
+#
+#     # G = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     G = [abar_current[0], abar_current[1] , (2*abar_current[0]*abar_current[1])**0.5 ]
+#
+#     e = [(abar_current[0]/(abar_current[0]+abar_current[1]))**0.5, (abar_current[1]/(abar_current[0]+abar_current[1]))**0.5]
+#     kappa = abar_current[0]+abar_current[1]
+#     alpha = math.atan2(e[1], e[0])
+#
+#     print('angle current:', alpha)
+#
+#     kappas.append(kappa)
+#     alphas.append(alpha)
+#
+#
+#
+# alphas = np.array(alphas)
+# kappas = np.array(kappas)
+#
+#
+# print('kappas:',kappas)
+# print('alphas:',alphas)
+# print('min alpha:', min(alphas))
+# print('min kappa:', min(kappas))
+#
+# mpl.rcParams['text.usetex'] = True
+# mpl.rcParams["font.family"] = "serif"
+# mpl.rcParams["font.size"] = "9"
+# width = 6.28 *0.5
+# height = width / 1.618
+# fig = plt.figure()
+# # ax = plt.axes((0.15,0.21 ,0.75,0.75))
+# ax = plt.axes((0.15,0.21 ,0.8,0.75))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# # ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# # ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# # ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# # ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+# ax.grid(True,which='major',axis='both',alpha=0.3)
+#
+#
+#
+#
+# ax.plot(alphas, kappas, 'royalblue', zorder=3, )
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )

JNLS_plotScripts/Energy_ContourG+_v3_plotSurf.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+from ClassifyMin import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+import time
+import matplotlib.ticker as ticker
+
+import matplotlib as mpl
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+import pandas as pd
+
+import seaborn as sns
+import matplotlib.colors as mcolors
+
+from chart_studio import plotly
+import plotly.graph_objs as go
+import plotly.express as px
+import plotly.colors
+# from matplotlib import rc
+# rc('text', usetex=True) # Use LaTeX font
+#
+# import seaborn as sns
+# sns.set(color_codes=True)
+
+
+def show(fig):
+    import io
+    import plotly.io as pio
+    from PIL import Image
+    buf = io.BytesIO()
+    pio.write_image(fig, buf)
+    img = Image.open(buf)
+    img.show()
+
+
+
+
+# set the colormap and centre the colorbar
+class MidpointNormalize(mcolors.Normalize):
+	"""
+	Normalise the colorbar so that diverging bars work there way either side from a prescribed midpoint value)
+
+	e.g. im=ax1.imshow(array, norm=MidpointNormalize(midpoint=0.,vmin=-100, vmax=100))
+	"""
+	def __init__(self, vmin=None, vmax=None, midpoint=None, clip=False):
+		self.midpoint = midpoint
+		mcolors.Normalize.__init__(self, vmin, vmax, clip)
+
+	def __call__(self, value, clip=None):
+		# I'm ignoring masked values and all kinds of edge cases to make a
+		# simple example...
+		x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
+		return np.ma.masked_array(np.interp(value, x, y), np.isnan(value))
+
+
+
+def set_size(width, fraction=1):
+    """Set figure dimensions to avoid scaling in LaTeX.
+
+    Parameters
+    ----------
+    width: float
+            Document textwidth or columnwidth in pts
+    fraction: float, optional
+            Fraction of the width which you wish the figure to occupy
+
+    Returns
+    -------
+    fig_dim: tuple
+            Dimensions of figure in inches
+    """
+    # Width of figure (in pts)
+    fig_width_pt = width * fraction
+
+    # Convert from pt to inches
+    inches_per_pt = 1 / 72.27
+
+    # Golden ratio to set aesthetic figure height
+    # https://disq.us/p/2940ij3
+    golden_ratio = (5**.5 - 1) / 2
+
+    # Figure width in inches
+    fig_width_in = fig_width_pt * inches_per_pt
+    # Figure height in inches
+    fig_height_in = fig_width_in * golden_ratio
+
+    fig_dim = (fig_width_in, fig_height_in)
+
+    return fig_dim
+
+
+
+def format_func(value, tick_number):
+    # find number of multiples of pi/2
+    # N = int(np.round(2 * value / np.pi))
+    # if N == 0:
+    #     return "0"
+    # elif N == 1:
+    #     return r"$\pi/2$"
+    # elif N == -1:
+    #     return r"$-\pi/2$"
+    # elif N == 2:
+    #     return r"$\pi$"
+    # elif N % 2 > 0:
+    #     return r"${0}\pi/2$".format(N)
+    # else:
+    #     return r"${0}\pi$".format(N // 2)
+    ##find number of multiples of pi/2
+    N = int(np.round(4 * value / np.pi))
+    if N == 0:
+        return "0"
+    elif N == 1:
+        return r"$\pi/4$"
+    elif N == -1:
+        return r"$-\pi/4$"
+    elif N == 2:
+        return r"$\pi/2$"
+    elif N == -2:
+        return r"$-\pi/2$"
+    elif N % 2 > 0:
+        return r"${0}\pi/2$".format(N)
+    else:
+        return r"${0}\pi$".format(N // 2)
+
+
+
+def find_nearest(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return array[idx]
+
+
+def find_nearestIdx(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return idx
+
+
+
+
+def check_case(q1,q2,q12,q3,b1,b2):
+
+    # a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+
+
+    print('det(H)=', np.linalg.det(H))
+
+    # check if g* is in G^*_R^2
+    tmp = A.dot(b)
+
+    ## compute inverse of H :
+    inv_H = np.linalg.inv(H)
+
+    g_star = 2*inv_H.dot(tmp)
+
+    print('g_star=', g_star)
+
+
+    return g_star
+
+
+def determine_b(q1,q2,q12,q3,g_star):
+    ##
+    # Input: g_star
+    # Output : b  such that g_star is minimizer, i.e A*b = (1/2)*H*g_star
+    # q1=1;
+    # q2=2;
+    # q12=1/2;
+    # q3=((4*q1*q2)**0.5-q12)/2;
+    # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+
+
+
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    abar = np.array([q12+2*q3, 2*q2])
+    rhs = (1/2)*H.dot(g_star)
+    print('rhs:', rhs)
+    b = np.linalg.lstsq(A, rhs)[0]
+    print('b',b)
+    b1=b[0]
+    b2=b[1]
+
+    return b
+    ## ---------------
+
+
+def get_minimizer(q1,q2,q3,b1,b2):
+
+    # In the case if q12 == 0:
+    quotient = (q1*q2-q3**2)
+    g_star = np.array([(q1*q2*b1-q3*q2*b2)/quotient, (q1*q2*b2-q3*q1*b1)/quotient])
+    print('g_star=', g_star)
+    return g_star
+
+
+def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+
+
+    a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+
+
+    tmp = H.dot(a)
+
+    # print('H',H)
+    # print('A',A)
+    # print('b',b)
+    # print('a',a)
+    # print('tmp',tmp)
+
+    tmp = (1/2)*a.dot(tmp)
+    # print('tmp',tmp)
+
+    tmp2 = A.dot(b)
+    # print('tmp2',tmp2)
+    tmp2 = 2*a.dot(tmp2)
+
+    # print('tmp2',tmp2)
+    energy = tmp - tmp2
+    # print('energy',energy)
+
+
+    # energy_axial1.append(energy_1)
+
+    return energy
+
+
+
+# def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+#
+#
+#     b = np.array([b1,b2])
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a',a)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy = tmp - tmp2
+#     print('energy',energy)
+#
+#
+#     # energy_axial1.append(energy_1)
+#
+#     return energy
+#
+
+
+def draw_1ParameterLine(q1,q2,q12,q3):
+
+    # q1=1;
+    # q2=2;
+    # q12=1/2;
+    # q3=((4*q1*q2)**0.5-q12)/2;
+    # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    abar = np.array([q12+2*q3, 2*q2])
+    abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+
+    print('abar:',abar)
+
+    b = np.linalg.lstsq(A, abar)[0]
+    print('b',b)
+
+    b1=b[0]
+    b2=b[1]
+
+
+    # print('abar:',np.shape(abar))
+    # print('np.transpose(abar):',np.shape(np.transpose(abar)))
+    sstar = (1/(q1+q2))*abar.dot(A.dot(b))
+    # sstar = (1/(q1+q2))*abar.dot(tmp)
+    print('sstar', sstar)
+    abarperp= np.array([abar[1],-abar[0]])
+    print('abarperp:',abarperp)
+
+    N=500;
+    scale_domain = 5
+    translate_startpoint = -1.8
+    scale_domain = 4.65
+    translate_startpoint = -1.85
+
+    # T = np.linspace(-sstar*(q12+2*q3)/(2*q2), sstar*(2*q2)/(q12+2*q3), num=N)
+    T = np.linspace(-sstar*(q12+2*q3)/(2*q2)*scale_domain + translate_startpoint, sstar*(2*q2)/(q12+2*q3)*scale_domain , num=N)
+    # T = np.linspace(-2,2, num=N)
+    # print('T:', T)
+
+    print('T.min():', T.min())
+    print('T.max():', T.max())
+
+    kappas = []
+    alphas = []
+    # G.append(float(s[0]))
+
+    G_container = []
+    abar_container = []
+
+
+    abar_tmp = abar
+
+    for t in T :
+    	abar_current = sstar*abar+t*abarperp;
+        # print('abar_current', abar_current)
+    	abar_current[abar_current < 1e-10] = 0
+    	# print('abar_current', abar_current)
+    	# G = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    	G = [abar_current[0], abar_current[1] , (2*abar_current[0]*abar_current[1])**0.5 ]
+    	# print('type of G', type(G))
+    	# print('G', G)
+    	G_container.append(G)
+    	abar_container.append(abar_current)
+    	e = [(abar_current[0]/(abar_current[0]+abar_current[1]))**0.5, (abar_current[1]/(abar_current[0]+abar_current[1]))**0.5]
+    	kappa = abar_current[0]+abar_current[1]
+    	alpha = math.atan2(e[1], e[0])
+    	# print('angle current:', alpha)
+    	kappas.append(kappa)
+    	alphas.append(alpha)
+
+
+    alphas = np.array(alphas)
+    kappas = np.array(kappas)
+
+    # print('G_container', G_container)
+    G = np.array(G_container)
+    abar = np.array(abar_container)
+
+    # print('G', G)
+    # print('abar', abar)
+    # print('abar.shape',abar.shape)
+    line = ax.plot(abar[:,0],abar[:,1], linewidth=2, color='royalblue', linestyle='-', zorder=4)
+
+
+    return line
+
+
+
+
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+print('---- Input parameters: -----')
+
+# q1=1;
+# q2=2;
+# q12=1/2;
+# q3=((4*q1*q2)**0.5-q12)/2;
+# # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+#
+# H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+# A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+# abar = np.array([q12+2*q3, 2*q2])
+# abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+#
+# print('abar:',abar)
+#
+# b = np.linalg.lstsq(A, abar)[0]
+# print('b',b)
+#
+#
+# # print('abar:',np.shape(abar))
+# # print('np.transpose(abar):',np.shape(np.transpose(abar)))
+# sstar = (1/(q1+q2))*abar.dot(A.dot(b))
+# # sstar = (1/(q1+q2))*abar.dot(tmp)
+# print('sstar', sstar)
+# abarperp= np.array([abar[1],-abar[0]])
+# print('abarperp:',abarperp)
+
+
+# -------------------------- Input Parameters --------------------
+#
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 5.0
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+#
+
+
+
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = -0.75
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+
+
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+
+
+#Figure3:
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/8
+# # theta= 0.1
+# beta = 2.0
+
+
+# alpha= -5
+
+
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+# gamma = '0'
+# # gamma = 'infinity'
+#
+#
+# lambda1 = 0.0
+
+
+print('---- Input parameters: -----')
+# print('mu1: ', mu1)
+# print('rho1: ', rho1)
+# # print('alpha: ', alpha)
+# print('beta: ', beta)
+# # print('theta: ', theta)
+# print('gamma:', gamma)
+#
+# print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+print('----------------------------')
+
+# ----------------------------------------------------------------
+
+
+
+
+
+
+# q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta)
+# q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta)
+# q12 = 0.0
+# q3 = GetMuGamma(beta, theta,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+# b1 = prestrain_b1(rho1,beta, alpha, theta )
+# b2 = prestrain_b2(rho1,beta, alpha, theta )
+#
+
+
+case = 'a'
+# case = 'b'
+case = 'c'
+
+
+
+if case == 'a':
+    print('---- CASE (a) ----')
+    q1 = 1
+    q2 = 2
+    q12 = 0
+    q3 = 1
+    g_star = np.array([0,1])
+    g_star = np.array([-1,1])
+    # ToDO
+    b = determine_b(q1,q2,q12,q3, g_star)
+    b1 = b[0]
+    b2 = b[1]
+
+
+if case == 'b':
+    print('---- CASE (b) ----')
+    q1 = 1
+    q2 = 2
+    q12 = 0
+    q3 = 1
+    g_star = np.array([1,1])
+    # ToDO
+    b = determine_b(q1,q2,q12,q3, g_star)
+    b1 = b[0]
+    b2 = b[1]
+
+
+if case == 'c':
+    print('---- CASE (c) ----')
+    ## ---- 1-ParameterFamilyCase:
+    q1=1;
+    q2=2;
+    q12=1/2;
+    q3=((4*q1*q2)**0.5-q12)/2;
+    # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    abar = np.array([q12+2*q3, 2*q2])
+    abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+    print('abar:',abar)
+    b = np.linalg.lstsq(A, abar)[0]
+    print('b',b)
+    b1=b[0]
+    b2=b[1]
+    ## ---------------
+
+
+
+
+print('q1 = ', q1)
+print('q2 = ', q2)
+print('q3 = ', q3)
+print('q12 = ', q12)
+print('b1 = ', b1)
+print('b2 = ', b2)
+
+## --- CHECK CASE ---
+
+
+
+
+
+g_star = check_case(q1,q2,q12,q3,b1,b2)
+print('g_star:',g_star)
+
+# TEST
+print('special case g_star:')
+get_minimizer(q1,q2,q3,b1,b2)
+
+
+
+
+## -------------------------------------
+
+num_Points = 400
+num_Points = 600
+num_Points = 200
+# num_Points = 100
+# num_Points = 20
+
+
+# Creating dataset
+x = np.linspace(-5,5,num_Points)
+y = np.linspace(-5,5,num_Points)
+
+x = np.linspace(-20,20,num_Points)
+y = np.linspace(-20,20,num_Points)
+
+
+x = np.linspace(-2,2,num_Points)
+y = np.linspace(-2,2,num_Points)
+# x = np.linspace(-10,10,num_Points)
+# y = np.linspace(-10,10,num_Points)
+
+# x = np.linspace(-60,60,num_Points)
+# y = np.linspace(-60,60,num_Points)
+#
+#
+# x = np.linspace(-40,40,num_Points)
+# y = np.linspace(-40,40,num_Points)
+
+
+a1, a2 = np.meshgrid(x,y)
+
+# geyser = sns.load_dataset("geyser")
+# print('type of geyser:', type(geyser))
+# print('geyser:',geyser)
+
+# ContourRange=20
+ContourRange=2
+
+# x_in = np.linspace(-ContourRange,ContourRange,num_Points)
+# y_in = np.linspace(-ContourRange,ContourRange,num_Points)
+# a1_in, a2_in = np.meshgrid(x_in,y_in)
+
+print('a1:', a1)
+print('a2:',a2 )
+print('a1.shape', a1.shape)
+
+#-- FILTER OUT VALUES for G+ :
+
+# tmp1 = a1[np.where(a1*a2 >= 0)]
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+#
+# np.take(a, np.where(a>100)[0], axis=0)
+# tmp1 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+
+tmp1 = a1[a1*a2 >= 0]
+tmp2 = a2[a1*a2 >= 0]
+tmp1 = tmp1.reshape(-1,5)
+tmp2 = tmp2.reshape(-1,5)
+
+
+# tmp1_pos = a1[np.where(a1*a2 >= 0) ]
+# tmp2_pos = a2[np.where(a1*a2 >= 0) ]
+# tmp1_pos = tmp1_pos[np.where(tmp1_pos  >= 0)]
+# tmp2_pos = tmp2_pos[np.where(tmp2_pos  >= 0)]
+#
+# tmp1_neg = a1[a1*a2 >= 0 ]
+# tmp2_neg = a2[a1*a2 >= 0 ]
+# tmp1_neg = tmp1_neg[tmp1_neg  < 0]
+# tmp2_neg = tmp2_neg[tmp2_neg  < 0]
+# a1 = tmp1
+# a2 = tmp2
+#
+# a1 = a1.reshape(-1,5)
+# a2 = a2.reshape(-1,5)
+#
+# tmp1_pos = tmp1_pos.reshape(-1,5)
+# tmp2_pos = tmp2_pos.reshape(-1,5)
+# tmp1_neg = tmp1_neg.reshape(-1,5)
+# tmp2_neg = tmp2_neg.reshape(-1,5)
+
+
+# print('a1:', a1)
+# print('a2:',a2 )
+# print('a1.shape', a1.shape)
+
+
+
+
+
+energyVec = np.vectorize(energy)
+
+# Z = energyVec(np.array([a1,a2]),q1,q2,q12,q3,b1,b2)
+Z = energyVec(a1,a2,q1,q2,q12,q3,b1,b2)
+
+# Z_in = energyVec(a1_in,a2_in,q1,q2,q12,q3,b1,b2)
+
+
+
+
+print('Z:', Z)
+print('any', np.any(Z<0))
+
+
+
+
+
+
+
+# negZ_a1 = a1[np.where(Z<0)]
+# negZ_a2 = a2[np.where(Z<0)]
+# negativeValues = Z[np.where(Z<0)]
+# print('negativeValues:',negativeValues)
+#
+# print('negZ_a1',negZ_a1)
+# print('negZ_a2',negZ_a2)
+#
+#
+# negZ_a1 = negZ_a1.reshape(-1,5)
+# negZ_a2 = negZ_a2.reshape(-1,5)
+# negativeValues = negativeValues.reshape(-1,5)
+#
+# Z_pos =  energyVec(tmp1_pos,tmp2_pos,q1,q2,q12,q3,b1,b2)
+# Z_neg = energyVec(tmp1_neg,tmp2_neg,q1,q2,q12,q3,b1,b2)
+
+
+
+
+
+# print('Test energy:' , energy(np.array([1,1]),q1,q2,q12,q3,b1,b2))
+
+
+
+
+# print('Z_pos.shape', Z_pos.shape)
+
+
+
+
+
+
+
+## -- PLOT :
+mpl.rcParams['text.usetex'] = True
+mpl.rcParams["font.family"] = "serif"
+mpl.rcParams["font.size"] = "9"
+
+label_size = 8
+mpl.rcParams['xtick.labelsize'] = label_size
+mpl.rcParams['ytick.labelsize'] = label_size
+
+# plt.style.use('seaborn')
+# plt.style.use('seaborn-whitegrid')
+# sns.set()
+# plt.style.use('seaborn-whitegrid')
+
+label_size = 9
+mpl.rcParams['xtick.labelsize'] = label_size
+mpl.rcParams['ytick.labelsize'] = label_size
+
+width = 6.28 *0.5
+# width = 6.28 *0.33
+# width = 6.28
+height = width #/ 1.618
+
+# width = 452.9579/2
+# size= set_size(width, fraction=0.5)
+# print('set_size(width, fraction=0.5)', set_size(width, fraction=1))
+# print('size[0]',size[0])
+
+f_size = 10
+# fig= plt.figure()
+# fig, ax = plt.subplots()
+# fig.set_size_inches(width, height)
+# fig.set_size_inches(set_size(width, fraction=0.5))
+ax = plt.axes(projection ='3d', adjustable='box')
+# ax = plt.axes((0.17,0.21 ,0.75,0.75))
+
+# ax = plt.axes((0.17,0.23 ,0.7,0.7))
+# ax = plt.axes((0.17,0.23 ,1.0,1.0))
+# ax=plt.axes()
+# ax = plt.axes((0.15,0.18,0.8,0.8))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+# ax.grid(True,which='major',axis='both',alpha=0.3)
+
+# colorfunction=(B*kappa)
+# print('colofunction',colorfunction)
+
+#translate Data
+# Z = Z - (Z.max()-Z.min())/2
+# Z = Z - 50
+# Z = Z - 500
+#
+# Z = Z.T
+
+
+# Substract constant:
+# c = (b1**2)*q1+b1*b2*q12+(b2**2)*q2
+# Z = Z-c
+#
+# print('Value of c:', c)
+
+
+
+print('Z.min()', Z.min())
+print('Z.max()', Z.max())
+norm=mcolors.Normalize(Z.min(),Z.max())
+# facecolors=cm.brg(norm)
+
+
+
+print('norm:', norm)
+print('type of norm', type(norm))
+print('norm(0):', norm(0))
+print('norm(Z):', norm(Z))
+
+# ax.plot(theta_rho, theta_values, 'royalblue', zorder=3, )
+
+# ax.scatter(a1,a2, s=0.5)
+
+# ax.scatter(tmp1_pos,tmp2_pos, s=0.5)
+# ax.scatter(tmp1_neg,tmp2_neg, s=0.5)
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, levels=100 )
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot,  levels=20 )
+
+
+# sns.kdeplot(np.array([a1, a2, Z]))
+# sns.kdeplot(tmp1_pos,tmp2_pos,Z_pos)
+
+# levels = [-5.0, -4, -3, 0.0, 1.5, 2.5, 3.5]
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, corner_mask=True,levels=levels)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot(norm(Z)), corner_mask=True)
+# CS = ax.contour(a1, a2, Z, cm.brg(norm(Z)), levels=20)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot, levels=20)
+# CS = ax.contour(a1, a2, Z, colors='k', levels=14,  linewidths=(0.5,))
+# CS = ax.contour(a1, a2, Z, colors='k', levels=18,  linewidths=(0.5,))
+
+# ax.contour(negZ_a1, negZ_a2, negativeValues, colors='k',  linewidths=(0.5,))
+# CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(0.75) ,zorder=5)
+
+
+step = (-1)*Z.min()
+# step = 3.0
+
+levels = np.arange(Z.min(),Z.max()/2,step)
+# evels = np.arange(-4, 25, 4)
+# levels = np.arange(-3, 23, 4)
+
+# levels = np.arange(Z.min(),Z.max()/12,step)
+# levels = np.arange(Z.min(),Z.max(),step)
+# levels = np.arange(0,Z.max()/2,200)
+# CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(0.75), levels=levels ,zorder=5)
+
+# CS =  ax.contour(a1, a2, Z, colors='k',  linewidths=(0.75), levels=levels ,zorder=5)
+# CS =  ax.contour(a1, a2, Z,5,  colors='k',  linewidths=(0.75) ,zorder=5, vmin=Z.min(), vmax=1)
+
+# CS =  ax.contour(a1, a2, Z,5,  colors='k',  linewidths=(0.75) ,zorder=5, vmin=Z.min(), vmax=1)
+
+if case == 'b':
+    levels = np.arange(-4, 25, 4)
+
+
+if case == 'a':
+    levels = np.arange(-1, 25, 5)  # if g_star = [0 1]
+    levels = np.arange(0, 24, 4)  # if g_star = [-1 1]
+if case == 'c':
+    levels = np.arange(0, 25, 4)
+
+# CS =  ax.contour(a1, a2, Z,levels,  colors='k',linewidths=(0.75), extent=(-2, 2, -2, 2), zorder=5)
+
+
+# CS =  ax.contour(a1 , a2 , Z, colors='k',  linewidths=(0.75), zorder=5)
+# CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(1) , vmin= Z.min()+0.04, zorder=5)
+# CS =  ax.contour(a1, a2, Z, colors='k',  linewidths=(1) , vmin= Z.min()+0.04, zorder=5)
+
+
+
+# df = pd.DataFrame(data=Z_in, columns=a1_in, index=a2_in)
+# df2 = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
+#                    columns=['a', 'b', 'c'])
+
+# sns.kdeplot(data=df2, x="waiting", y="duration")
+# sns.kdeplot(data=df2)
+
+# CS = ax.contour(a1, a2, Z, colors='k',   linewidths=(0.5,))
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k', extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k')
+#
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, levels=10 )
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, corner_mask=True)
+#
+# CS = ax.contour(a1, a2, Z,10,  colors = 'k')
+# ax.clabel(CS, inline=True, fontsize=4)
+
+# ax.clabel(CS, inline=True,  fontsize=4)
+
+
+# 1- ParameterFAMILY CASE :
+# manual_locations = [
+#                 (1, 1), (-5, -5), (-10, -10 ),(-12.5,-12.5),(-14,-14), (-15,-15),
+#                 (5, 5), (10, 10 ),(12.5,12.5), (15,15), (17,17)]
+
+
+if case == 'c':
+    manual_locations = [
+                    (1, 1), (0.5, 0.5),(1.5,1.5),(1.75,1.75),(-0.2,0.2), (-0.5,-0.5),
+                    (-1,-1),(-1.25,-1.25), (-1.5,-1.5)]
+    # ax.clabel(CS, inline=True, fontsize=9, colors='black', manual=manual_locations)
+else :
+    ax.clabel(CS, inline=True, fontsize=9, colors='black', zorder=5)
+
+# GAMMA = inf
+# manual_locations = [
+#                 (1, 1), (-5, -5), (-10, -10 ), (-15,-15),
+#                 (5, 5), (10, 10 ),(12.5,12.5), (15,15), (17,17)]
+
+#
+#
+# # GAMMA = 0
+# manual_locations = [
+#                 (1, 1), (-5, -5), (-10, -10 ), (-15,-15), (-15,7),
+#                 (5, 5), (10, 10 ), (15,15), (17,17)]
+
+
+# ax.clabel(CS, inline=True, fontsize=f_size, colors='black')
+# ax.clabel(CS, inline=True, fontsize=9, colors='black', zorder=5)
+
+# cmap = cm.brg(norm(Z))
+#
+# C_map = cm.inferno(norm(Z))
+
+# ax.imshow(Z, cmap=C_map, extent=[-20, 20, -20, 20], origin='lower', alpha=0.5)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20], origin='lower',
+#                   cmap='bwr', alpha=0.8)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', vmin=Z.min(), vmax=Z.max(),
+#                   cmap='bwr', alpha=0.6)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+
+cmap=mpl.cm.RdBu_r
+cmap=mpl.cm.viridis_r
+# cmap=mpl.cm.bwr
+cmap=mpl.cm.coolwarm
+# cmap=mpl.cm.gnuplot
+cmap=mpl.cm.magma_r
+# cmap=mpl.cm.inferno_r
+# cmap=mpl.cm.plasma
+# cmap=mpl.cm.plasma_r
+# cmap=mpl.cm.cividis_r
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","violet","red"])
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","orange"])
+
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", [(0,"red"), (.1,"violet"), (.5, "blue"), (1.0, "green")])
+# make a colormap that has land and ocean clearly delineated and of the
+# same length (256 + 256)
+#
+# colors_undersea = plt.cm.terrain(np.linspace(0, 0.17, 256))
+# colors_land = plt.cm.terrain(np.linspace(0.25, 1, 256))
+# all_colors = np.vstack((colors_undersea, colors_land))
+# # cmap = mcolors.LinearSegmentedColormap.from_list(
+# #     'terrain_map', all_colors)
+
+
+# cmap = px.colors.sequential.agsunset
+# cmap = plotly.colors.PLOTLY_SCALES["Viridis"]
+
+
+
+
+
+# cmap = cm.brg(Z)
+divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=(Z.max()+Z.min())/2, vmax=Z.max())
+# divnorm=mcolors.TwoSlopeNorm(vmin=-500, vcenter=0, vmax=Z.max())
+
+# divnorm=mcolors.TwoSlopeNorm(vmin=-10, vcenter=0. ,vmax=10)
+# divnorm=mcolors.TwoSlopeNorm(vmin=-10, vcenter=0., vmax=Z.max())
+
+# divnorm=mcolors.LogNorm(vmin=Z.min(),  vmax=Z.max())  #Test LogNorm
+
+# cmap = cm.brg(divnorm(Z))
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap='coolwarm', alpha=0.6)
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+# divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+# plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+#                   cmap=cmap, alpha=0.6)
+
+# plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+#                   cmap=cmap, alpha=0.9)
+
+
+
+
+# plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+#                   cmap=cmap, alpha=0.6)
+
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower',
+                  # cmap=cmap, alpha=0.6)
+
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = mcolors.CenteredNorm(),
+#                   cmap=cmap, alpha=0.6)
+
+
+
+# COLORBAR :
+# cbar = plt.colorbar()
+# cbar.ax.tick_params(labelsize=f_size)
+# fig.colorbar(I)
+
+
+
+##----- ADD RECTANGLE TO COVER QUADRANT :
+epsilon = 0.4
+epsilon = 0.2
+epsilon = 0.005
+epsilon = 0.01
+# ax.axvspan(0, x.max(), y.min(), 0, alpha=1, color='yellow', zorder=5)#yellow
+# ax.fill_between([0, x.max()], y.min(), 0, alpha=0.3, color='yellow', zorder=5)#yellow
+# ax.fill_between([x.min(), 0], 0, y.max(), alpha=0.3, color='yellow', zorder=5)#yellow
+
+fillcolor = 'white'
+# ax.fill_between([0+epsilon, x.max()], y.min(), 0-epsilon, alpha=0.7, color=fillcolor, zorder=4)#yellow
+# ax.fill_between([x.min(), 0-epsilon], 0+epsilon, y.max(), alpha=0.7, color=fillcolor, zorder=4)#yellow
+# ax.fill_between([0+epsilon, x.max()-epsilon], y.min()+epsilon, 0-epsilon, alpha=1.0, color=fillcolor, zorder=4)#yellow
+# ax.fill_between([x.min()+epsilon, 0-epsilon], 0+epsilon, y.max()-epsilon, alpha=1.0, color=fillcolor, zorder=4)#yellow
+
+ax.plot_surface(a1,a2, Z, cmap=cm.coolwarm,
+                       linewidth=0, antialiased=False)
+
+
+
+# ax.plot(theta_rho, energy_axial1, 'royalblue', zorder=3, label=r"axialMin1")
+# ax.plot(theta_rho, energy_axial2, 'forestgreen', zorder=3, label=r"axialMin2")
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )
+
+
+
+if case == 'c':
+    print('draw Line')
+    # line = draw_1ParameterLine(q1,q2,q12,q3)
+else:
+    # PLOT MINIMIZER g*:
+    ax.scatter(g_star[0],g_star[1], s=20, zorder=5)
+    ax.text(g_star[0]+0.1,g_star[1]-0.1, r"$g_*$", color='royalblue', size=15, zorder = 5)
+
+# lg = ax.legend(bbox_to_anchor=(0.0, 0.75), loc='upper left')
+
+if case == 'c':
+    # draw minimizers
+    print('np.where(Z == Z.min())',np.where(np.round(Z,3) == np.round(Z.min(),3)))
+    # tmp_x = a1[np.where(np.round(Z,6) == np.round(Z.min(),6))]
+    # tmp_y = a2[np.where(np.round(Z,6) == np.round(Z.min(),6))]
+    # # ax.scatter(tmp_x,tmp_y,color='red', zorder=5, s=1)
+    # # ax.plot(tmp_x,tmp_y,color='red', zorder=5)
+    # ax.plot(tmp_x,tmp_y,color='royalblue', zorder=5)
+
+
+### PLot x and y- Axes
+ax.plot(ax.get_xlim(),[0,0],'k--', linewidth=0.5, zorder=4)
+ax.plot([0,0],ax.get_ylim(), 'k--', linewidth=0.5, zorder=4)
+
+
+
+
+
+
+ax.set_xlabel(r"$a_1$", fontsize=f_size ,labelpad=0)
+ax.set_ylabel(r"$a_2$", fontsize=f_size ,labelpad=0)
+# ax.set_ylabel(r"energy")
+ax.tick_params(axis='both', which='major', labelsize=f_size)
+ax.tick_params(axis='both', which='minor', labelsize=f_size)
+
+
+
+# ax.set_xticks([-np.pi/2, -np.pi/4  ,0,  np.pi/4,  np.pi/2 ])
+# labels = ['$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$']
+# ax.set_yticklabels(labels)
+
+
+# plt.subplots_adjust(left = 0.25 )
+
+
+# ax.legend(loc='upper right')
+
+# fig.subplots_adjust(left=.18, bottom=.12, right=.90, top=.97)
+
+# fig.set_size_inches(width, height)
+# fig.set_size_inches(set_size(width, fraction=0.33))
+Outputname = 'Energy_ContourG+_case'+ str(case) + '.pdf'
+# fig.savefig(Outputname)
+
+plt.show()
+
+
+#
+#
+#
+# # Curve parametrised by \theta_rho = alpha in parameter space
+# N=100;
+# theta_rho = np.linspace(1, 3, num=N)
+# print('theta_rho:', theta_rho)
+#
+#
+# theta_values = []
+#
+#
+# for t in theta_rho:
+#
+#         s = (1.0/10.0)*t+0.1
+#         theta_values.append(s)
+#
+#
+#
+#
+#
+# theta_rho = np.array(theta_rho)
+# theta_values = np.array(theta_values)
+#
+# betas_ = 2.0
+#
+
+# alphas, betas, thetas = np.meshgrid(theta_rho, betas_, theta_values, indexing='ij')
+#
+#
+# harmonicMeanVec = np.vectorize(harmonicMean)
+# arithmeticMeanVec = np.vectorize(arithmeticMean)
+# prestrain_b1Vec = np.vectorize(prestrain_b1)
+# prestrain_b2Vec = np.vectorize(prestrain_b2)
+#
+# GetMuGammaVec = np.vectorize(GetMuGamma)
+# muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#
+# q1_vec = harmonicMeanVec(mu1, betas, thetas)
+# q2_vec = arithmeticMeanVec(mu1, betas, thetas)
+#
+# b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+# b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+
+# special case: q12 == 0!! .. braucht eigentlich nur b1 & b2 ...
+
+# print('type b1_values:', type(b1_values))
+
+
+
+# print('size(q1)',q1.shape)
+#
+#
+# energy_axial1 = []
+# energy_axial2 = []
+#
+# # for b1 in b1_values:
+# for i in range(len(theta_rho)):
+#     print('index i:', i)
+#
+#     print('theta_rho[i]',theta_rho[i])
+#     print('theta_values[i]',theta_values[i])
+#
+#     q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta_values[i])
+#     q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta_values[i])
+#     q12 = 0.0
+#     q3 = GetMuGamma(beta, theta_values[i],gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#     b1 = prestrain_b1(rho1,beta, theta_rho[i],theta_values[i] )
+#     b2 = prestrain_b2(rho1,beta, theta_rho[i],theta_values[i] )
+#
+#
+#     # q2_vec = arithmeticMean(mu1, betas, thetas)
+#     #
+#     # b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+#     # b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+#     print('q1[i]',q1)
+#     print('q2[i]',q2)
+#     print('q3[i]',q3)
+#     print('b1[i]',b1)
+#     print('b2[i]',b2)
+#     # print('q1[i]',q1[0][i])
+#     # print('q2[i]',q2[i])
+#     # print('b1[i]',b1[i])
+#     # print('b2[i]',b2[i])
+#     #compute axial energy #1 ...
+#
+#     a_axial1 = np.array([b1,0])
+#     a_axial2 = np.array([0,b2])
+#     b = np.array([b1,b2])
+#
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a_axial1)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial1',a_axial1)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial1.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial1.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_1 = tmp - tmp2
+#     print('energy_1',energy_1)
+#
+#
+#     energy_axial1.append(energy_1)
+#
+#
+#     tmp = H.dot(a_axial2)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial2',a_axial2)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial2.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial2.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_2 = tmp - tmp2
+#     print('energy_2',energy_2)
+#
+#
+#     energy_axial2.append(energy_2)
+#
+#
+#
+#
+#
+# print('theta_values', theta_values)
+#
+#
+#
+
+
+#
+#
+#
+#
+# kappas = []
+# alphas = []
+# # G.append(float(s[0]))
+#
+#
+#
+#
+# for t in T :
+#
+#     abar_current = sstar*abar+t*abarperp;
+#     # print('abar_current', abar_current)
+#     abar_current[abar_current < 1e-10] = 0
+#     # print('abar_current', abar_current)
+#
+#     # G = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     G = [abar_current[0], abar_current[1] , (2*abar_current[0]*abar_current[1])**0.5 ]
+#
+#     e = [(abar_current[0]/(abar_current[0]+abar_current[1]))**0.5, (abar_current[1]/(abar_current[0]+abar_current[1]))**0.5]
+#     kappa = abar_current[0]+abar_current[1]
+#     alpha = math.atan2(e[1], e[0])
+#
+#     print('angle current:', alpha)
+#
+#     kappas.append(kappa)
+#     alphas.append(alpha)
+#
+#
+#
+# alphas = np.array(alphas)
+# kappas = np.array(kappas)
+#
+#
+# print('kappas:',kappas)
+# print('alphas:',alphas)
+# print('min alpha:', min(alphas))
+# print('min kappa:', min(kappas))
+#
+# mpl.rcParams['text.usetex'] = True
+# mpl.rcParams["font.family"] = "serif"
+# mpl.rcParams["font.size"] = "9"
+# width = 6.28 *0.5
+# height = width / 1.618
+# fig = plt.figure()
+# # ax = plt.axes((0.15,0.21 ,0.75,0.75))
+# ax = plt.axes((0.15,0.21 ,0.8,0.75))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# # ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# # ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# # ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# # ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+# ax.grid(True,which='major',axis='both',alpha=0.3)
+#
+#
+#
+#
+# ax.plot(alphas, kappas, 'royalblue', zorder=3, )
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )

JNLS_plotScripts/Energy_ContourG+_v4.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+# from ClassifyMin import *
+from ClassifyMin_New import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+import time
+import matplotlib.ticker as ticker
+
+import matplotlib as mpl
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+import pandas as pd
+
+import seaborn as sns
+import matplotlib.colors as mcolors
+
+from chart_studio import plotly
+import plotly.graph_objs as go
+import plotly.express as px
+import plotly.colors
+# from matplotlib import rc
+# rc('text', usetex=True) # Use LaTeX font
+#
+# import seaborn as sns
+# sns.set(color_codes=True)
+
+
+def show(fig):
+    import io
+    import plotly.io as pio
+    from PIL import Image
+    buf = io.BytesIO()
+    pio.write_image(fig, buf)
+    img = Image.open(buf)
+    img.show()
+
+
+
+
+# set the colormap and centre the colorbar
+class MidpointNormalize(mcolors.Normalize):
+	"""
+	Normalise the colorbar so that diverging bars work there way either side from a prescribed midpoint value)
+
+	e.g. im=ax1.imshow(array, norm=MidpointNormalize(midpoint=0.,vmin=-100, vmax=100))
+	"""
+	def __init__(self, vmin=None, vmax=None, midpoint=None, clip=False):
+		self.midpoint = midpoint
+		mcolors.Normalize.__init__(self, vmin, vmax, clip)
+
+	def __call__(self, value, clip=None):
+		# I'm ignoring masked values and all kinds of edge cases to make a
+		# simple example...
+		x, y = [self.vmin, self.midpoint, self.vmax], [0, 0.5, 1]
+		return np.ma.masked_array(np.interp(value, x, y), np.isnan(value))
+
+
+
+def set_size(width, fraction=1):
+    """Set figure dimensions to avoid scaling in LaTeX.
+
+    Parameters
+    ----------
+    width: float
+            Document textwidth or columnwidth in pts
+    fraction: float, optional
+            Fraction of the width which you wish the figure to occupy
+
+    Returns
+    -------
+    fig_dim: tuple
+            Dimensions of figure in inches
+    """
+    # Width of figure (in pts)
+    fig_width_pt = width * fraction
+
+    # Convert from pt to inches
+    inches_per_pt = 1 / 72.27
+
+    # Golden ratio to set aesthetic figure height
+    # https://disq.us/p/2940ij3
+    golden_ratio = (5**.5 - 1) / 2
+
+    # Figure width in inches
+    fig_width_in = fig_width_pt * inches_per_pt
+    # Figure height in inches
+    fig_height_in = fig_width_in * golden_ratio
+
+    fig_dim = (fig_width_in, fig_height_in)
+
+    return fig_dim
+
+
+
+def format_func(value, tick_number):
+    # find number of multiples of pi/2
+    # N = int(np.round(2 * value / np.pi))
+    # if N == 0:
+    #     return "0"
+    # elif N == 1:
+    #     return r"$\pi/2$"
+    # elif N == -1:
+    #     return r"$-\pi/2$"
+    # elif N == 2:
+    #     return r"$\pi$"
+    # elif N % 2 > 0:
+    #     return r"${0}\pi/2$".format(N)
+    # else:
+    #     return r"${0}\pi$".format(N // 2)
+    ##find number of multiples of pi/2
+    N = int(np.round(4 * value / np.pi))
+    if N == 0:
+        return "0"
+    elif N == 1:
+        return r"$\pi/4$"
+    elif N == -1:
+        return r"$-\pi/4$"
+    elif N == 2:
+        return r"$\pi/2$"
+    elif N == -2:
+        return r"$-\pi/2$"
+    elif N % 2 > 0:
+        return r"${0}\pi/2$".format(N)
+    else:
+        return r"${0}\pi$".format(N // 2)
+
+
+
+def find_nearest(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return array[idx]
+
+
+def find_nearestIdx(array, value):
+    array = np.asarray(array)
+    idx = (np.abs(array - value)).argmin()
+    return idx
+
+
+
+
+def check_case(q1,q2,q12,q3,b1,b2):
+
+    # a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+
+
+    print('det(H)=', np.linalg.det(H))
+
+    # check if g* is in G^*_R^2
+    tmp = A.dot(b)
+
+    ## compute inverse of H :
+    inv_H = np.linalg.inv(H)
+
+    g_star = 2*inv_H.dot(tmp)
+
+    print('g_star=', g_star)
+
+
+    return g_star
+
+
+def get_gstar(q1,q2,q12,q3,b1,b2):
+
+    # a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    print('det(H)=', np.linalg.det(H))
+    # check if g* is in G^*_R^2
+    tmp = A.dot(b)
+    ## compute inverse of H :
+    inv_H = np.linalg.inv(H)
+    g_star = 2*inv_H.dot(tmp)
+    # print('g_star=', g_star)
+
+    return g_star
+
+
+def determine_b(q1,q2,q12,q3,g_star):
+    ##
+    # Input: g_star
+    # Output : b  such that g_star is minimizer, i.e A*b = (1/2)*H*g_star
+    # q1=1;
+    # q2=2;
+    # q12=1/2;
+    # q3=((4*q1*q2)**0.5-q12)/2;
+    # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+
+
+
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    abar = np.array([q12+2*q3, 2*q2])
+    rhs = (1/2)*H.dot(g_star)
+    print('rhs:', rhs)
+    b = np.linalg.lstsq(A, rhs)[0]
+    print('b',b)
+    b1=b[0]
+    b2=b[1]
+
+    return b
+    ## ---------------
+
+
+def get_minimizer(q1,q2,q3,b1,b2):
+
+    # In the case if q12 == 0:
+    quotient = (q1*q2-q3**2)
+    g_star = np.array([(q1*q2*b1-q3*q2*b2)/quotient, (q1*q2*b2-q3*q1*b1)/quotient])
+    print('g_star=', g_star)
+    return g_star
+
+
+def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+
+
+    a = np.array([a1,a2])
+    b = np.array([b1,b2])
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+
+
+    tmp = H.dot(a)
+
+    # print('H',H)
+    # print('A',A)
+    # print('b',b)
+    # print('a',a)
+    # print('tmp',tmp)
+
+    tmp = (1/2)*a.dot(tmp)
+    # print('tmp',tmp)
+
+    tmp2 = A.dot(b)
+    # print('tmp2',tmp2)
+    tmp2 = 2*a.dot(tmp2)
+
+    # print('tmp2',tmp2)
+    energy = tmp - tmp2
+    # print('energy',energy)
+
+
+    # energy_axial1.append(energy_1)
+
+    return energy
+
+
+
+# def energy(a1,a2,q1,q2,q12,q3,b1,b2):
+#
+#
+#     b = np.array([b1,b2])
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a',a)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy = tmp - tmp2
+#     print('energy',energy)
+#
+#
+#     # energy_axial1.append(energy_1)
+#
+#     return energy
+#
+
+
+def draw_1ParameterLine(q1,q2,q12,q3):
+
+    # q1=1;
+    # q2=2;
+    # q12=1/2;
+    # q3=((4*q1*q2)**0.5-q12)/2;
+    # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    abar = np.array([q12+2*q3, 2*q2])
+    abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+
+    print('abar:',abar)
+
+    b = np.linalg.lstsq(A, abar)[0]
+    print('b',b)
+
+    b1=b[0]
+    b2=b[1]
+
+
+    # print('abar:',np.shape(abar))
+    # print('np.transpose(abar):',np.shape(np.transpose(abar)))
+    sstar = (1/(q1+q2))*abar.dot(A.dot(b))
+    # sstar = (1/(q1+q2))*abar.dot(tmp)
+    print('sstar', sstar)
+    abarperp= np.array([abar[1],-abar[0]])
+    print('abarperp:',abarperp)
+
+    N=500;
+    scale_domain = 5
+    translate_startpoint = -1.8
+    scale_domain = 4.65
+    translate_startpoint = -1.85
+    # --- FUll LINE:
+    scale_domain = 4.5
+    translate_startpoint = -1.4
+    T_line = np.linspace(-sstar*(q12+2*q3)/(2*q2)*scale_domain + translate_startpoint, sstar*(2*q2)/(q12+2*q3)*scale_domain , num=N)
+    line_values = []
+    for t in T_line :
+        print('sstar*abar+t*abarperp', sstar*abar+t*abarperp)
+        line_values.append(sstar*abar+t*abarperp)
+    # ------
+
+
+    T = np.linspace(-sstar*(q12+2*q3)/(2*q2), sstar*(2*q2)/(q12+2*q3), num=N)
+    # T = np.linspace(-sstar*(q12+2*q3)/(2*q2)*scale_domain + translate_startpoint, sstar*(2*q2)/(q12+2*q3)*scale_domain , num=N)
+    # T = np.linspace(-2,2, num=N)
+    # print('T:', T)
+
+    print('T.min():', T.min())
+    print('T.max():', T.max())
+
+    kappas = []
+    alphas = []
+    # G.append(float(s[0]))
+
+    G_container = []
+    abar_container = []
+
+
+    abar_tmp = abar
+
+    for t in T :
+        abar_current = sstar*abar+t*abarperp;
+        abar_current[abar_current < 1e-10] = 0 # Project to x-y-axis!!
+        current_energy = energy(abar_current[0],abar_current[1],q1,q2,q12,q3,b1,b2)
+        print('energy along line:', current_energy )
+        G = [abar_current[0], abar_current[1] , (2*abar_current[0]*abar_current[1])**0.5 ]
+        G_container.append(G)
+        abar_container.append(abar_current)
+        e = [(abar_current[0]/(abar_current[0]+abar_current[1]))**0.5, (abar_current[1]/(abar_current[0]+abar_current[1]))**0.5]
+        kappa = abar_current[0]+abar_current[1]
+        alpha = math.atan2(e[1], e[0])
+        kappas.append(kappa)
+        alphas.append(alpha)
+
+
+    alphas = np.array(alphas)
+    kappas = np.array(kappas)
+
+    # print('G_container', G_container)
+    G = np.array(G_container)
+    abar = np.array(abar_container)
+
+    # print('G', G)
+    # print('abar', abar)
+    # print('abar.shape',abar.shape)
+    line = ax.plot(abar[:,0],abar[:,1], linewidth=2, color='royalblue', linestyle='-', zorder=4)
+
+    # Plot 1-Parameter Line
+    line_values= np.array(line_values)
+    ax.plot(line_values[:,0],line_values[:,1],'k--', linewidth=1,color='royalblue',alpha=0.8,zorder=4)
+
+    return line
+
+
+
+
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+print('---- Input parameters: -----')
+
+# q1=1;
+# q2=2;
+# q12=1/2;
+# q3=((4*q1*q2)**0.5-q12)/2;
+# # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+#
+# H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+# A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+# abar = np.array([q12+2*q3, 2*q2])
+# abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+#
+# print('abar:',abar)
+#
+# b = np.linalg.lstsq(A, abar)[0]
+# print('b',b)
+#
+#
+# # print('abar:',np.shape(abar))
+# # print('np.transpose(abar):',np.shape(np.transpose(abar)))
+# sstar = (1/(q1+q2))*abar.dot(A.dot(b))
+# # sstar = (1/(q1+q2))*abar.dot(tmp)
+# print('sstar', sstar)
+# abarperp= np.array([abar[1],-abar[0]])
+# print('abarperp:',abarperp)
+
+
+# -------------------------- Input Parameters --------------------
+#
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 5.0
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+#
+
+
+
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = -0.75
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+
+
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/2
+# # theta= 0.1
+# beta = 5.0
+
+
+#Figure3:
+# mu1 = 1.0
+# rho1 = 1.0
+# alpha = 2.0
+# theta = 1.0/8
+# # theta= 0.1
+# beta = 2.0
+
+
+# alpha= -5
+
+
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+# gamma = '0'
+# # gamma = 'infinity'
+#
+#
+# lambda1 = 0.0
+
+
+print('---- Input parameters: -----')
+# print('mu1: ', mu1)
+# print('rho1: ', rho1)
+# # print('alpha: ', alpha)
+# print('beta: ', beta)
+# # print('theta: ', theta)
+# print('gamma:', gamma)
+#
+# print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+print('----------------------------')
+
+# ----------------------------------------------------------------
+
+
+
+
+
+
+# q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta)
+# q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta)
+# q12 = 0.0
+# q3 = GetMuGamma(beta, theta,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+# b1 = prestrain_b1(rho1,beta, alpha, theta )
+# b2 = prestrain_b2(rho1,beta, alpha, theta )
+#
+
+
+case = 'a'
+# case = 'b'
+# case = 'c'
+
+
+
+if case == 'a':
+    print('---- CASE (a) ----')
+    q1 = 1
+    q2 = 2
+    q12 = 0
+    q3 = 1
+    g_star = np.array([0,1])
+    g_star = np.array([-1,1])
+    # ToDO
+    b = determine_b(q1,q2,q12,q3, g_star)
+    b1 = b[0]
+    b2 = b[1]
+
+
+if case == 'b':
+    print('---- CASE (b) ----')
+    q1 = 1
+    q2 = 2
+    q12 = 0
+    q3 = 1
+    g_star = np.array([1,1])
+    # ToDO
+    b = determine_b(q1,q2,q12,q3, g_star)
+    b1 = b[0]
+    b2 = b[1]
+
+
+if case == 'c':
+    print('---- CASE (c) ----')
+    ## ---- 1-ParameterFamilyCase:
+    q1=1;
+    q2=2;
+    q12=1/2;
+    q3=((4*q1*q2)**0.5-q12)/2;
+    # H=[2*q1,q12+2*q3;q12+2*q3,2*q2];
+    H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+    A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+    abar = np.array([q12+2*q3, 2*q2])
+    abar = (1.0/math.sqrt((q12+2*q3)**2+(2*q2)**2))*abar
+    print('abar:',abar)
+    b = np.linalg.lstsq(A, abar)[0]
+    print('b',b)
+    b1=b[0]
+    b2=b[1]
+    ## ---------------
+
+
+
+
+print('q1 = ', q1)
+print('q2 = ', q2)
+print('q3 = ', q3)
+print('q12 = ', q12)
+print('b1 = ', b1)
+print('b2 = ', b2)
+
+## --- CHECK CASE ---
+
+
+if case == 'a':
+    # Check Minimizers:
+    vec1 = np.array([(2*q1*b1+q12*b2)/(2*q1), 0])
+    vec2 = np.array([0, (2*q12*b1+q2*b2)/(2*q2)])
+    print('vec1:',vec1)
+    print('vec2:',vec2)
+    energy_1 = energy(vec1[0],vec1[1],q1,q2,q12,q3,b1,b2)
+    energy_2 = energy(vec2[0],vec2[1],q1,q2,q12,q3,b1,b2)
+    print('energy_1:',energy_1)
+    print('energy_2:',energy_2)
+    if energy_1 >= energy_2:
+        minvec = vec2
+    else:
+        minvec = vec1
+    print('minvec:', minvec)
+
+
+
+
+check_case(q1,q2,q12,q3,b1,b2)
+
+g_star = get_gstar(q1,q2,q12,q3,b1,b2)
+print('g_star:',g_star)
+
+# TEST
+print('special case g_star:')
+get_minimizer(q1,q2,q3,b1,b2)
+
+
+
+
+## -------------------------------------
+
+num_Points = 400
+# num_Points = 600
+# num_Points = 200
+# num_Points = 100
+# num_Points = 20
+
+
+# Creating dataset
+x = np.linspace(-5,5,num_Points)
+y = np.linspace(-5,5,num_Points)
+
+x = np.linspace(-20,20,num_Points)
+y = np.linspace(-20,20,num_Points)
+
+
+x = np.linspace(-2,2,num_Points)
+y = np.linspace(-2,2,num_Points)
+# x = np.linspace(-10,10,num_Points)
+# y = np.linspace(-10,10,num_Points)
+
+# x = np.linspace(-60,60,num_Points)
+# y = np.linspace(-60,60,num_Points)
+#
+#
+# x = np.linspace(-40,40,num_Points)
+# y = np.linspace(-40,40,num_Points)
+
+
+a1, a2 = np.meshgrid(x,y)
+
+# geyser = sns.load_dataset("geyser")
+# print('type of geyser:', type(geyser))
+# print('geyser:',geyser)
+
+# ContourRange=20
+ContourRange=2
+
+# x_in = np.linspace(-ContourRange,ContourRange,num_Points)
+# y_in = np.linspace(-ContourRange,ContourRange,num_Points)
+# a1_in, a2_in = np.meshgrid(x_in,y_in)
+
+print('a1:', a1)
+print('a2:',a2 )
+print('a1.shape', a1.shape)
+
+#-- FILTER OUT VALUES for G+ :
+
+# tmp1 = a1[np.where(a1*a2 >= 0)]
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+#
+# np.take(a, np.where(a>100)[0], axis=0)
+# tmp1 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = np.take(a1, np.where(a1*a2 >= 0)[0], axis=0)
+# tmp2 = a2[np.where(a1*a2 >= 0)]
+
+tmp1 = a1[a1*a2 >= 0]
+tmp2 = a2[a1*a2 >= 0]
+tmp1 = tmp1.reshape(-1,5)
+tmp2 = tmp2.reshape(-1,5)
+
+
+# tmp1_pos = a1[np.where(a1*a2 >= 0) ]
+# tmp2_pos = a2[np.where(a1*a2 >= 0) ]
+# tmp1_pos = tmp1_pos[np.where(tmp1_pos  >= 0)]
+# tmp2_pos = tmp2_pos[np.where(tmp2_pos  >= 0)]
+#
+# tmp1_neg = a1[a1*a2 >= 0 ]
+# tmp2_neg = a2[a1*a2 >= 0 ]
+# tmp1_neg = tmp1_neg[tmp1_neg  < 0]
+# tmp2_neg = tmp2_neg[tmp2_neg  < 0]
+# a1 = tmp1
+# a2 = tmp2
+#
+# a1 = a1.reshape(-1,5)
+# a2 = a2.reshape(-1,5)
+#
+# tmp1_pos = tmp1_pos.reshape(-1,5)
+# tmp2_pos = tmp2_pos.reshape(-1,5)
+# tmp1_neg = tmp1_neg.reshape(-1,5)
+# tmp2_neg = tmp2_neg.reshape(-1,5)
+
+
+# print('a1:', a1)
+# print('a2:',a2 )
+# print('a1.shape', a1.shape)
+
+
+
+
+
+energyVec = np.vectorize(energy)
+
+# Z = energyVec(np.array([a1,a2]),q1,q2,q12,q3,b1,b2)
+Z = energyVec(a1,a2,q1,q2,q12,q3,b1,b2)
+
+# Z_in = energyVec(a1_in,a2_in,q1,q2,q12,q3,b1,b2)
+
+
+
+
+print('Z:', Z)
+print('any', np.any(Z<0))
+
+
+
+
+
+
+
+# negZ_a1 = a1[np.where(Z<0)]
+# negZ_a2 = a2[np.where(Z<0)]
+# negativeValues = Z[np.where(Z<0)]
+# print('negativeValues:',negativeValues)
+#
+# print('negZ_a1',negZ_a1)
+# print('negZ_a2',negZ_a2)
+#
+#
+# negZ_a1 = negZ_a1.reshape(-1,5)
+# negZ_a2 = negZ_a2.reshape(-1,5)
+# negativeValues = negativeValues.reshape(-1,5)
+#
+# Z_pos =  energyVec(tmp1_pos,tmp2_pos,q1,q2,q12,q3,b1,b2)
+# Z_neg = energyVec(tmp1_neg,tmp2_neg,q1,q2,q12,q3,b1,b2)
+
+
+
+
+
+# print('Test energy:' , energy(np.array([1,1]),q1,q2,q12,q3,b1,b2))
+
+
+
+
+# print('Z_pos.shape', Z_pos.shape)
+
+
+
+
+
+
+
+## -- PLOT :
+# mpl.rcParams['text.usetex'] = True
+# mpl.rcParams["font.family"] = "serif"
+# mpl.rcParams["font.size"] = "9"
+#
+# label_size = 8
+# mpl.rcParams['xtick.labelsize'] = label_size
+# mpl.rcParams['ytick.labelsize'] = label_size
+#
+# label_size = 9
+# mpl.rcParams['xtick.labelsize'] = label_size
+# mpl.rcParams['ytick.labelsize'] = label_size
+
+label_size = 10
+#--- change plot style:  SEABORN
+# plt.style.use("seaborn-paper")
+
+# plt.style.use("seaborn-darkgrid")
+# plt.style.use("seaborn-whitegrid")
+# plt.style.use("seaborn")
+# plt.style.use("seaborn-paper")
+# plt.style.use('ggplot')
+# plt.rcParams["font.family"] = "Avenir"
+# plt.rcParams["font.size"] = 16
+
+# plt.style.use("seaborn-darkgrid")
+mpl.rcParams['text.usetex'] = True
+mpl.rcParams["font.family"] = "serif"
+mpl.rcParams["font.size"] = "10"
+# mpl.rcParams['xtick.labelsize'] = 16mpl.rcParams['xtick.major.size'] = 2.5
+# mpl.rcParams['xtick.bottom'] = True
+# mpl.rcParams['ticks'] = True
+mpl.rcParams['xtick.bottom'] = True
+mpl.rcParams['xtick.major.size'] = 3
+mpl.rcParams['xtick.minor.size'] = 1.5
+mpl.rcParams['xtick.major.width'] = 0.75
+mpl.rcParams['ytick.left'] = True
+mpl.rcParams['ytick.major.size'] = 3
+mpl.rcParams['ytick.minor.size'] = 1.5
+mpl.rcParams['ytick.major.width'] = 0.75
+
+mpl.rcParams.update({'font.size': 10})
+mpl.rcParams['axes.labelpad'] = 3.0
+
+#--- Adjust gobal matplotlib variables
+# mpl.rcParams['pdf.fonttype'] = 42
+# mpl.rcParams['ps.fonttype'] = 42
+mpl.rcParams['text.usetex'] = True
+mpl.rcParams["font.family"] = "serif"
+mpl.rcParams["font.size"] = "10"
+
+
+
+
+width = 6.28 *0.5
+# width = 6.28 *0.33
+# width = 6.28
+height = width #/ 1.618
+
+# width = 452.9579/2
+# size= set_size(width, fraction=0.5)
+# print('set_size(width, fraction=0.5)', set_size(width, fraction=1))
+# print('size[0]',size[0])
+
+f_size = 10
+# fig= plt.figure()
+fig, ax = plt.subplots()
+# fig.set_size_inches(width, height)
+# fig.set_size_inches(set_size(width, fraction=0.5))
+# ax = plt.axes(projection ='3d', adjustable='box')
+# ax = plt.axes((0.17,0.21 ,0.75,0.75))
+
+# ax = plt.axes((0.17,0.23 ,0.7,0.7))
+# ax = plt.axes((0.17,0.23 ,1.0,1.0))
+# ax=plt.axes()
+# ax = plt.axes((0.15,0.18,0.8,0.8))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+# ax.grid(True,which='major',axis='both',alpha=0.3)
+
+# colorfunction=(B*kappa)
+# print('colofunction',colorfunction)
+
+#translate Data
+# Z = Z - (Z.max()-Z.min())/2
+# Z = Z - 50
+# Z = Z - 500
+#
+# Z = Z.T
+
+
+# Substract constant:
+# c = (b1**2)*q1+b1*b2*q12+(b2**2)*q2
+# Z = Z-c
+#
+# print('Value of c:', c)
+
+
+
+print('Z.min()', Z.min())
+print('Z.max()', Z.max())
+norm=mcolors.Normalize(Z.min(),Z.max())
+# facecolors=cm.brg(norm)
+
+
+
+print('norm:', norm)
+print('type of norm', type(norm))
+print('norm(0):', norm(0))
+print('norm(Z):', norm(Z))
+
+# ax.plot(theta_rho, theta_values, 'royalblue', zorder=3, )
+
+# ax.scatter(a1,a2, s=0.5)
+
+# ax.scatter(tmp1_pos,tmp2_pos, s=0.5)
+# ax.scatter(tmp1_neg,tmp2_neg, s=0.5)
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, levels=100 )
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot,  levels=20 )
+
+
+# sns.kdeplot(np.array([a1, a2, Z]))
+# sns.kdeplot(tmp1_pos,tmp2_pos,Z_pos)
+
+# levels = [-5.0, -4, -3, 0.0, 1.5, 2.5, 3.5]
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, corner_mask=True,levels=levels)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot(norm(Z)), corner_mask=True)
+# CS = ax.contour(a1, a2, Z, cm.brg(norm(Z)), levels=20)
+# CS = ax.contour(a1, a2, Z, cmap=plt.cm.gnuplot, levels=20)
+# CS = ax.contour(a1, a2, Z, colors='k', levels=14,  linewidths=(0.5,))
+# CS = ax.contour(a1, a2, Z, colors='k', levels=18,  linewidths=(0.5,))
+
+# ax.contour(negZ_a1, negZ_a2, negativeValues, colors='k',  linewidths=(0.5,))
+# CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(0.75) ,zorder=5)
+
+
+step = (-1)*Z.min()
+# step = 3.0
+
+levels = np.arange(Z.min(),Z.max()/2,step)
+# evels = np.arange(-4, 25, 4)
+# levels = np.arange(-3, 23, 4)
+
+# levels = np.arange(Z.min(),Z.max()/12,step)
+# levels = np.arange(Z.min(),Z.max(),step)
+# levels = np.arange(0,Z.max()/2,200)
+# CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(0.75), levels=levels ,zorder=5)
+
+# CS =  ax.contour(a1, a2, Z, colors='k',  linewidths=(0.75), levels=levels ,zorder=5)
+# CS =  ax.contour(a1, a2, Z,5,  colors='k',  linewidths=(0.75) ,zorder=5, vmin=Z.min(), vmax=1)
+
+# CS =  ax.contour(a1, a2, Z,5,  colors='k',  linewidths=(0.75) ,zorder=5, vmin=Z.min(), vmax=1)
+
+if case == 'b':
+    levels = np.arange(-4, 25, 4)
+
+
+if case == 'a':
+    levels = np.arange(-1, 25, 5)  # if g_star = [0 1]
+    levels = np.arange(0, 24, 4)  # if g_star = [-1 1]
+if case == 'c':
+    levels = np.arange(0, 25, 4)
+
+CS =  ax.contour(a1, a2, Z,levels,  colors='k',linewidths=(0.75), extent=(-2, 2, -2, 2), zorder=5)
+
+
+# CS =  ax.contour(a1 , a2 , Z, colors='k',  linewidths=(0.75), zorder=5)
+# CS =  ax.contour(a1_in, a2_in, Z_in, colors='k',  linewidths=(1) , vmin= Z.min()+0.04, zorder=5)
+# CS =  ax.contour(a1, a2, Z, colors='k',  linewidths=(1) , vmin= Z.min()+0.04, zorder=5)
+
+
+
+# df = pd.DataFrame(data=Z_in, columns=a1_in, index=a2_in)
+# df2 = pd.DataFrame(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
+#                    columns=['a', 'b', 'c'])
+
+# sns.kdeplot(data=df2, x="waiting", y="duration")
+# sns.kdeplot(data=df2)
+
+# CS = ax.contour(a1, a2, Z, colors='k',   linewidths=(0.5,))
+
+# CS = ax.contour(a1, a2, Z,10, cmap=plt.cm.gnuplot, extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k', extend='both', levels=50)
+# CS = ax.contourf(a1, a2, Z,10, colors='k')
+#
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, levels=10 )
+# # CS = ax.contour(tmp1_pos,tmp2_pos, Z_pos,10, cmap=plt.cm.gnuplot, corner_mask=True)
+#
+# CS = ax.contour(a1, a2, Z,10,  colors = 'k')
+# ax.clabel(CS, inline=True, fontsize=4)
+
+# ax.clabel(CS, inline=True,  fontsize=4)
+
+
+# 1- ParameterFAMILY CASE :
+# manual_locations = [
+#                 (1, 1), (-5, -5), (-10, -10 ),(-12.5,-12.5),(-14,-14), (-15,-15),
+#                 (5, 5), (10, 10 ),(12.5,12.5), (15,15), (17,17)]
+
+
+if case == 'c':
+    manual_locations = [
+                    (1, 1), (0.5, 0.5),(1.5,1.5),(1.75,1.75),(-0.2,0.2), (-0.5,-0.5),
+                    (-1,-1),(-1.25,-1.25), (-1.5,-1.5)]
+    ax.clabel(CS, inline=True, fontsize=9, colors='black', manual=manual_locations)
+if case == 'b':
+    manual_locations = [
+                    (0.5, 0.5),(-0.2,0.2),(-0.2,-0.2),(-0.5,-0.5), (-0.75,-0.75),
+                    (-1,-1),(-1.25,-1.25), (-1.5,-1.5)]
+    ax.clabel(CS, inline=True, fontsize=9, colors='black', manual=manual_locations)
+if case == 'a':
+    manual_locations = [
+                  (1.8,1.8),(1.5,1.5) , (1, 1.5),(-1,0.25),(-0.75,-0.75),
+                    (-1,-1),(-1.25,-1.25), (-1.5,-1.5)]
+    ax.clabel(CS, inline=True, fontsize=9, colors='black', manual=manual_locations)
+# else :
+#     ax.clabel(CS, inline=True, fontsize=9, colors='black', zorder=5)
+
+# GAMMA = inf
+# manual_locations = [
+#                 (1, 1), (-5, -5), (-10, -10 ), (-15,-15),
+#                 (5, 5), (10, 10 ),(12.5,12.5), (15,15), (17,17)]
+
+#
+#
+# # GAMMA = 0
+# manual_locations = [
+#                 (1, 1), (-5, -5), (-10, -10 ), (-15,-15), (-15,7),
+#                 (5, 5), (10, 10 ), (15,15), (17,17)]
+
+
+# ax.clabel(CS, inline=True, fontsize=f_size, colors='black')
+# ax.clabel(CS, inline=True, fontsize=9, colors='black', zorder=5)
+
+# cmap = cm.brg(norm(Z))
+#
+# C_map = cm.inferno(norm(Z))
+
+# ax.imshow(Z, cmap=C_map, extent=[-20, 20, -20, 20], origin='lower', alpha=0.5)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20], origin='lower',
+#                   cmap='bwr', alpha=0.8)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', vmin=Z.min(), vmax=Z.max(),
+#                   cmap='bwr', alpha=0.6)
+
+# ax.imshow(norm(Z), extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+
+cmap=mpl.cm.RdBu_r
+cmap=mpl.cm.viridis_r
+# cmap=mpl.cm.bwr
+cmap=mpl.cm.coolwarm
+# cmap=mpl.cm.gnuplot
+cmap=mpl.cm.magma_r
+# cmap=mpl.cm.inferno_r
+# cmap=mpl.cm.plasma
+# cmap=mpl.cm.plasma_r
+# cmap=mpl.cm.cividis_r
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","violet","red"])
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","orange"])
+
+# cmap = mpl.colors.LinearSegmentedColormap.from_list("", [(0,"red"), (.1,"violet"), (.5, "blue"), (1.0, "green")])
+# make a colormap that has land and ocean clearly delineated and of the
+# same length (256 + 256)
+#
+# colors_undersea = plt.cm.terrain(np.linspace(0, 0.17, 256))
+# colors_land = plt.cm.terrain(np.linspace(0.25, 1, 256))
+# all_colors = np.vstack((colors_undersea, colors_land))
+# # cmap = mcolors.LinearSegmentedColormap.from_list(
+# #     'terrain_map', all_colors)
+
+
+# cmap = px.colors.sequential.agsunset
+# cmap = plotly.colors.PLOTLY_SCALES["Viridis"]
+
+
+
+
+
+# cmap = cm.brg(Z)
+divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=(Z.max()+Z.min())/2, vmax=Z.max())
+# divnorm=mcolors.TwoSlopeNorm(vmin=-500, vcenter=0, vmax=Z.max())
+
+# divnorm=mcolors.TwoSlopeNorm(vmin=-10, vcenter=0. ,vmax=10)
+# divnorm=mcolors.TwoSlopeNorm(vmin=-10, vcenter=0., vmax=Z.max())
+
+# divnorm=mcolors.LogNorm(vmin=Z.min(),  vmax=Z.max())  #Test LogNorm
+
+# cmap = cm.brg(divnorm(Z))
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower', norm = norm,
+#                   cmap='coolwarm', alpha=0.6)
+
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap='coolwarm', alpha=0.6)
+# ax.imshow(Z, extent=[-20, 20, -20, 20],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+# divnorm=mcolors.TwoSlopeNorm(vmin=Z.min(), vcenter=0., vmax=Z.max())
+# plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower',
+#                   cmap=cmap, alpha=0.6)
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+#                   cmap=cmap, alpha=0.6)
+plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+                  cmap=cmap, alpha=0.9)
+# plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = divnorm,
+#                   cmap=cmap, alpha=0.6)
+
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower',
+                  # cmap=cmap, alpha=0.6)
+
+
+# I = plt.imshow(Z, extent=[x.min(), x.max(), y.min(), y.max()],origin='lower', norm = mcolors.CenteredNorm(),
+#                   cmap=cmap, alpha=0.6)
+
+
+
+# COLORBAR :
+# cbar = plt.colorbar()
+# cbar.ax.tick_params(labelsize=f_size)
+# fig.colorbar(I)
+
+
+
+##----- ADD RECTANGLE TO COVER QUADRANT :
+epsilon = 0.4
+epsilon = 0.2
+epsilon = 0.005
+epsilon = 0.01
+# ax.axvspan(0, x.max(), y.min(), 0, alpha=1, color='yellow', zorder=5)#yellow
+# ax.fill_between([0, x.max()], y.min(), 0, alpha=0.3, color='yellow', zorder=5)#yellow
+# ax.fill_between([x.min(), 0], 0, y.max(), alpha=0.3, color='yellow', zorder=5)#yellow
+
+fillcolor = 'white'
+# ax.fill_between([0+epsilon, x.max()], y.min(), 0-epsilon, alpha=0.7, color=fillcolor, zorder=4)#yellow
+# ax.fill_between([x.min(), 0-epsilon], 0+epsilon, y.max(), alpha=0.7, color=fillcolor, zorder=4)#yellow
+ax.fill_between([0+epsilon, x.max()-epsilon], y.min()+epsilon, 0-epsilon, alpha=1.0, color=fillcolor, zorder=4)#yellow
+ax.fill_between([x.min()+epsilon, 0-epsilon], 0+epsilon, y.max()-epsilon, alpha=1.0, color=fillcolor, zorder=4)#yellow
+
+# ax.plot_surface(a1,a2, Z, cmap=cm.coolwarm,
+#                        linewidth=0, antialiased=False)
+
+
+
+# ax.plot(theta_rho, energy_axial1, 'royalblue', zorder=3, label=r"axialMin1")
+# ax.plot(theta_rho, energy_axial2, 'forestgreen', zorder=3, label=r"axialMin2")
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )
+
+if case == 'a':
+    # PLOT MINIMIZER g*:
+    # ax.scatter(g_star[0],g_star[1], s=20, zorder=5)
+    # ax.scatter(g_star[0],g_star[1], marker = 'x', s=20, zorder=5)
+    # ax.text(g_star[0]+0.1,g_star[1]-0.1, r"$g_*$", color='royalblue', size=15, zorder = 5)
+    ax.scatter(g_star[0],g_star[1], marker = 'x', s=40, color='darkslategray', zorder=4)
+    ax.text(g_star[0]+0.15,g_star[1]-0.15, r"$g_*$", color='darkslategray', size=13, alpha=1.0, zorder = 5)
+if case == 'b':
+    # PLOT MINIMIZER g*:
+    ax.scatter(g_star[0],g_star[1], s=20, color='royalblue', zorder=5)
+    ax.scatter(g_star[0],g_star[1], marker = 'x', s=40, color='darkslategray', zorder=4)
+    ax.text(g_star[0]+0.15,g_star[1]-0.15, r"$g_*$", color='darkslategray', size=13, alpha=1.0, zorder = 5)
+if case == 'c':
+    print('draw Line')
+    line = draw_1ParameterLine(q1,q2,q12,q3)
+
+
+# lg = ax.legend(bbox_to_anchor=(0.0, 0.75), loc='upper left')
+
+if case == 'c':
+    # draw MINIMAL VALUES
+    print('np.where(Z == Z.min())',np.where(np.round(Z,6) == np.round(Z.min(),6)))
+    tmp_x = a1[np.where(np.round(Z,6) == np.round(Z.min(),6))]
+    tmp_y = a2[np.where(np.round(Z,6) == np.round(Z.min(),6))]
+    # ax.scatter(tmp_x,tmp_y,color='red', zorder=5, s=1)
+    # ax.plot(tmp_x,tmp_y,color='forestgreen', zorder=5)
+
+# print('np.where(Z == Z.min())',np.where(np.round(Z,8) == np.round(Z.min(),8)))
+
+
+if case == 'a':
+    ax.scatter(minvec[0],minvec[1],color='royalblue',zorder=5, s=20)
+
+
+### PLot x and y- Axes
+ax.plot(ax.get_xlim(),[0,0],'k--', linewidth=0.5, zorder=4)
+ax.plot([0,0],ax.get_ylim(), 'k--', linewidth=0.5, zorder=4)
+
+
+
+
+
+
+# ax.set_xlabel(r"$a_1$", fontsize=f_size ,labelpad=0)
+# ax.set_ylabel(r"$a_2$", fontsize=f_size ,labelpad=0)
+ax.set_xlabel(r"$a_1$", fontsize=f_size )
+ax.set_ylabel(r"$a_2$", fontsize=f_size, rotation=0 )
+
+# ax.set_ylabel(r"energy")
+ax.tick_params(axis='both', which='major', labelsize=f_size)
+ax.tick_params(axis='both', which='minor', labelsize=f_size)
+
+
+
+# ax.set_xticks([-np.pi/2, -np.pi/4  ,0,  np.pi/4,  np.pi/2 ])
+# labels = ['$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$']
+# ax.set_yticklabels(labels)
+
+
+# plt.subplots_adjust(left = 0.25 )
+
+
+# ax.legend(loc='upper right')
+
+fig.subplots_adjust(left=.18, bottom=.12, right=.90, top=.97)
+
+fig.set_size_inches(width, height)
+# fig.set_size_inches(set_size(width, fraction=0.33))
+Outputname = 'Energy_ContourG+_case'+ str(case) + '.pdf'
+fig.savefig(Outputname)
+
+plt.show()
+
+
+#
+#
+#
+# # Curve parametrised by \theta_rho = alpha in parameter space
+# N=100;
+# theta_rho = np.linspace(1, 3, num=N)
+# print('theta_rho:', theta_rho)
+#
+#
+# theta_values = []
+#
+#
+# for t in theta_rho:
+#
+#         s = (1.0/10.0)*t+0.1
+#         theta_values.append(s)
+#
+#
+#
+#
+#
+# theta_rho = np.array(theta_rho)
+# theta_values = np.array(theta_values)
+#
+# betas_ = 2.0
+#
+
+# alphas, betas, thetas = np.meshgrid(theta_rho, betas_, theta_values, indexing='ij')
+#
+#
+# harmonicMeanVec = np.vectorize(harmonicMean)
+# arithmeticMeanVec = np.vectorize(arithmeticMean)
+# prestrain_b1Vec = np.vectorize(prestrain_b1)
+# prestrain_b2Vec = np.vectorize(prestrain_b2)
+#
+# GetMuGammaVec = np.vectorize(GetMuGamma)
+# muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#
+# q1_vec = harmonicMeanVec(mu1, betas, thetas)
+# q2_vec = arithmeticMeanVec(mu1, betas, thetas)
+#
+# b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+# b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+
+# special case: q12 == 0!! .. braucht eigentlich nur b1 & b2 ...
+
+# print('type b1_values:', type(b1_values))
+
+
+
+# print('size(q1)',q1.shape)
+#
+#
+# energy_axial1 = []
+# energy_axial2 = []
+#
+# # for b1 in b1_values:
+# for i in range(len(theta_rho)):
+#     print('index i:', i)
+#
+#     print('theta_rho[i]',theta_rho[i])
+#     print('theta_values[i]',theta_values[i])
+#
+#     q1 = (1.0/6.0)*harmonicMean(mu1, beta, theta_values[i])
+#     q2 = (1.0/6.0)*arithmeticMean(mu1, beta, theta_values[i])
+#     q12 = 0.0
+#     q3 = GetMuGamma(beta, theta_values[i],gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+#     b1 = prestrain_b1(rho1,beta, theta_rho[i],theta_values[i] )
+#     b2 = prestrain_b2(rho1,beta, theta_rho[i],theta_values[i] )
+#
+#
+#     # q2_vec = arithmeticMean(mu1, betas, thetas)
+#     #
+#     # b1_vec = prestrain_b1Vec(rho1, betas, alphas, thetas)
+#     # b2_vec = prestrain_b2Vec(rho1, betas, alphas, thetas)
+#     print('q1[i]',q1)
+#     print('q2[i]',q2)
+#     print('q3[i]',q3)
+#     print('b1[i]',b1)
+#     print('b2[i]',b2)
+#     # print('q1[i]',q1[0][i])
+#     # print('q2[i]',q2[i])
+#     # print('b1[i]',b1[i])
+#     # print('b2[i]',b2[i])
+#     #compute axial energy #1 ...
+#
+#     a_axial1 = np.array([b1,0])
+#     a_axial2 = np.array([0,b2])
+#     b = np.array([b1,b2])
+#
+#     H = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     A = np.array([[q1,1/2*q12], [1/2*q12,q2] ])
+#
+#
+#     tmp = H.dot(a_axial1)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial1',a_axial1)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial1.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial1.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_1 = tmp - tmp2
+#     print('energy_1',energy_1)
+#
+#
+#     energy_axial1.append(energy_1)
+#
+#
+#     tmp = H.dot(a_axial2)
+#
+#     print('H',H)
+#     print('A',A)
+#     print('b',b)
+#     print('a_axial2',a_axial2)
+#     print('tmp',tmp)
+#
+#     tmp = (1/2)*a_axial2.dot(tmp)
+#     print('tmp',tmp)
+#
+#     tmp2 = A.dot(b)
+#     print('tmp2',tmp2)
+#     tmp2 = 2*a_axial2.dot(tmp2)
+#
+#     print('tmp2',tmp2)
+#     energy_2 = tmp - tmp2
+#     print('energy_2',energy_2)
+#
+#
+#     energy_axial2.append(energy_2)
+#
+#
+#
+#
+#
+# print('theta_values', theta_values)
+#
+#
+#
+
+
+#
+#
+#
+#
+# kappas = []
+# alphas = []
+# # G.append(float(s[0]))
+#
+#
+#
+#
+# for t in T :
+#
+#     abar_current = sstar*abar+t*abarperp;
+#     # print('abar_current', abar_current)
+#     abar_current[abar_current < 1e-10] = 0
+#     # print('abar_current', abar_current)
+#
+#     # G = np.array([[2*q1, q12+2*q3], [q12+2*q3,2*q2] ])
+#     G = [abar_current[0], abar_current[1] , (2*abar_current[0]*abar_current[1])**0.5 ]
+#
+#     e = [(abar_current[0]/(abar_current[0]+abar_current[1]))**0.5, (abar_current[1]/(abar_current[0]+abar_current[1]))**0.5]
+#     kappa = abar_current[0]+abar_current[1]
+#     alpha = math.atan2(e[1], e[0])
+#
+#     print('angle current:', alpha)
+#
+#     kappas.append(kappa)
+#     alphas.append(alpha)
+#
+#
+#
+# alphas = np.array(alphas)
+# kappas = np.array(kappas)
+#
+#
+# print('kappas:',kappas)
+# print('alphas:',alphas)
+# print('min alpha:', min(alphas))
+# print('min kappa:', min(kappas))
+#
+# mpl.rcParams['text.usetex'] = True
+# mpl.rcParams["font.family"] = "serif"
+# mpl.rcParams["font.size"] = "9"
+# width = 6.28 *0.5
+# height = width / 1.618
+# fig = plt.figure()
+# # ax = plt.axes((0.15,0.21 ,0.75,0.75))
+# ax = plt.axes((0.15,0.21 ,0.8,0.75))
+# ax.tick_params(axis='x',which='major', direction='out',pad=5)
+# ax.tick_params(axis='y',which='major', length=3, width=1, direction='out',pad=3)
+# # ax.xaxis.set_major_locator(MultipleLocator(0.1))
+# # ax.xaxis.set_minor_locator(MultipleLocator(0.05))
+# # ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 8))
+# # ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 16))
+# ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
+# ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 4))
+# ax.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
+# ax.grid(True,which='major',axis='both',alpha=0.3)
+#
+#
+#
+#
+# ax.plot(alphas, kappas, 'royalblue', zorder=3, )
+# ax.plot(-1.0*alphas, kappas, 'red', zorder=3, )

JNLS_plotScripts/HelperFunctions.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import time
+# from ClassifyMin import *
+from ClassifyMin_New import *
+# from scipy.io import loadmat #not Needed anymore?
+import codecs
+import sys
+
+
+def ReadEffectiveQuantities(QFilePath = os.path.dirname(os.getcwd()) + '/outputs/QMatrix.txt', BFilePath = os.path.dirname(os.getcwd())+ '/outputs/BMatrix.txt'):
+    # Read Output Matrices (effective quantities)
+    # From Cell-Problem output Files : ../outputs/Qmatrix.txt , ../outputs/Bmatrix.txt
+    # -- Read Matrix Qhom
+    X = []
+    # with codecs.open(path + '/outputs/QMatrix.txt', encoding='utf-8-sig') as f:
+    with codecs.open(QFilePath, encoding='utf-8-sig') as f:
+        for line in f:
+            s = line.split()
+            X.append([float(s[i]) for i in range(len(s))])
+    Q = np.array([[X[0][2], X[1][2], X[2][2]],
+                  [X[3][2], X[4][2], X[5][2]],
+                  [X[6][2], X[7][2], X[8][2]] ])
+
+    # -- Read Beff (as Vector)
+    X = []
+    # with codecs.open(path + '/outputs/BMatrix.txt', encoding='utf-8-sig') as f:
+    with codecs.open(BFilePath, encoding='utf-8-sig') as f:
+        for line in f:
+            s = line.split()
+            X.append([float(s[i]) for i in range(len(s))])
+    B = np.array([X[0][2], X[1][2], X[2][2]])
+    return Q, B
+
+
+
+def SetParametersCellProblem(alpha,beta,theta,gamma,mu1,rho1,lambda1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset"):
+    with open(InputFilePath, 'r') as file:
+        filedata = file.read()
+    filedata = re.sub('(?m)^alpha=.*','alpha='+str(alpha),filedata)
+    filedata = re.sub('(?m)^beta=.*','beta='+str(beta),filedata)
+    filedata = re.sub('(?m)^theta=.*','theta='+str(theta),filedata)
+    filedata = re.sub('(?m)^gamma=.*','gamma='+str(gamma),filedata)
+    filedata = re.sub('(?m)^mu1=.*','mu1='+str(mu1),filedata)
+    filedata = re.sub('(?m)^rho1=.*','rho1='+str(rho1),filedata)
+    filedata = re.sub('(?m)^lambda1=.*','lambda1='+str(lambda1),filedata)
+    f = open(InputFilePath,'w')
+    f.write(filedata)
+    f.close()
+
+#TODO combine these...
+
+def SetParametersComputeMuGamma(beta,theta,gamma,mu1,rho1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset"):
+    with open(InputFilePath, 'r') as file:
+        filedata = file.read()
+    filedata = re.sub('(?m)^beta=.*','beta='+str(beta),filedata)
+    filedata = re.sub('(?m)^theta=.*','theta='+str(theta),filedata)
+    filedata = re.sub('(?m)^gamma=.*','gamma='+str(gamma),filedata)
+    filedata = re.sub('(?m)^mu1=.*','mu1='+str(mu1),filedata)
+    filedata = re.sub('(?m)^rho1=.*','rho1='+str(rho1),filedata)
+    f = open(InputFilePath,'w')
+    f.write(filedata)
+    f.close()
+
+
+
+
+def RunCellProblem(alpha,beta,theta,gamma,mu1,rho1,lambda1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset"):
+        # with open(InputFilePath, 'r') as file:
+        #     filedata = file.read()
+        # filedata = re.sub('(?m)^gamma=.*','gamma='+str(gamma),filedata)
+        # filedata = re.sub('(?m)^alpha=.*','alpha='+str(alpha),filedata)
+        # filedata = re.sub('(?m)^beta=.*','beta='+str(beta),filedata)
+        # filedata = re.sub('(?m)^theta=.*','theta='+str(theta),filedata)
+        # filedata = re.sub('(?m)^mu1=.*','mu1='+str(mu1),filedata)
+        # filedata = re.sub('(?m)^rho1=.*','rho1='+str(rho1),filedata)
+        # f = open(InputFilePath,'w')
+        # f.write(filedata)
+        # f.close()
+        SetParametersCellProblem(alpha,beta,theta,gamma,mu1,rho1,lambda1, InputFilePath)
+        # --- Run Cell-Problem
+        # Optional: Check Time
+        # t = time.time()
+        subprocess.run(['./build-cmake/src/Cell-Problem', './inputs/cellsolver.parset'],
+                                             capture_output=True, text=True)
+        # print('elapsed time:', time.time() - t)
+        # --------------------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+def GetCellOutput(alpha,beta,theta,gamma,mu1,rho1,lambda1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset",
+                OutputFilePath = os.path.dirname(os.getcwd()) + "/outputs/outputMuGamma.txt" ):
+        RunCellProblem(alpha,beta,theta,gamma,mu1,rho1,lambda1, InputFilePath)
+        print('Read effective quantities...')
+        Q, B = ReadEffectiveQuantities()
+        # print('Q:', Q)
+        # print('B:', B)
+        return Q, B
+
+
+# unabhängig von alpha...
+def GetMuGamma(beta,theta,gamma,mu1,rho1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset",
+                OutputFilePath = os.path.dirname(os.getcwd()) + "/outputs/outputMuGamma.txt" ):
+    # ------------------------------------ get mu_gamma ------------------------------
+    # ---Scenario 1.1: extreme regimes
+    if gamma == '0':
+        # print('extreme regime: gamma = 0')
+        mu_gamma = (1.0/6.0)*arithmeticMean(mu1, beta, theta) # = q2
+        # print("mu_gamma:", mu_gamma)
+    elif gamma == 'infinity':
+        # print('extreme regime: gamma = infinity')
+        mu_gamma = (1.0/6.0)*harmonicMean(mu1, beta, theta)   # = q1
+        # print("mu_gamma:", mu_gamma)
+    else:
+        # --- Scenario 1.2:  compute mu_gamma with 'Compute_MuGamma' (much faster than running full Cell-Problem)
+        # print("Run computeMuGamma for Gamma = ", gamma)
+
+        SetParametersComputeMuGamma(beta,theta,gamma,mu1,rho1, InputFilePath)
+        # with open(InputFilePath, 'r') as file:
+        #     filedata = file.read()
+        # filedata = re.sub('(?m)^gamma=.*','gamma='+str(gamma),filedata)
+        # # filedata = re.sub('(?m)^alpha=.*','alpha='+str(alpha),filedata)
+        # filedata = re.sub('(?m)^beta=.*','beta='+str(beta),filedata)
+        # filedata = re.sub('(?m)^theta=.*','theta='+str(theta),filedata)
+        # filedata = re.sub('(?m)^mu1=.*','mu1='+str(mu1),filedata)
+        # filedata = re.sub('(?m)^rho1=.*','rho1='+str(rho1),filedata)
+        # f = open(InputFilePath,'w')
+        # f.write(filedata)
+        # f.close()
+        # --- Run Cell-Problem
+
+        # Check Time
+        # t = time.time()
+        # subprocess.run(['./build-cmake/src/Cell-Problem', './inputs/cellsolver.parset'],
+        #                                      capture_output=True, text=True)
+        # --- Run Cell-Problem_muGama   -> faster
+        # subprocess.run(['./build-cmake/src/Cell-Problem_muGamma', './inputs/cellsolver.parset'],
+        #                                              capture_output=True, text=True)
+        # --- Run Compute_muGamma (2D Problem much much faster)
+
+        subprocess.run(['./build-cmake/src/Compute_MuGamma', './inputs/computeMuGamma.parset'],
+                                                             capture_output=True, text=True)
+        # print('elapsed time:', time.time() - t)
+
+        #Extract mu_gamma from Output-File                                           TODO: GENERALIZED THIS FOR QUANTITIES OF INTEREST
+        with open(OutputFilePath, 'r') as file:
+            output = file.read()
+        tmp = re.search(r'(?m)^mu_gamma=.*',output).group()                           # Not necessary for Intention of Program t output Minimizer etc.....
+        s = re.findall(r"[-+]?\d*\.\d+|\d+", tmp)
+        mu_gamma = float(s[0])
+        # print("mu_gamma:", mu_gammaValue)
+    # --------------------------------------------------------------------------------------
+    return mu_gamma
+
+
+
+
+
+
+def Compare_Classification(alpha,beta,theta,gamma,mu1,rho1,lambda1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset"):
+        # ---------------------------------------------------------------
+        # Comparison of the analytical Classification 'ClassifyMin'
+        # and the symbolic Minimizatio + Classification 'symMinimization'
+        # ----------------------------------------------------------------
+        comparison_successful = True
+        eps = 1e-8
+
+        # 1. Substitute Input-Parameters for the Cell-Problem
+        with open(InputFilePath, 'r') as file:
+            filedata = file.read()
+        filedata = re.sub('(?m)^gamma=.*','gamma='+str(gamma),filedata)
+        filedata = re.sub('(?m)^alpha=.*','alpha='+str(alpha),filedata)
+        filedata = re.sub('(?m)^beta=.*','beta='+str(beta),filedata)
+        filedata = re.sub('(?m)^theta=.*','theta='+str(theta),filedata)
+        filedata = re.sub('(?m)^mu1=.*','mu1='+str(mu1),filedata)
+        filedata = re.sub('(?m)^rho1=.*','rho1='+str(rho1),filedata)
+        filedata = re.sub('(?m)^lambda1=.*','lambda1='+str(lambda1),filedata)
+        f = open(InputFilePath,'w')
+        f.write(filedata)
+        f.close()
+        # 2. --- Run Cell-Problem
+        print('Run Cell-Problem ...')
+        # Optional: Check Time
+        # t = time.time()
+        subprocess.run(['./build-cmake/src/Cell-Problem', './inputs/cellsolver.parset'],
+                                             capture_output=True, text=True)
+
+
+        # 3. --- Run Matlab symbolic minimization program: 'symMinimization'
+        eng = matlab.engine.start_matlab()
+        # s = eng.genpath(path + '/Matlab-Programs')
+        s = eng.genpath(os.path.dirname(os.getcwd()))
+        eng.addpath(s, nargout=0)
+        # print('current Matlab folder:', eng.pwd(nargout=1))
+        eng.cd('Matlab-Programs', nargout=0)  #switch to Matlab-Programs folder
+        # print('current Matlab folder:', eng.pwd(nargout=1))
+        Inp = False
+        print('Run symbolic Minimization...')
+        G, angle, type, kappa = eng.symMinimization(Inp,Inp,Inp,Inp, nargout=4)  #Name of program:symMinimization
+        # G, angle, type, kappa = eng.symMinimization(Inp,Inp,Inp,Inp,path + "/outputs", nargout=4)  #Optional: add Path
+        G = np.asarray(G) #cast Matlab Outout to numpy array
+        # --- print Output ---
+        print('Minimizer G:')
+        print(G)
+        print('angle:', angle)
+        print('type:', type )
+        print('curvature:', kappa)
+
+        # 4. --- Read the effective quantities (output values of the Cell-Problem)
+        # Read Output Matrices (effective quantities)
+        print('Read effective quantities...')
+        Q, B = ReadEffectiveQuantities()
+        print('Q:', Q)
+        print('B:', B)
+        q1 = Q[0][0]
+        q2 = Q[1][1]
+        q3 = Q[2][2]
+        q12 = Q[0][1]
+        b1 = B[0]
+        b2 = B[1]
+        b3 = B[2]
+        print("q1:", q1)
+        print("q2:", q2)
+        print("q3:", q3)
+        print("q12:", q12)
+        print("b1:", b1)
+        print("b2:", b2)
+        print("b3:", b3)
+
+        # --- Check Assumptions:
+        # Assumption of Classification-Lemma1.6:  [b3 == 0] & [Q orthotropic]
+        # Check if b3 is close to zero
+        assert (b3 < eps), "ClassifyMin only defined for b3 == 0 !"
+
+        # Check if Q is orthotropic i.e. q13 = q31 = q23 = q32 == 0
+        assert(Q[2][0] < eps and Q[0][2] < eps and Q[1][2] < eps and Q[2][1] < eps), "Q is not orthotropic !"
+
+        # 5. --- Get output from the analytical Classification 'ClassifyMin'
+        G_ana, angle_ana, type_ana, kappa_ana = classifyMin(q1, q2, q3, q12, b1, b2)
+        print('Minimizer G_ana:')
+        print(G_ana)
+        print('angle_ana:', angle_ana)
+        print('type_ana:', type_ana )
+        print('curvature_ana:', kappa_ana)
+
+        # 6. Compare
+        # print('DifferenceMatrix:', G_ana - G )
+        # print('MinimizerError (FrobeniusNorm):', np.linalg.norm(G_ana - G , 'fro') )
+
+        if np.linalg.norm(G_ana - G , 'fro') > eps :
+            comparison_successful = False
+            print('Difference between Minimizers is too large !')
+        if type != type_ana :
+            comparison_successful = False
+            print('Difference in type !')
+        if abs(angle-angle_ana) > eps :
+            comparison_successful = False
+            print('Difference in angle is too large!')
+        if abs(kappa-kappa_ana) > eps :
+            comparison_successful = False
+            print('Difference in curvature is too large!')
+
+
+        if comparison_successful:
+            print('Comparison successful')
+        else:
+            print('Comparison unsuccessful')
+
+        return comparison_successful
+
+
+
+
+# ----------------------------------------------------------------------------------------------------------------------------

JNLS_plotScripts/ParaViewSettings.txt

+
+Colormap: Cool-to-Warm
+
+Representation: Point-Gaussian
+Opacity: 0.01
+PointSize: 2
+Gaussian-radius: 0.0075
+Shader-Preset: Plain-Circle

JNLS_plotScripts/PhaseDiagram.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+# from ClassifyMin import *
+from ClassifyMin_New import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+
+import time
+
+from chart_studio import plotly
+import plotly.graph_objs as go
+
+import mayavi.mlab as mlab
+from mayavi.api import OffScreenEngine
+
+import scipy.signal
+
+import matplotlib as mpl
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+import pandas as pd
+
+import seaborn as sns
+import matplotlib.colors as mcolors
+
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+# mlab.options.offscreen = True
+
+# print(sys.executable)
+
+# --------------------------------------------------------------------
+# START :
+# INPUT (Parameters):   alpha, beta, theta, gamma, mu1, rho1
+#
+# -Option 1 : (Case lambda = 0 => q12 = 0)
+#   compute q1,q2,b1,b2 from Formula
+#       Option 1.1 :
+#           set mu_gamma = 'q1' or 'q2' (extreme regimes: gamma \in {0,\infty})
+#       Option 1.2 :
+#           compute mu_gamma with 'Compute_MuGamma' (2D problem much faster then Cell-Problem)
+# -Option 2 :
+#   compute Q_hom & B_eff by running 'Cell-Problem'
+#
+# -> CLASSIFY ...
+#
+# OUTPUT: Minimizer G, angle , type, curvature
+# -----------------------------------------------------------------------
+#
+#
+# def GetMuGamma(beta,theta,gamma,mu1,rho1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset",
+#                 OutputFilePath = os.path.dirname(os.getcwd()) + "/outputs/outputMuGamma.txt" ):
+#     # ------------------------------------ get mu_gamma ------------------------------
+#     # ---Scenario 1.1: extreme regimes
+#     if gamma == '0':
+#         print('extreme regime: gamma = 0')
+#         mu_gamma = (1.0/6.0)*arithmeticMean(mu1, beta, theta) # = q2
+#         print("mu_gamma:", mu_gamma)
+#     elif gamma == 'infinity':
+#         print('extreme regime: gamma = infinity')
+#         mu_gamma = (1.0/6.0)*harmonicMean(mu1, beta, theta)   # = q1
+#         print("mu_gamma:", mu_gamma)
+#     else:
+#         # --- Scenario 1.2:  compute mu_gamma with 'Compute_MuGamma' (much faster than running full Cell-Problem)
+#         # print("Run computeMuGamma for Gamma = ", gamma)
+#         with open(InputFilePath, 'r') as file:
+#             filedata = file.read()
+#         filedata = re.sub('(?m)^gamma=.*','gamma='+str(gamma),filedata)
+#         # filedata = re.sub('(?m)^alpha=.*','alpha='+str(alpha),filedata)
+#         filedata = re.sub('(?m)^beta=.*','beta='+str(beta),filedata)
+#         filedata = re.sub('(?m)^theta=.*','theta='+str(theta),filedata)
+#         filedata = re.sub('(?m)^mu1=.*','mu1='+str(mu1),filedata)
+#         filedata = re.sub('(?m)^rho1=.*','rho1='+str(rho1),filedata)
+#         f = open(InputFilePath,'w')
+#         f.write(filedata)
+#         f.close()
+#         # --- Run Cell-Problem
+#
+#         # Check Time
+#         # t = time.time()
+#         # subprocess.run(['./build-cmake/src/Cell-Problem', './inputs/cellsolver.parset'],
+#         #                                      capture_output=True, text=True)
+#         # --- Run Cell-Problem_muGama   -> faster
+#         # subprocess.run(['./build-cmake/src/Cell-Problem_muGamma', './inputs/cellsolver.parset'],
+#         #                                              capture_output=True, text=True)
+#         # --- Run Compute_muGamma (2D Problem much much faster)
+#
+#         subprocess.run(['./build-cmake/src/Compute_MuGamma', './inputs/computeMuGamma.parset'],
+#                                                              capture_output=True, text=True)
+#         # print('elapsed time:', time.time() - t)
+#
+#         #Extract mu_gamma from Output-File                                           TODO: GENERALIZED THIS FOR QUANTITIES OF INTEREST
+#         with open(OutputFilePath, 'r') as file:
+#             output = file.read()
+#         tmp = re.search(r'(?m)^mu_gamma=.*',output).group()                           # Not necessary for Intention of Program t output Minimizer etc.....
+#         s = re.findall(r"[-+]?\d*\.\d+|\d+", tmp)
+#         mu_gamma = float(s[0])
+#         # print("mu_gamma:", mu_gammaValue)
+#     # --------------------------------------------------------------------------------------
+#     return mu_gamma
+#
+
+
+
+# ----------- SETUP PATHS
+# InputFile  = "/inputs/cellsolver.parset"
+# OutputFile = "/outputs/output.txt"
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+
+# -------------------------- Input Parameters --------------------
+# mu1 = 10.0               # TODO : here must be the same values as in the Parset for computeMuGamma
+mu1 = 1.0
+rho1 = 1.0
+alpha = 2.0
+beta = 2.0
+# beta = 5.0
+theta = 1.0/4.0
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+gamma = '0'
+# gamma = 'infinity'
+# gamma = 0.5
+# gamma = 0.25
+# gamma = 1.0
+
+# gamma = 5.0
+
+#added
+# lambda1 = 10.0
+lambda1 = 0.0
+
+#Test:
+# rho1 = -1.0
+
+
+
+print('---- Input parameters: -----')
+print('mu1: ', mu1)
+print('rho1: ', rho1)
+print('alpha: ', alpha)
+print('beta: ', beta)
+print('theta: ', theta)
+print('gamma:', gamma)
+
+print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+
+#
+# gamma_min = 0.5
+# gamma_max = 1.0
+#
+# # gamma_min = 1
+# # gamma_max = 1
+# Gamma_Values = np.linspace(gamma_min, gamma_max, num=3)
+# # #
+# # # Gamma_Values = np.linspace(gamma_min, gamma_max, num=13)    # TODO variable Input Parameters...alpha,beta...
+# print('(Input) Gamma_Values:', Gamma_Values)
+
+print('type of gamma:', type(gamma))
+# # #
+# Gamma_Values = ['0', 'infinity']
+# Gamma_Values = ['infinity']
+Gamma_Values = ['0']
+# Gamma_Values = [ 'infinity','0']
+print('(Input) Gamma_Values:', Gamma_Values)
+
+for gamma in Gamma_Values:
+
+    print('Run for gamma = ', gamma)
+    print('type of gamma:', type(gamma))
+        # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1,InputFilePath)
+        # # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1)
+        # print('Test MuGamma:', muGamma)
+
+        # ------- Options --------
+        # print_Cases = True
+        # print_Output = True
+
+                            #TODO
+    # generalCase = True #Read Output from Cell-Problem instead of using Lemma1.4 (special case)
+    generalCase = False
+
+    make_3D_plot = True
+    make_3D_PhaseDiagram = True
+    make_2D_plot = False
+    make_2D_PhaseDiagram = False
+    make_3D_plot = False
+
+    # make_3D_PhaseDiagram = False
+    # make_2D_plot = True
+    # make_2D_PhaseDiagram = True
+    #
+
+    # --- Define effective quantities: q1, q2 , q3 = mu_gamma, q12 ---
+    # q1 = harmonicMean(mu1, beta, theta)
+    # q2 = arithmeticMean(mu1, beta, theta)
+    # --- Set q12
+    # q12 = 0.0  # (analytical example)              # TEST / TODO read from Cell-Output
+
+
+
+
+
+    # b1 = prestrain_b1(rho1, beta, alpha, theta)
+    # b2 = prestrain_b2(rho1, beta, alpha, theta)
+    #
+    # print('---- Input parameters: -----')
+    # print('mu1: ', mu1)
+    # print('rho1: ', rho1)
+    # print('alpha: ', alpha)
+    # print('beta: ', beta)
+    # print('theta: ', theta)
+    # print("q1: ", q1)
+    # print("q2: ", q2)
+    # print("mu_gamma: ", mu_gamma)
+    # print("q12: ", q12)
+    # print("b1: ", b1)
+    # print("b2: ", b2)
+    # print('----------------------------')
+    # print("machine epsilon", sys.float_info.epsilon)
+
+    # G, angle, type, kappa = classifyMin(q1, q2, mu_gamma, q12,  b1, b2, print_Cases, print_Output)
+    # Test = f(1,2 ,q1,q2,mu_gamma,q12,b1,b2)
+    # print("Test", Test)
+
+    # ---------------------- MAKE PLOT / Write to VTK------------------------------------------------------------------------------
+
+    # SamplePoints_3D = 10 # Number of sample points in each direction
+    # SamplePoints_2D = 10 # Number of sample points in each direction
+    # SamplePoints_3D = 300 # Number of sample points in each direction
+    # SamplePoints_3D = 150 # Number of sample points in each direction
+    SamplePoints_3D = 100 # Number of sample points in each direction
+    # # SamplePoints_3D = 50 # Number of sample points in each direction
+    # SamplePoints_3D = 25 # Number of sample points in each direction
+    # SamplePoints_3D = 200 # Number of sample points in each direction
+    # SamplePoints_3D = 400 # Number of sample points in each direction
+    # SamplePoints_2D = 7500 # Number of sample points in each direction
+    # SamplePoints_2D = 4000 # 4000 # Number of sample points in each direction
+    # SamplePoints_2D = 400 # 4000 # Number of sample points in each direction
+    # SamplePoints_2D = 1000 # 4000 # Number of sample points in each direction
+    # SamplePoints_3D = 10 # Number of sample points in each direction
+
+    print('NUMBER OF POINTS USED(3D):', SamplePoints_3D)
+
+    if make_3D_PhaseDiagram:
+        alphas_ = np.linspace(-20, 20, SamplePoints_3D)
+        # alphas_ = np.linspace(-10, 10, SamplePoints_3D)
+
+        # betas_  = np.linspace(0.01,40.01,SamplePoints_3D) # Full Range
+        # betas_  = np.linspace(0.01,20.01,SamplePoints_3D) # FULL Range
+
+
+
+        # betas_  = np.linspace(0.01,0.99,SamplePoints_3D)  # weird part
+        # betas_  = np.linspace(1.01,40.01,SamplePoints_3D)     #TEST !!!!!  For Beta <1 weird tings happen...
+
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_3D)
+
+        #TEST
+        alphas_ = np.linspace(-5, 15, SamplePoints_3D)
+        betas_  = np.linspace(1.01,20.01,SamplePoints_3D)     #TEST !!!!!  For Beta <1 weird tings happen...
+        # TEST
+        # alphas_ = np.linspace(-2, 2, SamplePoints_3D)
+        # betas_  = np.linspace(1.01,10.01,SamplePoints_3D)
+        # print('betas:', betas_)
+
+        # TEST :
+        # alphas_ = np.linspace(-40, 40, SamplePoints_3D)
+        # betas_  = np.linspace(0.01,80.01,SamplePoints_3D) # Full Range
+
+        # print('type of alphas', type(alphas_))
+        # print('Test:', type(np.array([mu_gamma])) )
+        alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+        classifyMin_anaVec = np.vectorize(classifyMin_ana)
+
+        # Get MuGamma values ...
+        GetMuGammaVec = np.vectorize(GetMuGamma)
+        muGammas = GetMuGammaVec(betas, thetas, gamma, mu1, rho1)
+        # Classify Minimizers....
+        G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1)   # Sets q12 to zero!!!
+        # G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1,True,True)   # Sets q12 to zero!!!
+        # G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1, True, True)
+        # print('size of G:', G.shape)
+        # print('G:', G)
+
+        # Option to print angles
+        # print('angles:', angles)
+
+
+        # Out = classifyMin_anaVec(alphas,betas,thetas)
+        # T = Out[2]
+        # --- Write to VTK
+
+        GammaString = str(gamma)
+        VTKOutputName = "outputs/PhaseDiagram3D" + "Gamma" + GammaString
+        gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        print('Written to VTK-File:', VTKOutputName )
+
+    if make_2D_PhaseDiagram:
+        # alphas_ = np.linspace(-20, 20, SamplePoints_2D)
+        # alphas_ = np.linspace(0, 1, SamplePoints_2D)
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        alphas_ = np.linspace(-5, 5, SamplePoints_2D)
+        # alphas_ = np.linspace(-5, 15, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.25,SamplePoints_2D)
+
+
+        # good range:
+        # alphas_ = np.linspace(9, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.075,0.14,SamplePoints_2D)
+
+        # range used:
+        # alphas_ = np.linspace(8, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.16,SamplePoints_2D)
+
+            # alphas_ = np.linspace(8, 12, SamplePoints_2D)
+            # thetas_ = np.linspace(0.05,0.2,SamplePoints_2D)
+        # betas_  = np.linspace(0.01,40.01,1)
+        #fix to one value:
+        betas_ = 2.0;
+        # betas_ = 10.0;
+        # betas_ = 5.0;
+        # betas_ = 0.5;
+
+
+        #intermediate Values
+        # alphas_ = np.linspace(-2, 1, SamplePoints_2D)
+        # thetas_ = np.linspace(0.4,0.6,SamplePoints_2D)
+        # betas_ = 10.0;
+
+        # TEST
+        # alphas_ = np.linspace(-8, 8, SamplePoints_2D)
+        # thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        # betas_ = 1.0; #TEST Problem: disvison by zero if alpha = 9, theta = 0.1 !
+        # betas_ = 0.9;
+        # betas_ = 0.5;  #TEST!!!
+        alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+
+
+        if generalCase:
+            classifyMin_matVec = np.vectorize(classifyMin_mat)
+            GetCellOutputVec = np.vectorize(GetCellOutput, otypes=[np.ndarray, np.ndarray])
+            Q, B = GetCellOutputVec(alphas,betas,thetas,gamma,mu1,rho1,lambda1, InputFilePath ,OutputFilePath )
+
+
+            # print('type of Q:', type(Q))
+            # print('Q:', Q)
+            G, angles, Types, curvature = classifyMin_matVec(Q,B)
+
+        else:
+            classifyMin_anaVec = np.vectorize(classifyMin_ana)
+            GetMuGammaVec = np.vectorize(GetMuGamma)
+            muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+            G, angles, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+            # print('size of G:', G.shape)
+            # print('G:', G)
+            # print('Types:', Types)
+            # Out = classifyMin_anaVec(alphas,betas,thetas)
+            # T = Out[2]
+            # --- Write to VTK
+            # VTKOutputName = + path + "./PhaseDiagram2DNEW"
+
+
+        GammaString = str(gamma)
+        VTKOutputName = "outputs/PhaseDiagram2D" + "Gamma_" + GammaString
+        gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        print('Written to VTK-File:', VTKOutputName )
+
+
+    # --- Make 3D Scatter plot
+    if(make_3D_plot or make_2D_plot):
+        fig = plt.figure()
+        ax = fig.add_subplot(111, projection='3d')
+        # ax = plt.axes(projection ='3d', adjustable='box')
+        # fig,ax = plt.subplots(111, projection='3d')
+        # ax = plt.axes(projection ='3d', adjustable='box')
+        colors = cm.plasma(Types)
+        # if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=Types.flat)
+
+        if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=angles.flat)
+
+
+
+
+        if make_3D_plot:
+
+            width = 6.28 *0.5
+            # width = 6.28
+            # height = width / 1.618
+            height = width
+
+            # pnt3d=ax.scatter(alphas,betas,thetas,c=angles.flatten())
+            plt.style.use("seaborn")
+            # plt.style.use("seaborn-paper")
+            # plt.style.use('ggplot')
+            # plt.rcParams["font.family"] = "Avenir"
+            # plt.rcParams["font.size"] = 16
+
+            # plt.style.use("seaborn-darkgrid")
+            mpl.rcParams['text.usetex'] = True
+            mpl.rcParams["font.family"] = "serif"
+            mpl.rcParams["font.size"] = "10"
+            # mpl.rcParams['xtick.labelsize'] = 16mpl.rcParams['xtick.major.size'] = 2.5
+            # mpl.rcParams['xtick.bottom'] = True
+            # mpl.rcParams['ticks'] = True
+            mpl.rcParams['xtick.bottom'] = True
+            mpl.rcParams['xtick.major.size'] = 3
+            mpl.rcParams['xtick.minor.size'] = 1.5
+            mpl.rcParams['xtick.major.width'] = 0.75
+            mpl.rcParams['ytick.left'] = True
+            mpl.rcParams['ytick.major.size'] = 3
+            mpl.rcParams['ytick.minor.size'] = 1.5
+            mpl.rcParams['ytick.major.width'] = 0.75
+
+            mpl.rcParams.update({'font.size': 10})
+            mpl.rcParams['axes.labelpad'] = 1
+
+
+
+            angles = angles.flatten()
+            cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","violet","red"])
+            cmap=mpl.cm.RdBu_r
+            # cmap=mpl.cm.viridis_r
+            # cmap=mpl.cm.bwr
+            # cmap=mpl.cm.coolwarm
+            # cmap=mpl.cm.Blues_r
+
+            # norm = mpl.colors.Normalize(vmin=5, vmax=10)
+            # cmap=mpl.cm.gnuplot
+            # cmap=mpl.cm.magma_r
+            # cmap=mpl.cm.inferno_r
+            # cmap=mpl.cm.plasma
+            # cmap=mpl.cm.plasma_r
+            # cmap=mpl.cm.cividis_r
+            # cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","violet","red"])
+            # cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","orange"])
+            divnorm=mcolors.TwoSlopeNorm(vmin=angles.min(), vcenter=(angles.max()+angles.min())/2, vmax=angles.max())
+            # cmap = cm.ScalarMappable(norm=divnorm, cmap=cmap)
+
+            opacity_list = 1-angles/angles.max()
+            print('opacity_list', opacity_list)
+            print('opacity_list.max():', opacity_list.max())
+
+            # get a Nx4 array of RGBA corresponding to zs
+            # cmap expects values between 0 and 1
+            colors = cmap(angles/angles.max())
+            # colors = angles/angles.max()
+            print('colors:', colors)
+
+            ### set the alpha values according to i_list
+            ### must satisfy 0 <= i <= 1
+            # epsilon =0.01
+            opacity_list = np.array(opacity_list)
+            colors[:,-1] = opacity_list / opacity_list.max()
+
+
+            # ax.scatter(alphas,betas,thetas,c=angles.flatten())
+            # S = ax.scatter(alphas,betas,thetas,c=colors, cmap=cmap, norm = divnorm)
+            S = ax.scatter(alphas,betas,thetas,c=colors)
+
+            S_2 = ax.scatter(alphas,betas,thetas,c=angles/angles.max(), cmap=cmap, s=0) # Hack for colormap...
+            # ax.view_init(elev=30, azim=75)
+            ax.view_init(elev=25, azim=75)
+
+
+
+            # fig.colorbar(mpl.cm.ScalarMappable(norm=norm, cmap=cmap),
+            #  cax=ax, orientation='horizontal', label='Some Units')
+            # plt.colorbar(S)
+            # fig.colorbar(S, ax=ax)
+            # axins1 = inset_axes(ax,
+            #                    width="5%",  # width = 5% of parent_bbox width
+            #                    height="100%",  # height : 50%
+            #                    loc='lower left',
+            #                    bbox_to_anchor=(1.05, 0., 1, 1),
+            #                    bbox_transform=ax[1].transAxes,
+            #                    borderpad=0,
+            #                    )
+
+            # ax.clabel(CS2, CS2.levels, inline=True, fontsize=10)
+            # ax.clabel(CS,  fontsize=5, colors='black')
+            # cbar = fig.colorbar(CS,label=r'angle $\alpha$', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+            # cbar = fig.colorbar(CS_1, ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+
+            # cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])
+            # cbar = fig.colorbar(S, cax=ax, ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+            # cbar = fig.colorbar(S_2, ax=ax)
+            # cbar = fig.colorbar(S, ax=ax)
+            # cbar = fig.colorbar(CS_1, cax=cbar_ax, shrink=0.2, location='right', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+            # cbar = fig.colorbar(CS_1,  ax=ax[:], shrink=0.8, location='right', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+
+            ## ADD COLORBAR:
+
+            axins = inset_axes(ax,
+                                width="5%",
+                                height="100%",
+                                loc='right',
+                                borderpad=0,
+                                bbox_to_anchor=[0.0, 0.5]
+                               )
+            cbar = fig.colorbar(S_2, cax=axins)
+            # cbar = fig.colorbar(S_2, orientation="horizontal", pad=0.2)
+            # cbar = fig.colorbar(S_2, pad=0.2)
+            cbar.ax.set_yticklabels([r'$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$'])
+            cbar.ax.set_title(r'$\alpha$')
+
+
+            ### COLORBAR :
+            # cbar = plt.colorbar()
+            # cbar.ax.tick_params(labelsize=10)
+            # fig.colorbar(S)
+        # cbar=plt.colorbar(pnt3d)
+        # cbar.set_label("Values (units)")
+        # plt.axvline(x = 8, color = 'b', linestyle = ':', label='$q_1$')
+        # plt.axhline(y = 0.083333333, color = 'b', linestyle = ':', label='$q_1$')
+
+        # if make_3D_plot: pnt3d=ax.scatter(alphas,betas,thetas,c=angles.flat)
+        # if make_3D_plot: fig = go.Figure(data=[go.Surface(z=thetas, x=alphas, y=betas, color=angles.flat)])
+        #### PLOTLY:
+        # print('angles.flatten()',angles.flatten())
+        # fig = go.Figure(data=go.Isosurface(
+        #     x=alphas.flatten(),
+        #     y=betas.flatten(),
+        #     z=thetas.flatten(),
+        #     value=angles.flatten(),
+        #     isomin=0,
+        #     isomax=1.565,
+        #     opacity=1.0,
+        #     colorscale='agsunset',
+        #     flatshading = True
+        #     # caps=dict(x_show=False, y_show=False)
+        #     ))
+        # fig.show()
+
+        # ----TEST SAVITZKY_GOLAY FILTER
+        # zhat = scipy.signal.savgol_filter(angles.flatten(), 5, 4) # window size 51, polynomial order 3
+        #
+        # fig = go.Figure(data=go.Volume(
+        #     x=alphas.flatten(),
+        #     y=betas.flatten(),
+        #     z=thetas.flatten(),
+        #     value=zhat,
+        #     isomin=0.0,
+        #     isomax=1.56,
+        #     opacity=0.1, # needs to be small to see through all surfaces
+        #     surface_count=17, # needs to be a large number for good volume rendering
+        #     colorscale='RdBu'
+        #     ))
+        # fig.show()
+
+
+        ## --------------------------------
+        # alphas = np.array(alphas)
+        # print('alphas.shape:',np.shape(alphas))
+        # #### ------- MAYAVI:
+        # # s = angles.flatten()
+        # s = angles
+        # src = mlab.pipeline.scalar_field(s)
+        # mlab.pipeline.iso_surface(src, contours=[s.min()+0.1*s.ptp(), ], opacity=0.3)
+        # mlab.pipeline.iso_surface(src, contours=[s.max()-0.1*s.ptp(), ],)
+        # # mlab.outline()
+        # # mlab.mesh(alphas,betas,thetas)
+        # mlab.colorbar( orientation='vertical', nb_labels=5)
+        # # mlab.orientation_axes()
+        # mlab.show()
+        ### ---------------
+
+
+
+
+
+        ax.set_xlabel(r'$\theta_\rho$', labelpad=2)
+        ax.set_ylabel(r"$\theta_\mu$", labelpad=2)
+        if make_3D_plot: ax.set_zlabel(r'$\theta$',labelpad=2)
+
+        fig.set_size_inches(width, height)
+        # fig.savefig('PhaseDiagram3D.pdf')
+        fig.savefig('PhaseDiagram3D.png', format='png')
+        # fig.savefig('Plot-Prestrain-Theta_AlphaFix.pdf',bbox_extra_artists=(cbar,),
+        #             bbox_inches='tight')
+        # fig.savefig('Plot-Prestrain-Theta_AlphaFix.pdf',format='png',bbox_extra_artists=(cbar,),
+                    # bbox_inches='tight')
+        # fig.savefig('PhaseDiagram3D', format='svg')
+        # fig.savefig('PhaseDiagram3D.pdf', dpi=90)
+        plt.show()
+
+        # fig.set_size_inches(width, height)
+        # fig.savefig('PhaseDiagram3D.pdf')
+        # plt.savefig('common_labels.png', dpi=300)
+        # print('T:', T)
+        # print('Type 1 occured here:', np.where(T == 1))
+        # print('Type 2 occured here:', np.where(T == 2))
+
+
+        # print(alphas_)
+        # print(betas_)
+
+
+
+
+
+# ALTERNATIVE
+# colors = ("red", "green", "blue")
+# groups = ("Type 1", "Type2", "Type3")
+#
+# # Create plot
+# fig = plt.figure()
+# ax = fig.add_subplot(1, 1, 1)
+#
+# for data, color, group in zip(Types, colors, groups):
+#     # x, y = data
+#     ax.scatter(alphas, thetas, alpha=0.8, c=color, edgecolors='none', label=group)
+#
+# plt.title('Matplot scatter plot')
+# plt.legend(loc=2)
+# plt.show()

JNLS_plotScripts/PhaseDiagram_Contour.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+from ClassifyMin import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+
+import time
+# print(sys.executable)
+
+# --------------------------------------------------------------------
+# START :
+# INPUT (Parameters):   alpha, beta, theta, gamma, mu1, rho1
+#
+# -Option 1 : (Case lambda = 0 => q12 = 0)
+#   compute q1,q2,b1,b2 from Formula
+#       Option 1.1 :
+#           set mu_gamma = 'q1' or 'q2' (extreme regimes: gamma \in {0,\infty})
+#       Option 1.2 :
+#           compute mu_gamma with 'Compute_MuGamma' (2D problem much faster then Cell-Problem)
+# -Option 2 :
+#   compute Q_hom & B_eff by running 'Cell-Problem'
+#
+# -> CLASSIFY ...
+#
+# OUTPUT: Minimizer G, angle , type, curvature
+# -----------------------------------------------------------------------
+#
+#
+# def GetMuGamma(beta,theta,gamma,mu1,rho1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset",
+#                 OutputFilePath = os.path.dirname(os.getcwd()) + "/outputs/outputMuGamma.txt" ):
+#     # ------------------------------------ get mu_gamma ------------------------------
+#     # ---Scenario 1.1: extreme regimes
+#     if gamma == '0':
+#         print('extreme regime: gamma = 0')
+#         mu_gamma = (1.0/6.0)*arithmeticMean(mu1, beta, theta) # = q2
+#         print("mu_gamma:", mu_gamma)
+#     elif gamma == 'infinity':
+#         print('extreme regime: gamma = infinity')
+#         mu_gamma = (1.0/6.0)*harmonicMean(mu1, beta, theta)   # = q1
+#         print("mu_gamma:", mu_gamma)
+#     else:
+#         # --- Scenario 1.2:  compute mu_gamma with 'Compute_MuGamma' (much faster than running full Cell-Problem)
+#         # print("Run computeMuGamma for Gamma = ", gamma)
+#         with open(InputFilePath, 'r') as file:
+#             filedata = file.read()
+#         filedata = re.sub('(?m)^gamma=.*','gamma='+str(gamma),filedata)
+#         # filedata = re.sub('(?m)^alpha=.*','alpha='+str(alpha),filedata)
+#         filedata = re.sub('(?m)^beta=.*','beta='+str(beta),filedata)
+#         filedata = re.sub('(?m)^theta=.*','theta='+str(theta),filedata)
+#         filedata = re.sub('(?m)^mu1=.*','mu1='+str(mu1),filedata)
+#         filedata = re.sub('(?m)^rho1=.*','rho1='+str(rho1),filedata)
+#         f = open(InputFilePath,'w')
+#         f.write(filedata)
+#         f.close()
+#         # --- Run Cell-Problem
+#
+#         # Check Time
+#         # t = time.time()
+#         # subprocess.run(['./build-cmake/src/Cell-Problem', './inputs/cellsolver.parset'],
+#         #                                      capture_output=True, text=True)
+#         # --- Run Cell-Problem_muGama   -> faster
+#         # subprocess.run(['./build-cmake/src/Cell-Problem_muGamma', './inputs/cellsolver.parset'],
+#         #                                              capture_output=True, text=True)
+#         # --- Run Compute_muGamma (2D Problem much much faster)
+#
+#         subprocess.run(['./build-cmake/src/Compute_MuGamma', './inputs/computeMuGamma.parset'],
+#                                                              capture_output=True, text=True)
+#         # print('elapsed time:', time.time() - t)
+#
+#         #Extract mu_gamma from Output-File                                           TODO: GENERALIZED THIS FOR QUANTITIES OF INTEREST
+#         with open(OutputFilePath, 'r') as file:
+#             output = file.read()
+#         tmp = re.search(r'(?m)^mu_gamma=.*',output).group()                           # Not necessary for Intention of Program t output Minimizer etc.....
+#         s = re.findall(r"[-+]?\d*\.\d+|\d+", tmp)
+#         mu_gamma = float(s[0])
+#         # print("mu_gamma:", mu_gammaValue)
+#     # --------------------------------------------------------------------------------------
+#     return mu_gamma
+#
+
+
+
+# ----------- SETUP PATHS
+# InputFile  = "/inputs/cellsolver.parset"
+# OutputFile = "/outputs/output.txt"
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+
+# -------------------------- Input Parameters --------------------
+# mu1 = 10.0               # TODO : here must be the same values as in the Parset for computeMuGamma
+mu1 = 1.0
+rho1 = 1.0
+alpha = 2.0
+beta = 2.0
+# beta = 5.0
+theta = 1.0/4.0
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+gamma = '0'
+# gamma = 'infinity'
+# gamma = 0.5
+# gamma = 0.25
+# gamma = 1.0
+
+# gamma = 5.0
+
+#added
+# lambda1 = 10.0
+lambda1 = 0.0
+
+#Test:
+# rho1 = -1.0
+
+
+
+print('---- Input parameters: -----')
+print('mu1: ', mu1)
+print('rho1: ', rho1)
+print('alpha: ', alpha)
+print('beta: ', beta)
+print('theta: ', theta)
+print('gamma:', gamma)
+
+print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+
+#
+# gamma_min = 0.5
+# gamma_max = 1.0
+#
+# # gamma_min = 1
+# # gamma_max = 1
+# Gamma_Values = np.linspace(gamma_min, gamma_max, num=3)
+# # #
+# # # Gamma_Values = np.linspace(gamma_min, gamma_max, num=13)    # TODO variable Input Parameters...alpha,beta...
+# print('(Input) Gamma_Values:', Gamma_Values)
+
+print('type of gamma:', type(gamma))
+# # #
+# Gamma_Values = ['0', 'infinity']
+Gamma_Values = ['infinity']
+Gamma_Values = ['0']
+print('(Input) Gamma_Values:', Gamma_Values)
+
+for gamma in Gamma_Values:
+
+    print('Run for gamma = ', gamma)
+    print('type of gamma:', type(gamma))
+        # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1,InputFilePath)
+        # # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1)
+        # print('Test MuGamma:', muGamma)
+
+        # ------- Options --------
+        # print_Cases = True
+        # print_Output = True
+
+                            #TODO
+    # generalCase = True #Read Output from Cell-Problem instead of using Lemma1.4 (special case)
+    generalCase = False
+
+    # make_3D_plot = True
+    # make_3D_PhaseDiagram = True
+    make_2D_plot = False
+    make_2D_PhaseDiagram = False
+    make_3D_plot = False
+    make_3D_PhaseDiagram = False
+    make_2D_plot = True
+    make_2D_PhaseDiagram = True
+    #
+
+    # --- Define effective quantities: q1, q2 , q3 = mu_gamma, q12 ---
+    # q1 = harmonicMean(mu1, beta, theta)
+    # q2 = arithmeticMean(mu1, beta, theta)
+    # --- Set q12
+    # q12 = 0.0  # (analytical example)              # TEST / TODO read from Cell-Output
+
+
+
+
+
+    # b1 = prestrain_b1(rho1, beta, alpha, theta)
+    # b2 = prestrain_b2(rho1, beta, alpha, theta)
+    #
+    # print('---- Input parameters: -----')
+    # print('mu1: ', mu1)
+    # print('rho1: ', rho1)
+    # print('alpha: ', alpha)
+    # print('beta: ', beta)
+    # print('theta: ', theta)
+    # print("q1: ", q1)
+    # print("q2: ", q2)
+    # print("mu_gamma: ", mu_gamma)
+    # print("q12: ", q12)
+    # print("b1: ", b1)
+    # print("b2: ", b2)
+    # print('----------------------------')
+    # print("machine epsilon", sys.float_info.epsilon)
+
+    # G, angle, type, kappa = classifyMin(q1, q2, mu_gamma, q12,  b1, b2, print_Cases, print_Output)
+    # Test = f(1,2 ,q1,q2,mu_gamma,q12,b1,b2)
+    # print("Test", Test)
+
+    # ---------------------- MAKE PLOT / Write to VTK------------------------------------------------------------------------------
+
+    # SamplePoints_3D = 10 # Number of sample points in each direction
+    # SamplePoints_2D = 10 # Number of sample points in each direction
+    SamplePoints_3D = 300 # Number of sample points in each direction
+    # SamplePoints_3D = 150 # Number of sample points in each direction
+    # SamplePoints_3D = 100 # Number of sample points in each direction
+    # SamplePoints_3D = 200 # Number of sample points in each direction
+    # SamplePoints_3D = 400 # Number of sample points in each direction
+    # SamplePoints_2D = 7500 # Number of sample points in each direction
+    # SamplePoints_2D = 4000 # 4000 # Number of sample points in each direction
+    # SamplePoints_2D = 400 # 4000  # Number of sample points in each direction
+    # SamplePoints_2D = 500 # 4000    # Number of sample points in each direction
+    # SamplePoints_2D = 100 # 4000  # Number of sample points in each direction
+    # SamplePoints_2D = 2000 # 4000 # Number of sample points in each direction
+    SamplePoints_2D = 1000   # 4000 # Number of sample points in each direction
+
+    if make_3D_PhaseDiagram:
+        alphas_ = np.linspace(-20, 20, SamplePoints_3D)
+        # alphas_ = np.linspace(-10, 10, SamplePoints_3D)
+
+        # betas_  = np.linspace(0.01,40.01,SamplePoints_3D) # Full Range
+        # betas_  = np.linspace(0.01,20.01,SamplePoints_3D) # FULL Range
+
+
+
+        # betas_  = np.linspace(0.01,0.99,SamplePoints_3D)  # weird part
+        betas_  = np.linspace(1.01,40.01,SamplePoints_3D)     #TEST !!!!!  For Beta <1 weird tings happen...
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_3D)
+
+
+        # TEST
+        # alphas_ = np.linspace(-2, 2, SamplePoints_3D)
+        # betas_  = np.linspace(1.01,10.01,SamplePoints_3D)
+        # print('betas:', betas_)
+
+        # TEST :
+        # alphas_ = np.linspace(-40, 40, SamplePoints_3D)
+        # betas_  = np.linspace(0.01,80.01,SamplePoints_3D) # Full Range
+
+        # print('type of alphas', type(alphas_))
+        # print('Test:', type(np.array([mu_gamma])) )
+        alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+        classifyMin_anaVec = np.vectorize(classifyMin_ana)
+
+        # Get MuGamma values ...
+        GetMuGammaVec = np.vectorize(GetMuGamma)
+        muGammas = GetMuGammaVec(betas, thetas, gamma, mu1, rho1)
+        # Classify Minimizers....
+        G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1)   # Sets q12 to zero!!!
+
+        # G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1, True, True)
+        # print('size of G:', G.shape)
+        # print('G:', G)
+
+        # Option to print angles
+        # print('angles:', angles)
+
+
+        # Out = classifyMin_anaVec(alphas,betas,thetas)
+        # T = Out[2]
+        # --- Write to VTK
+
+        GammaString = str(gamma)
+        VTKOutputName = "outputs/PhaseDiagram3D" + "Gamma" + GammaString
+        gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        print('Written to VTK-File:', VTKOutputName )
+
+    if make_2D_PhaseDiagram:
+        # alphas_ = np.linspace(-20, 20, SamplePoints_2D)
+        # alphas_ = np.linspace(0, 1, SamplePoints_2D)
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        alphas_ = np.linspace(-5, 5, SamplePoints_2D)
+        # alphas_ = np.linspace(-5, 15, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.25,SamplePoints_2D)
+
+
+        # good range:
+        # alphas_ = np.linspace(9, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.075,0.14,SamplePoints_2D)
+
+        # range used:
+        # alphas_ = np.linspace(8, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.16,SamplePoints_2D)
+
+            # alphas_ = np.linspace(8, 12, SamplePoints_2D)
+            # thetas_ = np.linspace(0.05,0.2,SamplePoints_2D)
+        # betas_  = np.linspace(0.01,40.01,1)
+        #fix to one value:
+        betas_ = 2.0;
+        # betas_ = 10.0;
+        # betas_ = 5.0;
+        # betas_ = 0.5;
+
+
+        #intermediate Values
+        # alphas_ = np.linspace(-2, 1, SamplePoints_2D)
+        # thetas_ = np.linspace(0.4,0.6,SamplePoints_2D)
+        # betas_ = 10.0;
+
+        # TEST
+        # alphas_ = np.linspace(-8, 8, SamplePoints_2D)
+        # thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        # betas_ = 1.0; #TEST Problem: disvison by zero if alpha = 9, theta = 0.1 !
+        # betas_ = 0.9;
+        # betas_ = 0.5;  #TEST!!!
+        # alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+        betas = betas_
+        alphas, thetas = np.meshgrid(alphas_, thetas_, indexing='ij')
+
+        if generalCase:
+            classifyMin_matVec = np.vectorize(classifyMin_mat)
+            GetCellOutputVec = np.vectorize(GetCellOutput, otypes=[np.ndarray, np.ndarray])
+            Q, B = GetCellOutputVec(alphas,betas,thetas,gamma,mu1,rho1,lambda1, InputFilePath ,OutputFilePath )
+
+
+            # print('type of Q:', type(Q))
+            # print('Q:', Q)
+            G, angles, Types, curvature = classifyMin_matVec(Q,B)
+
+        else:
+            classifyMin_anaVec = np.vectorize(classifyMin_ana)
+            GetMuGammaVec = np.vectorize(GetMuGamma)
+            # muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+            # G, angles, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+            muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+            G, angles, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+
+            # print('size of G:', G.shape)
+            # print('G:', G)
+            # print('Types:', Types)
+            # Out = classifyMin_anaVec(alphas,betas,thetas)
+            # T = Out[2]
+            # --- Write to VTK
+            # VTKOutputName = + path + "./PhaseDiagram2DNEW"
+
+        print('angles:',angles)
+        # GammaString = str(gamma)
+        # VTKOutputName = "outputs/PhaseDiagram2D" + "Gamma_" + GammaString
+        # gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        # print('Written to VTK-File:', VTKOutputName )
+
+
+    # --- Make 3D Scatter plot
+    if(make_3D_plot or make_2D_plot):
+        # fig = plt.figure()
+        # ax = fig.add_subplot(111, projection='3d')
+        # colors = cm.plasma(Types)
+        colors = cm.coolwarm(angles)
+
+
+        width = 6.28
+        height = width / 1.618
+        # height = width / 2.5
+        fig, ax = plt.subplots()
+        # ax = plt.axes((0.15,0.21 ,0.8,0.75))
+
+
+
+
+        # if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=Types.flat)
+        # if make_3D_plot: pnt3d=ax.scatter(alphas,betas,thetas,c=Types.flat)
+        #
+        # if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=angles.flat)
+        # if make_3D_plot: pnt3d=ax.scatter(alphas,betas,thetas,c=angles.flat)
+
+
+        # pnt=ax.scatter(alphas,thetas,c=angles,cmap='coolwarm')
+        # # ax.colorbar()
+        # CS = ax.contourf(alphas, thetas, angles,6, cmap=plt.cm.coolwarm, linestyle=dashed)
+        # # CS = ax.contour(alphas, thetas, angles,6, colors='k')
+        # ax.clabel(CS, inline=True, fontsize=7.5)
+        # # ax.set_title('Simplest default with labels')
+
+        if gamma =='0':
+            CS = ax.contourf(alphas, thetas, angles, 10, cmap=plt.cm.coolwarm)
+            # CS = ax.contourf(alphas, thetas, angles, 10, cmap='RdBu')
+            CS2 = ax.contour(CS, levels=CS.levels[::2], colors='black',inline=True, linewidths=(0.5,))
+            # ax.clabel(CS2, inline=True, fontsize=9, colors='black')
+            # ax.clabel(CS2, inline=True, inline_spacing=3, rightside_up=True, colors='k', fontsize=8)
+            manual_locations = [
+                (-0.5, 0.3), (-0.7, 0.4), (-0.8, 0.5), (-0.9, 0.6), (-1,0.7)]
+            # ax.clabel(CS2, inline=True, fontsize=6, colors='black', manual=manual_locations)
+            # ax.clabel(CS2, inline=True, fontsize=6, colors='black')
+            # ax.clabel(CS2, CS2.levels, inline=True, fontsize=10)
+            # ax.clabel(CS,  fontsize=5, colors='black')
+            # cbar = fig.colorbar(CS,label=r'angle $\alpha$', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+            cbar = fig.colorbar(CS, ticks=[0, np.pi/2 ])
+            cbar.ax.set_yticklabels(['$0$', r'$\pi/2$'])
+            cbar.ax.set_title(r'angle $\alpha$')
+
+        if gamma == 'infinity':
+            CS = ax.contourf(alphas, thetas, angles, 10, cmap=plt.cm.coolwarm)
+            # CS = ax.contourf(alphas, thetas, angles, 10, cmap='RdBu')
+            CS2 = ax.contour(CS, levels=CS.levels[::2], colors='black',inline=True, linewidths=(0.5,))
+            # ax.clabel(CS2, inline=True, fontsize=9, colors='black')
+            # ax.clabel(CS2, inline=True, inline_spacing=3, rightside_up=True, colors='k', fontsize=8)
+            manual_locations = [
+                (-0.5, 0.3), (-0.7, 0.4), (-0.8, 0.5), (-0.9, 0.6), (-1,0.7)]
+            ax.clabel(CS2, inline=True, fontsize=6, colors='black', manual=manual_locations)
+
+            # ax.clabel(CS2, CS2.levels, inline=True, fontsize=10)
+            # ax.clabel(CS,  fontsize=5, colors='black')
+            # cbar = fig.colorbar(CS,label=r'angle $\alpha$', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+            cbar = fig.colorbar(CS, ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+            cbar.ax.set_yticklabels(['$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$'])
+            cbar.ax.set_title(r'angle $\alpha$')
+        # cbar=plt.colorbar(pnt3d)
+        # cbar.set_label("Values (units)")
+        # plt.axvline(x = 8, color = 'b', linestyle = ':', label='$q_1$')
+        # plt.axhline(y = 0.083333333, color = 'b', linestyle = ':', label='$q_1$')
+
+        ax.set_xlabel(r'$\theta_\rho$',fontsize=10)
+        # ax.xaxis.set_minor_locator(MultipleLocator(0.5))
+        ax.yaxis.set_major_locator(MultipleLocator(0.1))
+        ax.xaxis.set_major_locator(MultipleLocator(1))
+        # ax.set_ylabel('beta')
+        ax.set_ylabel(r'$\theta$   ',fontsize=10, rotation=0)
+        # if make_3D_plot: ax.set_zlabel('theta')
+        plt.subplots_adjust(bottom=0.2)
+        plt.grid( linestyle = '--', linewidth = 0.25)
+
+        fig.set_size_inches(width, height)
+        outputName = 'Plot-Contour_Gamma' +str(gamma) + '.pdf'
+        fig.savefig(outputName)
+        # fig.savefig('Plot-Contour.pdf')
+        plt.show()
+        # plt.savefig('common_labels.png', dpi=300)
+        # print('T:', T)
+        # print('Type 1 occured here:', np.where(T == 1))
+        # print('Type 2 occured here:', np.where(T == 2))
+
+
+        # print(alphas_)
+        # print(betas_)
+
+
+
+
+
+# ALTERNATIVE
+# colors = ("red", "green", "blue")
+# groups = ("Type 1", "Type2", "Type3")
+#
+# # Create plot
+# fig = plt.figure()
+# ax = fig.add_subplot(1, 1, 1)
+#
+# for data, color, group in zip(Types, colors, groups):
+#     # x, y = data
+#     ax.scatter(alphas, thetas, alpha=0.8, c=color, edgecolors='none', label=group)
+#
+# plt.title('Matplot scatter plot')
+# plt.legend(loc=2)
+# plt.show()

JNLS_plotScripts/PhaseDiagram_ContourSubPlots.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+from ClassifyMin import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+import time
+# print(sys.executable)
+
+# --------------------------------------------------------------------
+# START :
+# INPUT (Parameters):   alpha, beta, theta, gamma, mu1, rho1
+#
+# -Option 1 : (Case lambda = 0 => q12 = 0)
+#   compute q1,q2,b1,b2 from Formula
+#       Option 1.1 :
+#           set mu_gamma = 'q1' or 'q2' (extreme regimes: gamma \in {0,\infty})
+#       Option 1.2 :
+#           compute mu_gamma with 'Compute_MuGamma' (2D problem much faster then Cell-Problem)
+# -Option 2 :
+#   compute Q_hom & B_eff by running 'Cell-Problem'
+#
+# -> CLASSIFY ...
+#
+# OUTPUT: Minimizer G, angle , type, curvature
+# -----------------------------------------------------------------------
+#
+#
+# def GetMuGamma(beta,theta,gamma,mu1,rho1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset",
+#                 OutputFilePath = os.path.dirname(os.getcwd()) + "/outputs/outputMuGamma.txt" ):
+#     # ------------------------------------ get mu_gamma ------------------------------
+#     # ---Scenario 1.1: extreme regimes
+#     if gamma == '0':
+#         print('extreme regime: gamma = 0')
+#         mu_gamma = (1.0/6.0)*arithmeticMean(mu1, beta, theta) # = q2
+#         print("mu_gamma:", mu_gamma)
+#     elif gamma == 'infinity':
+#         print('extreme regime: gamma = infinity')
+#         mu_gamma = (1.0/6.0)*harmonicMean(mu1, beta, theta)   # = q1
+#         print("mu_gamma:", mu_gamma)
+#     else:
+#         # --- Scenario 1.2:  compute mu_gamma with 'Compute_MuGamma' (much faster than running full Cell-Problem)
+#         # print("Run computeMuGamma for Gamma = ", gamma)
+#         with open(InputFilePath, 'r') as file:
+#             filedata = file.read()
+#         filedata = re.sub('(?m)^gamma=.*','gamma='+str(gamma),filedata)
+#         # filedata = re.sub('(?m)^alpha=.*','alpha='+str(alpha),filedata)
+#         filedata = re.sub('(?m)^beta=.*','beta='+str(beta),filedata)
+#         filedata = re.sub('(?m)^theta=.*','theta='+str(theta),filedata)
+#         filedata = re.sub('(?m)^mu1=.*','mu1='+str(mu1),filedata)
+#         filedata = re.sub('(?m)^rho1=.*','rho1='+str(rho1),filedata)
+#         f = open(InputFilePath,'w')
+#         f.write(filedata)
+#         f.close()
+#         # --- Run Cell-Problem
+#
+#         # Check Time
+#         # t = time.time()
+#         # subprocess.run(['./build-cmake/src/Cell-Problem', './inputs/cellsolver.parset'],
+#         #                                      capture_output=True, text=True)
+#         # --- Run Cell-Problem_muGama   -> faster
+#         # subprocess.run(['./build-cmake/src/Cell-Problem_muGamma', './inputs/cellsolver.parset'],
+#         #                                              capture_output=True, text=True)
+#         # --- Run Compute_muGamma (2D Problem much much faster)
+#
+#         subprocess.run(['./build-cmake/src/Compute_MuGamma', './inputs/computeMuGamma.parset'],
+#                                                              capture_output=True, text=True)
+#         # print('elapsed time:', time.time() - t)
+#
+#         #Extract mu_gamma from Output-File                                           TODO: GENERALIZED THIS FOR QUANTITIES OF INTEREST
+#         with open(OutputFilePath, 'r') as file:
+#             output = file.read()
+#         tmp = re.search(r'(?m)^mu_gamma=.*',output).group()                           # Not necessary for Intention of Program t output Minimizer etc.....
+#         s = re.findall(r"[-+]?\d*\.\d+|\d+", tmp)
+#         mu_gamma = float(s[0])
+#         # print("mu_gamma:", mu_gammaValue)
+#     # --------------------------------------------------------------------------------------
+#     return mu_gamma
+#
+
+
+
+# ----------- SETUP PATHS
+# InputFile  = "/inputs/cellsolver.parset"
+# OutputFile = "/outputs/output.txt"
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+
+# -------------------------- Input Parameters --------------------
+# mu1 = 10.0               # TODO : here must be the same values as in the Parset for computeMuGamma
+mu1 = 1.0
+rho1 = 1.0
+alpha = 2.0
+beta = 2.0
+# beta = 5.0
+theta = 1.0/4.0
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+gamma = '0'
+# gamma = 'infinity'
+# gamma = 0.5
+# gamma = 0.25
+# gamma = 1.0
+
+# gamma = 5.0
+
+#added
+# lambda1 = 10.0
+lambda1 = 0.0
+
+#Test:
+# rho1 = -1.0
+
+
+
+print('---- Input parameters: -----')
+print('mu1: ', mu1)
+print('rho1: ', rho1)
+print('alpha: ', alpha)
+print('beta: ', beta)
+print('theta: ', theta)
+print('gamma:', gamma)
+
+print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+
+#
+# gamma_min = 0.5
+# gamma_max = 1.0
+#
+# # gamma_min = 1
+# # gamma_max = 1
+# Gamma_Values = np.linspace(gamma_min, gamma_max, num=3)
+# # #
+# # # Gamma_Values = np.linspace(gamma_min, gamma_max, num=13)    # TODO variable Input Parameters...alpha,beta...
+# print('(Input) Gamma_Values:', Gamma_Values)
+
+print('type of gamma:', type(gamma))
+# # #
+Gamma_Values = ['0', 'infinity']
+# Gamma_Values = ['infinity']
+# Gamma_Values = ['0']
+print('(Input) Gamma_Values:', Gamma_Values)
+
+for gamma in Gamma_Values:
+
+    print('Run for gamma = ', gamma)
+    print('type of gamma:', type(gamma))
+        # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1,InputFilePath)
+        # # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1)
+        # print('Test MuGamma:', muGamma)
+
+        # ------- Options --------
+        # print_Cases = True
+        # print_Output = True
+
+                            #TODO
+    # generalCase = True #Read Output from Cell-Problem instead of using Lemma1.4 (special case)
+    generalCase = False
+
+    # make_3D_plot = True
+    # make_3D_PhaseDiagram = True
+    make_2D_plot = False
+    make_2D_PhaseDiagram = False
+    make_3D_plot = False
+    make_3D_PhaseDiagram = False
+    make_2D_plot = True
+    make_2D_PhaseDiagram = True
+    #
+
+    # --- Define effective quantities: q1, q2 , q3 = mu_gamma, q12 ---
+    # q1 = harmonicMean(mu1, beta, theta)
+    # q2 = arithmeticMean(mu1, beta, theta)
+    # --- Set q12
+    # q12 = 0.0  # (analytical example)              # TEST / TODO read from Cell-Output
+
+
+
+
+
+    # b1 = prestrain_b1(rho1, beta, alpha, theta)
+    # b2 = prestrain_b2(rho1, beta, alpha, theta)
+    #
+    # print('---- Input parameters: -----')
+    # print('mu1: ', mu1)
+    # print('rho1: ', rho1)
+    # print('alpha: ', alpha)
+    # print('beta: ', beta)
+    # print('theta: ', theta)
+    # print("q1: ", q1)
+    # print("q2: ", q2)
+    # print("mu_gamma: ", mu_gamma)
+    # print("q12: ", q12)
+    # print("b1: ", b1)
+    # print("b2: ", b2)
+    # print('----------------------------')
+    # print("machine epsilon", sys.float_info.epsilon)
+
+    # G, angle, type, kappa = classifyMin(q1, q2, mu_gamma, q12,  b1, b2, print_Cases, print_Output)
+    # Test = f(1,2 ,q1,q2,mu_gamma,q12,b1,b2)
+    # print("Test", Test)
+
+    # ---------------------- MAKE PLOT / Write to VTK------------------------------------------------------------------------------
+
+    # SamplePoints_3D = 10 # Number of sample points in each direction
+    # SamplePoints_2D = 10 # Number of sample points in each direction
+    SamplePoints_3D = 300 # Number of sample points in each direction
+    # SamplePoints_3D = 150 # Number of sample points in each direction
+    # SamplePoints_3D = 100 # Number of sample points in each direction
+    # SamplePoints_3D = 200 # Number of sample points in each direction
+    # SamplePoints_3D = 400 # Number of sample points in each direction
+    # SamplePoints_2D = 7500 # Number of sample points in each direction
+    # SamplePoints_2D = 4000 # 4000 # Number of sample points in each direction
+    SamplePoints_2D = 400 # 4000  # Number of sample points in each direction
+    # SamplePoints_2D = 500 # 4000    # Number of sample points in each direction
+    # SamplePoints_2D = 100 # 4000  # Number of sample points in each direction
+    # SamplePoints_2D = 2000 # 4000 # Number of sample points in each direction
+    # SamplePoints_2D = 1000   # 4000 # Number of sample points in each direction
+
+    if make_3D_PhaseDiagram:
+        alphas_ = np.linspace(-20, 20, SamplePoints_3D)
+        # alphas_ = np.linspace(-10, 10, SamplePoints_3D)
+
+        # betas_  = np.linspace(0.01,40.01,SamplePoints_3D) # Full Range
+        # betas_  = np.linspace(0.01,20.01,SamplePoints_3D) # FULL Range
+
+
+
+        # betas_  = np.linspace(0.01,0.99,SamplePoints_3D)  # weird part
+        betas_  = np.linspace(1.01,40.01,SamplePoints_3D)     #TEST !!!!!  For Beta <1 weird tings happen...
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_3D)
+
+
+        # TEST
+        # alphas_ = np.linspace(-2, 2, SamplePoints_3D)
+        # betas_  = np.linspace(1.01,10.01,SamplePoints_3D)
+        # print('betas:', betas_)
+
+        # TEST :
+        # alphas_ = np.linspace(-40, 40, SamplePoints_3D)
+        # betas_  = np.linspace(0.01,80.01,SamplePoints_3D) # Full Range
+
+        # print('type of alphas', type(alphas_))
+        # print('Test:', type(np.array([mu_gamma])) )
+        alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+        classifyMin_anaVec = np.vectorize(classifyMin_ana)
+
+        # Get MuGamma values ...
+        GetMuGammaVec = np.vectorize(GetMuGamma)
+        muGammas = GetMuGammaVec(betas, thetas, gamma, mu1, rho1)
+        # Classify Minimizers....
+        G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1)   # Sets q12 to zero!!!
+
+        # G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1, True, True)
+        # print('size of G:', G.shape)
+        # print('G:', G)
+
+        # Option to print angles
+        # print('angles:', angles)
+
+
+        # Out = classifyMin_anaVec(alphas,betas,thetas)
+        # T = Out[2]
+        # --- Write to VTK
+
+        GammaString = str(gamma)
+        VTKOutputName = "outputs/PhaseDiagram3D" + "Gamma" + GammaString
+        gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        print('Written to VTK-File:', VTKOutputName )
+
+    if make_2D_PhaseDiagram:
+        # alphas_ = np.linspace(-20, 20, SamplePoints_2D)
+        # alphas_ = np.linspace(0, 1, SamplePoints_2D)
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        alphas_ = np.linspace(-5, 5, SamplePoints_2D)
+        # alphas_ = np.linspace(-5, 15, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.25,SamplePoints_2D)
+
+
+        # good range:
+        # alphas_ = np.linspace(9, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.075,0.14,SamplePoints_2D)
+
+        # range used:
+        # alphas_ = np.linspace(8, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.16,SamplePoints_2D)
+
+            # alphas_ = np.linspace(8, 12, SamplePoints_2D)
+            # thetas_ = np.linspace(0.05,0.2,SamplePoints_2D)
+        # betas_  = np.linspace(0.01,40.01,1)
+        #fix to one value:
+        betas_ = 2.0;
+        # betas_ = 10.0;
+        # betas_ = 5.0;
+        # betas_ = 0.5;
+
+
+        #intermediate Values
+        alphas_ = np.linspace(-2, 1, SamplePoints_2D)
+        # thetas_ = np.linspace(0.4,0.6,SamplePoints_2D)
+        # betas_ = 10.0;
+
+        # TEST
+        # alphas_ = np.linspace(-8, 8, SamplePoints_2D)
+        # thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        # betas_ = 1.0; #TEST Problem: disvison by zero if alpha = 9, theta = 0.1 !
+        # betas_ = 0.9;
+        # betas_ = 0.5;  #TEST!!!
+        # alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+        betas = betas_
+        alphas, thetas = np.meshgrid(alphas_, thetas_, indexing='ij')
+
+        if generalCase:
+            classifyMin_matVec = np.vectorize(classifyMin_mat)
+            GetCellOutputVec = np.vectorize(GetCellOutput, otypes=[np.ndarray, np.ndarray])
+            Q, B = GetCellOutputVec(alphas,betas,thetas,gamma,mu1,rho1,lambda1, InputFilePath ,OutputFilePath )
+
+
+            # print('type of Q:', type(Q))
+            # print('Q:', Q)
+            G, angles, Types, curvature = classifyMin_matVec(Q,B)
+
+        else:
+            classifyMin_anaVec = np.vectorize(classifyMin_ana)
+            GetMuGammaVec = np.vectorize(GetMuGamma)
+            # muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+            # G, angles, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+            muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+
+            if gamma == '0':
+                G, angles_0, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+            if gamma == 'infinity':
+                G, angles_inf, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+
+            # print('size of G:', G.shape)
+            # print('G:', G)
+            # print('Types:', Types)
+            # Out = classifyMin_anaVec(alphas,betas,thetas)
+            # T = Out[2]
+            # --- Write to VTK
+            # VTKOutputName = + path + "./PhaseDiagram2DNEW"
+
+        # print('angles:',angles)
+        # GammaString = str(gamma)
+        # VTKOutputName = "outputs/PhaseDiagram2D" + "Gamma_" + GammaString
+        # gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        # print('Written to VTK-File:', VTKOutputName )
+
+
+# --- Make 3D Scatter plot
+if(make_3D_plot or make_2D_plot):
+    # fig = plt.figure()
+    # ax = fig.add_subplot(111, projection='3d')
+    # colors = cm.plasma(Types)
+    colors = cm.coolwarm(angles_inf)
+
+
+    width = 6.28
+    # height = width / 1.618
+    height = width / 2.5
+    # fig, ax = plt.subplots()
+    fig,ax = plt.subplots(nrows=1,ncols=2,figsize=(width,height), sharey=True)
+    # ax = plt.axes((0.15,0.21 ,0.8,0.75))
+
+
+
+
+    # if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=Types.flat)
+    # if make_3D_plot: pnt3d=ax.scatter(alphas,betas,thetas,c=Types.flat)
+    #
+    # if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=angles.flat)
+    # if make_3D_plot: pnt3d=ax.scatter(alphas,betas,thetas,c=angles.flat)
+
+
+    # pnt=ax.scatter(alphas,thetas,c=angles,cmap='coolwarm')
+    # # ax.colorbar()
+    # CS = ax.contourf(alphas, thetas, angles,6, cmap=plt.cm.coolwarm, linestyle=dashed)
+    # # CS = ax.contour(alphas, thetas, angles,6, colors='k')
+    # ax.clabel(CS, inline=True, fontsize=7.5)
+    # # ax.set_title('Simplest default with labels')
+
+    # matplotlib.rcParams['contour.linestyles'] = 'dashed'
+
+
+    CS_0 = ax[0].contourf(alphas, thetas, angles_0, 10, cmap=plt.cm.coolwarm)
+    # CS = ax.contourf(alphas, thetas, angles, 10, cmap='RdBu')
+    CS_02 = ax[0].contour(CS_0, levels=CS_0.levels[::2], colors='black',inline=True, linewidths=(0.5,))
+    # ax.clabel(CS2, inline=True, fontsize=9, colors='black')
+    # ax.clabel(CS2, inline=True, inline_spacing=3, rightside_up=True, colors='k', fontsize=8)
+    # manual_locations = [
+    #     (-0.5, 0.3), (-0.7, 0.4), (-0.8, 0.5), (-0.9, 0.6), (-1,0.7)]
+    manual_locations = [
+        (-0.4, 0.2),(-0.6, 0.3), (-0.7, 0.4), (-0.8, 0.5), (-0.9, 0.6), (-1,0.7)]
+    # ax.clabel(CS2, inline=True, fontsize=6, colors='black', manual=manual_locations)
+    # ax.clabel(CS2, inline=True, fontsize=6, colors='black')
+    # ax.clabel(CS2, CS2.levels, inline=True, fontsize=10)
+    # ax.clabel(CS,  fontsize=5, colors='black')
+    # cbar = fig.colorbar(CS,label=r'angle $\alpha$', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+    # cbar = fig.colorbar(CS_0, ticks=[0, np.pi/2 ])
+    # cbar.ax.set_yticklabels(['$0$', r'$\pi/2$'])
+    # cbar.ax.set_title(r'angle $\alpha$')
+
+
+    CS_1 = ax[1].contourf(alphas, thetas, angles_inf, 10, cmap=plt.cm.coolwarm)
+    # CS = ax.contourf(alphas, thetas, angles, 10, cmap='RdBu')
+    CS_12 = ax[1].contour(CS_1, levels=CS_1.levels[::2], colors='black',inline=True, linewidths=(0.5,))
+    # ax.clabel(CS2, inline=True, fontsize=9, colors='black')
+    # ax.clabel(CS2, inline=True, inline_spacing=3, rightside_up=True, colors='k', fontsize=8)
+    # manual_locations = [
+    #     (-0.5, 0.3), (-0.7, 0.4), (-0.8, 0.5), (-0.9, 0.6), (-1,0.7)]
+    manual_locations = [
+        (-0.5, 0.15), (-0.7, 0.3), (-0.8, 0.45), (-0.9, 0.6), (-1,0.75)]
+    # ax[1].clabel(CS_12, inline=True, fontsize=10, colors='black', manual=manual_locations)
+    ax[1].clabel(CS_12, inline=True, fontsize=8, colors='black', manual=manual_locations)
+    # ax[1].clabel(CS_12, inline=True, fontsize=8, colors='black')
+
+
+    axins1 = inset_axes(ax[1],
+                       width="5%",  # width = 5% of parent_bbox width
+                       height="100%",  # height : 50%
+                       loc='lower left',
+                       bbox_to_anchor=(1.05, 0., 1, 1),
+                       bbox_transform=ax[1].transAxes,
+                       borderpad=0,
+                       )
+
+    # ax.clabel(CS2, CS2.levels, inline=True, fontsize=10)
+    # ax.clabel(CS,  fontsize=5, colors='black')
+    # cbar = fig.colorbar(CS,label=r'angle $\alpha$', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+    # cbar = fig.colorbar(CS_1, ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+
+    # cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])
+    cbar = fig.colorbar(CS_1, cax=axins1, ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+    # cbar = fig.colorbar(CS_1, cax=cbar_ax, shrink=0.2, location='right', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+    # cbar = fig.colorbar(CS_1,  ax=ax[:], shrink=0.8, location='right', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+
+    cbar.ax.set_yticklabels(['$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$'])
+    # cbar.ax.set_title(r'angle $\alpha$')
+    cbar.ax.set_title(r'$\alpha$')
+    # cbar=plt.colorbar(pnt3d)
+    # cbar.set_label("Values (units)")
+    # plt.axvline(x = 8, color = 'b', linestyle = ':', label='$q_1$')
+    # plt.axhline(y = 0.083333333, color = 'b', linestyle = ':', label='$q_1$')
+
+    ax[0].set_xlabel(r'$\theta_\rho$',fontsize=10)
+    # ax[0].yaxis.set_major_locator(MultipleLocator(0.1))
+    # ax[0].xaxis.set_major_locator(MultipleLocator(1))
+    ax[0].yaxis.set_major_locator(MultipleLocator(0.1))
+    ax[0].xaxis.set_major_locator(MultipleLocator(0.5))
+    ax[0].set_ylabel(r'$\theta$   ',fontsize=10, rotation=0)
+    ax[0].tick_params(axis='x', labelsize=7 )
+    ax[0].tick_params(axis='y', labelsize=7 )
+
+    ax[1].set_xlabel(r'$\theta_\rho$',fontsize=10)
+    # ax.xaxis.set_minor_locator(MultipleLocator(0.5))
+    # ax[1].yaxis.set_major_locator(MultipleLocator(0.1))
+    # ax[1].xaxis.set_major_locator(MultipleLocator(1))
+    ax[1].yaxis.set_major_locator(MultipleLocator(0.1))
+    ax[1].xaxis.set_major_locator(MultipleLocator(0.5))
+    ax[1].tick_params(axis='x', labelsize=7 )
+    ax[1].tick_params(axis='y', labelsize=7 )
+    # ax.set_ylabel('beta')
+    # ax[1].set_ylabel(r'$\theta$   ',fontsize=10, rotation=0)
+    # if make_3D_plot: ax.set_zlabel('theta')
+    # plt.subplots_adjust(bottom=0.2)
+    # plt.subplots_adjust(wspace=0.22, hspace=0.1)
+    plt.subplots_adjust(hspace=0.15, wspace=0.1)
+    plt.subplots_adjust(bottom=0.2)
+    # fig.subplots_adjust(right=0.75)
+
+
+    ax[0].grid( linestyle = '--', linewidth = 0.25)
+    ax[1].grid( linestyle = '--', linewidth = 0.25)
+
+
+
+    fig.set_size_inches(width, height)
+    outputName = 'Plot-Contour_Gamma' +str(gamma) + '.pdf'
+    fig.savefig(outputName)
+    # fig.savefig('Plot-Contour.pdf')
+    plt.show()
+    # plt.savefig('common_labels.png', dpi=300)
+    # print('T:', T)
+    # print('Type 1 occured here:', np.where(T == 1))
+    # print('Type 2 occured here:', np.where(T == 2))
+
+
+    # print(alphas_)
+    # print(betas_)
+
+
+
+
+
+# ALTERNATIVE
+# colors = ("red", "green", "blue")
+# groups = ("Type 1", "Type2", "Type3")
+#
+# # Create plot
+# fig = plt.figure()
+# ax = fig.add_subplot(1, 1, 1)
+#
+# for data, color, group in zip(Types, colors, groups):
+#     # x, y = data
+#     ax.scatter(alphas, thetas, alpha=0.8, c=color, edgecolors='none', label=group)
+#
+# plt.title('Matplot scatter plot')
+# plt.legend(loc=2)
+# plt.show()

JNLS_plotScripts/PhaseDiagram_ContourSubPlots_v2.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+# from ClassifyMin import *
+from ClassifyMin_New import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+import matplotlib as mpl
+import seaborn as sns
+import matplotlib.colors as mcolors
+import time
+
+from scipy.ndimage.filters import gaussian_filter
+# from scipy import ndimage
+# print(sys.executable)
+
+# --------------------------------------------------------------------
+# START :
+# INPUT (Parameters):   alpha, beta, theta, gamma, mu1, rho1
+#
+# -Option 1 : (Case lambda = 0 => q12 = 0)
+#   compute q1,q2,b1,b2 from Formula
+#       Option 1.1 :
+#           set mu_gamma = 'q1' or 'q2' (extreme regimes: gamma \in {0,\infty})
+#       Option 1.2 :
+#           compute mu_gamma with 'Compute_MuGamma' (2D problem much faster then Cell-Problem)
+# -Option 2 :
+#   compute Q_hom & B_eff by running 'Cell-Problem'
+#
+# -> CLASSIFY ...
+#
+# OUTPUT: Minimizer G, angle , type, curvature
+# -----------------------------------------------------------------------
+#
+#
+# def GetMuGamma(beta,theta,gamma,mu1,rho1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset",
+#                 OutputFilePath = os.path.dirname(os.getcwd()) + "/outputs/outputMuGamma.txt" ):
+#     # ------------------------------------ get mu_gamma ------------------------------
+#     # ---Scenario 1.1: extreme regimes
+#     if gamma == '0':
+#         print('extreme regime: gamma = 0')
+#         mu_gamma = (1.0/6.0)*arithmeticMean(mu1, beta, theta) # = q2
+#         print("mu_gamma:", mu_gamma)
+#     elif gamma == 'infinity':
+#         print('extreme regime: gamma = infinity')
+#         mu_gamma = (1.0/6.0)*harmonicMean(mu1, beta, theta)   # = q1
+#         print("mu_gamma:", mu_gamma)
+#     else:
+#         # --- Scenario 1.2:  compute mu_gamma with 'Compute_MuGamma' (much faster than running full Cell-Problem)
+#         # print("Run computeMuGamma for Gamma = ", gamma)
+#         with open(InputFilePath, 'r') as file:
+#             filedata = file.read()
+#         filedata = re.sub('(?m)^gamma=.*','gamma='+str(gamma),filedata)
+#         # filedata = re.sub('(?m)^alpha=.*','alpha='+str(alpha),filedata)
+#         filedata = re.sub('(?m)^beta=.*','beta='+str(beta),filedata)
+#         filedata = re.sub('(?m)^theta=.*','theta='+str(theta),filedata)
+#         filedata = re.sub('(?m)^mu1=.*','mu1='+str(mu1),filedata)
+#         filedata = re.sub('(?m)^rho1=.*','rho1='+str(rho1),filedata)
+#         f = open(InputFilePath,'w')
+#         f.write(filedata)
+#         f.close()
+#         # --- Run Cell-Problem
+#
+#         # Check Time
+#         # t = time.time()
+#         # subprocess.run(['./build-cmake/src/Cell-Problem', './inputs/cellsolver.parset'],
+#         #                                      capture_output=True, text=True)
+#         # --- Run Cell-Problem_muGama   -> faster
+#         # subprocess.run(['./build-cmake/src/Cell-Problem_muGamma', './inputs/cellsolver.parset'],
+#         #                                              capture_output=True, text=True)
+#         # --- Run Compute_muGamma (2D Problem much much faster)
+#
+#         subprocess.run(['./build-cmake/src/Compute_MuGamma', './inputs/computeMuGamma.parset'],
+#                                                              capture_output=True, text=True)
+#         # print('elapsed time:', time.time() - t)
+#
+#         #Extract mu_gamma from Output-File                                           TODO: GENERALIZED THIS FOR QUANTITIES OF INTEREST
+#         with open(OutputFilePath, 'r') as file:
+#             output = file.read()
+#         tmp = re.search(r'(?m)^mu_gamma=.*',output).group()                           # Not necessary for Intention of Program t output Minimizer etc.....
+#         s = re.findall(r"[-+]?\d*\.\d+|\d+", tmp)
+#         mu_gamma = float(s[0])
+#         # print("mu_gamma:", mu_gammaValue)
+#     # --------------------------------------------------------------------------------------
+#     return mu_gamma
+#
+
+
+
+# ----------- SETUP PATHS
+# InputFile  = "/inputs/cellsolver.parset"
+# OutputFile = "/outputs/output.txt"
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+
+# -------------------------- Input Parameters --------------------
+# mu1 = 10.0               # TODO : here must be the same values as in the Parset for computeMuGamma
+mu1 = 1.0
+rho1 = 1.0
+alpha = 2.0
+beta = 2.0
+# beta = 5.0
+theta = 1.0/4.0
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+gamma = '0'
+# gamma = 'infinity'
+# gamma = 0.5
+# gamma = 0.25
+# gamma = 1.0
+
+# gamma = 5.0
+
+#added
+# lambda1 = 10.0
+lambda1 = 0.0
+
+#Test:
+# rho1 = -1.0
+
+
+
+print('---- Input parameters: -----')
+print('mu1: ', mu1)
+print('rho1: ', rho1)
+print('alpha: ', alpha)
+print('beta: ', beta)
+print('theta: ', theta)
+print('gamma:', gamma)
+
+print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+
+#
+# gamma_min = 0.5
+# gamma_max = 1.0
+#
+# # gamma_min = 1
+# # gamma_max = 1
+# Gamma_Values = np.linspace(gamma_min, gamma_max, num=3)
+# # #
+# # # Gamma_Values = np.linspace(gamma_min, gamma_max, num=13)    # TODO variable Input Parameters...alpha,beta...
+# print('(Input) Gamma_Values:', Gamma_Values)
+
+print('type of gamma:', type(gamma))
+# # #
+Gamma_Values = ['0', 'infinity']
+# Gamma_Values = ['infinity']
+# Gamma_Values = ['0']
+print('(Input) Gamma_Values:', Gamma_Values)
+
+for gamma in Gamma_Values:
+
+    print('Run for gamma = ', gamma)
+    print('type of gamma:', type(gamma))
+        # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1,InputFilePath)
+        # # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1)
+        # print('Test MuGamma:', muGamma)
+
+        # ------- Options --------
+        # print_Cases = True
+        # print_Output = True
+
+                            #TODO
+    # generalCase = True #Read Output from Cell-Problem instead of using Lemma1.4 (special case)
+    generalCase = False
+
+    # make_3D_plot = True
+    # make_3D_PhaseDiagram = True
+    make_2D_plot = False
+    make_2D_PhaseDiagram = False
+    make_3D_plot = False
+    make_3D_PhaseDiagram = False
+    make_2D_plot = True
+    make_2D_PhaseDiagram = True
+    #
+
+    # --- Define effective quantities: q1, q2 , q3 = mu_gamma, q12 ---
+    # q1 = harmonicMean(mu1, beta, theta)
+    # q2 = arithmeticMean(mu1, beta, theta)
+    # --- Set q12
+    # q12 = 0.0  # (analytical example)              # TEST / TODO read from Cell-Output
+
+
+
+
+
+    # b1 = prestrain_b1(rho1, beta, alpha, theta)
+    # b2 = prestrain_b2(rho1, beta, alpha, theta)
+    #
+    # print('---- Input parameters: -----')
+    # print('mu1: ', mu1)
+    # print('rho1: ', rho1)
+    # print('alpha: ', alpha)
+    # print('beta: ', beta)
+    # print('theta: ', theta)
+    # print("q1: ", q1)
+    # print("q2: ", q2)
+    # print("mu_gamma: ", mu_gamma)
+    # print("q12: ", q12)
+    # print("b1: ", b1)
+    # print("b2: ", b2)
+    # print('----------------------------')
+    # print("machine epsilon", sys.float_info.epsilon)
+
+    # G, angle, type, kappa = classifyMin(q1, q2, mu_gamma, q12,  b1, b2, print_Cases, print_Output)
+    # Test = f(1,2 ,q1,q2,mu_gamma,q12,b1,b2)
+    # print("Test", Test)
+
+    # ---------------------- MAKE PLOT / Write to VTK------------------------------------------------------------------------------
+
+    # SamplePoints_3D = 10 # Number of sample points in each direction
+    # SamplePoints_2D = 10 # Number of sample points in each direction
+    SamplePoints_3D = 300 # Number of sample points in each direction
+    # SamplePoints_3D = 150 # Number of sample points in each direction
+    # SamplePoints_3D = 100 # Number of sample points in each direction
+    # SamplePoints_3D = 200 # Number of sample points in each direction
+    # SamplePoints_3D = 400 # Number of sample points in each direction
+    # SamplePoints_2D = 7500 # Number of sample points in each direction
+    # SamplePoints_2D = 4000 # 4000 # Number of sample points in each direction
+    SamplePoints_2D = 400 # 4000  # Number of sample points in each direction
+    # SamplePoints_2D = 500 # 4000    # Number of sample points in each direction
+    # SamplePoints_2D = 100 # 4000  # Number of sample points in each direction
+    # SamplePoints_2D = 2000 # 4000 # Number of sample points in each direction
+    # SamplePoints_2D = 1000   # 4000 # Number of sample points in each direction
+    # SamplePoints_2D = 1500 # 4000 # Number of sa
+
+    if make_3D_PhaseDiagram:
+        alphas_ = np.linspace(-20, 20, SamplePoints_3D)
+        # alphas_ = np.linspace(-10, 10, SamplePoints_3D)
+
+        # betas_  = np.linspace(0.01,40.01,SamplePoints_3D) # Full Range
+        # betas_  = np.linspace(0.01,20.01,SamplePoints_3D) # FULL Range
+
+
+
+        # betas_  = np.linspace(0.01,0.99,SamplePoints_3D)  # weird part
+        betas_  = np.linspace(1.01,40.01,SamplePoints_3D)     #TEST !!!!!  For Beta <1 weird tings happen...
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_3D)
+
+
+        # TEST
+        # alphas_ = np.linspace(-2, 2, SamplePoints_3D)
+        # betas_  = np.linspace(1.01,10.01,SamplePoints_3D)
+        # print('betas:', betas_)
+
+        # TEST :
+        # alphas_ = np.linspace(-40, 40, SamplePoints_3D)
+        # betas_  = np.linspace(0.01,80.01,SamplePoints_3D) # Full Range
+
+        # print('type of alphas', type(alphas_))
+        # print('Test:', type(np.array([mu_gamma])) )
+        alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+        classifyMin_anaVec = np.vectorize(classifyMin_ana)
+
+        # Get MuGamma values ...
+        GetMuGammaVec = np.vectorize(GetMuGamma)
+        muGammas = GetMuGammaVec(betas, thetas, gamma, mu1, rho1)
+        # Classify Minimizers....
+        G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1)   # Sets q12 to zero!!!
+
+        # G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1, True, True)
+        # print('size of G:', G.shape)
+        # print('G:', G)
+
+        # Option to print angles
+        # print('angles:', angles)
+
+
+        # Out = classifyMin_anaVec(alphas,betas,thetas)
+        # T = Out[2]
+        # --- Write to VTK
+
+        GammaString = str(gamma)
+        VTKOutputName = "outputs/PhaseDiagram3D" + "Gamma" + GammaString
+        gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        print('Written to VTK-File:', VTKOutputName )
+
+    if make_2D_PhaseDiagram:
+        # alphas_ = np.linspace(-20, 20, SamplePoints_2D)
+        # alphas_ = np.linspace(0, 1, SamplePoints_2D)
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        alphas_ = np.linspace(-5, 5, SamplePoints_2D)
+        # alphas_ = np.linspace(-5, 15, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.25,SamplePoints_2D)
+
+
+        # good range:
+        # alphas_ = np.linspace(9, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.075,0.14,SamplePoints_2D)
+
+        # range used:
+        # alphas_ = np.linspace(8, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.16,SamplePoints_2D)
+
+            # alphas_ = np.linspace(8, 12, SamplePoints_2D)
+            # thetas_ = np.linspace(0.05,0.2,SamplePoints_2D)
+        # betas_  = np.linspace(0.01,40.01,1)
+        #fix to one value:
+        betas_ = 2.0;
+        # betas_ = 10.0;
+        # betas_ = 5.0;
+        # betas_ = 0.5;
+
+
+        #intermediate Values
+        alphas_ = np.linspace(-2, 1, SamplePoints_2D)
+        # alphas_ = np.linspace(-1.5, 1, SamplePoints_2D)
+        # thetas_ = np.linspace(0.4,0.6,SamplePoints_2D)
+        # betas_ = 10.0;
+
+        # TEST
+        # alphas_ = np.linspace(-8, 8, SamplePoints_2D)
+        # thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        # betas_ = 1.0; #TEST Problem: disvison by zero if alpha = 9, theta = 0.1 !
+        # betas_ = 0.9;
+        # betas_ = 0.5;  #TEST!!!
+        # alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+        betas = betas_
+        alphas, thetas = np.meshgrid(alphas_, thetas_, indexing='ij')
+
+        if generalCase:
+            classifyMin_matVec = np.vectorize(classifyMin_mat)
+            GetCellOutputVec = np.vectorize(GetCellOutput, otypes=[np.ndarray, np.ndarray])
+            Q, B = GetCellOutputVec(alphas,betas,thetas,gamma,mu1,rho1,lambda1, InputFilePath ,OutputFilePath )
+
+
+            # print('type of Q:', type(Q))
+            # print('Q:', Q)
+            G, angles, Types, curvature = classifyMin_matVec(Q,B)
+
+        else:
+            classifyMin_anaVec = np.vectorize(classifyMin_ana)
+            GetMuGammaVec = np.vectorize(GetMuGamma)
+            # muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+            # G, angles, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+            muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+
+            if gamma == '0':
+                G, angles_0, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+            if gamma == 'infinity':
+                G, angles_inf, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+
+            # print('size of G:', G.shape)
+            # print('G:', G)
+            # print('Types:', Types)
+            # Out = classifyMin_anaVec(alphas,betas,thetas)
+            # T = Out[2]
+            # --- Write to VTK
+            # VTKOutputName = + path + "./PhaseDiagram2DNEW"
+
+        # print('angles:',angles)
+        # GammaString = str(gamma)
+        # VTKOutputName = "outputs/PhaseDiagram2D" + "Gamma_" + GammaString
+        # gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        # print('Written to VTK-File:', VTKOutputName )
+
+
+# --- Make 3D Scatter plot
+if(make_3D_plot or make_2D_plot):
+
+
+    # Styling
+    plt.style.use("seaborn-darkgrid")
+    plt.style.use("seaborn-whitegrid")
+    plt.style.use("seaborn")
+    # plt.style.use("seaborn-paper")
+    # plt.style.use('ggplot')
+    # plt.rcParams["font.family"] = "Avenir"
+    # plt.rcParams["font.size"] = 16
+
+    # plt.style.use("seaborn-darkgrid")
+    mpl.rcParams['text.usetex'] = True
+    mpl.rcParams["font.family"] = "serif"
+    mpl.rcParams["font.size"] = "10"
+    # mpl.rcParams['xtick.labelsize'] = 16mpl.rcParams['xtick.major.size'] = 2.5
+    # mpl.rcParams['xtick.bottom'] = True
+    # mpl.rcParams['ticks'] = True
+    mpl.rcParams['xtick.bottom'] = True
+    mpl.rcParams['xtick.major.size'] = 3
+    mpl.rcParams['xtick.minor.size'] = 1.5
+    mpl.rcParams['xtick.major.width'] = 0.75
+    mpl.rcParams['ytick.left'] = True
+    mpl.rcParams['ytick.major.size'] = 3
+    mpl.rcParams['ytick.minor.size'] = 1.5
+    mpl.rcParams['ytick.major.width'] = 0.75
+
+    mpl.rcParams.update({'font.size': 10})
+
+    ### ADJUST GRID:
+    mpl.rcParams['axes.labelpad'] = 5
+    mpl.rcParams['grid.linewidth'] = 0.25
+    mpl.rcParams['grid.alpha'] = 0.9 # 0.75
+    mpl.rcParams['grid.linestyle'] = '-'
+    mpl.rcParams['grid.color']   = 'gray'#'black'
+
+    # mpl.rcParams['axes.axisbelow'] = True
+    # mpl.rcParams.update({"axes.grid" : True, "grid.color": "gray"})
+    # mpl.rcParams["axes.grid"] = False
+    # fig = plt.figure()
+    # ax = fig.add_subplot(111, projection='3d')
+    # colors = cm.plasma(Types)
+    colors = cm.coolwarm(angles_inf)
+
+
+    width = 6.28
+    # height = width / 1.618
+    height = width / 2.5
+    # height = width
+    # fig, ax = plt.subplots()
+    fig,ax = plt.subplots(nrows=1,ncols=2,figsize=(width,height), sharey=True)
+    # ax = plt.axes((0.15,0.21 ,0.8,0.75))
+
+
+
+
+    # if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=Types.flat)
+    # if make_3D_plot: pnt3d=ax.scatter(alphas,betas,thetas,c=Types.flat)
+    #
+    # if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=angles.flat)
+    # if make_3D_plot: pnt3d=ax.scatter(alphas,betas,thetas,c=angles.flat)
+
+
+    # pnt=ax.scatter(alphas,thetas,c=angles,cmap='coolwarm')
+    # # ax.colorbar()
+    # CS = ax.contourf(alphas, thetas, angles,6, cmap=plt.cm.coolwarm, linestyle=dashed)
+    # # CS = ax.contour(alphas, thetas, angles,6, colors='k')
+    # ax.clabel(CS, inline=True, fontsize=7.5)
+    # # ax.set_title('Simplest default with labels')
+
+    # matplotlib.rcParams['contour.linestyles'] = 'dashed'
+    cmap=mpl.cm.coolwarm
+    # cmap = sns.color_palette("flare", as_cmap=True)
+    # cmap = sns.color_palette('species')
+    ### GET COLORS :
+    deep_colors = sns.color_palette("pastel")
+    print('deep_colors.as_hex():',deep_colors.as_hex())
+
+
+    diverging_colors = sns.color_palette("RdBu", 10)
+    print('diverging_colors.as_hex():',diverging_colors.as_hex())
+
+    pal = sns.color_palette("Blues")
+    pal = sns.color_palette()
+    print(pal.as_hex())
+
+    # flatui = ["#9b59b6", "#3498db", "#95a5a6", "#e74c3c", "#34495e", "#2ecc71"]
+    flatui = ["coral","white", "cornflowerblue"]
+    flatui = ["cornflowerblue", "coral"]
+    flatui = ['#4c72b0','white', '#c44e52']
+    flatui = ['#4c72b0','white', '#8de5a1']
+    flatui = ['#a1c9f4', '#ffb482','#ff9f9b'] #Test colors
+    flatui = ['#4c72b0','white', '#ffb482']
+    flatui = ['#4c72b0','white', '#ff9f9b']
+    flatui = ['#4c72b0','white', '#ab162a']
+
+    # flatui = ['#4c72b0','white', '#eb9172']
+    # flatui = ['#4c72b0','white', '#64b5cd']
+    cmap = mpl.colors.ListedColormap(sns.color_palette(flatui).as_hex())
+    cmap = mpl.colors.ListedColormap(sns.color_palette(flatui).as_hex())
+    cmap = mpl.colors.ListedColormap(sns.color_palette("RdBu_r", 10).as_hex())
+    cmap = mpl.colors.ListedColormap(sns.color_palette("coolwarm", 10).as_hex())  #Discrete CMAP
+    cmap = sns.color_palette("coolwarm", as_cmap=True)
+    # cmap = sns.color_palette("vlag", as_cmap=True)
+    # cmap = sns.color_palette("icefire", as_cmap=True)
+    # cmap = sns.color_palette("Spectral_r", as_cmap=True)
+    # cmap = sns.color_palette("flare_r", as_cmap=True)
+    # cmap = sns.diverging_palette(220, 20, as_cmap=True)
+    # cmap = sns.diverging_palette(250, 30, l=65, center="dark", as_cmap=True)
+    # cmap = mpl.colors.ListedColormap(sns.color_palette().as_hex())
+    # cmap = mpl.colors.LinearSegmentedColormap.from_list("", sns.color_palette(flatui).as_hex())
+
+    ### REVERSE COLORMAP :
+    # cmap = mpl.colors.ListedColormap(cmap.colors[::-1])
+    # cmap = cmap.reverse()
+
+    # cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","violet","red"])
+    # cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["cornflowerblue","coral"])
+
+    # plt.imshow(angles_0, extent=[-2, 1, 0, 1],origin='lower',
+                      # cmap=cmap, alpha=1.0)
+    divnorm=mcolors.TwoSlopeNorm(vmin=angles_0.min(), vcenter=(angles_0.max()+angles_0.min())/2, vmax=angles_0.max())
+    ax[0].imshow(angles_0.T, extent=[-2, 1, 0, 1], origin='lower', norm = divnorm,
+                      cmap=cmap, alpha=0.9, aspect=2.5)
+    # CS =  ax[0].contour(alphas, thetas, angles_0, colors='k',linewidths=(0.75), extent=(-2, 1, 0, 1), zorder=5)
+    levels = np.arange(0.0, 1.58, 1)
+    # angles_0 = gaussian_filter(angles_0, sigma=0.1)  # Try to smooth contour
+    # CS =  ax[0].contour(alphas, thetas, angles_0, levels, colors='k',linewidths=(0.75), extent=(-2, 1, 0, 1), zorder=5)
+    # CS =  ax[0].contour(alphas, thetas, angles_0, levels=[0.0], colors='black',linewidths=(0.75), extent=(-2, 1, 0, 1), zorder=5)
+    CS =  ax[0].contour(alphas, thetas, angles_0, levels=1, colors='black',linewidths=(0.5), extent=(-2, 1, 0, 1), zorder=5)
+    # ax[0].clabel(CS, inline=True, fontsize=8, colors='black')
+    # manual_locations = [(-0.75, 0.2),(0.5,0.6)]
+    # ax[0].clabel(CS, inline=True, fontsize=8, colors='black', manual=manual_locations)
+    # CS_0 = ax[0].contourf(alphas, thetas, angles_0, 10, cmap=plt.cm.coolwarm)
+    # CS_02 = ax[0].contour(CS_0, levels=CS_0.levels[::2], colors='black',inline=True, linewidths=(0.5,))
+
+
+
+    # ax.clabel(CS2, inline=True, fontsize=9, colors='black')
+    # ax.clabel(CS2, inline=True, inline_spacing=3, rightside_up=True, colors='k', fontsize=8)
+    # manual_locations = [
+    #     (-0.5, 0.3), (-0.7, 0.4), (-0.8, 0.5), (-0.9, 0.6), (-1,0.7)]
+    manual_locations = [
+        (-0.4, 0.2),(-0.6, 0.3), (-0.7, 0.4), (-0.8, 0.5), (-0.9, 0.6), (-1,0.7)]
+    # ax.clabel(CS2, inline=True, fontsize=6, colors='black', manual=manual_locations)
+    # ax.clabel(CS2, inline=True, fontsize=6, colors='black')
+    # ax.clabel(CS2, CS2.levels, inline=True, fontsize=10)
+    # ax.clabel(CS,  fontsize=5, colors='black')
+    # cbar = fig.colorbar(CS,label=r'angle $\alpha$', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+    # cbar = fig.colorbar(CS_0, ticks=[0, np.pi/2 ])
+    # cbar.ax.set_yticklabels(['$0$', r'$\pi/2$'])
+    # cbar.ax.set_title(r'angle $\alpha$')
+
+
+    divnorm=mcolors.TwoSlopeNorm(vmin=angles_inf.min(), vcenter=(angles_inf.max()+angles_inf.min())/2, vmax=angles_inf.max())
+
+    Im = ax[1].imshow(angles_inf.T, extent=[-2, 1, 0, 1], origin='lower', norm = divnorm,
+                      cmap=cmap, alpha=0.9, aspect=2.5)
+    # CS_1 =  ax[1].contour(alphas, thetas, angles_inf, colors='k',linewidths=(0.75), extent=(-2, 1, 0, 1), zorder=5)
+
+    levels = np.arange(0.25, 1.6, 0.25)
+    # levels = np.arange(0.1, 1.58, 0.25)
+
+    # angles_inf = gaussian_filter(angles_inf, sigma=2)  # Try to smooth contour
+
+    CS_1 =  ax[1].contour(alphas, thetas, angles_inf,levels, colors='black',linewidths=(0.5), extent=(-2, 1, 0, 1), zorder=5)
+    # ax[1].clabel(CS_1, inline=True, fontsize=8, colors='black')
+    # manual_locations = [
+    #     (-0.5, 0.15), (-0.7, 0.3), (-0.8, 0.45), (-0.9, 0.6), (-1,0.75)]
+    manual_locations = [
+        (-0.4, 0.1), (-0.6,0.30), (-0.7, 0.45), (-0.8, 0.6), (-0.9, 0.75), (-1,0.90)]
+    ax[1].clabel(CS_1, inline=True, fontsize=10, colors='black', manual=manual_locations)
+
+
+    # CS_1 = ax[1].contourf(alphas, thetas, angles_inf, 10, cmap=plt.cm.coolwarm)
+    # # CS = ax.contourf(alphas, thetas, angles, 10, cmap='RdBu')
+    # CS_12 = ax[1].contour(CS_1, levels=CS_1.levels[::2], colors='black',inline=True, linewidths=(0.5,))
+    # # ax.clabel(CS2, inline=True, fontsize=9, colors='black')
+    # # ax.clabel(CS2, inline=True, inline_spacing=3, rightside_up=True, colors='k', fontsize=8)
+    # # manual_locations = [
+    # #     (-0.5, 0.3), (-0.7, 0.4), (-0.8, 0.5), (-0.9, 0.6), (-1,0.7)]
+    # manual_locations = [
+    #     (-0.5, 0.15), (-0.7, 0.3), (-0.8, 0.45), (-0.9, 0.6), (-1,0.75)]
+    # # ax[1].clabel(CS_12, inline=True, fontsize=10, colors='black', manual=manual_locations)
+    # ax[1].clabel(CS_12, inline=True, fontsize=8, colors='black', manual=manual_locations)
+    # # ax[1].clabel(CS_12, inline=True, fontsize=8, colors='black')
+
+
+    axins1 = inset_axes(ax[1],
+                       width="5%",  # width = 5% of parent_bbox width
+                       height="100%",  # height : 50%
+                       loc='lower left',
+                       bbox_to_anchor=(1.05, 0., 1, 1),
+                       bbox_transform=ax[1].transAxes,
+                       borderpad=0,
+                       )
+
+    # ax.clabel(CS2, CS2.levels, inline=True, fontsize=10)
+    # ax.clabel(CS,  fontsize=5, colors='black')
+    # cbar = fig.colorbar(CS,label=r'angle $\alpha$', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+    # cbar = fig.colorbar(CS_1, ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+
+    # cbar_ax = fig.add_axes([0.85, 0.15, 0.05, 0.7])
+    cbar = fig.colorbar(Im, cax=axins1, ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+    # cbar = fig.colorbar(CS_1, cax=cbar_ax, shrink=0.2, location='right', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+    # cbar = fig.colorbar(CS_1,  ax=ax[:], shrink=0.8, location='right', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+
+    cbar.ax.set_yticklabels(['$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$'])
+    # cbar.ax.set_title(r'angle $\alpha$')
+    # cbar.ax.set_title(r'angle $\alpha$', fontsize=10)
+    cbar.ax.set_title(r'$\alpha$', fontsize=10)
+    # cbar=plt.colorbar(pnt3d)
+    # cbar.set_label("Values (units)")
+    # plt.axvline(x = 8, color = 'b', linestyle = ':', label='$q_1$')
+    # plt.axhline(y = 0.083333333, color = 'b', linestyle = ':', label='$q_1$')
+
+    ax[0].set_xlabel(r'$\theta_\rho$',fontsize=10)
+    # ax[0].yaxis.set_major_locator(MultipleLocator(0.1))
+    # ax[0].xaxis.set_major_locator(MultipleLocator(1))
+    ax[0].yaxis.set_major_locator(MultipleLocator(0.1))
+    ax[0].xaxis.set_major_locator(MultipleLocator(0.5))
+    ax[0].set_ylabel(r'$\theta$   ',fontsize=10, rotation=0, labelpad=10)
+    ax[0].tick_params(axis='x', labelsize=10 )
+    ax[0].tick_params(axis='y', labelsize=10)
+
+    ax[0].set_title(r"$0<\gamma\ll1$")
+
+    ax[1].set_xlabel(r'$\theta_\rho$',fontsize=10)
+    # ax.xaxis.set_minor_locator(MultipleLocator(0.5))
+    # ax[1].yaxis.set_major_locator(MultipleLocator(0.1))
+    # ax[1].xaxis.set_major_locator(MultipleLocator(1))
+    ax[1].yaxis.set_major_locator(MultipleLocator(0.1))
+    ax[1].xaxis.set_major_locator(MultipleLocator(0.5))
+    ax[1].tick_params(axis='x', labelsize=10 )
+    ax[1].tick_params(axis='y', labelsize=10 )
+
+    ax[1].set_title(r"$\gamma \gg 1$")
+    # ax.set_ylabel('beta')
+    # ax[1].set_ylabel(r'$\theta$   ',fontsize=10, rotation=0)
+    # if make_3D_plot: ax.set_zlabel('theta')
+    # plt.subplots_adjust(bottom=0.2)
+    # plt.subplots_adjust(wspace=0.22, hspace=0.1)
+    plt.subplots_adjust(hspace=0.15, wspace=0.1)
+    plt.subplots_adjust(bottom=0.2)
+    # fig.subplots_adjust(right=0.75)
+
+
+    # ax[0].grid( linestyle = '-', linewidth = 0.25, alpha=0.5, zorder=1)
+    # ax[1].grid( linestyle = '--', linewidth = 0.25, zorder=1)
+    # ax[1].set_axisbelow(True)
+    # ax[1].yaxis.grid(color='gray', linestyle='dashed')
+
+    # # Hide grid lines
+    # ax.grid(False)
+
+
+
+    fig.set_size_inches(width, height)
+    outputName = '2D-PhaseDiagram-Angle.pdf'
+    fig.savefig(outputName, dpi=300, format='pdf')
+    # fig.savefig('Plot-Contour.pdf')
+    plt.show()
+    # plt.savefig('common_labels.png', dpi=300)
+    # print('T:', T)
+    # print('Type 1 occured here:', np.where(T == 1))
+    # print('Type 2 occured here:', np.where(T == 2))
+
+
+    # print(alphas_)
+    # print(betas_)
+
+
+
+
+
+# ALTERNATIVE
+# colors = ("red", "green", "blue")
+# groups = ("Type 1", "Type2", "Type3")
+#
+# # Create plot
+# fig = plt.figure()
+# ax = fig.add_subplot(1, 1, 1)
+#
+# for data, color, group in zip(Types, colors, groups):
+#     # x, y = data
+#     ax.scatter(alphas, thetas, alpha=0.8, c=color, edgecolors='none', label=group)
+#
+# plt.title('Matplot scatter plot')
+# plt.legend(loc=2)
+# plt.show()

JNLS_plotScripts/PhaseDiagram_Contour_v2.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+from ClassifyMin import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+import matplotlib as mpl
+import seaborn as sns
+import matplotlib.colors as mcolors
+import time
+
+from scipy.ndimage.filters import gaussian_filter
+# from scipy import ndimage
+# print(sys.executable)
+
+# --------------------------------------------------------------------
+# START :
+# INPUT (Parameters):   alpha, beta, theta, gamma, mu1, rho1
+#
+# -Option 1 : (Case lambda = 0 => q12 = 0)
+#   compute q1,q2,b1,b2 from Formula
+#       Option 1.1 :
+#           set mu_gamma = 'q1' or 'q2' (extreme regimes: gamma \in {0,\infty})
+#       Option 1.2 :
+#           compute mu_gamma with 'Compute_MuGamma' (2D problem much faster then Cell-Problem)
+# -Option 2 :
+#   compute Q_hom & B_eff by running 'Cell-Problem'
+#
+# -> CLASSIFY ...
+#
+# OUTPUT: Minimizer G, angle , type, curvature
+# -----------------------------------------------------------------------
+#
+#
+# def GetMuGamma(beta,theta,gamma,mu1,rho1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset",
+#                 OutputFilePath = os.path.dirname(os.getcwd()) + "/outputs/outputMuGamma.txt" ):
+#     # ------------------------------------ get mu_gamma ------------------------------
+#     # ---Scenario 1.1: extreme regimes
+#     if gamma == '0':
+#         print('extreme regime: gamma = 0')
+#         mu_gamma = (1.0/6.0)*arithmeticMean(mu1, beta, theta) # = q2
+#         print("mu_gamma:", mu_gamma)
+#     elif gamma == 'infinity':
+#         print('extreme regime: gamma = infinity')
+#         mu_gamma = (1.0/6.0)*harmonicMean(mu1, beta, theta)   # = q1
+#         print("mu_gamma:", mu_gamma)
+#     else:
+#         # --- Scenario 1.2:  compute mu_gamma with 'Compute_MuGamma' (much faster than running full Cell-Problem)
+#         # print("Run computeMuGamma for Gamma = ", gamma)
+#         with open(InputFilePath, 'r') as file:
+#             filedata = file.read()
+#         filedata = re.sub('(?m)^gamma=.*','gamma='+str(gamma),filedata)
+#         # filedata = re.sub('(?m)^alpha=.*','alpha='+str(alpha),filedata)
+#         filedata = re.sub('(?m)^beta=.*','beta='+str(beta),filedata)
+#         filedata = re.sub('(?m)^theta=.*','theta='+str(theta),filedata)
+#         filedata = re.sub('(?m)^mu1=.*','mu1='+str(mu1),filedata)
+#         filedata = re.sub('(?m)^rho1=.*','rho1='+str(rho1),filedata)
+#         f = open(InputFilePath,'w')
+#         f.write(filedata)
+#         f.close()
+#         # --- Run Cell-Problem
+#
+#         # Check Time
+#         # t = time.time()
+#         # subprocess.run(['./build-cmake/src/Cell-Problem', './inputs/cellsolver.parset'],
+#         #                                      capture_output=True, text=True)
+#         # --- Run Cell-Problem_muGama   -> faster
+#         # subprocess.run(['./build-cmake/src/Cell-Problem_muGamma', './inputs/cellsolver.parset'],
+#         #                                              capture_output=True, text=True)
+#         # --- Run Compute_muGamma (2D Problem much much faster)
+#
+#         subprocess.run(['./build-cmake/src/Compute_MuGamma', './inputs/computeMuGamma.parset'],
+#                                                              capture_output=True, text=True)
+#         # print('elapsed time:', time.time() - t)
+#
+#         #Extract mu_gamma from Output-File                                           TODO: GENERALIZED THIS FOR QUANTITIES OF INTEREST
+#         with open(OutputFilePath, 'r') as file:
+#             output = file.read()
+#         tmp = re.search(r'(?m)^mu_gamma=.*',output).group()                           # Not necessary for Intention of Program t output Minimizer etc.....
+#         s = re.findall(r"[-+]?\d*\.\d+|\d+", tmp)
+#         mu_gamma = float(s[0])
+#         # print("mu_gamma:", mu_gammaValue)
+#     # --------------------------------------------------------------------------------------
+#     return mu_gamma
+#
+
+
+
+# ----------- SETUP PATHS
+# InputFile  = "/inputs/cellsolver.parset"
+# OutputFile = "/outputs/output.txt"
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+
+# -------------------------- Input Parameters --------------------
+# mu1 = 10.0               # TODO : here must be the same values as in the Parset for computeMuGamma
+mu1 = 1.0
+rho1 = 1.0
+alpha = 2.0
+beta = 2.0
+# beta = 5.0
+theta = 1.0/4.0
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+gamma = '0'
+# gamma = 'infinity'
+# gamma = 0.5
+# gamma = 0.25
+# gamma = 1.0
+
+# gamma = 5.0
+
+#added
+# lambda1 = 10.0
+lambda1 = 0.0
+
+#Test:
+# rho1 = -1.0
+
+
+
+print('---- Input parameters: -----')
+print('mu1: ', mu1)
+print('rho1: ', rho1)
+print('alpha: ', alpha)
+print('beta: ', beta)
+print('theta: ', theta)
+print('gamma:', gamma)
+
+print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+
+#
+# gamma_min = 0.5
+# gamma_max = 1.0
+#
+# # gamma_min = 1
+# # gamma_max = 1
+# Gamma_Values = np.linspace(gamma_min, gamma_max, num=3)
+# # #
+# # # Gamma_Values = np.linspace(gamma_min, gamma_max, num=13)    # TODO variable Input Parameters...alpha,beta...
+# print('(Input) Gamma_Values:', Gamma_Values)
+
+print('type of gamma:', type(gamma))
+# # #
+Gamma_Values = ['0', 'infinity']
+# Gamma_Values = ['infinity']
+# Gamma_Values = ['0']
+print('(Input) Gamma_Values:', Gamma_Values)
+
+for gamma in Gamma_Values:
+
+    print('Run for gamma = ', gamma)
+    print('type of gamma:', type(gamma))
+        # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1,InputFilePath)
+        # # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1)
+        # print('Test MuGamma:', muGamma)
+
+        # ------- Options --------
+        # print_Cases = True
+        # print_Output = True
+
+                            #TODO
+    # generalCase = True #Read Output from Cell-Problem instead of using Lemma1.4 (special case)
+    generalCase = False
+
+    # make_3D_plot = True
+    # make_3D_PhaseDiagram = True
+    make_2D_plot = False
+    make_2D_PhaseDiagram = False
+    make_3D_plot = False
+    make_3D_PhaseDiagram = False
+    make_2D_plot = True
+    make_2D_PhaseDiagram = True
+    #
+
+    # --- Define effective quantities: q1, q2 , q3 = mu_gamma, q12 ---
+    # q1 = harmonicMean(mu1, beta, theta)
+    # q2 = arithmeticMean(mu1, beta, theta)
+    # --- Set q12
+    # q12 = 0.0  # (analytical example)              # TEST / TODO read from Cell-Output
+
+
+
+
+
+    # b1 = prestrain_b1(rho1, beta, alpha, theta)
+    # b2 = prestrain_b2(rho1, beta, alpha, theta)
+    #
+    # print('---- Input parameters: -----')
+    # print('mu1: ', mu1)
+    # print('rho1: ', rho1)
+    # print('alpha: ', alpha)
+    # print('beta: ', beta)
+    # print('theta: ', theta)
+    # print("q1: ", q1)
+    # print("q2: ", q2)
+    # print("mu_gamma: ", mu_gamma)
+    # print("q12: ", q12)
+    # print("b1: ", b1)
+    # print("b2: ", b2)
+    # print('----------------------------')
+    # print("machine epsilon", sys.float_info.epsilon)
+
+    # G, angle, type, kappa = classifyMin(q1, q2, mu_gamma, q12,  b1, b2, print_Cases, print_Output)
+    # Test = f(1,2 ,q1,q2,mu_gamma,q12,b1,b2)
+    # print("Test", Test)
+
+    # ---------------------- MAKE PLOT / Write to VTK------------------------------------------------------------------------------
+
+    # SamplePoints_3D = 10 # Number of sample points in each direction
+    # SamplePoints_2D = 10 # Number of sample points in each direction
+    SamplePoints_3D = 300 # Number of sample points in each direction
+    # SamplePoints_3D = 150 # Number of sample points in each direction
+    # SamplePoints_3D = 100 # Number of sample points in each direction
+    # SamplePoints_3D = 200 # Number of sample points in each direction
+    # SamplePoints_3D = 400 # Number of sample points in each direction
+    # SamplePoints_2D = 7500 # Number of sample points in each direction
+    # SamplePoints_2D = 4000 # 4000 # Number of sample points in each direction
+    SamplePoints_2D = 400 # 4000  # Number of sample points in each direction
+    # SamplePoints_2D = 500 # 4000    # Number of sample points in each direction
+    # SamplePoints_2D = 100 # 4000  # Number of sample points in each direction
+    # SamplePoints_2D = 2000 # 4000 # Number of sample points in each direction
+    # SamplePoints_2D = 1000   # 4000 # Number of sample points in each direction
+    # SamplePoints_2D = 1500 # 4000 # Number of sa
+
+    if make_3D_PhaseDiagram:
+        alphas_ = np.linspace(-20, 20, SamplePoints_3D)
+        # alphas_ = np.linspace(-10, 10, SamplePoints_3D)
+
+        # betas_  = np.linspace(0.01,40.01,SamplePoints_3D) # Full Range
+        # betas_  = np.linspace(0.01,20.01,SamplePoints_3D) # FULL Range
+
+
+
+        # betas_  = np.linspace(0.01,0.99,SamplePoints_3D)  # weird part
+        betas_  = np.linspace(1.01,40.01,SamplePoints_3D)     #TEST !!!!!  For Beta <1 weird tings happen...
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_3D)
+
+
+        # TEST
+        # alphas_ = np.linspace(-2, 2, SamplePoints_3D)
+        # betas_  = np.linspace(1.01,10.01,SamplePoints_3D)
+        # print('betas:', betas_)
+
+        # TEST :
+        # alphas_ = np.linspace(-40, 40, SamplePoints_3D)
+        # betas_  = np.linspace(0.01,80.01,SamplePoints_3D) # Full Range
+
+        # print('type of alphas', type(alphas_))
+        # print('Test:', type(np.array([mu_gamma])) )
+        alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+        classifyMin_anaVec = np.vectorize(classifyMin_ana)
+
+        # Get MuGamma values ...
+        GetMuGammaVec = np.vectorize(GetMuGamma)
+        muGammas = GetMuGammaVec(betas, thetas, gamma, mu1, rho1)
+        # Classify Minimizers....
+        G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1)   # Sets q12 to zero!!!
+
+        # G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1, True, True)
+        # print('size of G:', G.shape)
+        # print('G:', G)
+
+        # Option to print angles
+        # print('angles:', angles)
+
+
+        # Out = classifyMin_anaVec(alphas,betas,thetas)
+        # T = Out[2]
+        # --- Write to VTK
+
+        GammaString = str(gamma)
+        VTKOutputName = "outputs/PhaseDiagram3D" + "Gamma" + GammaString
+        gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        print('Written to VTK-File:', VTKOutputName )
+
+    if make_2D_PhaseDiagram:
+        # alphas_ = np.linspace(-20, 20, SamplePoints_2D)
+        # alphas_ = np.linspace(0, 1, SamplePoints_2D)
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        alphas_ = np.linspace(-5, 5, SamplePoints_2D)
+        # alphas_ = np.linspace(-5, 15, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.25,SamplePoints_2D)
+
+
+        # good range:
+        # alphas_ = np.linspace(9, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.075,0.14,SamplePoints_2D)
+
+        # range used:
+        # alphas_ = np.linspace(8, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.16,SamplePoints_2D)
+
+            # alphas_ = np.linspace(8, 12, SamplePoints_2D)
+            # thetas_ = np.linspace(0.05,0.2,SamplePoints_2D)
+        # betas_  = np.linspace(0.01,40.01,1)
+        #fix to one value:
+        betas_ = 2.0;
+        # betas_ = 10.0;
+        # betas_ = 5.0;
+        # betas_ = 0.5;
+
+
+        #intermediate Values
+        alphas_ = np.linspace(-2, 1, SamplePoints_2D)
+        # alphas_ = np.linspace(-1.5, 1, SamplePoints_2D)
+        # thetas_ = np.linspace(0.4,0.6,SamplePoints_2D)
+        # betas_ = 10.0;
+
+        # TEST
+        # alphas_ = np.linspace(-8, 8, SamplePoints_2D)
+        # thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        # betas_ = 1.0; #TEST Problem: disvison by zero if alpha = 9, theta = 0.1 !
+        # betas_ = 0.9;
+        # betas_ = 0.5;  #TEST!!!
+        # alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+        betas = betas_
+        alphas, thetas = np.meshgrid(alphas_, thetas_, indexing='ij')
+
+        if generalCase:
+            classifyMin_matVec = np.vectorize(classifyMin_mat)
+            GetCellOutputVec = np.vectorize(GetCellOutput, otypes=[np.ndarray, np.ndarray])
+            Q, B = GetCellOutputVec(alphas,betas,thetas,gamma,mu1,rho1,lambda1, InputFilePath ,OutputFilePath )
+
+
+            # print('type of Q:', type(Q))
+            # print('Q:', Q)
+            G, angles, Types, curvature = classifyMin_matVec(Q,B)
+
+        else:
+            classifyMin_anaVec = np.vectorize(classifyMin_ana)
+            GetMuGammaVec = np.vectorize(GetMuGamma)
+            # muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+            # G, angles, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+            muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+
+            if gamma == '0':
+                G, angles_0, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+            if gamma == 'infinity':
+                G, angles_inf, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+
+            # print('size of G:', G.shape)
+            # print('G:', G)
+            # print('Types:', Types)
+            # Out = classifyMin_anaVec(alphas,betas,thetas)
+            # T = Out[2]
+            # --- Write to VTK
+            # VTKOutputName = + path + "./PhaseDiagram2DNEW"
+
+        # print('angles:',angles)
+        # GammaString = str(gamma)
+        # VTKOutputName = "outputs/PhaseDiagram2D" + "Gamma_" + GammaString
+        # gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        # print('Written to VTK-File:', VTKOutputName )
+
+
+# --- Make 3D Scatter plot
+if(make_3D_plot or make_2D_plot):
+
+
+    # Styling
+    plt.style.use("seaborn-darkgrid")
+    plt.style.use("seaborn-whitegrid")
+    plt.style.use("seaborn")
+    # plt.style.use("seaborn-paper")
+    # plt.style.use('ggplot')
+    # plt.rcParams["font.family"] = "Avenir"
+    # plt.rcParams["font.size"] = 16
+
+    # plt.style.use("seaborn-darkgrid")
+    mpl.rcParams['text.usetex'] = True
+    mpl.rcParams["font.family"] = "serif"
+    mpl.rcParams["font.size"] = "10"
+    # mpl.rcParams['xtick.labelsize'] = 16mpl.rcParams['xtick.major.size'] = 2.5
+    # mpl.rcParams['xtick.bottom'] = True
+    # mpl.rcParams['ticks'] = True
+    mpl.rcParams['xtick.bottom'] = True
+    mpl.rcParams['xtick.major.size'] = 3
+    mpl.rcParams['xtick.minor.size'] = 1.5
+    mpl.rcParams['xtick.major.width'] = 0.75
+    mpl.rcParams['ytick.left'] = True
+    mpl.rcParams['ytick.major.size'] = 3
+    mpl.rcParams['ytick.minor.size'] = 1.5
+    mpl.rcParams['ytick.major.width'] = 0.75
+
+    mpl.rcParams.update({'font.size': 10})
+
+    ### ADJUST GRID:
+    mpl.rcParams['axes.labelpad'] = 5
+    mpl.rcParams['grid.linewidth'] = 0.25
+    mpl.rcParams['grid.alpha'] = 0.9 # 0.75
+    mpl.rcParams['grid.linestyle'] = '-'
+    mpl.rcParams['grid.color']   = 'gray'#'black'
+
+    # mpl.rcParams['axes.axisbelow'] = True
+    # mpl.rcParams.update({"axes.grid" : True, "grid.color": "gray"})
+    # mpl.rcParams["axes.grid"] = False
+    # fig = plt.figure()
+    # ax = fig.add_subplot(111, projection='3d')
+    # colors = cm.plasma(Types)
+    colors = cm.coolwarm(angles_inf)
+
+
+    width = 6.28*0.5
+    # height = width / 1.618
+    # height = width / 2.5
+    height = width
+    # fig, ax = plt.subplots()
+    # fig,ax = plt.subplots(nrows=1,ncols=2,figsize=(width,height), sharey=True)
+    fig,ax = plt.subplots(nrows=1,ncols=1,figsize=(width,height))
+    # ax = plt.axes((0.15,0.21 ,0.8,0.75))
+
+
+
+
+    # if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=Types.flat)
+    # if make_3D_plot: pnt3d=ax.scatter(alphas,betas,thetas,c=Types.flat)
+    #
+    # if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=angles.flat)
+    # if make_3D_plot: pnt3d=ax.scatter(alphas,betas,thetas,c=angles.flat)
+
+
+    # pnt=ax.scatter(alphas,thetas,c=angles,cmap='coolwarm')
+    # # ax.colorbar()
+    # CS = ax.contourf(alphas, thetas, angles,6, cmap=plt.cm.coolwarm, linestyle=dashed)
+    # # CS = ax.contour(alphas, thetas, angles,6, colors='k')
+    # ax.clabel(CS, inline=True, fontsize=7.5)
+    # # ax.set_title('Simplest default with labels')
+
+    # matplotlib.rcParams['contour.linestyles'] = 'dashed'
+    cmap=mpl.cm.coolwarm
+    # cmap = sns.color_palette("flare", as_cmap=True)
+    # cmap = sns.color_palette('species')
+    ### GET COLORS :
+    deep_colors = sns.color_palette("pastel")
+    print('deep_colors.as_hex():',deep_colors.as_hex())
+
+
+    diverging_colors = sns.color_palette("RdBu", 10)
+    print('diverging_colors.as_hex():',diverging_colors.as_hex())
+
+    pal = sns.color_palette("Blues")
+    pal = sns.color_palette()
+    print(pal.as_hex())
+
+    # flatui = ["#9b59b6", "#3498db", "#95a5a6", "#e74c3c", "#34495e", "#2ecc71"]
+    flatui = ["coral","white", "cornflowerblue"]
+    flatui = ["cornflowerblue", "coral"]
+    flatui = ['#4c72b0','white', '#c44e52']
+    flatui = ['#4c72b0','white', '#8de5a1']
+    flatui = ['#a1c9f4', '#ffb482','#ff9f9b'] #Test colors
+    flatui = ['#4c72b0','white', '#ffb482']
+    flatui = ['#4c72b0','white', '#ff9f9b']
+    flatui = ['#4c72b0','white', '#ab162a']
+
+    # flatui = ['#4c72b0','white', '#eb9172']
+    # flatui = ['#4c72b0','white', '#64b5cd']
+    cmap = mpl.colors.ListedColormap(sns.color_palette(flatui).as_hex())
+    cmap = mpl.colors.ListedColormap(sns.color_palette(flatui).as_hex())
+    cmap = mpl.colors.ListedColormap(sns.color_palette("RdBu_r", 10).as_hex())
+    cmap = mpl.colors.ListedColormap(sns.color_palette("coolwarm", 10).as_hex())  #Discrete CMAP
+    cmap = sns.color_palette("coolwarm", as_cmap=True)
+    # cmap = sns.color_palette("vlag", as_cmap=True)
+    # cmap = sns.color_palette("icefire", as_cmap=True)
+    # cmap = sns.color_palette("Spectral_r", as_cmap=True)
+    # cmap = sns.color_palette("flare_r", as_cmap=True)
+    # cmap = sns.diverging_palette(220, 20, as_cmap=True)
+    # cmap = sns.diverging_palette(250, 30, l=65, center="dark", as_cmap=True)
+    # cmap = mpl.colors.ListedColormap(sns.color_palette().as_hex())
+    # cmap = mpl.colors.LinearSegmentedColormap.from_list("", sns.color_palette(flatui).as_hex())
+
+
+    # choose PLOT
+    gamma = '0'
+    # gamma = 'infinity'
+
+
+    ### REVERSE COLORMAP :
+    # cmap = mpl.colors.ListedColormap(cmap.colors[::-1])
+    # cmap = cmap.reverse()
+
+    # cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["blue","violet","red"])
+    # cmap = mpl.colors.LinearSegmentedColormap.from_list("", ["cornflowerblue","coral"])
+
+    # plt.imshow(angles_0, extent=[-2, 1, 0, 1],origin='lower',
+                      # cmap=cmap, alpha=1.0)
+    if gamma == '0':
+        divnorm=mcolors.TwoSlopeNorm(vmin=angles_0.min(), vcenter=(angles_0.max()+angles_0.min())/2, vmax=angles_0.max())
+        ax.imshow(angles_0.T, extent=[-2, 1, 0, 1], origin='lower', norm = divnorm,
+                          cmap=cmap, alpha=0.9, aspect=2.5)
+        levels = np.arange(0.0, 1.58, 1)
+        CS =  ax.contour(alphas, thetas, angles_0, levels=1, colors='black',linewidths=(0.5), extent=(-2, 1, 0, 1), zorder=5)
+
+
+
+    # manual_locations = [
+    #     (-0.4, 0.2),(-0.6, 0.3), (-0.7, 0.4), (-0.8, 0.5), (-0.9, 0.6), (-1,0.7)]
+    # ax.clabel(CS2, inline=True, fontsize=6, colors='black', manual=manual_locations)
+    # ax.clabel(CS2, inline=True, fontsize=6, colors='black')
+    # ax.clabel(CS2, CS2.levels, inline=True, fontsize=10)
+    # ax.clabel(CS,  fontsize=5, colors='black')
+    # cbar = fig.colorbar(CS,label=r'angle $\alpha$', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+    # cbar = fig.colorbar(CS_0, ticks=[0, np.pi/2 ])
+    # cbar.ax.set_yticklabels(['$0$', r'$\pi/2$'])
+    # cbar.ax.set_title(r'angle $\alpha$')
+
+    if gamma == 'infinity':
+        divnorm=mcolors.TwoSlopeNorm(vmin=angles_inf.min(), vcenter=(angles_inf.max()+angles_inf.min())/2, vmax=angles_inf.max())
+        Im = ax.imshow(angles_inf.T, extent=[-2, 1, 0, 1], origin='lower', norm = divnorm,
+                          cmap=cmap, alpha=0.9, aspect=2.5)
+        levels = np.arange(0.25, 1.6, 0.25)
+        CS_1 =  ax.contour(alphas, thetas, angles_inf,levels, colors='black',linewidths=(0.5), extent=(-2, 1, 0, 1), zorder=5)
+        manual_locations = [
+            (-0.4, 0.1), (-0.6,0.30), (-0.7, 0.45), (-0.8, 0.6), (-0.9, 0.75), (-1,0.90)]
+        ax.clabel(CS_1, inline=True, fontsize=10, colors='black', manual=manual_locations)
+        axins1 = inset_axes(ax,
+                           width="5%",  # width = 5% of parent_bbox width
+                           height="100%",  # height : 50%
+                           loc='lower left',
+                           bbox_to_anchor=(1.05, 0., 1, 1),
+                           bbox_transform=ax.transAxes,
+                           borderpad=0,
+                           )
+        cbar = fig.colorbar(Im, cax=axins1, ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+        cbar.ax.set_yticklabels(['$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$'])
+        cbar.ax.set_title(r'angle $\alpha$', fontsize=10)
+
+
+
+    if gamma == '0':
+        ax.set_xlabel(r'$\theta_\rho$',fontsize=10)
+        # ax.yaxis.set_major_locator(MultipleLocator(0.1))
+        # ax.xaxis.set_major_locator(MultipleLocator(1))
+        ax.yaxis.set_major_locator(MultipleLocator(0.1))
+        ax.xaxis.set_major_locator(MultipleLocator(0.5))
+        ax.set_ylabel(r'$\theta$   ',fontsize=10, rotation=0, labelpad=10)
+        ax.tick_params(axis='x', labelsize=10 )
+        ax.tick_params(axis='y', labelsize=10)
+        plt.subplots_adjust(left = 0.2)
+
+
+    if gamma == 'infinity':
+        ax.set_xlabel(r'$\theta_\rho$',fontsize=10)
+        # ax.xaxis.set_minor_locator(MultipleLocator(0.5))
+        # ax.yaxis.set_major_locator(MultipleLocator(0.1))
+        # ax.xaxis.set_major_locator(MultipleLocator(1))
+        ax.yaxis.set_major_locator(MultipleLocator(0.1))
+        ax.xaxis.set_major_locator(MultipleLocator(0.5))
+        ax.tick_params(axis='x', labelsize=10 )
+        # ax.tick_params(axis='y', labelsize=10 )
+        ax.yaxis.set_ticklabels([])
+        plt.subplots_adjust(right= 0.75)
+        plt.subplots_adjust(left = 0.05)
+    # ax.set_ylabel('beta')
+    # ax.set_ylabel(r'$\theta$   ',fontsize=10, rotation=0)
+    # if make_3D_plot: ax.set_zlabel('theta')
+    # plt.subplots_adjust(bottom=0.2)
+    # plt.subplots_adjust(wspace=0.22, hspace=0.1)
+    # plt.subplots_adjust(hspace=0.15, wspace=0.1)
+    # plt.subplots_adjust(right= 0.75)
+    plt.subplots_adjust(bottom=0.2)
+    # fig.subplots_adjust(right=0.75)
+
+
+    # ax.grid( linestyle = '-', linewidth = 0.25, alpha=0.5, zorder=1)
+    # ax.grid( linestyle = '--', linewidth = 0.25, zorder=1)
+    # ax.set_axisbelow(True)
+    # ax.yaxis.grid(color='gray', linestyle='dashed')
+
+    # # Hide grid lines
+    # ax.grid(False)
+
+
+
+    fig.set_size_inches(width, height)
+    # outputName = '2D-PhaseDiagram-Angle.pdf'
+    outputName = '2D-PhaseDiagram-Angle_' + gamma + '.pdf'
+    fig.savefig(outputName, dpi=300, format='pdf')
+    # fig.savefig('Plot-Contour.pdf')
+    plt.show()
+    # plt.savefig('common_labels.png', dpi=300)
+    # print('T:', T)
+    # print('Type 1 occured here:', np.where(T == 1))
+    # print('Type 2 occured here:', np.where(T == 2))
+
+
+    # print(alphas_)
+    # print(betas_)
+
+
+
+
+
+# ALTERNATIVE
+# colors = ("red", "green", "blue")
+# groups = ("Type 1", "Type2", "Type3")
+#
+# # Create plot
+# fig = plt.figure()
+# ax = fig.add_subplot(1, 1, 1)
+#
+# for data, color, group in zip(Types, colors, groups):
+#     # x, y = data
+#     ax.scatter(alphas, thetas, alpha=0.8, c=color, edgecolors='none', label=group)
+#
+# plt.title('Matplot scatter plot')
+# plt.legend(loc=2)
+# plt.show()

JNLS_plotScripts/PhaseDiagram_CurvContourSubPlots.py

+import numpy as np
+import matplotlib.pyplot as plt
+import sympy as sym
+import math
+import os
+import subprocess
+import fileinput
+import re
+import matlab.engine
+import sys
+from ClassifyMin import *
+from HelperFunctions import *
+# from CellScript import *
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.cm as cm
+from vtk.util import numpy_support
+from pyevtk.hl import gridToVTK
+from matplotlib.ticker import MultipleLocator,FormatStrFormatter,MaxNLocator
+
+from mpl_toolkits.axes_grid1.inset_locator import inset_axes
+
+import time
+# print(sys.executable)
+
+# --------------------------------------------------------------------
+# START :
+# INPUT (Parameters):   alpha, beta, theta, gamma, mu1, rho1
+#
+# -Option 1 : (Case lambda = 0 => q12 = 0)
+#   compute q1,q2,b1,b2 from Formula
+#       Option 1.1 :
+#           set mu_gamma = 'q1' or 'q2' (extreme regimes: gamma \in {0,\infty})
+#       Option 1.2 :
+#           compute mu_gamma with 'Compute_MuGamma' (2D problem much faster then Cell-Problem)
+# -Option 2 :
+#   compute Q_hom & B_eff by running 'Cell-Problem'
+#
+# -> CLASSIFY ...
+#
+# OUTPUT: Minimizer G, angle , type, curvature
+# -----------------------------------------------------------------------
+#
+#
+# def GetMuGamma(beta,theta,gamma,mu1,rho1, InputFilePath = os.path.dirname(os.getcwd()) +"/inputs/computeMuGamma.parset",
+#                 OutputFilePath = os.path.dirname(os.getcwd()) + "/outputs/outputMuGamma.txt" ):
+#     # ------------------------------------ get mu_gamma ------------------------------
+#     # ---Scenario 1.1: extreme regimes
+#     if gamma == '0':
+#         print('extreme regime: gamma = 0')
+#         mu_gamma = (1.0/6.0)*arithmeticMean(mu1, beta, theta) # = q2
+#         print("mu_gamma:", mu_gamma)
+#     elif gamma == 'infinity':
+#         print('extreme regime: gamma = infinity')
+#         mu_gamma = (1.0/6.0)*harmonicMean(mu1, beta, theta)   # = q1
+#         print("mu_gamma:", mu_gamma)
+#     else:
+#         # --- Scenario 1.2:  compute mu_gamma with 'Compute_MuGamma' (much faster than running full Cell-Problem)
+#         # print("Run computeMuGamma for Gamma = ", gamma)
+#         with open(InputFilePath, 'r') as file:
+#             filedata = file.read()
+#         filedata = re.sub('(?m)^gamma=.*','gamma='+str(gamma),filedata)
+#         # filedata = re.sub('(?m)^alpha=.*','alpha='+str(alpha),filedata)
+#         filedata = re.sub('(?m)^beta=.*','beta='+str(beta),filedata)
+#         filedata = re.sub('(?m)^theta=.*','theta='+str(theta),filedata)
+#         filedata = re.sub('(?m)^mu1=.*','mu1='+str(mu1),filedata)
+#         filedata = re.sub('(?m)^rho1=.*','rho1='+str(rho1),filedata)
+#         f = open(InputFilePath,'w')
+#         f.write(filedata)
+#         f.close()
+#         # --- Run Cell-Problem
+#
+#         # Check Time
+#         # t = time.time()
+#         # subprocess.run(['./build-cmake/src/Cell-Problem', './inputs/cellsolver.parset'],
+#         #                                      capture_output=True, text=True)
+#         # --- Run Cell-Problem_muGama   -> faster
+#         # subprocess.run(['./build-cmake/src/Cell-Problem_muGamma', './inputs/cellsolver.parset'],
+#         #                                              capture_output=True, text=True)
+#         # --- Run Compute_muGamma (2D Problem much much faster)
+#
+#         subprocess.run(['./build-cmake/src/Compute_MuGamma', './inputs/computeMuGamma.parset'],
+#                                                              capture_output=True, text=True)
+#         # print('elapsed time:', time.time() - t)
+#
+#         #Extract mu_gamma from Output-File                                           TODO: GENERALIZED THIS FOR QUANTITIES OF INTEREST
+#         with open(OutputFilePath, 'r') as file:
+#             output = file.read()
+#         tmp = re.search(r'(?m)^mu_gamma=.*',output).group()                           # Not necessary for Intention of Program t output Minimizer etc.....
+#         s = re.findall(r"[-+]?\d*\.\d+|\d+", tmp)
+#         mu_gamma = float(s[0])
+#         # print("mu_gamma:", mu_gammaValue)
+#     # --------------------------------------------------------------------------------------
+#     return mu_gamma
+#
+
+
+
+# ----------- SETUP PATHS
+# InputFile  = "/inputs/cellsolver.parset"
+# OutputFile = "/outputs/output.txt"
+InputFile  = "/inputs/computeMuGamma.parset"
+OutputFile = "/outputs/outputMuGamma.txt"
+# --------- Run  from src folder:
+path_parent = os.path.dirname(os.getcwd())
+os.chdir(path_parent)
+path = os.getcwd()
+print(path)
+InputFilePath = os.getcwd()+InputFile
+OutputFilePath = os.getcwd()+OutputFile
+print("InputFilepath: ", InputFilePath)
+print("OutputFilepath: ", OutputFilePath)
+print("Path: ", path)
+
+
+# -------------------------- Input Parameters --------------------
+# mu1 = 10.0               # TODO : here must be the same values as in the Parset for computeMuGamma
+mu1 = 1.0
+rho1 = 1.0
+alpha = 2.0
+beta = 2.0
+# beta = 5.0
+theta = 1.0/4.0
+#set gamma either to 1. '0' 2. 'infinity' or 3. a numerical positive value
+gamma = '0'
+# gamma = 'infinity'
+# gamma = 0.5
+# gamma = 0.25
+# gamma = 1.0
+
+# gamma = 5.0
+
+#added
+# lambda1 = 10.0
+lambda1 = 0.0
+
+#Test:
+# rho1 = -1.0
+
+
+
+print('---- Input parameters: -----')
+print('mu1: ', mu1)
+print('rho1: ', rho1)
+print('alpha: ', alpha)
+print('beta: ', beta)
+print('theta: ', theta)
+print('gamma:', gamma)
+
+print('lambda1: ', lambda1)
+print('----------------------------')
+# ----------------------------------------------------------------
+
+#
+# gamma_min = 0.5
+# gamma_max = 1.0
+#
+# # gamma_min = 1
+# # gamma_max = 1
+# Gamma_Values = np.linspace(gamma_min, gamma_max, num=3)
+# # #
+# # # Gamma_Values = np.linspace(gamma_min, gamma_max, num=13)    # TODO variable Input Parameters...alpha,beta...
+# print('(Input) Gamma_Values:', Gamma_Values)
+
+print('type of gamma:', type(gamma))
+# # #
+Gamma_Values = ['0', 'infinity']
+# Gamma_Values = ['infinity']
+# Gamma_Values = ['0']
+print('(Input) Gamma_Values:', Gamma_Values)
+
+for gamma in Gamma_Values:
+
+    print('Run for gamma = ', gamma)
+    print('type of gamma:', type(gamma))
+        # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1,InputFilePath)
+        # # muGamma = GetMuGamma(beta,theta,gamma,mu1,rho1)
+        # print('Test MuGamma:', muGamma)
+
+        # ------- Options --------
+        # print_Cases = True
+        # print_Output = True
+
+                            #TODO
+    # generalCase = True #Read Output from Cell-Problem instead of using Lemma1.4 (special case)
+    generalCase = False
+
+    # make_3D_plot = True
+    # make_3D_PhaseDiagram = True
+    make_2D_plot = False
+    make_2D_PhaseDiagram = False
+    make_3D_plot = False
+    make_3D_PhaseDiagram = False
+    make_2D_plot = True
+    make_2D_PhaseDiagram = True
+    #
+
+    # --- Define effective quantities: q1, q2 , q3 = mu_gamma, q12 ---
+    # q1 = harmonicMean(mu1, beta, theta)
+    # q2 = arithmeticMean(mu1, beta, theta)
+    # --- Set q12
+    # q12 = 0.0  # (analytical example)              # TEST / TODO read from Cell-Output
+
+
+
+
+
+    # b1 = prestrain_b1(rho1, beta, alpha, theta)
+    # b2 = prestrain_b2(rho1, beta, alpha, theta)
+    #
+    # print('---- Input parameters: -----')
+    # print('mu1: ', mu1)
+    # print('rho1: ', rho1)
+    # print('alpha: ', alpha)
+    # print('beta: ', beta)
+    # print('theta: ', theta)
+    # print("q1: ", q1)
+    # print("q2: ", q2)
+    # print("mu_gamma: ", mu_gamma)
+    # print("q12: ", q12)
+    # print("b1: ", b1)
+    # print("b2: ", b2)
+    # print('----------------------------')
+    # print("machine epsilon", sys.float_info.epsilon)
+
+    # G, angle, type, kappa = classifyMin(q1, q2, mu_gamma, q12,  b1, b2, print_Cases, print_Output)
+    # Test = f(1,2 ,q1,q2,mu_gamma,q12,b1,b2)
+    # print("Test", Test)
+
+    # ---------------------- MAKE PLOT / Write to VTK------------------------------------------------------------------------------
+
+    # SamplePoints_3D = 10 # Number of sample points in each direction
+    # SamplePoints_2D = 10 # Number of sample points in each direction
+    SamplePoints_3D = 300 # Number of sample points in each direction
+    # SamplePoints_3D = 150 # Number of sample points in each direction
+    # SamplePoints_3D = 100 # Number of sample points in each direction
+    # SamplePoints_3D = 200 # Number of sample points in each direction
+    # SamplePoints_3D = 400 # Number of sample points in each direction
+    # SamplePoints_2D = 7500 # Number of sample points in each direction
+    # SamplePoints_2D = 4000 # 4000 # Number of sample points in each direction
+    # SamplePoints_2D = 400 # 4000  # Number of sample points in each direction
+    SamplePoints_2D = 500 # 4000    # Number of sample points in each direction
+    # SamplePoints_2D = 100 # 4000  # Number of sample points in each direction
+    # SamplePoints_2D = 2000 # 4000 # Number of sample points in each direction
+    # SamplePoints_2D = 1000   # 4000 # Number of sample points in each direction
+
+    if make_3D_PhaseDiagram:
+        alphas_ = np.linspace(-20, 20, SamplePoints_3D)
+        # alphas_ = np.linspace(-10, 10, SamplePoints_3D)
+
+        # betas_  = np.linspace(0.01,40.01,SamplePoints_3D) # Full Range
+        # betas_  = np.linspace(0.01,20.01,SamplePoints_3D) # FULL Range
+
+
+
+        # betas_  = np.linspace(0.01,0.99,SamplePoints_3D)  # weird part
+        betas_  = np.linspace(1.01,40.01,SamplePoints_3D)     #TEST !!!!!  For Beta <1 weird tings happen...
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_3D)
+
+
+        # TEST
+        # alphas_ = np.linspace(-2, 2, SamplePoints_3D)
+        # betas_  = np.linspace(1.01,10.01,SamplePoints_3D)
+        # print('betas:', betas_)
+
+        # TEST :
+        # alphas_ = np.linspace(-40, 40, SamplePoints_3D)
+        # betas_  = np.linspace(0.01,80.01,SamplePoints_3D) # Full Range
+
+        # print('type of alphas', type(alphas_))
+        # print('Test:', type(np.array([mu_gamma])) )
+        alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+        classifyMin_anaVec = np.vectorize(classifyMin_ana)
+
+        # Get MuGamma values ...
+        GetMuGammaVec = np.vectorize(GetMuGamma)
+        muGammas = GetMuGammaVec(betas, thetas, gamma, mu1, rho1)
+        # Classify Minimizers....
+        G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1)   # Sets q12 to zero!!!
+
+        # G, angles, Types, curvature = classifyMin_anaVec(alphas, betas, thetas, muGammas,  mu1, rho1, True, True)
+        # print('size of G:', G.shape)
+        # print('G:', G)
+
+        # Option to print angles
+        # print('angles:', angles)
+
+
+        # Out = classifyMin_anaVec(alphas,betas,thetas)
+        # T = Out[2]
+        # --- Write to VTK
+
+        GammaString = str(gamma)
+        VTKOutputName = "outputs/PhaseDiagram3D" + "Gamma" + GammaString
+        gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        print('Written to VTK-File:', VTKOutputName )
+
+    if make_2D_PhaseDiagram:
+        # alphas_ = np.linspace(-20, 20, SamplePoints_2D)
+        # alphas_ = np.linspace(0, 1, SamplePoints_2D)
+        thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        alphas_ = np.linspace(-5, 5, SamplePoints_2D)
+        # alphas_ = np.linspace(-5, 15, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.25,SamplePoints_2D)
+
+
+        # good range:
+        # alphas_ = np.linspace(9, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.075,0.14,SamplePoints_2D)
+
+        # range used:
+        # alphas_ = np.linspace(8, 10, SamplePoints_2D)
+        # thetas_ = np.linspace(0.05,0.16,SamplePoints_2D)
+
+            # alphas_ = np.linspace(8, 12, SamplePoints_2D)
+            # thetas_ = np.linspace(0.05,0.2,SamplePoints_2D)
+        # betas_  = np.linspace(0.01,40.01,1)
+        #fix to one value:
+        betas_ = 2.0;
+        # betas_ = 10.0;
+        # betas_ = 5.0;
+        # betas_ = 0.5;
+
+
+        #intermediate Values
+        alphas_ = np.linspace(-2, 1, SamplePoints_2D)
+        # thetas_ = np.linspace(0.4,0.6,SamplePoints_2D)
+        # betas_ = 10.0;
+
+        # TEST
+        # alphas_ = np.linspace(-8, 8, SamplePoints_2D)
+        # thetas_ = np.linspace(0.01,0.99,SamplePoints_2D)
+        # betas_ = 1.0; #TEST Problem: disvison by zero if alpha = 9, theta = 0.1 !
+        # betas_ = 0.9;
+        # betas_ = 0.5;  #TEST!!!
+        # alphas, betas, thetas = np.meshgrid(alphas_, betas_, thetas_, indexing='ij')
+        betas = betas_
+        alphas, thetas = np.meshgrid(alphas_, thetas_, indexing='ij')
+
+        if generalCase:
+            classifyMin_matVec = np.vectorize(classifyMin_mat)
+            GetCellOutputVec = np.vectorize(GetCellOutput, otypes=[np.ndarray, np.ndarray])
+            Q, B = GetCellOutputVec(alphas,betas,thetas,gamma,mu1,rho1,lambda1, InputFilePath ,OutputFilePath )
+
+
+            # print('type of Q:', type(Q))
+            # print('Q:', Q)
+            G, angles, Types, curvature = classifyMin_matVec(Q,B)
+
+        else:
+            classifyMin_anaVec = np.vectorize(classifyMin_ana)
+            GetMuGammaVec = np.vectorize(GetMuGamma)
+            # muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+            # G, angles, Types, curvature = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+            muGammas = GetMuGammaVec(betas,thetas,gamma,mu1,rho1,InputFilePath ,OutputFilePath )
+
+            if gamma == '0':
+                G, angles_0, Types, curvature_0 = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+            if gamma == 'infinity':
+                G, angles_inf, Types, curvature_inf = classifyMin_anaVec(alphas,betas,thetas, muGammas,  mu1, rho1)    # Sets q12 to zero!!!
+
+            # print('size of G:', G.shape)
+            # print('G:', G)
+            # print('Types:', Types)
+            # Out = classifyMin_anaVec(alphas,betas,thetas)
+            # T = Out[2]
+            # --- Write to VTK
+            # VTKOutputName = + path + "./PhaseDiagram2DNEW"
+
+        # print('angles:',angles)
+        # GammaString = str(gamma)
+        # VTKOutputName = "outputs/PhaseDiagram2D" + "Gamma_" + GammaString
+        # gridToVTK(VTKOutputName , alphas, betas, thetas, pointData = {'Type': Types, 'angles': angles, 'curvature': curvature} )
+        # print('Written to VTK-File:', VTKOutputName )
+
+
+# --- Make 3D Scatter plot
+if(make_3D_plot or make_2D_plot):
+    # fig = plt.figure()
+    # ax = fig.add_subplot(111, projection='3d')
+    # colors = cm.plasma(Types)
+    colors = cm.coolwarm(angles_inf)
+
+
+    width = 6.28
+    # height = width / 1.618
+    height = width / 2.5
+    # fig, ax = plt.subplots()
+    fig,ax = plt.subplots(nrows=1,ncols=2,figsize=(width,height), sharey=True)
+    # ax = plt.axes((0.15,0.21 ,0.8,0.75))
+
+
+
+
+    # if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=Types.flat)
+    # if make_3D_plot: pnt3d=ax.scatter(alphas,betas,thetas,c=Types.flat)
+    #
+    # if make_2D_plot: pnt3d=ax.scatter(alphas,thetas,c=angles.flat)
+    # if make_3D_plot: pnt3d=ax.scatter(alphas,betas,thetas,c=angles.flat)
+
+
+    # pnt=ax.scatter(alphas,thetas,c=angles,cmap='coolwarm')
+    # # ax.colorbar()
+    # CS = ax.contourf(alphas, thetas, angles,6, cmap=plt.cm.coolwarm, linestyle=dashed)
+    # # CS = ax.contour(alphas, thetas, angles,6, colors='k')
+    # ax.clabel(CS, inline=True, fontsize=7.5)
+    # # ax.set_title('Simplest default with labels')
+
+
+    # CS_0 = ax[0].contourf(alphas, thetas, curvature_0, 10, cmap=plt.cm.coolwarm)
+    CS_0 = ax[0].contourf(alphas, thetas, curvature_0, 10, cmap=plt.cm.gnuplot)
+    # CS = ax.contourf(alphas, thetas, angles, 10, cmap='RdBu')
+    CS_02 = ax[0].contour(CS_0, levels=CS_0.levels[::2], colors='black',inline=True, linewidths=(0.5,))
+    # ax.clabel(CS2, inline=True, fontsize=9, colors='black')
+    # ax.clabel(CS2, inline=True, inline_spacing=3, rightside_up=True, colors='k', fontsize=8)
+    # manual_locations = [
+    #     (-0.5, 0.3), (-0.7, 0.4), (-0.8, 0.5), (-0.9, 0.6), (-1,0.7)]
+    manual_locations = [
+        (-0.4, 0.2),(-0.6, 0.3), (-0.7, 0.4), (-0.8, 0.5), (-0.9, 0.6), (-1,0.7)]
+    # ax[0].clabel(CS_02, inline=True, fontsize=6, colors='black', manual=manual_locations)
+    # ax[0].clabel(CS_02, inline=True, fontsize=10, colors='black')
+
+
+
+    # ax.clabel(CS2, CS2.levels, inline=True, fontsize=10)
+    # ax.clabel(CS,  fontsize=5, colors='black')
+    # cbar = fig.colorbar(CS,label=r'angle $\alpha$', ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+    # cbar = fig.colorbar(CS_0, ticks=[0, np.pi/2 ])
+    # cbar.ax.set_yticklabels(['$0$', r'$\pi/2$'])
+    # cbar.ax.set_title(r'angle $\alpha$')
+
+
+    CS_1 = ax[1].contourf(alphas, thetas, curvature_inf, 10, cmap=plt.cm.gnuplot)
+    # CS_1 = ax[1].contourf(alphas, thetas, curvature_inf, 10, cmap=plt.cm.jet)
+    # CS = ax.contourf(alphas, thetas, angles, 10, cmap='RdBu')
+    CS_12 = ax[1].contour(CS_1, levels=CS_1.levels[::2], colors='black',inline=True, linewidths=(0.5,))
+    # ax.clabel(CS2, inline=True, fontsize=9, colors='black')
+    # ax.clabel(CS2, inline=True, inline_spacing=3, rightside_up=True, colors='k', fontsize=8)
+    manual_locations = [
+        (-1.8,0.9), (-1.5,0.4), (-1,0.3), (0,0.15),(0,0.67) ,(0.5,0.75) , (0.5,0.8), (0.8,0.9)   ]
+    # ax[1].clabel(CS_12, inline=True, fontsize=10, colors='black', manual=manual_locations)
+    # ax[1].clabel(CS_12, inline=True, fontsize=10, colors='black')
+
+
+    axins1 = inset_axes(ax[1],
+                       width="5%",  # width = 5% of parent_bbox width
+                       height="100%",  # height : 50%
+                       loc='lower left',
+                       bbox_to_anchor=(1.05, 0., 1, 1),
+                       bbox_transform=ax[1].transAxes,
+                       borderpad=0,
+                       )
+
+
+    # cbar = fig.colorbar(CS_1, cax=axins1, ticks=[0, np.pi/8, np.pi/4, 3*np.pi/8 , np.pi/2 ])
+    cbar = fig.colorbar(CS_1, cax=axins1)
+    cbar.ax.tick_params(labelsize=8)
+
+
+    # cbar.ax.set_yticklabels(['$0$',r'$\pi/8$', r'$\pi/4$' ,r'$3\pi/8$' , r'$\pi/2$'])
+    # cbar.ax.set_title(r'angle $\alpha$')
+    # cbar.ax.set_title(r'curvature $\kappa$')
+    cbar.ax.set_title(r'$\kappa$')
+    # cbar=plt.colorbar(pnt3d)
+    # cbar.set_label("Values (units)")
+    # plt.axvline(x = 8, color = 'b', linestyle = ':', label='$q_1$')
+    # plt.axhline(y = 0.083333333, color = 'b', linestyle = ':', label='$q_1$')
+
+    ax[0].set_xlabel(r'$\theta_\rho$',fontsize=10)
+    # ax[0].yaxis.set_major_locator(MultipleLocator(0.1))
+    # ax[0].xaxis.set_major_locator(MultipleLocator(1))
+    ax[0].yaxis.set_major_locator(MultipleLocator(0.1))
+    ax[0].xaxis.set_major_locator(MultipleLocator(0.5))
+    ax[0].set_ylabel(r'$\theta$   ',fontsize=10, rotation=0)
+    ax[0].tick_params(axis='x', labelsize=7 )
+    ax[0].tick_params(axis='y', labelsize=7 )
+
+    ax[1].set_xlabel(r'$\theta_\rho$',fontsize=10)
+    # ax.xaxis.set_minor_locator(MultipleLocator(0.5))
+    # ax[1].yaxis.set_major_locator(MultipleLocator(0.1))
+    # ax[1].xaxis.set_major_locator(MultipleLocator(1))
+    ax[1].yaxis.set_major_locator(MultipleLocator(0.1))
+    ax[1].xaxis.set_major_locator(MultipleLocator(0.5))
+    ax[1].tick_params(axis='x', labelsize=7 )
+    ax[1].tick_params(axis='y', labelsize=7 )
+    # ax.set_ylabel('beta')
+    # ax[1].set_ylabel(r'$\theta$   ',fontsize=10, rotation=0)
+    # if make_3D_plot: ax.set_zlabel('theta')
+    # plt.subplots_adjust(bottom=0.2)
+    # plt.subplots_adjust(wspace=0.22, hspace=0.1)
+    plt.subplots_adjust(hspace=0.15, wspace=0.1)
+    # plt.subplots_adjust(hspace=0.15, wspace=0.0)
+    plt.subplots_adjust(bottom=0.2)
+    # plt.subplots_adjust(right=0.1)
+    # fig.subplots_adjust(right=0.1)
+
+
+    ax[0].grid( linestyle = '--', linewidth = 0.25)
+    ax[1].grid( linestyle = '--', linewidth = 0.25)
+
+
+
+    fig.set_size_inches(width, height)
+    outputName = 'Plot-CurvContour.pdf'
+    fig.savefig(outputName)
+    # fig.savefig('Plot-Contour.pdf')
+    plt.show()
+    # plt.savefig('common_labels.png', dpi=300)
+    # print('T:', T)
+    # print('Type 1 occured here:', np.where(T == 1))
+    # print('Type 2 occured here:', np.where(T == 2))