{toggle-cloak:id=ipimb_psana}

{cloak:id=ipimb_psana}

#include "psddl_psana/ipimb.ddl.h"

Source m_src = configStr("source", "DetInfo(:Ipimb)");
shared_ptr<Psana::Ipimb::ConfigV1> config1 = env.configStore().get(m_src);

shared_ptr<Psana::Ipimb::DataV1> data1 = evt.get(m_src);

{cloak}

{toggle-cloak:id=ipimb_pyana}

{cloak:id=ipimb_pyana}

from pypdsdata.xtc import TypeId

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        config = env.getConfig( xtc.TypeId.Type.Id_IpimbConfig , self.addr )

    def event(self, evt, env):
        ipm_raw = evt.get(xtc.TypeId.Type.Id_IpimbData, self.addr )
        ipm_fex = evt.get(xtc.TypeId.Type.Id_IpmFex, self.addr )

{cloak}

{toggle-cloak:id=enc_psana}

{cloak:id=enc_psana}

#include "psddl_psana/encoder.ddl.h"

Source m_src = configStr("source", "DetInfo(:Encoder)");
shared_ptr<Psana::Encoder::ConfigV1> config1 = env.configStore().get(m_src);

shared_ptr<Psana::Encoder::DataV1> data1 = evt.get(m_src);

{cloak}

{toggle-cloak:id=enc_pyana}

{cloak:id=enc_pyana}

from pypdsdata.xtc import TypeId

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        config = env.getConfig( xtc.TypeId.Type.Id_EncoderConfig , self.addr )
        self.channel = None
        try:  # only for ConfigV2 and higher
            self.channel = 0
            while ( (config._chan_mask & (1<<self.channel==0 )):
                self.channel+=1
        except: 
            pass

    def event(self, evt, env):
        data = evt.get(xtc.TypeId.Type.Id_EncoderData, self.addr )
        if self.channel is not None:
            value = encoder.value( self.channel )
        else :
            value = encoder.value() )

{cloak}

{toggle-cloak:id=opal_psana}

{cloak:id=opal_psana}

#include "psddl_psana/opal1k.ddl.h"

Source m_src = configStr("source", "DetInfo(:Opal1000)");
shared_ptr<Psana::Opal1k::ConfigV1> config1 = env.configStore().get(m_src);

shared_ptr<Psana::Opal1k::DataV1> data1 = evt.get(m_src);

{cloak}

{toggle-cloak:id=opal_pyana}

{cloak:id=opal_pyana}

from pypdsdata.xtc import TypeId

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        config = env.getConfig(TypeId.Type.Id_Opal1kConfig, self.addr )

    def event(self, evt, env):
        frame = evt.get(TypeId.Type.Id_Frame, self.addr )
        image = frame.data()

{cloak}

{toggle-cloak:id=pulnix_psana}

{cloak:id=pulnix_psana}

{cloak}

{toggle-cloak:id=pulnix_pyana}

{cloak:id=pulnix_pyana}

from pypdsdata.xtc import TypeId

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        config = env.getConfig(TypeId.Type.Id_TM6740Config, self.addr )

    def event(self, evt, env):
        frame = evt.get(TypeId.Type.Id_Frame, self.addr )
        image = frame.data()

{cloak}

{toggle-cloak:id=princ_psana}

{cloak:id=princ_psana}

#include "psddl_psana/princeton.ddl.h"

   shared_ptr<Psana::Princeton::ConfigV2> config = env.configStore().get("DetInfo(:Princeton)");

   shared_ptr<Psana::Princeton::FrameV2> frame = evt.get("DetInfo(:Princeton)");
   const ndarray<uint16_t, 2>& data = frame->data();
   // data is now a 2d array of 16-bit integers. Access it's elements in the usual array fashion: data[i][j]

{cloak}

{toggle-cloak:id=princ_pyana}

{cloak:id=princ_pyana}

from pypdsdata.xtc import TypeId

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        config = env.getConfig(TypeId.Type.Id_PrincetonConfig, self.addr )

    def event(self, evt, env):
        frame = evt.get(TypeId.Type.Id_PrincetonFrame, self.addr )
        image = frame.data()

{cloak}

{toggle-cloak:id=fccd_psana}

{cloak:id=fccd_psana}

{cloak}

{toggle-cloak:id=fccd_pyana}

