def starting_time(self, exp_run):
        """exp_run: contains experiment number, run number, e.g.
        'exp=xppj1216:run=17'"""
        from tempfile import gettempdir
        from pickle import load, dump

        if self.starting_times == {}:
            try:
                self.starting_times = load(
                    file(gettempdir() + "/datastream.starting_times.pkl"))
            except:
                pass

        if exp_run in self.starting_times:
            return self.starting_times[exp_run]
        from psana import DataSource, EventId
        try:
            ds = DataSource(exp_run)
            for event in ds.events():
                s, ns = event.get(EventId).time()
                t = s + ns * 1e-9
                debug("%s: %s" % (exp_run, date_time(t)))
                break
        except Exception, msg:
            debug("%s: %s" % (exp_run, msg))
            t = nan
Beispiel #2
0
    def _retrieve_batch_evt(self, num_shots):
        """
        Retrieve num_shots patterns from a run of the experiment.
        
        :param num_shots: number of patterns to retrieve
        :return data: array of patterns in shape (num_shots, n_pedestals, ped_x, ped_y)
        """
        # set up psana1 DataSource object
        from psana import DataSource
        ds = DataSource('exp=%s:run=%i' %(self.exp, self.run_num))
    
        # set up storage array
        if self.pedestals.ndim == 4:
            pshape = self.pedestals.shape[1:]
        else:
            pshape = self.pedestals.shape
        data = np.zeros((num_shots, pshape[0], pshape[1], pshape[2]))

        # retrieve multiple events (shots)
        counter = 0
        for num,evt in enumerate(ds.events()):
            if counter < num_shots:
                data[counter] = np.array(self._calibrate_evt(evt))
                counter += 1
            else:
                break

        # if run is shorter than num_shots, fill in remainder by linear combination
        if counter < num_shots:
            for i in range(counter, num_shots):
                indices = np.random.randint(0, high=counter, size=2)
                weights = np.random.dirichlet(np.ones(2))
                data[i] = weights[0]*data[indices[0]] + weights[1]*data[indices[1]]
            
        return data
Beispiel #3
0
def myroutine():
    ds = DataSource('data.xtc')
    for nevent, evt in enumerate(ds.events()):
        if nevent == 0:
            dgrambytes_event0 = evt.dgrams[0]._dgrambytes
        elif nevent == 1:
            dgram_event1 = evt.dgrams[0]

    # be sure you know what you are doing before you change
    # these reference count numbers. - cpo
    dgrambytes_event1 = dgram_event1._dgrambytes
    # 4 for arrays, 1 for dgram, 1 for getref, 1 for dgrambytes_event1
    assert getref(dgrambytes_event1) == 7
    # event0 dgram is deleted, so only 1 for dgrambytes_event0 and 1 for getref
    assert getref(dgrambytes_event0) == 2

    return dgram_event1, ds._configs[0]
 def detectors(self, exp_run):
     """What are the names of the detectors in the datastream?
     exp_run: contains experiment number, run number, e.g. 'exp=xppj1216:run=17'
     """
     from psana import DataSource
     ds = DataSource(exp_run)
     es = ds.env().epicsStore()
     names = []
     for evt in ds.events():
         keys = evt.keys()
         for d in keys:
             # E.g. d.src(): DetInfo(NoDetector.0:Evr.0), d.alias(): 'evr0'
             name = str(d.src()).split("(")[-1].split(")")[0]
             if name and not name in names: names += [name]
             name = d.alias()
             if name and not name in names: names += [name]
             for name in es.pvNames():
                 if not name in names: names += [name]
             for name in es.aliases():
                 if not name in names: names += [name]
     return names
Beispiel #5
0
def refcnt_test(fname, nsegments, cydgram):
    ds = DataSource(files=fname)
    for nevent, evt in enumerate(ds.events()):
        if nevent == 0:
            dgrambytes_event0 = evt._dgrams[0]._dgrambytes
        elif nevent == 1:
            dgram_event1 = evt._dgrams[0]

    # be sure you know what you are doing before you change
    # these reference count numbers. - cpo
    dgrambytes_event1 = dgram_event1._dgrambytes
    # 4 arrays per segment, 1 for dgram, 1 for getref, 1 for dgrambytes_event1
    # cydgram test eliminates 3 of these arrays however (a hack since
    # the xpphsd detector has unsupported cydgram types of charstr/enum)
    if cydgram:
        assert getref(dgrambytes_event1) == 1 * nsegments + 3
    else:
        assert getref(dgrambytes_event1) == 4 * nsegments + 3

    # event0 dgram is deleted, so only 1 for dgrambytes_event0 and 1 for getref
    assert getref(dgrambytes_event0) == 2

    return dgram_event1, ds._configs[0]
Beispiel #6
0
from psana import DataSource


def filter(evt):
    return True


# Usecase#1 : two iterators
xtc_dir = os.path.join(os.getcwd(), '.tmp')
ds = DataSource('exp=xpptut13:run=1:dir=%s' % (xtc_dir), filter=filter)

#beginJobCode
for run in ds.runs():
    #beginRunCode
    for evt in run.events():
        #eventCode
        for d in evt:
            pass
    #endRunCode
#endJobCode

# Usecase#2: one iterator
for evt in ds.events():
    pass

# Usecase#3: looping through configs
for run in ds.runs():
    for configUpdate in run.configUpdates():
        for config in configUpdate.events():
            pass
Beispiel #7
0
from psana import DataSource
import matplotlib.pyplot as plt
import time

doPlot = 1

ds = DataSource('/reg/neh/home/yoon82/hsd_nov30_ps2_db.xtc') # TODO: add an example xtc file to git

tstart = time.time()
for nevt,evt in enumerate(ds.events()):
    raw = evt.xpphsd.hsd._raw()
    fex = evt.xpphsd.hsd._fex()
    samples = evt.xpphsd.hsd._samples()
    streams = evt.xpphsd.hsd._streams()
    channels = evt.xpphsd.hsd._channels()
    sync = evt.xpphsd.hsd._sync()
    waveform = evt.xpphsd.hsd.waveforms()
    pks = evt.xpphsd.hsd.peaks()
    print("raw, fex, samples, streams, channels, sync, waveform: ",
          raw, fex, samples, streams, channels, sync, waveform, pks)

    if doPlot and len(pks['chan00'][0]) > 0:
        if waveform['chan00'].size > 0:
            plt.subplot(121)
            plt.plot(waveform['chan00'], 'x-')
            plt.title("chan00 waveform: " + str(nevt))
            plt.subplot(122)
        plt.plot(pks['chan00'][1][0], 'x-')
        plt.title("chan00 fex: " + str(nevt))
        plt.show()
    #if nevt == 1: break