Changeset 12874


Ignore:
Timestamp:
02/08/12 14:22:47 (13 years ago)
Author:
lusterma
Message:
various corrections - not finished
File:
1 edited

Legend:

Unmodified
Added
Removed
  • fact/tools/pyscripts/tools/fbsl2.py

    r12813 r12874  
    1313    """
    1414    """
    15     def __init__( self, fnames = {}, step = 500, bsl_corr = True ):
     15    def __init__( self, rfiles = {}, step = 500, bsl_corr = True,
     16                  max_events = -1 ):
    1617        """
    17         fnames   : dictionary of strings : run file names
    18         step     : integer : number of events to be used for the calculation of a baseline values
     18        rfiles   : dictionary of strings : run file names
     19        step     : integer : number of events to be used for
     20                   the calculation of a baseline values
    1921        bsl_corr : bool : apply baseline correction
    20 
     22        max_events : maximum number of events to be processed
     23       
    2124        self:
    2225            blsMeanValues : np.array() to store computed baseline values
    2326        """
    2427
    25         if fnames = {}:
     28        if rfiles == {}:
    2629            print "no file names given for analysis!!!"
    2730            return (-1)
    2831        else:
    29             print "analysing data: "
    30             fnames.info()
     32            print "baseline analysing data: "
     33            rfiles.info()
    3134
    32         self.step = step
    33         self.bsl_corr = True
     35        self.rfiles   = rfiles
     36        self.step     = step
     37        self.bsl_corr = bsl_corr
    3438
    3539        if bsl_corr:
     
    3842            print 'no baseline correction'
    3943
    40         self.bslMeanValues = np.zeros( ( nsteps, rd.NPIX) )
    4144
    4245        # create the object providing the rawdata
    43         rd = pyfact.rawdata( fnames['data'], fnames['drscal'] )
    44         self.nevents = rd.NEvents
     46        self.rd = pyfact.rawdata( rfiles.names['data'], rfiles.names['drscal'] )
     47        self.npix    = self.rd.NPIX
     48       
     49        if max_events == -1:
     50            self.nevents = self.rd.NEvents
     51        else:
     52            self.nevents = max_events
     53       
     54        self.steps() # compute the number of steps
    4555
    46         self.steps()
     56        self.bslMeanValues = np.zeros( ( self.nsteps, self.npix ) )
     57           
     58        self.pixhist = hist_array( self.npix, 400, -99.5, 100.5,
     59                              'bsl_pix', 'Pixel Baseline',
     60                              'sample value in mV', 'Entries / 0.5 mV' ) 
     61        self.bslSummaryHistos = bslHistograms( 'bsl_sum' )
     62
     63        self.run()  # compute baseline
     64        self.save() # save results
    4765       
    48         # rd.ReadBaseline( 'histo.root', 'bls_sum/hplt_mean' )
     66    def steps( self ):
     67        """ compute the ranges of events
     68       
     69            self:
     70                nsteps   : integer : number of ranges of events
     71                evranges : list of range boundaries of length nsteps + 1
     72        """
     73           
     74        nsteps   = self.nevents / self.step + 1
     75        evranges = range(0, nsteps * self.step, self.step)
     76           
     77        # add the events of the last incomplete step to the previous once
     78        evranges[-1] = int( self.nevents )
    4979
    50         def steps( self ):
    51             """ compute the ranges of events
     80        self.nsteps   = nsteps
     81        self.evranges = evranges
    5282
    53             self:
    54                 nsteps   : integer : number of ranges the events are devided into
    55                 evranges : list of range boundaries of length nsteps + 1
    56             """
    57            
    58             nsteps   = self.nevents / self.step
    59             evranges = range(0, (nsteps + 1) * self.step, self.step)
    60            
    61             # add the events of the last incomplete step to the previous once
    62             evranges[-1] = int( rd.NEvents )
     83        print 'nevents: ', self.nevents
     84        print 'ranges:  ', self.evranges
    6385
    64             self.nsteps   = nsteps
    65             self.evranges = evranges
    6686
    67             print 'nevents: ', self.nevents
    68             print 'ranges:  ', self.evranges
    69 
    70         def loopEvents( first, last, hist):
    71             """
    72             LOOP over all events: Do what you want, here!
    73             """
    74             for ev in range( first, last ):
    75                 print 'Event', ev
    76                 rd.next()
    77                 # rd.CorrectBaseline()
    78                 hist.fillall( rd.acalData )
     87    def loopEvents( self, first, last, hist):
     88        """ LOOP over all events: Do what you want, here!
     89        first : integer : first event to process
     90        last  : integer : last event to process
     91        hist  : hist_array : fill all pixel data
     92        """
     93        for ev in range( first, last ):
     94            if ev%100 == 0: print 'Event', ev
     95            self.rd.next()
     96            # rd.CorrectBaseline()
     97            hist.fillall( self.rd.acalData )
    7998               
    8099               
    81         def loopPixel( npix, phist ):
    82            
    83             vmaxprob = np.zeros( npix )
    84             v_rms    = np.zeros( npix )
     100    def loopPixel( self, npix, phist ):
     101        """ loop over pixel and extract most probable values
     102        """
     103        vmaxprob = np.zeros( npix )
     104        v_rms    = np.zeros( npix )
    85105
    86             for pix in range( npix ):
     106        for pix in range( npix ):
    87107   
    88                 hpix = phist.list[pix]
     108            hpix = phist.list[pix]
    89109   
    90                 vmaxprob[pix] = hpix.GetXaxis().GetBinCenter( hpix.GetMaximumBin() )
    91                 bslSummaryHistos.dict['hbsl_mean'].Fill( vmaxprob[pix] )
    92                 bslSummaryHistos.dict['hplt_mean'].SetBinContent(pix+1, vmaxprob[pix] )
     110            vmaxprob[pix] = hpix.GetXaxis().GetBinCenter( hpix.GetMaximumBin() )
     111            self.bslSummaryHistos.dict['hbsl_mean'].Fill( vmaxprob[pix] )
     112            self.bslSummaryHistos.dict['hplt_mean'].SetBinContent(pix+1,
     113                                                             vmaxprob[pix] )
    93114               
    94                 v_rms[pix] = hpix.GetRMS()
    95                 bslSummaryHistos.dict['hbsl_rms'].Fill( v_rms[pix] )
    96                 bslSummaryHistos.dict['hplt_rms'].SetBinContent( pix+1, v_rms[pix] );
    97                
    98             return vmaxprob
     115            v_rms[pix] = hpix.GetRMS()
     116            self.bslSummaryHistos.dict['hbsl_rms'].Fill( v_rms[pix] )
     117            self.bslSummaryHistos.dict['hplt_rms'].SetBinContent( pix+1,
     118                                                             v_rms[pix] );
     119       
     120        self.vmaxprob = vmaxprob
    99121
    100122
    101         def run( self ):
    102             """ run the analysis
    103             """
     123    def run( self ):
     124        """ run the analysis
     125        """
     126       
     127        for step in range( self.nsteps - 1 ):
     128               
     129            print step, 'processing events: ', self.evranges[ step ], 'to ',
     130            print self.evranges[ step+1 ]
    104131           
    105             pixhist = hist_array( rd.NPIX, 400, -99.5, 100.5,
    106                                   'bsl_pix', 'Pixel Baseline',
    107                                   'sample value in mV', 'Entries / 0.5 mV' ) 
     132            pixstephist = hist_array( self.npix, 400, -99.5, 100.5,
     133                                      'bsl_pix_step', 'Pixel Baseline',
     134                                      'sample value in mV', 'Entries / 0.5 mV' )
     135               
     136            self.loopEvents( self.evranges[step], self.evranges[step+1],
     137                             pixstephist )
    108138
    109             for step in range( self.nsteps ):
    110                
    111                 print self.step, 'processing events: ', self.evranges[ self.step], 'to ',
    112                       self.evranges[self.step+1]
     139            self.pixhist.y[:,:] += pixstephist.y[:,:]
     140            pixstephist.SetBinContent()
    113141           
    114                 pixstephist = hist_array( rd.NPIX, 400, -99.5, 100.5,
    115                                           'bsl_pix', 'Pixel Baseline',
    116                                           'sample value in mV', 'Entries / 0.5 mV' )
    117                
    118                 self.loopEvents( evranges[step], evranges[step+1], pixstephist )
     142            bslSummaryHistos = bslHistograms( 'bsl_sum_step' )
     143            self.bslMeanValues[step,:] = self.loopPixel( self.npix, pixstephist )
     144            # print self.bslMeanValues
    119145
    120                 pixhist.y[:,:] += pixstephist.y[:,:]
    121                 pixstephist.SetBinContent()
    122            
    123                 bslSummaryHistos = bslHistograms( 'bsl_sum' )
    124                 self.bslMeanValues[step,:] = loopPixel( rd.NPIX, pixstephist )
    125                 # print self.bslMeanValues
    126                
    127                 fname = 'h'+ str( evranges[step] ) + '_to_'+ str( evranges[step+1] ) + '.root'
    128                 pyfact.SaveHistograms( [pixstephist, bslSummaryHistos], fname )
     146            fname = 'h'+ str( self.evranges[step] ) + '_to_'+ str( self.evranges[step+1] ) + '.root'
     147            SaveHistograms( [pixstephist, bslSummaryHistos], fname )
    129148   
    130                 del pixstephist
    131                 del bslSummaryHistos
     149            del pixstephist
     150            del bslSummaryHistos
    132151
    133             pixhist.SetBinContent()
     152        self.pixhist.SetBinContent()
    134153
    135             bslSummaryHistos = bslHistograms( 'bsl_sum' )   
    136             loopPixel( rd.NPIX, pixhist )
     154        self.loopPixel( self.rd.NPIX, self.pixhist )
    137155
    138             self.save()
    139             # fname = 'hbsl.root'
    140156
    141         def save( self ):
    142             """ save data after completion of analysis
    143             """
    144             pyfact.SaveHistograms( [pixhist, bslSummaryHistos], resFileName + '_bsl.root' )
     157    def save( self ):
     158        """ save baseline values and histograms
     159        """
     160        SaveHistograms( [ self.pixhist, self.bslSummaryHistos],
     161                               self.rfiles.names['results'] + '_bsl.root' )
     162       
     163        np.savetxt( self.rfiles.names['results'] + '_bls.txt', self.bslMeanValues,
     164                    fmt = '%8.3f' )
     165        np.save( self.rfiles.names['results'] + '_bsl.npy', self.bslMeanValues )
     166       
    145167
    146             np.savetxt( resFileName + '_bls.dat', self.bslMeanValues, fmt = '%8.3f' )
    147             np.save( resFileName + '_bsl.npy', self.bslMeanValues )
     168if __name__ == '__main__':
     169    """ create an instance for test purposes
     170
     171    """
     172    runfiles = pyfact.fnames()
     173
     174    runfiles.info()
     175
     176    bcal = baseline_ana( rfiles = runfiles, step = 14,
     177                         bsl_corr = False, max_events = 60 )
Note: See TracChangeset for help on using the changeset viewer.