Public Member Functions
def	__init__ (self, cut, invert=False)

def	reset_cutindices (self)

def	__call__ (self, tables)

def	__and__ (self, other)

def	__invert__ (self)

def	__or__ (self, other)

Public Attributes
	filteridx

Private Attributes
	_cut

	_invert

	_filter

	_cutid

Detailed Description

Definition at line 256 of file core.py.

Constructor & Destructor Documentation

def PandAna.core.core.Cut.__init__	(	self,
		cut,
		invert = `False`
	)

Definition at line 257 of file core.py.

     def __init__(self, cut, invert=False):
         if type(cut) is not list: cut = [cut]
         if type(invert) is not list: invert = [invert]
         assert len(cut) == len(invert), "invalid cut definition!" 
 
         self._cut = list(cut)
         self._invert = list(invert)
 
         # index that runs over the cutlist 
         self.filteridx = 0
 
         # use these to keep track of cuts already computed
         self._filter = [0]*len(self._cut)
         self._cutid = [0]*len(self._cut)
 

Member Function Documentation

def PandAna.core.core.Cut.__and__	(	self,
		other
	)

Definition at line 323 of file core.py.

References PandAna.core.core.spectrum._cut, PandAna.core.core.Cut._cut, and PandAna.core.core.Cut._invert.

     def __and__(self, other):
         return Cut(self._cut + other._cut, self._invert + other._invert)
 

def PandAna.core.core.Cut.__call__	(	self,
		tables
	)

Definition at line 277 of file core.py.

References PandAna.core.core.spectrum._cut, PandAna.core.core.Cut._cut, PandAna.core.core.Cut._cutid, PandAna.core.core.Cut._filter, PandAna.core.core.Cut._invert, plot_validation_datamc.c, PandAna.core.core.Cut.filteridx, PandAna.Demos.demo1.range, and PandAna.core.core.Cut.reset_cutindices().

     def __call__(self, tables):
         if not tables.gone:
             cutlist = [(~c(tables) if b else c(tables)) for c, b in zip(self._cut, self._invert)]
             if not tables.interactive:
                 # tables is empty anyway. takes negligible time 
                 #return dummy cut series
                 return cutlist[0]
             else:
                 cut_df = pd.concat(cutlist, axis=1).all(axis=1)
                 cutidx = cut_df.index[np.where(cut_df)]
                 tables._tables['indices'] = cutidx
                 return cut_df
 
         # cutid holds the filtered index list after applying the cut on the entire dataset
         cutidx = self._cutid[self.filteridx]
         # actual cut that was already computed
         applycut = self._filter[self.filteridx]
 
         # cut is being computed for the first time
         if cutidx is 0:
             cut0 = self._cut[self.filteridx](tables)
             if self._invert[self.filteridx]:
                 cut0 = ~cut0
 
             # find filtered index list 
             cutidx = cut0.index[np.where(cut0)]
 
             applycut = cut0
             self._cutid[self.filteridx] = cutidx
             self._filter[self.filteridx] = applycut
         
         self.filteridx += 1
         
         # check if filtered index list is empty and if so, stop computing other cuts
         canfiltermore = all([len(cutidx.codes[k]) for k in range(len(cutidx.codes))])
         
         # if its not empty, run next cut on the filtered list rather than the entire dataset
         if len(self._cut) > self.filteridx and canfiltermore:
             return self(tables[cutidx])
         else:
             # use filtered index list for evaluation of the var that comes later 
             tables._tables['indices'] = cutidx
             self.filteridx = 0
             self.reset_cutindices()
             return applycut
 

def PandAna.core.core.Cut.__invert__ ( self )

Definition at line 326 of file core.py.

References PandAna.core.core.spectrum._cut, PandAna.core.core.Cut._cut, PandAna.core.core.Cut._invert, and PandAna.Demos.demo1.range.

     def __invert__(self):
         cut = Cut(self._cut[0], not self._invert[0])
         for i in range(1, len(self._cut)):
           cut = cut | Cut(self._cut[i], not self._invert[i])
         return cut
 

def PandAna.core.core.Cut.__or__	(	self,
		other
	)

Definition at line 332 of file core.py.

References fhicl.other.

     def __or__(self, other):
         def orcut(tables):
             idx = tables._tables['indices']
             df1 = self(tables)
             tables._tables['indices'] = idx
             df2 = other(tables)
             # or operators are not commutative???
             compare = pd.concat([df1,df2], axis=1, join='outer').fillna(False)
             return compare.any(axis=1)
         return Cut(orcut)
 
 

def PandAna.core.core.Cut.reset_cutindices ( self )

Definition at line 272 of file core.py.

References PandAna.core.core.spectrum._cut, PandAna.core.core.Cut._cut, PandAna.core.core.Cut._cutid, and PandAna.core.core.Cut._filter.

Referenced by PandAna.core.core.Cut.__call__().

     def reset_cutindices(self):
         # need to reset after use by loader
         self._filter = [0]*len(self._cut)
         self._cutid = [0]*len(self._cut)
 