Use rawbank views for sprucing

##Usage, inside Moore/
#./run python -i DSTexplore.py -input xxx.[dst, mdf] -tck yyy.tck.json -process process -stream stream

import sys, GaudiPython as GP
from GaudiConf import IOExtension
from GaudiConf.reading import (decoder, unpackers, unpack_rawevent,
                               hlt2_decisions, spruce_decisions)
from Configurables import ApplicationMgr, LHCbApp
LHCb = GP.gbl.LHCb
import argparse

#Argument parser
parser = argparse.ArgumentParser(
    usage="./run python -i %(prog)s xxx.[dst, mdf] yyy.tck.json process stream",
    description='Inspect Moore output')
parser.add_argument('-input', type=str, help='Input MDF or DST')
parser.add_argument('-tck', type=str, help='.tck.json file from the job')
parser.add_argument(
    '-process',
    type=str,
    help=
    'process can be Spruce or Turbo (or Hlt2). Note Hlt2 option will be removed as all streams will go through Sprucing'
)
parser.add_argument(
    '-stream',
    type=str,
    nargs='?',
    default="default",
    help='Stream to test, default if no value given')
args = parser.parse_args()


# Helper function to select events with given line decision
def advance_HLT(decision):
    """Return event with given line decision."""
    while True:
        appMgr.run(1)
        if not evt['/Event']:
            sys.exit("Did not find positive {0} decision".format(decision))
        if args.process == 'Hlt2':
            loc = '/Event/Hlt/DecReports'
        else:
            loc = '/Event/' + args.stream
        reports = evt[loc]
        report = reports.decReport('{0}Decision'.format(decision))
        if report.decision() == 1:
            break

    return


##Helper functions for returning routing bits
def routing_bits():
    """Return a list with the 96 routing bit values."""

    if args.process == 'Hlt2':
        loc = '/Event/DAQ/RawEvent'
    else:
        loc = '/Event/' + args.stream
    rawevent = evt[loc]
    rbbanks = rawevent.banks(LHCb.RawBank.HltRoutingBits)
    on_bits = []
    for bank in range(0, len(rbbanks)):
        d = rbbanks[bank].data()
        bits = "{:032b}{:032b}{:032b}".format(d[2], d[1], d[0])
        ordered = list(map(int, reversed(bits)))
        for i in range(0, len(ordered)):
            if ordered[i] == 1:
                on_bits.append(str(i))

    return on_bits


# Change the tags if required
LHCbApp(
    DataType="Upgrade",
    Simulation=True,
    DDDBtag="dddb-20201211",
    CondDBtag="sim-20201218-vc-md100",
)

assert args.process == "Spruce" or args.process == "Turbo" or args.process == "Hlt2", 'process is Turbo or Spruce (or Hlt2). Note Hlt2 option will be removed as all streams will go through Sprucing'

# Setup HltANNSvc
if args.process == 'Hlt2':
    from Moore.tcks import load_hlt2_configuration as load_tck
else:
    from Moore.tcks import load_sprucing_configuration as load_tck

ann = load_tck(args.tck, annsvc_name="HltANNSvc")

inputFiles = [args.input]
IOExtension().inputFiles((inputFiles), clear=True)

# Unpack the raw event to give RawBank::Views.
# Unpacks 'DstData' and 'HltDecReports' to RawBank::Views by default
# which are input to `decoder` (which calls `HltPackedDataDecoder`)
# and `HltDecReportsDecoder`
algs = [
    unpack_rawevent(process=args.process, stream=args.stream, OutputLevel=4)
]

# Decoder uses HltANNSvc to convert integers back to the packed TES locations according to tck
algs += [decoder(process=args.process, stream=args.stream, OutputLevel=4)]

# HltDecReports decoders uses HltANNSvc to decode integers back to the line decision names according to tck
algs += [
    hlt2_decisions(process=args.process, stream=args.stream, OutputLevel=4)
]

if args.process == 'Spruce' or args.process == 'Turbo':
    algs += [
        spruce_decisions(
            process=args.process, stream=args.stream, OutputLevel=4)
    ]

# Unpack TES locations
algs += unpackers(process=args.process, OutputLevel=4)

ApplicationMgr(TopAlg=algs)

appMgr = GP.AppMgr()
evt = appMgr.evtsvc()

appMgr.run(1)
evt.dump()