Пример #1
0
func (w *CalibBase) FileTree(file, tree string) (croot.File, croot.Tree) {
	var err error
	var f croot.File
	var t croot.Tree

	key := w.workdir + file
	if c, ok := w.cache[key]; ok {
		f = c.file
		t = c.tree
	} else {
		fname := path.Join(w.workdir, file)
		f, err = croot.OpenFile(fname, "read", "TUCS ROOT file", 1, 0)
		if f != nil && err == nil {
			t = f.GetTree(tree)
			if t == nil {
				fmt.Printf("**error** tucs.FileTree failed to grab file=%s tree=%s\n",
					file, tree)
			} else {
				w.cache[key] = centry{
					file: f,
					tree: t,
				}
			}
		}
	}
	return f, t
}
Пример #2
0
// InitHistFile grabs the ROOT file 'fname' and makes it the current gDirectory
func (b *Base) InitHistFile(fname string) error {
	var err error
	const compress = 1
	const netopt = 0

	hfile := croot.GRoot.GetFile(fname)
	if hfile == nil {
		hfile, err = croot.OpenFile(fname, "recreate", "TUCS histogram", compress, netopt)
	}
	if err != nil {
		return err
	}
	if hfile == nil {
		return fmt.Errorf("tucs.Base: could not open file [%s]", fname)
	}
	b.HistFile = hfile
	if !b.HistFile.Cd("") {
		return fmt.Errorf("tucs.Base: could not make [%s] the current directory", fname)
	}
	return err
}
Пример #3
0
func main() {
	flag.Parse()

	if *fname == "" {
		if len(os.Args) > 1 {
			*fname = os.Args[1]
		}
	}

	if *oname == "" {
		if len(os.Args) > 2 {
			*oname = os.Args[2]
		}
	}

	if *oname == "" || *fname == "" {
		fmt.Fprintf(
			os.Stderr,
			"**error** you need to give an input file name and an output file name\n",
		)
		flag.Usage()
		os.Exit(1)
	}

	var f io.Reader

	ff, err := os.Open(*fname)
	if err != nil {
		fmt.Fprintf(
			os.Stderr,
			"**error** %v\n",
			err,
		)
		os.Exit(1)
	}
	defer ff.Close()
	f = ff
	if strings.HasSuffix(*fname, ".gz") {
		f, err = gzip.NewReader(ff)
		if err != nil {
			fmt.Fprintf(
				os.Stderr,
				"**error** %v\n",
				err,
			)
			os.Exit(1)
		}
	}

	dec, err := arff.NewDecoder(f)
	if err != nil {
		fmt.Fprintf(
			os.Stderr,
			"**error** %v\n",
			err,
		)
		os.Exit(1)
	}

	o, err := croot.OpenFile(*oname, "recreate", "ARFF event file", 1, 0)
	if err != nil {
		fmt.Fprintf(
			os.Stderr,
			"**error** %v\n",
			err,
		)
		os.Exit(1)
	}
	defer o.Close("")

	fmt.Printf(":: arff file - relation: [%v]\n", dec.Header.Relation)

	tree := croot.NewTree(dec.Header.Relation, dec.Header.Relation, 32)
	if tree == nil {
		err = fmt.Errorf(
			"arff2root: could not create output tree [%s] in file [%s]",
			dec.Header.Relation,
			*oname,
		)
		fmt.Fprintf(
			os.Stderr,
			"**error** %v\n",
			err,
		)
		os.Exit(1)
	}

	type RootVar struct {
		Value interface{}
	}
	idata := make(map[string]interface{})
	//odata := make(map[string]*RootVar)
	odata := make([]interface{}, len(dec.Header.Attrs))
	const bufsize = 32000

	// declare branches
	for i, attr := range dec.Header.Attrs {
		//fmt.Printf(">>> [%d]: %v\n", i, attr)
		switch attr.Type {
		case arff.Integer:
			vv := int64(0)
			br_name := attr.Name
			br_type := br_name + "/L"
			odata[i] = &vv
			_, err = tree.Branch2(br_name, odata[i], br_type, bufsize)
		case arff.Real, arff.Numeric:
			vv := float64(-999.0)
			br_name := attr.Name
			br_type := br_name + "/D"
			odata[i] = &vv
			_, err = tree.Branch2(br_name, odata[i], br_type, bufsize)
		case arff.Nominal:
			vv := ""
			br_name := attr.Name
			br_type := br_name + "/C"
			odata[i] = &vv
			_, err = tree.Branch2(br_name, odata[i], br_type, bufsize)
		default:
			fmt.Fprintf(
				os.Stderr,
				"**error** invalid type for attribute: %v\n",
				attr,
			)
			os.Exit(1)
		}
		if err != nil {
			fmt.Fprintf(
				os.Stderr,
				"**error** setting up branch for attribute [%s]: %v\n",
				attr.Name,
				err,
			)
			os.Exit(1)
		}
	}

	for {
		err = dec.Decode(idata)
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Fprintf(
				os.Stderr,
				"**error** %v\n",
				err,
			)
			os.Exit(1)
		}
		for i, attr := range dec.Header.Attrs {
			k := attr.Name
			v := idata[k]
			//fmt.Printf(">>> [%v]: %v\n", k, v)
			if v == nil {
				err = fmt.Errorf(
					"nil value for attribute [%v]",
					k,
				)
				fmt.Fprintf(
					os.Stderr,
					"**error** %v\n",
					err,
				)
				os.Exit(1)
			}
			switch attr.Type {
			case arff.Integer:
				vv := odata[i].(*int64)
				*vv = v.(int64)
				//fmt.Printf(">> [%v]: %v %v %T\n", k, v, odata[i], odata[i])
			case arff.Numeric, arff.Real:
				vv := odata[i].(*float64)
				*vv = v.(float64)
				//fmt.Printf(">> [%v]: %v %v %T\n", k, v, odata[i], odata[i])
			case arff.Nominal:
				vv := odata[i].(*string)
				*vv = v.(string)
			}
		}
		_, err = tree.Fill()
		if err != nil {
			fmt.Fprintf(
				os.Stderr,
				"**error** filling tree: %v\n",
				err,
			)
			os.Exit(1)
		}
	}
	tree.Write("", 0, 0)

}
Пример #4
0
func inspect_root_file(filename, treename string) []pb_field {

	f := croot.OpenFile(filename, "read", "ROOT file", 1, 0)
	if f == nil {
		fmt.Printf("**error** could not open ROOT file [%s]\n", filename)
		os.Exit(1)
	}
	defer f.Close("")

	tree := f.GetTree(treename)
	if tree == nil {
		fmt.Printf("**error** could not retrieve Tree [%s] from file [%s]\n",
			treename, filename)
	}

	//tree.Print("*")

	branches := tree.GetListOfBranches()
	fmt.Printf("   #-branches: %v\n", branches.GetSize())

	imax := branches.GetSize()

	type stringset map[string]struct{}

	pb_fields := []pb_field{}

	for i := int64(0); i < imax; i++ {
		obj := branches.At(i)
		br := obj.(croot.Branch)
		typename := br.GetClassName()
		if typename == "" {
			leaf := tree.GetLeaf(br.GetName())
			typename = leaf.GetTypeName()
		}
		if *verbose {
			fmt.Printf(" [%d] -> [%v] (%v) (type:%v)\n", i, obj.GetName(), br.ClassName(), typename)
		}
		name := br.GetName()
		pb_type, isrepeated := get_pb_type(typename)
		accept := true
		if *brsel != "" {
			accept = false
			for _, pattern := range strings.Split(*brsel, ",") {
				switch pattern[0] {
				case '-':
					matched, err := filepath.Match(pattern[1:], name)
					if err == nil && matched {
						accept = false
						break
					}
				case '+':
					matched, err := filepath.Match(pattern[1:], name)
					if err == nil && matched {
						accept = true
						break
					}
				default:
					matched, err := filepath.Match(pattern, name)
					if err == nil && matched {
						accept = true
						break
					}
				}
			}
		}
		if accept {
			pb_fields = append(pb_fields,
				pb_field{
					Name:     pb_gen.CamelCase(name),
					Type:     pb_type,
					Id:       <-gen_id,
					Branch:   name,
					repeated: isrepeated,
				})
		}
	}

	return pb_fields
}
Пример #5
0
func main() {
	flag.Parse()

	if *fname == "" || *tname == "" {
		flag.Usage()
		os.Exit(1)
	}

	if *oname == "" {
		*oname = path.Base(*fname)
		*oname = strings.Replace(*oname, ".root", ".pbuf", -1)
	}

	fmt.Printf(":: cnv ROOT file into pbuf...\n")
	fmt.Printf("::  ROOT file: [%s]\n", *fname)
	fmt.Printf("::  ROOT tree: [%s]\n", *tname)
	fmt.Printf("::  PBuf file: [%s]\n", *oname)
	fmt.Printf("::  evtmax:    [%v]\n", *evtmax)

	f := croot.OpenFile(*fname, "read", "ROOT file", 1, 0)
	if f == nil {
		fmt.Printf("**error** could not open ROOT file [%s]\n", *fname)
		os.Exit(1)
	}
	defer f.Close("")

	tree := f.GetTree(*tname)
	if tree == nil {
		fmt.Printf("**error** could not retrieve Tree [%s] from file [%s]\n",
			*tname, *fname)
	}

	if *evtmax < 0 {
		*evtmax = int64(tree.GetEntries())
	}
	
	out, err := os.Create(*oname)
	if err != nil {
		fmt.Printf("**error** could not create output file [%s]\n%v\n", 
			*oname, err)
		os.Exit(1)
	}
	defer func(){
		err := out.Sync()
		if err != nil {
			fmt.Printf("**error** problem commiting data to disk: %v\n", err)
		}
		err = out.Close()
		if err != nil {
			fmt.Printf("**error** problem closing file: %v\n", err)
		}
	}()

	// proto-buf data-hdr
	{
		hdr := msgpkg.{{.DataHeader}}{}
		hdr.Nevts = proto.Uint64(uint64(*evtmax))
		data, err := proto.Marshal(&hdr)
		if err != nil {
			fmt.Printf("**error** event-hdr: problem marshalling pbuf: %v\n", 
				err)
			os.Exit(1)
		}
		_, err = out.Write(data)
		if err != nil {
			fmt.Printf("**error** event-hdr: problem writing header: %v\n", 
				err)
			os.Exit(1)
		}
	}