go-hep.org/x/hep@v0.38.1/groot/rsql/scan_test.go (about)

     1  // Copyright ©2019 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 rsql_test
     6  
     7  import (
     8  	"fmt"
     9  	"log"
    10  
    11  	"go-hep.org/x/hep/groot"
    12  	"go-hep.org/x/hep/groot/rsql"
    13  	"go-hep.org/x/hep/groot/rtree"
    14  	"go-hep.org/x/hep/hbook"
    15  )
    16  
    17  func ExampleScan() {
    18  	f, err := groot.Open("../testdata/simple.root")
    19  	if err != nil {
    20  		log.Fatal(err)
    21  	}
    22  	defer f.Close()
    23  
    24  	o, err := f.Get("tree")
    25  	if err != nil {
    26  		log.Fatal(err)
    27  	}
    28  
    29  	tree := o.(rtree.Tree)
    30  
    31  	var data []float64
    32  
    33  	err = rsql.Scan(tree, "SELECT two FROM tree", func(x float64) error {
    34  		data = append(data, x)
    35  		return nil
    36  	})
    37  
    38  	if err != nil {
    39  		log.Fatal(err)
    40  	}
    41  
    42  	fmt.Printf("tree[%q]: %v\n", "two", data)
    43  
    44  	// Output:
    45  	// tree["two"]: [1.1 2.2 3.3 4.4]
    46  }
    47  
    48  func ExampleScan_nVars() {
    49  	f, err := groot.Open("../testdata/simple.root")
    50  	if err != nil {
    51  		log.Fatal(err)
    52  	}
    53  	defer f.Close()
    54  
    55  	o, err := f.Get("tree")
    56  	if err != nil {
    57  		log.Fatal(err)
    58  	}
    59  
    60  	tree := o.(rtree.Tree)
    61  
    62  	var (
    63  		v1s []int32
    64  		v2s []float64
    65  		v3s []string
    66  	)
    67  
    68  	err = rsql.Scan(tree, "SELECT (one, two, three) FROM tree", func(x int32, y float64, z string) error {
    69  		v1s = append(v1s, x)
    70  		v2s = append(v2s, y)
    71  		v3s = append(v3s, z)
    72  		return nil
    73  	})
    74  
    75  	if err != nil {
    76  		log.Fatal(err)
    77  	}
    78  
    79  	fmt.Printf("tree[%q]: %v\n", "one", v1s)
    80  	fmt.Printf("tree[%q]: %v\n", "two", v2s)
    81  	fmt.Printf("tree[%q]: %q\n", "three", v3s)
    82  
    83  	// Output:
    84  	// tree["one"]: [1 2 3 4]
    85  	// tree["two"]: [1.1 2.2 3.3 4.4]
    86  	// tree["three"]: ["uno" "dos" "tres" "quatro"]
    87  }
    88  
    89  func ExampleScanH1D() {
    90  	f, err := groot.Open("../testdata/simple.root")
    91  	if err != nil {
    92  		log.Fatal(err)
    93  	}
    94  	defer f.Close()
    95  
    96  	o, err := f.Get("tree")
    97  	if err != nil {
    98  		log.Fatal(err)
    99  	}
   100  
   101  	tree := o.(rtree.Tree)
   102  
   103  	h, err := rsql.ScanH1D(tree, "SELECT two FROM tree", nil)
   104  	if err != nil {
   105  		log.Fatal(err)
   106  	}
   107  
   108  	fmt.Printf("entries: %v\n", h.Entries())
   109  	fmt.Printf("x-axis: (min=%v, max=%v)\n", h.XMin(), h.XMax())
   110  	fmt.Printf("x-mean: %v\n", h.XMean())
   111  	fmt.Printf("x-std-dev: %1.3f\nx-std-err: %1.3f\n", h.XStdDev(), h.XStdErr())
   112  
   113  	// Output:
   114  	// entries: 4
   115  	// x-axis: (min=1.1, max=4.400000000000001)
   116  	// x-mean: 2.75
   117  	// x-std-dev: 1.420
   118  	// x-std-err: 0.710
   119  }
   120  
   121  func ExampleScanH1D_withH1D() {
   122  	f, err := groot.Open("../testdata/simple.root")
   123  	if err != nil {
   124  		log.Fatal(err)
   125  	}
   126  	defer f.Close()
   127  
   128  	o, err := f.Get("tree")
   129  	if err != nil {
   130  		log.Fatal(err)
   131  	}
   132  
   133  	tree := o.(rtree.Tree)
   134  
   135  	h, err := rsql.ScanH1D(tree, "SELECT two FROM tree", hbook.NewH1D(100, 0, 10))
   136  	if err != nil {
   137  		log.Fatal(err)
   138  	}
   139  
   140  	fmt.Printf("entries: %v\n", h.Entries())
   141  	fmt.Printf("x-axis: (min=%v, max=%v)\n", h.XMin(), h.XMax())
   142  	fmt.Printf("x-mean: %v\n", h.XMean())
   143  	fmt.Printf("x-std-dev: %1.3f\nx-std-err: %1.3f\n", h.XStdDev(), h.XStdErr())
   144  
   145  	// Output:
   146  	// entries: 4
   147  	// x-axis: (min=0, max=10)
   148  	// x-mean: 2.75
   149  	// x-std-dev: 1.420
   150  	// x-std-err: 0.710
   151  }
   152  
   153  func ExampleScanH2D() {
   154  	f, err := groot.Open("../testdata/simple.root")
   155  	if err != nil {
   156  		log.Fatal(err)
   157  	}
   158  	defer f.Close()
   159  
   160  	o, err := f.Get("tree")
   161  	if err != nil {
   162  		log.Fatal(err)
   163  	}
   164  
   165  	tree := o.(rtree.Tree)
   166  
   167  	h, err := rsql.ScanH2D(tree, "SELECT (one, two) FROM tree", nil)
   168  	if err != nil {
   169  		log.Fatal(err)
   170  	}
   171  
   172  	fmt.Printf("entries: %v\n", h.Entries())
   173  	fmt.Printf("x-axis: (min=%v, max=%v)\n", h.XMin(), h.XMax())
   174  	fmt.Printf("x-mean: %v\n", h.XMean())
   175  	fmt.Printf("x-std-dev: %1.3f\nx-std-err: %1.3f\n", h.XStdDev(), h.XStdErr())
   176  	fmt.Printf("y-axis: (min=%v, max=%v)\n", h.YMin(), h.YMax())
   177  	fmt.Printf("y-mean: %v\n", h.YMean())
   178  	fmt.Printf("y-std-dev: %1.3f\ny-std-err: %1.3f\n", h.YStdDev(), h.YStdErr())
   179  
   180  	// Output:
   181  	// entries: 4
   182  	// x-axis: (min=1, max=4.000000000000001)
   183  	// x-mean: 2.5
   184  	// x-std-dev: 1.291
   185  	// x-std-err: 0.645
   186  	// y-axis: (min=1.1, max=4.400000000000001)
   187  	// y-mean: 2.75
   188  	// y-std-dev: 1.420
   189  	// y-std-err: 0.710
   190  }
   191  
   192  func ExampleScanH2D_withH2D() {
   193  	f, err := groot.Open("../testdata/simple.root")
   194  	if err != nil {
   195  		log.Fatal(err)
   196  	}
   197  	defer f.Close()
   198  
   199  	o, err := f.Get("tree")
   200  	if err != nil {
   201  		log.Fatal(err)
   202  	}
   203  
   204  	tree := o.(rtree.Tree)
   205  
   206  	h, err := rsql.ScanH2D(tree, "SELECT (one, two) FROM tree", hbook.NewH2D(100, 0, 10, 100, 0, 10))
   207  	if err != nil {
   208  		log.Fatal(err)
   209  	}
   210  
   211  	fmt.Printf("entries: %v\n", h.Entries())
   212  	fmt.Printf("x-axis: (min=%v, max=%v)\n", h.XMin(), h.XMax())
   213  	fmt.Printf("x-mean: %v\n", h.XMean())
   214  	fmt.Printf("x-std-dev: %1.3f\nx-std-err: %1.3f\n", h.XStdDev(), h.XStdErr())
   215  	fmt.Printf("y-axis: (min=%v, max=%v)\n", h.YMin(), h.YMax())
   216  	fmt.Printf("y-mean: %v\n", h.YMean())
   217  	fmt.Printf("y-std-dev: %1.3f\ny-std-err: %1.3f\n", h.YStdDev(), h.YStdErr())
   218  
   219  	// Output:
   220  	// entries: 4
   221  	// x-axis: (min=0, max=10)
   222  	// x-mean: 2.5
   223  	// x-std-dev: 1.291
   224  	// x-std-err: 0.645
   225  	// y-axis: (min=0, max=10)
   226  	// y-mean: 2.75
   227  	// y-std-dev: 1.420
   228  	// y-std-err: 0.710
   229  }