go-hep.org/x/hep@v0.38.1/groot/rhist/graph_example_test.go (about)

     1  // Copyright ©2017 The go-hep Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package rhist_test
     6  
     7  import (
     8  	"fmt"
     9  	"log"
    10  	"os"
    11  
    12  	"go-hep.org/x/hep/groot"
    13  	"go-hep.org/x/hep/groot/rhist"
    14  	"go-hep.org/x/hep/hbook"
    15  	"go-hep.org/x/hep/hbook/rootcnv"
    16  )
    17  
    18  func ExampleGraph() {
    19  	f, err := groot.Open("../testdata/graphs.root")
    20  	if err != nil {
    21  		log.Fatal(err)
    22  	}
    23  	defer f.Close()
    24  
    25  	obj, err := f.Get("tg")
    26  	if err != nil {
    27  		log.Fatal(err)
    28  	}
    29  
    30  	g := obj.(rhist.Graph)
    31  	fmt.Printf("name:  %q\n", g.Name())
    32  	fmt.Printf("title: %q\n", g.Title())
    33  	fmt.Printf("#pts:  %d\n", g.Len())
    34  	for i := range g.Len() {
    35  		x, y := g.XY(i)
    36  		fmt.Printf("(x,y)[%d] = (%+e, %+e)\n", i, x, y)
    37  	}
    38  
    39  	// Output:
    40  	// name:  "tg"
    41  	// title: "graph without errors"
    42  	// #pts:  4
    43  	// (x,y)[0] = (+1.000000e+00, +2.000000e+00)
    44  	// (x,y)[1] = (+2.000000e+00, +4.000000e+00)
    45  	// (x,y)[2] = (+3.000000e+00, +6.000000e+00)
    46  	// (x,y)[3] = (+4.000000e+00, +8.000000e+00)
    47  }
    48  
    49  func ExampleGraphErrors() {
    50  	f, err := groot.Open("../testdata/graphs.root")
    51  	if err != nil {
    52  		log.Fatal(err)
    53  	}
    54  	defer f.Close()
    55  
    56  	obj, err := f.Get("tge")
    57  	if err != nil {
    58  		log.Fatal(err)
    59  	}
    60  
    61  	g := obj.(rhist.GraphErrors)
    62  	fmt.Printf("name:  %q\n", g.Name())
    63  	fmt.Printf("title: %q\n", g.Title())
    64  	fmt.Printf("#pts:  %d\n", g.Len())
    65  	for i := range g.Len() {
    66  		x, y := g.XY(i)
    67  		xlo, xhi := g.XError(i)
    68  		ylo, yhi := g.YError(i)
    69  		fmt.Printf("(x,y)[%d] = (%+e +/- [%+e, %+e], %+e +/- [%+e, %+e])\n", i, x, xlo, xhi, y, ylo, yhi)
    70  	}
    71  
    72  	// Output:
    73  	// name:  "tge"
    74  	// title: "graph with errors"
    75  	// #pts:  4
    76  	// (x,y)[0] = (+1.000000e+00 +/- [+1.000000e-01, +1.000000e-01], +2.000000e+00 +/- [+2.000000e-01, +2.000000e-01])
    77  	// (x,y)[1] = (+2.000000e+00 +/- [+2.000000e-01, +2.000000e-01], +4.000000e+00 +/- [+4.000000e-01, +4.000000e-01])
    78  	// (x,y)[2] = (+3.000000e+00 +/- [+3.000000e-01, +3.000000e-01], +6.000000e+00 +/- [+6.000000e-01, +6.000000e-01])
    79  	// (x,y)[3] = (+4.000000e+00 +/- [+4.000000e-01, +4.000000e-01], +8.000000e+00 +/- [+8.000000e-01, +8.000000e-01])
    80  }
    81  
    82  func ExampleGraphErrors_asymmErrors() {
    83  	f, err := groot.Open("../testdata/graphs.root")
    84  	if err != nil {
    85  		log.Fatal(err)
    86  	}
    87  	defer f.Close()
    88  
    89  	obj, err := f.Get("tgae")
    90  	if err != nil {
    91  		log.Fatal(err)
    92  	}
    93  
    94  	g := obj.(rhist.GraphErrors)
    95  	fmt.Printf("name:  %q\n", g.Name())
    96  	fmt.Printf("title: %q\n", g.Title())
    97  	fmt.Printf("#pts:  %d\n", g.Len())
    98  	for i := range g.Len() {
    99  		x, y := g.XY(i)
   100  		xlo, xhi := g.XError(i)
   101  		ylo, yhi := g.YError(i)
   102  		fmt.Printf("(x,y)[%d] = (%+e +/- [%+e, %+e], %+e +/- [%+e, %+e])\n", i, x, xlo, xhi, y, ylo, yhi)
   103  	}
   104  
   105  	// Output:
   106  	// name:  "tgae"
   107  	// title: "graph with asymmetric errors"
   108  	// #pts:  4
   109  	// (x,y)[0] = (+1.000000e+00 +/- [+1.000000e-01, +2.000000e-01], +2.000000e+00 +/- [+3.000000e-01, +4.000000e-01])
   110  	// (x,y)[1] = (+2.000000e+00 +/- [+2.000000e-01, +4.000000e-01], +4.000000e+00 +/- [+6.000000e-01, +8.000000e-01])
   111  	// (x,y)[2] = (+3.000000e+00 +/- [+3.000000e-01, +6.000000e-01], +6.000000e+00 +/- [+9.000000e-01, +1.200000e+00])
   112  	// (x,y)[3] = (+4.000000e+00 +/- [+4.000000e-01, +8.000000e-01], +8.000000e+00 +/- [+1.200000e+00, +1.600000e+00])
   113  }
   114  
   115  func ExampleCreate_graph() {
   116  	const fname = "graph_example.root"
   117  	defer os.Remove(fname)
   118  
   119  	f, err := groot.Create(fname)
   120  	if err != nil {
   121  		log.Fatal(err)
   122  	}
   123  	defer f.Close()
   124  
   125  	hg := hbook.NewS2D(hbook.Point2D{X: 1, Y: 1}, hbook.Point2D{X: 2, Y: 1.5}, hbook.Point2D{X: -1, Y: +2})
   126  
   127  	fmt.Printf("original graph:\n")
   128  	for i, pt := range hg.Points() {
   129  		fmt.Printf("pt[%d]=%+v\n", i, pt)
   130  	}
   131  
   132  	rg := rhist.NewGraphFrom(hg)
   133  
   134  	err = f.Put("gr", rg)
   135  	if err != nil {
   136  		log.Fatal(err)
   137  	}
   138  
   139  	err = f.Close()
   140  	if err != nil {
   141  		log.Fatalf("error closing ROOT file: %v", err)
   142  	}
   143  
   144  	r, err := groot.Open(fname)
   145  	if err != nil {
   146  		log.Fatal(err)
   147  	}
   148  	defer r.Close()
   149  
   150  	robj, err := r.Get("gr")
   151  	if err != nil {
   152  		log.Fatal(err)
   153  	}
   154  
   155  	hr := rootcnv.S2D(robj.(rhist.Graph))
   156  
   157  	fmt.Printf("\ngraph read back:\n")
   158  	for i, pt := range hr.Points() {
   159  		fmt.Printf("pt[%d]=%+v\n", i, pt)
   160  	}
   161  
   162  	// Output:
   163  	// original graph:
   164  	// pt[0]={X:1 Y:1 ErrX:{Min:0 Max:0} ErrY:{Min:0 Max:0}}
   165  	// pt[1]={X:2 Y:1.5 ErrX:{Min:0 Max:0} ErrY:{Min:0 Max:0}}
   166  	// pt[2]={X:-1 Y:2 ErrX:{Min:0 Max:0} ErrY:{Min:0 Max:0}}
   167  	//
   168  	// graph read back:
   169  	// pt[0]={X:1 Y:1 ErrX:{Min:0 Max:0} ErrY:{Min:0 Max:0}}
   170  	// pt[1]={X:2 Y:1.5 ErrX:{Min:0 Max:0} ErrY:{Min:0 Max:0}}
   171  	// pt[2]={X:-1 Y:2 ErrX:{Min:0 Max:0} ErrY:{Min:0 Max:0}}
   172  }
   173  
   174  func ExampleCreate_graphErrors() {
   175  	const fname = "grapherr_example.root"
   176  	defer os.Remove(fname)
   177  
   178  	f, err := groot.Create(fname)
   179  	if err != nil {
   180  		log.Fatal(err)
   181  	}
   182  	defer f.Close()
   183  
   184  	hg := hbook.NewS2D(
   185  		hbook.Point2D{X: 1, Y: 1, ErrX: hbook.Range{Min: 2, Max: 2}, ErrY: hbook.Range{Min: 3, Max: 3}},
   186  		hbook.Point2D{X: 2, Y: 1.5, ErrX: hbook.Range{Min: 2, Max: 2}, ErrY: hbook.Range{Min: 3, Max: 3}},
   187  		hbook.Point2D{X: -1, Y: +2, ErrX: hbook.Range{Min: 2, Max: 2}, ErrY: hbook.Range{Min: 3, Max: 3}},
   188  	)
   189  
   190  	fmt.Printf("original graph:\n")
   191  	for i, pt := range hg.Points() {
   192  		fmt.Printf("pt[%d]=%+v\n", i, pt)
   193  	}
   194  
   195  	rg := rhist.NewGraphErrorsFrom(hg)
   196  
   197  	err = f.Put("gr", rg)
   198  	if err != nil {
   199  		log.Fatal(err)
   200  	}
   201  
   202  	err = f.Close()
   203  	if err != nil {
   204  		log.Fatalf("error closing ROOT file: %v", err)
   205  	}
   206  
   207  	r, err := groot.Open(fname)
   208  	if err != nil {
   209  		log.Fatal(err)
   210  	}
   211  	defer r.Close()
   212  
   213  	robj, err := r.Get("gr")
   214  	if err != nil {
   215  		log.Fatal(err)
   216  	}
   217  
   218  	hr := rootcnv.S2D(robj.(rhist.GraphErrors))
   219  
   220  	fmt.Printf("\ngraph read back:\n")
   221  	for i, pt := range hr.Points() {
   222  		fmt.Printf("pt[%d]=%+v\n", i, pt)
   223  	}
   224  
   225  	// Output:
   226  	// original graph:
   227  	// pt[0]={X:1 Y:1 ErrX:{Min:2 Max:2} ErrY:{Min:3 Max:3}}
   228  	// pt[1]={X:2 Y:1.5 ErrX:{Min:2 Max:2} ErrY:{Min:3 Max:3}}
   229  	// pt[2]={X:-1 Y:2 ErrX:{Min:2 Max:2} ErrY:{Min:3 Max:3}}
   230  	//
   231  	// graph read back:
   232  	// pt[0]={X:1 Y:1 ErrX:{Min:2 Max:2} ErrY:{Min:3 Max:3}}
   233  	// pt[1]={X:2 Y:1.5 ErrX:{Min:2 Max:2} ErrY:{Min:3 Max:3}}
   234  	// pt[2]={X:-1 Y:2 ErrX:{Min:2 Max:2} ErrY:{Min:3 Max:3}}
   235  }
   236  
   237  func ExampleCreate_graphAsymmErrors() {
   238  	const fname = "graphasymmerr_example.root"
   239  	defer os.Remove(fname)
   240  
   241  	f, err := groot.Create(fname)
   242  	if err != nil {
   243  		log.Fatal(err)
   244  	}
   245  	defer f.Close()
   246  
   247  	hg := hbook.NewS2D(
   248  		hbook.Point2D{X: 1, Y: 1, ErrX: hbook.Range{Min: 1, Max: 2}, ErrY: hbook.Range{Min: 3, Max: 4}},
   249  		hbook.Point2D{X: 2, Y: 1.5, ErrX: hbook.Range{Min: 1, Max: 2}, ErrY: hbook.Range{Min: 3, Max: 4}},
   250  		hbook.Point2D{X: -1, Y: +2, ErrX: hbook.Range{Min: 1, Max: 2}, ErrY: hbook.Range{Min: 3, Max: 4}},
   251  	)
   252  
   253  	fmt.Printf("original graph:\n")
   254  	for i, pt := range hg.Points() {
   255  		fmt.Printf("pt[%d]=%+v\n", i, pt)
   256  	}
   257  
   258  	rg := rhist.NewGraphAsymmErrorsFrom(hg)
   259  
   260  	err = f.Put("gr", rg)
   261  	if err != nil {
   262  		log.Fatal(err)
   263  	}
   264  
   265  	err = f.Close()
   266  	if err != nil {
   267  		log.Fatalf("error closing ROOT file: %v", err)
   268  	}
   269  
   270  	r, err := groot.Open(fname)
   271  	if err != nil {
   272  		log.Fatal(err)
   273  	}
   274  	defer r.Close()
   275  
   276  	robj, err := r.Get("gr")
   277  	if err != nil {
   278  		log.Fatal(err)
   279  	}
   280  
   281  	hr := rootcnv.S2D(robj.(rhist.GraphErrors))
   282  
   283  	fmt.Printf("\ngraph read back:\n")
   284  	for i, pt := range hr.Points() {
   285  		fmt.Printf("pt[%d]=%+v\n", i, pt)
   286  	}
   287  
   288  	// Output:
   289  	// original graph:
   290  	// pt[0]={X:1 Y:1 ErrX:{Min:1 Max:2} ErrY:{Min:3 Max:4}}
   291  	// pt[1]={X:2 Y:1.5 ErrX:{Min:1 Max:2} ErrY:{Min:3 Max:4}}
   292  	// pt[2]={X:-1 Y:2 ErrX:{Min:1 Max:2} ErrY:{Min:3 Max:4}}
   293  	//
   294  	// graph read back:
   295  	// pt[0]={X:1 Y:1 ErrX:{Min:1 Max:2} ErrY:{Min:3 Max:4}}
   296  	// pt[1]={X:2 Y:1.5 ErrX:{Min:1 Max:2} ErrY:{Min:3 Max:4}}
   297  	// pt[2]={X:-1 Y:2 ErrX:{Min:1 Max:2} ErrY:{Min:3 Max:4}}
   298  }