KaptureControlGui/KCG/base/backend/CalibrationHandle.py

import time
import os
import math
import numpy as np
import h5py
import traceback

import datetime


class CalibrationHandle(object):
    """docstring for CalibrationHandle
    This Class Handles the CalibrationFiles. 
    ! You may not make your own instance !
    There is one called 'theCalibration' so just use:
    'from CalibrationHandle import theCalibration'

    """
    def __init__(self):
        super(CalibrationHandle, self).__init__()
        self.fileHandle = None
        self.calibrationFile = ""
        self.HandleList = {}

    def openFile(self, calibrationFile, force=False, write=False):
        """
        opens a Calibration File
        :param calibartionFile: filename
        :param force: default False - a already opened file will not be opened again. set True to force reopnening.
        :param write: default False - for internal use only
        """
        if self.calibrationFile == calibrationFile and not force and self.fileHandle is not None:
            return calibrationFile

        if calibrationFile in self.HandleList.keys():                
            self.calibrationFile = calibrationFile
            self.fileHandle = self.HandleList[calibrationFile]
            
            if force:
                self.fileHandle.close()
            else:
                return calibrationFile

        if os.path.isfile(calibrationFile):
            try:
                self.fileHandle = h5py.File(calibrationFile, 'r+' if write else 'r')
                self.grpX = self.fileHandle['x']
                self.grpY = self.fileHandle['y']
                self.calibrationFile = calibrationFile
                self.HandleList[self.calibrationFile] = self.fileHandle
                return calibrationFile
                #self.HandleList["current"] = self.fileHandle
            except:
                print('error opening file "{}"'.format(calibrationFile))
                #self.fileHandle = None    
        else:
            print('file "{}" not found'.format(calibrationFile))
            #self.fileHandle = None
            return 'None'
        return 'current'

    def setHandle(self, name='current'):
        if name == "None":
            return
            
        if len(self.HandleList.keys()) == 0:
            raise Exception('No Calibration File Opened!')

        if name in self.HandleList.keys() and name != "current":   
            self.calibrationFile = name
            self.fileHandle = self.HandleList[name]
            self.grpX = self.fileHandle['x']
            self.grpY = self.fileHandle['y']
            #self.HandleList["current"] = self.fileHandle

        elif name != "current":
            self.openFile(name)

    def reload(self):
        if self.calibrationFile != "":
            self.openFile(self.calibrationFile, force=True)

    def closeHandle(self, name):
        if name in self.HandleList.keys() and name != "current":   
            self.setHandle(name)
            self.fileHandle.close()
            self.HandleList.pop(name)
            if len(self.HandleList):
                self.setHandle(list(self.HandleList.keys())[0])

    def getCalibrationValues(self, id='current'):
        if id == 'None':
            out = []
            for adc in range(8):
                popt = [2048.0, 1.0]
                out.extend(popt)
            return np.array(out)

        self.setHandle(id)
        out = []
        for adc in range(8):
            try:
                popt = self.grpY[str(adc)][0]
            except:
                popt = [2048.0, 1.0]

            out.extend(popt)
        return np.array(out)

    def getSigma(self, id='current'):
        if id == 'None':
            return 34
        self.setHandle(id)
        try:
            return self.fileHandle['info']['Sigma']
        except:
            return 34

    def calibrateY(self, data, adc, id='current'):
        self.setHandle(id)
        if (self.fileHandle is None) or (id =='None'):
            return data

        popt = self.grpY[str(adc)][0]
        return (data-popt[0])/(popt[1])#-popt[0])

    def calibrateX(self, adc, c330, c25, f, c25b=4, id='current'):
        self.setHandle(id)
        if (self.fileHandle is None) or (id == 'None'):
            cascade=0
            if adc < 4:
                cascade = (c25b-4)*25
            return (c330*330 + c25*25 + f*3 + cascade)*1e-12

        try:
            return self.grpX['map'][int(adc)][int(c330)][int(c25)][int(f)][int(c25b)] + self.grpX[str(adc)]['offset'][()]
        except:
            #print('error reading Map')
            #traceback.print_exc()
            cascade=0
            if adc < 4:
                cascade = (c25b-4)*25
            return (c330*330 + c25*25 + f*3 + cascade)*1e-12

    def correctorX(self, adc, c330, c25, f, c25b=4, id='current'):
        self.setHandle(id)
        if (self.fileHandle is None) or (id =='None'):
            return 0
        try:
            corr=  (self.grpX[str(adc)]['330'][c330] + 
                    self.grpX[str(adc)]['25'][c25] + 
                    self.grpX[str(adc)]['3'][f])
            if adc < 4:
                corr += self.grpX[str(adc)]['25b'][c25b]
            corr = corr*1e-12

            corr += self.grpX[str(adc)]['offset']
            return corr
        except:
            traceback.print_exc()
            return 0
         

    def _calibrateX(self, adc, c330, c25, f, c25b=4, id='current'):
        self.setHandle(id)
        if (self.fileHandle is None) or (id =='None'):
            return c330*330 + c25*25 + f*3

        x = c330*self.grpX['d330'] + c25*self.grpX['d25'] + f*self.grpX['d3']
        if adc < 4:
            x -= (c25b - self.grpX['d25b_zero'][()]) * self.grpX['d25b']
        x = x*1e-12
        x += self.correctorX(adc, c330, c25, f, c25b)
        return x

    
theCalibration = CalibrationHandle()