{cloak:id=fccd_pyana}

from pypdsdata.xtc import TypeId

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        config = env.getConfig(TypeId.Type.Id_FccdConfig, self.addr )

    def event(self, evt, env):
        frame = evt.get(TypeId.Type.Id_Frame, self.addr )
        image = frame.data()

        # convert to 16-bit integer
        image.dtype = np.uint16

{cloak}

{toggle-cloak:id=pnccd_psana}

{cloak:id=pnccd_psana}

{cloak}

{toggle-cloak:id=pnccd_pyana}

{cloak:id=pnccd_pyana}

from pypdsdata.xtc import TypeId

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        config = env.getConfig(TypeId.Type.Id_pnCCDconfig, self.addr )

    def event(self, evt, env):
        frame = evt.get(TypeId.Type.Id_pnCCDframe, self.addr )
        image = frame.data()

{cloak}

{toggle-cloak:id=cspad_psana}

{cloak:id=cspad_psana}

{cloak}

{toggle-cloak:id=cspad_pyana}

{cloak:id=cspad_pyana}

from pypdsdata.xtc import TypeId

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        config = env.getConfig(TypeId.Type.Id_CspadConfig, self.addr )

        self.sections = map(config.sections, range(4))
        # keep this list of sections in use by each quad

    def event(self, evt, env):
        elements = evt.get(TypeId.Type.Id_CspadElement, self.addr )
        # elements is a python list of CspadElement objects

        # To fully populate a 4x8x185x388 array (standard used by pedestal files),
        # create array of zeros and fill in what we have
        pixel_array = np.zeros((4,8,185,388), dtype="uint16")
        for e in elements :
            data = e.data()        # 8x185x388
            quad = e.quad()        # integer
            for n,s in enumerate(self.sections[quad]) :
                pixel_array[quad,s] = data[n]

{cloak}

{toggle-cloak:id=mini_psana}

{cloak:id=mini_psana}

{cloak}

{toggle-cloak:id=mini_pyana}

{cloak:id=mini_pyana}

from pypdsdata.xtc import TypeId

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        config = env.getConfig(TypeId.Type.Id_CspadConfig, self.addr )

    def event(self, evt, env):
        element = evt.get(TypeId.Type.Id_Cspad2x2Element, self.addr )
        data = element.data()
        # data is now a 3D array: 185x388x2 

{cloak}

{toggle-cloak:id=timepix_psana}

{cloak:id=timepix_psana}

{cloak}

{toggle-cloak:id=timepix_pyana}

{cloak:id=timepix_pyana}

from pypdsdata.xtc import TypeId

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        config = env.getConfig(TypeId.Type.Id_TimepixConfig, self.addr )

    def event(self, evt, env):
        frame = evt.get(TypeId.Type.Id_TimepixData, self.addr )
        image = frame.data()

{cloak}

{toggle-cloak:id=ebeam_psana}

{cloak:id=ebeam_psana}

{cloak}

{toggle-cloak:id=ebeam_pyana}

{cloak:id=ebeam_pyana}

    def __init__ ( self ):
        pass

    def beginjob(self, evt, env):
        pass

    def event(self, evt, env):
        ebeam = evt.getEBeam()
        if ebeam is not None: 
            beamDmgM = ebeam.uDamageMask
            beamChrg = ebeam.fEbeamCharge
            beamEnrg = ebeam.fEbeamL3Energy
            beamPosX = ebeam.fEbeamLTUPosX
            beamPosY = ebeam.fEbeamLTUPosY
            beamAngX = ebeam.fEbeamLTUAngX
            beamAngY = ebeam.fEbeamLTUAngY           

{cloak}

{toggle-cloak:id=gasd_psana}

{cloak:id=gasd_psana}

{cloak}

{toggle-cloak:id=gasd_pyana}

{cloak:id=gasd_pyana}

    def __init__ ( self ):
        pass

    def beginjob(self, evt, env):
        pass

    def event(self, evt, env):
        fee_energy_array = evt.getFeeGasDet()
        # an array of 4 energy measurements

{cloak}

{toggle-cloak:id=pc_psana}

{cloak:id=pc_psana}

#include "psddl_psana/bld.ddl.h"

ClassName::ClassName(const std::string& name)
  : Module(name)
{
   m_cavSrc = configStr("phaseCavSource", "BldInfo(PhaseCavity)");
}

