func EnvSplitTcB(baseEnv *tempAll.Environment, TcFactors, BeFields []float64, epsAbs, epsRel float64) ([]*tempAll.Environment, error) {
TcEnv := baseEnv.Copy()
TcEnv.Be_field = 0.0
TcEnv.Mu_b = 0.0
_, err := tempCrit.CritTempSolve(TcEnv, epsAbs, epsRel)
if err != nil {
return nil, err
}
Tc := 1.0 / TcEnv.Beta
omegaFit, err := tempCrit.OmegaFit(TcEnv, tempCrit.OmegaPlus)
if err != nil {
return nil, err
}
TcEnv.A, TcEnv.B = omegaFit[0], omegaFit[2]
TcEnv.PairCoeffsReady = true
result := []*tempAll.Environment{}
for _, TcFactor := range TcFactors {
env := TcEnv.Copy()
T := TcFactor * Tc
env.Beta = 1.0 / T
env.Temp = T
// fix (D1, Mu_h) appropriate for Beta
//_, err := SolveD1Mu_h(env, epsAbs, epsRel)
_, err := SolveD1Mu_hMu_b(env, epsAbs, epsRel)
if err != nil {
return nil, err
}
// keep (D1, Mu_h) independent of magnetic field
BeNum := len(BeFields)
thisEnv_BeSplit := env.MultiSplit([]string{"Be_field"}, []int{BeNum}, []float64{BeFields[0]}, []float64{BeFields[BeNum-1]})
result = append(result, thisEnv_BeSplit...)
}
return result, nil
}
// Solve the (D1, Mu_h, Beta) system with x and F0 fixed.
func D1MuBetaSolve(env *tempAll.Environment, epsAbs, epsRel float64) (vec.Vector, error) {
// our guess for beta should be above beta_c
if env.A == 0.0 && env.B == 0.0 {
D1, Mu_h, F0 := env.D1, env.Mu_h, env.F0
env.F0 = 0.0 // F0 is 0 at T_c
_, err := tempCrit.CritTempSolve(env, epsAbs, epsRel)
if err != nil {
return nil, err
}
fmt.Printf("%v; Tc = %f\n", env, 1.0/env.Beta)
omegaFit, err := tempCrit.OmegaFit(env, tempCrit.OmegaPlus)
if err != nil {
return nil, err
}
env.A, env.B = omegaFit[0], omegaFit[2]
env.PairCoeffsReady = true
env.Beta += 0.1
// we are at T < T_c; uncache env
env.D1, env.Mu_h, env.F0 = D1, Mu_h, F0
}
//fmt.Printf("%v; Tc = %f\n", env, 1.0 / env.Beta)
// solve low temp system for reasonable values of D1 and Mu_h first
_, err := D1MuSolve(env, epsAbs, epsRel)
if err != nil {
return nil, err
}
// solve the full low temp system
system, start := D1MuBetaSystem(env)
solution, err := solve.MultiDim(system, start, epsAbs, epsRel)
if err != nil {
return nil, err
}
return solution, nil
}
// Solve the (D1, Mu_h, F0) system with x and Beta fixed.
func D1MuF0Solve(env *tempAll.Environment, epsAbs, epsRel float64) (vec.Vector, error) {
if env.A == 0.0 && env.B == 0.0 {
// We must have T < T_c < T_p (Beta > Beta_c > Beta_p).
// Getting Beta_p is fast, so do that first.
D1, Mu_h, F0, Beta := env.F0, env.Mu_h, env.F0, env.Beta // cache env
env.F0 = 0.0 // F0 is 0 at T_c and T_p
_, err := tempPair.PairTempSolve(env, epsAbs, epsRel)
if err != nil {
return nil, err
}
if Beta < env.Beta {
return nil, fmt.Errorf("Beta = %f less than Beta_p in env %s", Beta, env.String())
}
_, err = tempCrit.CritTempSolve(env, epsAbs, epsRel)
if err != nil {
return nil, err
}
if Beta < env.Beta {
return nil, fmt.Errorf("Beta = %f less than Beta_c in env %s", Beta, env.String())
}
fmt.Printf("%v; Tc = %f\n", env, 1.0/env.Beta)
omegaFit, err := tempCrit.OmegaFit(env, tempCrit.OmegaPlus)
if err != nil {
return nil, err
}
env.A, env.B = omegaFit[0], omegaFit[2]
env.PairCoeffsReady = true
// we are at T < T_c; uncache env
env.D1, env.Mu_h, env.F0, env.Beta = D1, Mu_h, F0, Beta
}
// solve low temp system for reasonable values of D1 and Mu_h first
_, err := D1MuSolve(env, epsAbs, epsRel)
if err != nil {
return nil, err
}
// solve the full low temp system
system, start := D1MuF0System(env)
solution, err := solve.MultiDim(system, start, epsAbs, epsRel)
if err != nil {
return nil, err
}
return solution, nil
}
// Solve the (D1, Mu_h, Beta) system with x and Mu_b fixed.
func FlucTempSolve(env *tempAll.Environment, epsAbs, epsRel float64) (vec.Vector, error) {
// fix pair coefficients
if env.A == 0.0 && env.B == 0.0 && env.FixedPairCoeffs {
D1, Mu_h, Mu_b, Beta := env.D1, env.Mu_h, env.Mu_b, env.Beta
env.Mu_b = 0.0 // Mu_b is 0 at T_c
_, err := tempCrit.CritTempSolve(env, epsAbs, epsRel)
if err != nil {
return nil, err
}
omegaFit, err := tempCrit.OmegaFit(env, tempCrit.OmegaPlus)
if err != nil {
return nil, err
}
env.A, env.B = omegaFit[0], omegaFit[2]
env.PairCoeffsReady = true
// uncache env
env.D1, env.Mu_h, env.Mu_b, env.Beta = D1, Mu_h, Mu_b, Beta
}
// our guess for beta should be a bit above Beta_p
pairSystem, pairStart := tempPair.PairTempSystem(env)
_, err := solve.MultiDim(pairSystem, pairStart, epsAbs, epsRel)
if err != nil {
return nil, err
}
env.Beta += 0.1
// solve fluc temp system for reasonable values of Mu_h and D1 first
system, start := FlucTempD1MuSystem(env)
_, err = solve.MultiDim(system, start, epsAbs, epsRel)
if err != nil {
return nil, err
}
// solve the full fluc temp system
system, start = FlucTempFullSystem(env)
solution, err := solve.MultiDim(system, start, epsAbs, epsRel)
if err != nil {
return nil, err
}
return solution, nil
}
func solveAndPlot(envs []*tempAll.Environment, epsabs, epsrel float64, fileLabelMu_b, fileLabelMu_h, fileLabelD1, fileLabel_a, fileLabel_b, fileLabel_x2, fileLabel_x1 string) error {
// solve
plotEnvs, errs := tempAll.MultiSolve(envs, epsabs, epsrel, FlucTempSolve)
// Mu_b vs T plot
vars := plots.GraphVars{"", "Mu_b", []string{"Tz", "Thp", "X"}, []string{"t_z/t_0", "t_h^{\\prime}/t_0", "x_{eff}"}, tempAll.GetTemp, nil}
wd, _ := os.Getwd()
grapherPath := wd + "/../plots/grapher.py"
graphParams := map[string]string{plots.FILE_KEY: wd + "/" + fileLabelMu_b, plots.XLABEL_KEY: "$T$", plots.YLABEL_KEY: "$\\mu_{pair}/t_0$", plots.YMIN_KEY: ""}
err := plots.MultiPlotStyle(plotEnvs, errs, vars, graphParams, grapherPath, false)
if err != nil {
return err
}
graphParams[plots.FILE_KEY] = wd + "/" + fileLabelMu_b + "_BW_"
err = plots.MultiPlotStyle(plotEnvs, errs, vars, graphParams, grapherPath, true)
if err != nil {
return err
}
// Mu_h vs T plots
graphParams[plots.FILE_KEY] = wd + "/" + fileLabelMu_h
graphParams[plots.YLABEL_KEY] = "$\\mu_h/t_0$"
vars.Y = "Mu_h"
err = plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
return err
}
graphParams[plots.FILE_KEY] = wd + "/" + fileLabelMu_h + "_BW_"
err = plots.MultiPlotStyle(plotEnvs, errs, vars, graphParams, grapherPath, true)
if err != nil {
return err
}
// D_1 vs T plots
graphParams[plots.FILE_KEY] = wd + "/" + fileLabelD1
graphParams[plots.YLABEL_KEY] = "$D_1$"
vars.Y = "D1"
err = plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
return err
}
graphParams[plots.FILE_KEY] = wd + "/" + fileLabelD1 + "_BW_"
err = plots.MultiPlotStyle(plotEnvs, errs, vars, graphParams, grapherPath, true)
if err != nil {
return err
}
// x_2 vs T plots
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel_x2
graphParams[plots.YLABEL_KEY] = "$x_2$"
graphParams[plots.YMIN_KEY] = "0.0"
vars.Y = ""
vars.YFunc = tempCrit.GetX2
err = plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
return err
}
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel_x2 + "_BW_"
err = plots.MultiPlotStyle(plotEnvs, errs, vars, graphParams, grapherPath, true)
if err != nil {
return err
}
// x_1 vs T plots
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel_x1
graphParams[plots.YLABEL_KEY] = "$x_1$"
x1fn := func(data interface{}) float64 {
env := data.(tempAll.Environment)
return env.X - tempCrit.GetX2(data)
}
vars.Y = ""
vars.YFunc = x1fn
err = plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
return err
}
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel_x1 + "_BW_"
err = plots.MultiPlotStyle(plotEnvs, errs, vars, graphParams, grapherPath, true)
if err != nil {
return err
}
// omega_+(q) parameters (a, b) vs T
get_fit := func(data interface{}, i int) float64 {
env := data.(tempAll.Environment)
if env.FixedPairCoeffs {
if i == 0 || i == 1 {
return env.A
} else {
return env.B
}
}
fit, err := tempCrit.OmegaFit(&env, tempCrit.OmegaPlus)
if err != nil {
fmt.Printf("%v\n", err)
}
return fit[i]
}
get_a := func(data interface{}) float64 {
return get_fit(data, 0)
}
get_b := func(data interface{}) float64 {
return get_fit(data, 2)
}
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel_a
graphParams[plots.YLABEL_KEY] = "$a/t_0$"
graphParams[plots.YMIN_KEY] = ""
vars.Y = ""
vars.YFunc = get_a
err = plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
return err
}
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel_a + "_BW_"
err = plots.MultiPlotStyle(plotEnvs, errs, vars, graphParams, grapherPath, true)
if err != nil {
return err
}
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel_b
graphParams[plots.YLABEL_KEY] = "$b/t_0$"
vars.Y = ""
vars.YFunc = get_b
err = plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
return err
}
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel_b + "_BW_"
err = plots.MultiPlotStyle(plotEnvs, errs, vars, graphParams, grapherPath, true)
if err != nil {
return err
}
return nil
}
func TestPlotX2VsMu_b(t *testing.T) {
flag.Parse()
if !(*testPlot || *longPlot) {
return
}
var plotEnvs []interface{}
var errs []error
wd, _ := os.Getwd()
cachePath := wd + "/__data_cache_tempFluc"
if *loadCache {
var err error
plotEnvs, errs, err = tempAll.LoadEnvCache(cachePath)
if err != nil {
t.Fatal(err)
}
} else {
envs, err := flucDefaultEnvSet(*longPlot)
if err != nil {
t.Fatal(err)
}
// solve the full system
eps := 1e-9
plotEnvs, errs = tempAll.MultiSolve(envs, eps, eps, FlucTempSolve)
// cache results for future use
err = tempAll.SaveEnvCache(cachePath, plotEnvs, errs)
if err != nil {
t.Fatal(err)
}
}
Xs := getXs(plotEnvs)
// T vs Mu_b plots
vars := plots.GraphVars{"Mu_b", "", []string{"Tz", "Thp", "X", "Be_field"}, []string{"t_z", "t_h^{\\prime}", "x", "eB"}, nil, tempAll.GetTemp}
fileLabel := "plot_data.T_mu_b"
grapherPath := wd + "/../plots/grapher.py"
graphParams := map[string]string{plots.FILE_KEY: wd + "/" + fileLabel, plots.XLABEL_KEY: "$\\mu_b$", plots.YLABEL_KEY: "$T$"}
if !*skipPlots {
err := plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
t.Fatalf("error making T(Mu_b) plot: %v", err)
}
}
// X2 vs T plots
fileLabel = "plot_data.x2_T"
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel
graphParams[plots.XLABEL_KEY] = "$T$"
graphParams[plots.YLABEL_KEY] = "$x_2$"
vars.X = ""
vars.XFunc = tempAll.GetTemp
vars.YFunc = tempCrit.GetX2
if !*skipPlots {
err := plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
t.Fatalf("error making X2(T) plot: %v", err)
}
}
// Mu_h vs T plots
fileLabel = "plot_data.mu_h_T"
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel
graphParams[plots.YLABEL_KEY] = "$\\mu_h$"
vars.Y = "Mu_h"
vars.YFunc = nil
if !*skipPlots {
err := plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
t.Fatalf("error making Mu_h plot: %v", err)
}
}
// omega(q) parameters (a, b) vs T
get_fit := func(data interface{}, i int) float64 {
env := data.(tempAll.Environment)
if env.FixedPairCoeffs {
if i == 0 || i == 1 {
return env.A
} else {
return env.B
}
}
fit, err := tempCrit.OmegaFit(&env, tempCrit.OmegaPlus)
if err != nil {
fmt.Printf("%v\n", err)
}
return fit[i]
}
get_a := func(data interface{}) float64 {
return get_fit(data, 0)
}
get_b := func(data interface{}) float64 {
return get_fit(data, 2)
}
fileLabel = "plot_data.a_T"
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel
graphParams[plots.YLABEL_KEY] = "$a$"
vars.Y = ""
vars.YFunc = get_a
if !*skipPlots {
err := plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
t.Fatalf("error making a plot: %v", err)
}
}
fileLabel = "plot_data.b_T"
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel
graphParams[plots.YLABEL_KEY] = "$b$"
vars.Y = ""
vars.YFunc = get_b
if !*skipPlots {
err := plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
t.Fatalf("error making b plot: %v", err)
}
}
// if looking for magnetization plot, make that plot and don't get Cv
if *magnetization_calc && !*skipPlots {
fileLabel = "plot_data.M_eB"
//fileLabel := "plot_data.M_eB"
//graphParams := map[string]string{plots.FILE_KEY: wd + "/" + fileLabel, plots.XLABEL_KEY: "$eB$", plots.YLABEL_KEY: "$M$"}
graphParams[plots.FILE_KEY] = wd + "/" + fileLabel
graphParams[plots.XLABEL_KEY] = "$eB$"
graphParams[plots.YLABEL_KEY] = "$M$"
//vars := plots.GraphVars{"Be_field", "", []string{"Tz", "Thp", "X", "Mu_b"}, []string{"t_z", "t_h^{\\prime}", "x", "\\mu_b"}, nil, tempCrit.GetMagnetization}
vars.X = "Be_field"
vars.XFunc = nil
vars.Y = ""
vars.YFunc = tempCrit.GetMagnetization
vars.Params = []string{"Tz", "Thp", "X", "Mu_b"}
vars.ParamLabels = []string{"t_z", "t_h^{\\prime}", "x", "\\mu_b"}
//grapherPath := wd + "/../plots/grapher.py"
err := plots.MultiPlot(plotEnvs, errs, vars, graphParams, grapherPath)
if err != nil {
t.Fatalf("error making M plot: %v", err)
}
return
}
// calculate specific heat contributions
SH_envs := makeSHEnvs(plotEnvs, errs, Xs)
// specific heat plots
fileLabelSH1 := "plot_data.SH-1_mu_b"
fileLabelSH2 := "plot_data.SH-2_mu_b"
fileLabelSH12 := "plot_data.SH-12_mu_b"
fileLabelGamma12 := "plot_data.gamma-12_mu_b"
fileLabelGamma1 := "plot_data.gamma-1_mu_b"
fileLabelGamma2 := "plot_data.gamma-2_mu_b"
err := makeSHPlots(SH_envs, errs, fileLabelSH1, fileLabelSH2, fileLabelSH12, fileLabelGamma1, fileLabelGamma2, fileLabelGamma12)
if err != nil {
t.Fatalf("error making specific heat plot: %v", err)
}
}
