go-hep.org/x/hep@v0.38.1/groot/rtree/chain_example_test.go (about)

     1  // Copyright ©2018 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 rtree_test
     6  
     7  import (
     8  	"fmt"
     9  	"log"
    10  
    11  	"go-hep.org/x/hep/groot"
    12  	"go-hep.org/x/hep/groot/rtree"
    13  )
    14  
    15  // ExampleChain shows how to create a chain made of 2 trees.
    16  func ExampleChain() {
    17  	const name = "tree"
    18  
    19  	f1, err := groot.Open("../testdata/chain.1.root")
    20  	if err != nil {
    21  		log.Fatal(err)
    22  	}
    23  	defer f1.Close()
    24  
    25  	o1, err := f1.Get(name)
    26  	if err != nil {
    27  		log.Fatal(err)
    28  	}
    29  	t1 := o1.(rtree.Tree)
    30  
    31  	f2, err := groot.Open("../testdata/chain.2.root")
    32  	if err != nil {
    33  		log.Fatal(err)
    34  	}
    35  	defer f2.Close()
    36  
    37  	o2, err := f2.Get(name)
    38  	if err != nil {
    39  		log.Fatal(err)
    40  	}
    41  	t2 := o2.(rtree.Tree)
    42  
    43  	chain := rtree.Chain(t1, t2)
    44  
    45  	type Data struct {
    46  		Event struct {
    47  			Beg       string      `groot:"Beg"`
    48  			F64       float64     `groot:"F64"`
    49  			ArrF64    [10]float64 `groot:"ArrayF64"`
    50  			N         int32       `groot:"N"`
    51  			SliF64    []float64   `groot:"SliceF64"`
    52  			StdStr    string      `groot:"StdStr"`
    53  			StlVecF64 []float64   `groot:"StlVecF64"`
    54  			StlVecStr []string    `groot:"StlVecStr"`
    55  			End       string      `groot:"End"`
    56  		} `groot:"evt"`
    57  	}
    58  
    59  	var data Data
    60  	r, err := rtree.NewReader(chain, rtree.ReadVarsFromStruct(&data))
    61  	if err != nil {
    62  		log.Fatal(err)
    63  	}
    64  	defer r.Close()
    65  
    66  	err = r.Read(func(ctx rtree.RCtx) error {
    67  		fmt.Printf(
    68  			"entry[%02d]: beg=%q f64=%v\n",
    69  			ctx.Entry, data.Event.Beg, data.Event.F64,
    70  		)
    71  		return nil
    72  	})
    73  
    74  	if err != nil {
    75  		log.Fatalf("error during scan: %v", err)
    76  	}
    77  
    78  	// Output:
    79  	// entry[00]: beg="beg-000" f64=0
    80  	// entry[01]: beg="beg-001" f64=1
    81  	// entry[02]: beg="beg-002" f64=2
    82  	// entry[03]: beg="beg-003" f64=3
    83  	// entry[04]: beg="beg-004" f64=4
    84  	// entry[05]: beg="beg-005" f64=5
    85  	// entry[06]: beg="beg-006" f64=6
    86  	// entry[07]: beg="beg-007" f64=7
    87  	// entry[08]: beg="beg-008" f64=8
    88  	// entry[09]: beg="beg-009" f64=9
    89  	// entry[10]: beg="beg-010" f64=10
    90  	// entry[11]: beg="beg-011" f64=11
    91  	// entry[12]: beg="beg-012" f64=12
    92  	// entry[13]: beg="beg-013" f64=13
    93  	// entry[14]: beg="beg-014" f64=14
    94  	// entry[15]: beg="beg-015" f64=15
    95  	// entry[16]: beg="beg-016" f64=16
    96  	// entry[17]: beg="beg-017" f64=17
    97  	// entry[18]: beg="beg-018" f64=18
    98  	// entry[19]: beg="beg-019" f64=19
    99  }
   100  
   101  // ExampleChainOf shows how to create a chain made of trees from 2 files.
   102  func ExampleChainOf() {
   103  	const name = "tree"
   104  
   105  	chain, closer, err := rtree.ChainOf(name, "../testdata/chain.1.root", "../testdata/chain.2.root")
   106  	if err != nil {
   107  		log.Fatal(err)
   108  	}
   109  	defer func() {
   110  		err = closer()
   111  		if err != nil {
   112  			log.Fatalf("could not close ROOT chain: %+v", err)
   113  		}
   114  	}()
   115  
   116  	type Data struct {
   117  		Event struct {
   118  			Beg       string      `groot:"Beg"`
   119  			F64       float64     `groot:"F64"`
   120  			ArrF64    [10]float64 `groot:"ArrayF64"`
   121  			N         int32       `groot:"N"`
   122  			SliF64    []float64   `groot:"SliceF64"`
   123  			StdStr    string      `groot:"StdStr"`
   124  			StlVecF64 []float64   `groot:"StlVecF64"`
   125  			StlVecStr []string    `groot:"StlVecStr"`
   126  			End       string      `groot:"End"`
   127  		} `groot:"evt"`
   128  	}
   129  
   130  	var data Data
   131  	r, err := rtree.NewReader(chain, rtree.ReadVarsFromStruct(&data))
   132  	if err != nil {
   133  		log.Fatal(err)
   134  	}
   135  	defer r.Close()
   136  
   137  	err = r.Read(func(ctx rtree.RCtx) error {
   138  		fmt.Printf(
   139  			"entry[%02d]: beg=%q f64=%v\n",
   140  			ctx.Entry, data.Event.Beg, data.Event.F64,
   141  		)
   142  		return nil
   143  	})
   144  
   145  	if err != nil {
   146  		log.Fatalf("error during scan: %v", err)
   147  	}
   148  
   149  	// Output:
   150  	// entry[00]: beg="beg-000" f64=0
   151  	// entry[01]: beg="beg-001" f64=1
   152  	// entry[02]: beg="beg-002" f64=2
   153  	// entry[03]: beg="beg-003" f64=3
   154  	// entry[04]: beg="beg-004" f64=4
   155  	// entry[05]: beg="beg-005" f64=5
   156  	// entry[06]: beg="beg-006" f64=6
   157  	// entry[07]: beg="beg-007" f64=7
   158  	// entry[08]: beg="beg-008" f64=8
   159  	// entry[09]: beg="beg-009" f64=9
   160  	// entry[10]: beg="beg-010" f64=10
   161  	// entry[11]: beg="beg-011" f64=11
   162  	// entry[12]: beg="beg-012" f64=12
   163  	// entry[13]: beg="beg-013" f64=13
   164  	// entry[14]: beg="beg-014" f64=14
   165  	// entry[15]: beg="beg-015" f64=15
   166  	// entry[16]: beg="beg-016" f64=16
   167  	// entry[17]: beg="beg-017" f64=17
   168  	// entry[18]: beg="beg-018" f64=18
   169  	// entry[19]: beg="beg-019" f64=19
   170  }