func main() { t := table.NewOutTable("Time Step", "C Correlation", "X Correlation") info := &ising.SweepInfo{ ising.New(ising.Grid2DType, widthPow), ising.RandomSweep, mcrand.New(mcrand.GoCrypto, int64(time.Now().UnixNano())), temp, } stats := ising.SweepStatistics(info, initialSweeps, trials) fCs, _ := ising.Tau(stats.EHistory) fMags, _ := ising.Tau(stats.MagHistory) if len(fCs) < len(fMags) { for 0 < len(fMags)-len(fCs) { fCs = append(fCs, 0.0) } } else { for 0 < len(fCs)-len(fMags) { fMags = append(fMags, 0.0) } } info.Im.Print() println("Total steps:", len(fMags)) for i := 0; i < len(fMags); i++ { t.AddRow(float64(i), fCs[i], fMags[i]) } t.Write(table.KeepHeader, "tau.table") }
func BenchmarkIterateSweep8(b *testing.B) { im := New(Grid2DType, 3) b.ResetTimer() info := &SweepInfo{ im, IterSweep, mcrand.New(mcrand.GoRand, 0), testTemp, } Sweep(info, b.N) }
func BenchmarkRandomSweep64(b *testing.B) { im := New(Grid2DType, 6) b.ResetTimer() info := &SweepInfo{ im, RandomSweep, mcrand.New(mcrand.GoRand, 0), testTemp, } Sweep(info, b.N) }
func BenchmarkMultiplyWithCarryGenerator(b *testing.B) { im := New(Grid2DType, 5) b.ResetTimer() info := &SweepInfo{ im, CheckerSweep, mcrand.New(mcrand.MultiplyWithCarry, 0), testTemp, } Sweep(info, b.N) }
func BenchmarkXorshiftGenerator(b *testing.B) { im := New(Grid2DType, 5) b.ResetTimer() info := &SweepInfo{ im, CheckerSweep, mcrand.New(mcrand.Xorshift, 0), testTemp, } Sweep(info, b.N) }
func BenchmarkCheckerSweep32(b *testing.B) { im := New(Grid2DType, 5) b.ResetTimer() info := &SweepInfo{ im, CheckerSweep, mcrand.New(mcrand.GoRand, 0), testTemp, } Sweep(info, b.N) }
func main() { fmt.Println("Run statistics:") fmt.Printf(" %15s %5d\n", "Grid Width", 1<<widthPow) fmt.Printf(" %15s %5d\n", "Initial Sweeps", initialSweeps) fmt.Printf(" %15s %5d\n", "Trial Sweeps", trials) fmt.Printf(" %15s %5d\n", "Runs", runs) fmt.Printf(" %15s %5d\n", "Plot Points", int(points)) t0 := float64(time.Now().UnixNano()) infos := make([]*ising.SweepInfo, runs) for i := 0; i < runs; i++ { infos[i] = &ising.SweepInfo{ ising.New(ising.Grid2DType, widthPow), ising.RandomSweep, mcrand.New(mcrand.Xorshift, int64(time.Now().Nanosecond())), minTemp, } } t := table.NewOutTable("Temp", "Energy", "Mag", "S. Heat", "Chi") stats := make([]*ising.SweepStats, runs) print("Running simulation") for point := 0.0; point < points; point++ { print(".") for i, info := range infos { info.Temp = minTemp + (maxTemp-minTemp)*point/points stats[i] = ising.SweepStatistics(info, initialSweeps, trials) } stat := ising.AvgSweepStats(stats) t.AddRow(infos[0].Temp, stat.E, stat.Mag, stat.C, stat.X) } println() t.Write(table.KeepHeader, fmt.Sprintf("temp%d.table", 1<<widthPow)) t1 := float64(time.Now().UnixNano()) fmt.Printf("Run time: %.3gs\n", (t1-t0)/1e9) }
// This is too monolithic and should be pruned. func main() { sampleTemp := minSampleTemp maximumTable := table.NewOutTable("L", "1/L", "Critical Temperature", "Max Specific Heat", "Max Specific Heat Per Site") maximumTable.SetHeader(fmt.Sprintf("Created with %g trials per grid.", math.Pow(10, maxTrialsPow))) for widthPow := minPow; widthPow <= maxPow; widthPow++ { cols := make([]string, 1+2*(maxTrialsPow-minTrialsPow+1)) cols[0] = "Temperature" fcols := make([][]float64, int((maxTemp-minTemp)/tempStep)) for i := 0; i < len(fcols); i++ { fcols[i] = make([]float64, 1+2*(maxTrialsPow-minTrialsPow+1)) } secs1 := 0.0 secs2 := 0.0 fmt.Printf("\n%d-Width Grid:\n", 1<<widthPow) for i := 0; i <= maxTrialsPow-minTrialsPow; i++ { trials := int(math.Pow(10, float64(minTrialsPow+i))) fmt.Printf(" Running %d trial suite\n", trials) cols[2*i+1] = fmt.Sprintf("E (%d)", trials) cols[2*i+2] = fmt.Sprintf("C (%d)", trials) info := &ising.SweepInfo{ ising.New(ising.Grid2DType, uint32(widthPow)), ising.IterSweep, mcrand.New(mcrand.Xorshift, int64(time.Now().UnixNano())), sampleTemp, } t0 := time.Now().UnixNano() ising.SweepStatistics(info, initialSweeps, trials) t1 := time.Now().UnixNano() secs1 += float64(t1-t0) / 1e9 h := info.Im.EnergyHistogram() minValidTemp, maxValidTemp := maxTemp, minTemp for j := 0; j < len(fcols); j++ { temp := minTemp + float64(j)*tempStep E := h.Energy(sampleTemp, temp) C := h.SpecificHeat(sampleTemp, temp) if !math.IsNaN(C) && !math.IsInf(C, 0) { if temp > maxValidTemp { maxValidTemp = temp } if temp < minValidTemp { minValidTemp = temp } } fcols[j][2*i+1] = E / float64(info.Im.Sites()) fcols[j][2*i+2] = C / float64(info.Im.Sites()) } if i+minTrialsPow == maxTrialsPow { tCrit := h.CriticalTemp(sampleTemp, minValidTemp, maxValidTemp) cCrit := h.SpecificHeat(sampleTemp, tCrit) maximumTable.AddRow(float64(int(1<<widthPow)), 1.0/float64(int(1<<widthPow)), tCrit, cCrit, cCrit/float64(info.Im.Sites())) sampleTemp = tCrit } t2 := time.Now().UnixNano() secs2 += float64(t2-t1) / 1e9 } headerString := fmt.Sprintf( "%16s: %g\n%16s: %d\n%16s: %d\n"+ "%16s: %s\n%16s: %s\n%16s: %g\n%20s: %g", "Sample Temperature", sampleTemp, "Initial Sweeps", initialSweeps, "Width", 1<<widthPow, "Generator", "Xorshift", "Sweep Pattern", "IterSweep", "Total Sweep Time", secs1, "Total Histogram Time", secs2) t := table.NewOutTable(cols...) t.SetHeader(headerString) for i := 0; i < len(fcols); i++ { if !math.IsNaN(fcols[i][1]) { fcols[i][0] = minTemp + tempStep*float64(i) t.AddRow(fcols[i]...) } } t.Write(table.KeepHeader, fmt.Sprintf("tables/iter/hist-temp%d.table", 1<<widthPow)) } maximumTable.Write(table.KeepHeader, "tables/iter/hist-maximum.table") }