wirecell.sigproc.response.PlaneImpactBlocks Class Reference

Inheritance diagram for wirecell.sigproc.response.PlaneImpactBlocks:

Public Member Functions
def	__init__ (self, rflist, xstart=0.0 *units.cm)
def	region_block (self, plane, impact)
def	response (self, plane, impact, region)

Public Attributes
	ntbins
	tmin
	tbin
	trange
	tmax
	xstart
	plane_keys
	region_keys
	impact_keys

Private Attributes
	_tree
	_by_plane_impact

Detailed Description

Organize responses into per (plane,impact) and make available as
array blocks of shape (Nregion,Ntbins).

There are two symmetries for response Resp(w,r,i) on wire w for
path near wire region r on impact i.

    - Due to reciprocity: Resp(w=0,r=N,i) = R(w=N,r=0,i)

    - Due to geometry: R(w=0,r=N,i=M) = R(w=0,r=-N,i=-M)

See the functions `plots.plane_impact_blocks_full()` and
`plots.plane_impact_blocks()` for visualizing this data.  In
particular check for continuous patterns of responses across
different impact positions in the first and check that U-plane,
high-positive impact position puts most response on wires 0 and 1
and high-negative impact positions puts most response on wires 0
and -1.

Definition at line 372 of file __init__.py.

Constructor & Destructor Documentation

def wirecell.sigproc.response.PlaneImpactBlocks.__init__	(		self,
			rflist,
			xstart = 0.0*units.cm
	)

Definition at line 392 of file __init__.py.

    def __init__(self, rflist, xstart = 0.0*units.cm):

        onerf = rflist[0]
        self.ntbins = len(onerf.response)
        self.tmin = onerf.times[0]
        self.tbin = onerf.times[1]-onerf.times[0]
        self.trange = self.tbin*self.ntbins
        self.tmax = self.trange + self.tmin

        self.xstart = xstart # x position at start of field response drift


        self.plane_keys = sorted(set([rf.plane for rf in rflist]))
        self.region_keys = sorted(set([rf.region for rf in rflist]))
        self.impact_keys = sorted(set([rf.impact for rf in rflist] + [-rf.impact for rf in rflist]))

        # Organize flat rflist into tree [plane][impact][region]
        tree = dict()
        byplane = group_by(rflist, 'plane') # uvw
        for inplane in byplane:
            plane_letter = inplane[0].plane
            tree[plane_letter] = tree_plane = dict()
            byimpact = group_by(inplane, 'impact')
            for inimpact in byimpact:
                # WARNING: Garfield seems to measure either wire
                # region number xor impact position in a different
                # direction than is assumed here.  Garfield impact
                # positions are always positive.
                impact = -1*inimpact[0].impact
                assert impact <= 0.0

                tree_plane[-impact] = tree_impact_pos = dict()
                tree_plane[impact] = tree_impact_neg = dict()
                
                byregion = group_by(inimpact, 'region')
                for inregion in byregion:
                    assert len(inregion) == 1
                    rf = inregion[0]
                    region = rf.region
                    tree_impact_pos[region] = rf
                    tree_impact_neg[-region] = rf
        self._tree = tree
        self._by_plane_impact = dict()

Member Function Documentation

def wirecell.sigproc.response.PlaneImpactBlocks.region_block	(		self,
			plane,
			impact
	)

Return an array shaped (Nregions, Ntbins) for the given plane
and impact.  Row=0 corresponds to the highest region (wire 10).

Definition at line 436 of file __init__.py.

    def region_block(self, plane, impact):
        '''
        Return an array shaped (Nregions, Ntbins) for the given plane
        and impact.  Row=0 corresponds to the highest region (wire 10).
        '''
        key = (plane,impact)    # cache the built array
        try:
            return self._by_plane_impact[key]
        except KeyError:
            pass
        ppi = self._tree[plane][impact]
        rfs = [ppi[r] for r in self.region_keys]
        mat = numpy.zeros((len(self.region_keys), len(rfs[0].response)))
        for row,rf in enumerate(rfs):
            mat[row] = rf.response
        self._by_plane_impact[key] = mat
        return mat
            

def wirecell.sigproc.response.PlaneImpactBlocks.response	(		self,
			plane,
			impact,
			region
	)

Definition at line 454 of file __init__.py.

    def response(self, plane, impact, region):
        return self._tree[plane][impact][region].response

Member Data Documentation

wirecell.sigproc.response.PlaneImpactBlocks._by_plane_impact

private

Definition at line 434 of file __init__.py.

wirecell.sigproc.response.PlaneImpactBlocks._tree

private

Definition at line 433 of file __init__.py.

wirecell.sigproc.response.PlaneImpactBlocks.impact_keys

Definition at line 406 of file __init__.py.

wirecell.sigproc.response.PlaneImpactBlocks.ntbins

Definition at line 395 of file __init__.py.

wirecell.sigproc.response.PlaneImpactBlocks.plane_keys

Definition at line 404 of file __init__.py.

wirecell.sigproc.response.PlaneImpactBlocks.region_keys

Definition at line 405 of file __init__.py.

wirecell.sigproc.response.PlaneImpactBlocks.tbin

Definition at line 397 of file __init__.py.

wirecell.sigproc.response.PlaneImpactBlocks.tmax

Definition at line 399 of file __init__.py.

wirecell.sigproc.response.PlaneImpactBlocks.tmin

Definition at line 396 of file __init__.py.

wirecell.sigproc.response.PlaneImpactBlocks.trange

Definition at line 398 of file __init__.py.

wirecell.sigproc.response.PlaneImpactBlocks.xstart

Definition at line 401 of file __init__.py.

---

The documentation for this class was generated from the following file:

• wire-cell-build/python/wirecell/sigproc/response/__init__.py