void
ClassName::event(Event& evt, Env& env)
{
  shared_ptr<Psana::Bld::BldDataPhaseCavity> myPhaseCavity = evt.get(m_cavSrc);
  if (myPhaseCavity.get()) {
    WithMsgLog(name(), info, str) {
      str << "Bld::BldDataPhaseCavity:"
          << "\n  fitTime1=" << myPhaseCavity->fitTime1()
          << "\n  fitTime2=" << myPhaseCavity->fitTime2()
          << "\n  charge1=" << myPhaseCavity->charge1()
          << "\n  charge2=" << myPhaseCavity->charge2();
    }
}

{cloak}

{toggle-cloak:id=pc_pyana}

{cloak:id=pc_pyana}

    def __init__ ( self ):
        pass

    def beginjob(self, evt, env):
        pass

    def event(self, evt, env):
        pc = evt.getPhaseCavity()
        if pc is not None:
            fitTime1 = pc.fFitTime1 
            fitTime2 pc.fFitTime2 
            charge1 = pc.fCharge1 
            charge2 = pc.fCharge2 

{cloak}

{toggle-cloak:id=shared_psana}

{cloak:id=shared_psana}

{cloak}

{toggle-cloak:id=shared_pyana}

{cloak:id=shared_pyana}

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        pass

    def event(self, evt, env):
        ipm = evt.get(xtc.TypeId.Type.Id_SharedIpimb, self.addr )
        if ipm is not None: 

            # raw counts
            ch0 = ipm.ipimbData.channel0Volts()
            ch1 = ipm.ipimbData.channel1Volts()
            ch2 = ipm.ipimbData.channel2Volts()
            ch3 = ipm.ipimbData.channel3Volts()
          
            # fex values and derived quantities
            channels = ipm.ipmFexData.channel
            sum = ipm.ipmFexData.sum
            xpos = ipm.ipmFexData.xpos
            ypos = ipm.ipmFexData.ypos

{cloak}

{toggle-cloak:id=epics_psana}

{cloak:id=epics_psana}

{cloak}

{toggle-cloak:id=epics_pyana}

{cloak:id=epics_pyana}

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        pass

    def event(self, evt, env):
        pass

{cloak}

{toggle-cloak:id=evr_psana}

{cloak:id=evr_psana}

#include "psddl_psana/evr.ddl.h"
void MyClass::beginCalibCycle(Event& evt, Env& env)
{
   shared_ptr<Psana::EvrData::ConfigV1> config = env.configStore().get(source);
   if (config.get()){
        // do something with the config object here (see examples in psana_examples/src/DumpEvt.cpp
   }
}

void MyClass::event(Event& evt, Env& env)
{
  shared_ptr<Psana::EvrData::DataV3> data3 = evt.get(m_evrSrc);
  if (data3.get()) {   
      ndarray<Psana::EvrData::FIFOEvent, 1>  fifoEvents = data3->fifoEvents();
      for (int i(0); i<data3->numFifoEvents(); i++){
	evtCode = fifoEvents[i].eventCode(); 
	tsLow =  fifoEvents[i].timestampLow(); 
	tsHigh = fifoEvents[i].timestampHigh(); 
      }
    }
}

{cloak}

{toggle-cloak:id=evr_pyana}

{cloak:id=evr_pyana}

import pyana
from pypdsdata import xtc

    def __init__ ( self, addr = "" ):
        self.addr = addr

    def beginjob(self, evt, env):
        pass

    def event(self, evt, env):

        data = evt.get(xtc.TypeId.Type.Id_EvrData, "NoDetector-0|Evr-0")
        if data:
            # print info to screen:
            print "  numFifoEvents =", data.numFifoEvents()
            for i in range(data.numFifoEvents()):
                f = data.fifoEvent(i)
                print "    fifo event #%d TimestampHigh=%d TimestampLow=%d EventCode=%d" % \
                (i, f.TimestampHigh, f.TimestampLow, f.EventCode)

             # filter on event codes: 
             # get a list of all event codes in this event
             event_codes = [ data.fifoEvent(i).EventCode
                             for i in range(0,data.numFifoEvents()) ]
             # skip event if we find code 162
             if 162 in event_codes :
                 print "Found EventCode 162, skipping this event!"
                 return pyana.Skip

{cloak}