Changeset 167


Ignore:
Timestamp:
May 5, 2010 5:29:42 PM (14 years ago)
Author:
jemian
Message:

major changes to translate 2-D files, still fails on any that stopped early

File:
1 edited

Legend:

Unmodified
Added
Removed

  • dc2mda/src/pythonlib/dc2mda.py

    r165 r167  
    2121
    2222
     23SVN_ID = "$Id$"
    2324DC2MDA_DEBUG = False
    2425#DC2MDA_DEBUG = True
    … …  
    2728NUM_DETECTORS = 15
    2829MDA_VERSION_FOR_MDAEXPLORER = 1.3   # this number is expected by mdaExplorer.py
     30
     31TEST_1D_MDA_FILE = '../cha_0001.mda'
     32TEST_2D_MDA_FILE = '../cha_0023.mda'
     33TEST_1D_DC_FILE = '../UNLV_Aug09'
     34TEST_1D_DC_FILE = '../topo/2020U125SEB'
     35TEST_2D_DC_FILE = '../AlGe311.feb09'
     36TEST_2D_DC_FILE = '../topo/19BM2_Finger'
     37TEST_2D_DC_FILE = '../topo/AliASMLmirror#1_jan03'
    2938
    3039
    … …  
    7786        @note: There are no useful instance variables to be accessed
    7887    '''
     88
     89    FILE_TEMPLATE_1D = '%s_%04d.mda'
     90    FILE_TEMPLATE_2D = '%s_2D_%04d.mda'
     91    ENV_PV_TEMPLATE = 'env:pv_%s'
    7992   
    8093    def __init__(self):
    … …  
    135148        return struct.unpack("!d", fp.read(8))[0]
    136149
    137     def read_STRING(self, fp, numChars, strip = True, indexFile = False):
     150    def read_STRING(self, fp, numChars, strip=True, indexFile=False):
    138151        '''
    139152            Read and return a STRING from file descriptor fp.
    … …  
    154167        return data
    155168
    156     def u_read(self, fp, isIndexFile = False):
     169    def u_read(self, fp, isIndexFile=False):
    157170        '''
    158171            @param fp: file descriptor
    … …  
    306319                data = []
    307320                for i in range(nx):
    308                     data.append(self.read_STRING(fp, 
    309                          numChars = s4, strip = True, indexFile = isIndexFile))
     321                    data.append(self.read_STRING(fp,
     322                         numChars=s4, strip=True, indexFile=isIndexFile))
    310323                    if not isIndexFile:
    311324                        self.align_DWORD(fp)
    312325            else:
    313                 data = self.read_STRING(fp, 
    314                     numChars = s4, strip = False, indexFile = isIndexFile)
     326                data = self.read_STRING(fp,
     327                    numChars=s4, strip=False, indexFile=isIndexFile)
    315328                if not isIndexFile:
    316329                    self.align_DWORD(fp)        # align file pointer to next DWORD boundary
    … …  
    350363        # not implemented yet
    351364        pass
     365
     366    def getFileNames(self, file):
     367        '''
     368            get the names of the EPICS Data Catcher files that are available
     369            @param file: name of file to test
     370            @return: names of (data.file, data.file.index, data.file.image) files
     371            @note: file names are empty if they do not exist
     372        '''
     373        dcFile = file
     374        while os.path.splitext(dcFile)[1] in ['.index', '.image']:
     375            dcFile = os.path.splitext(dcFile)[0]
     376        indexFile = dcFile + '.index'
     377        imageFile = dcFile + '.image'
     378       
     379        if not os.path.exists(dcFile):
     380            dcFile = ''
     381        if not os.path.exists(indexFile):
     382            indexFile = ''
     383        if not os.path.exists(imageFile):
     384            imageFile = ''
     385        if not self.isCatcherV1(dcFile):
     386            dcFile = indexFile = imageFile = ''
     387        return (dcFile, indexFile, imageFile)
     388
     389
     390    def isImageFileName(self, file):
     391        '''
     392            test if a given file name is a catcher data.file.image name
     393            @param file: full path name of file to test
     394            @return: True or False
     395            @note: strategy:
     396              * simple test of file extension
     397        '''
     398        return os.path.splitext(file)[1] == ".image"
     399
     400    def isIndexFileName(self, file):
     401        '''
     402            test if a given file name is a catcher data.file.index name
     403            @param file: full path name of file to test
     404            @return: True or False
     405            @note: strategy:
     406              * simple test of file extension
     407        '''
     408        return os.path.splitext(file)[1] == ".index"
    352409
    353410    def isCatcherV1(self, file):
    … …  
    395452        self.open(file)
    396453        extension = os.path.splitext(file)[1]
    397         isIndexFile = extension == ".index"
    398         isImageFile = extension == ".image"
    399         records = [isIndexFile, isImageFile]
     454        isIndexFile = self.isIndexFileName(file)
     455        isImageFile = self.isImageFileName(file)
     456        records = []
    400457        while self.fp.tell() < size:
    401             rec = self.u_read(self.fp, isIndexFile = isIndexFile)
     458            rec = self.u_read(self.fp, isIndexFile=isIndexFile)
    402459            records.append(rec)
    403460        self.close()
    404461        return records
    405462
     463    def recordView(self, file):
     464        '''
     465            read and print the records in any of
     466            the three types of catcher files
     467            @param file: any/path/to/datafile
     468        '''
     469        records = self.readFileRecords(file)
     470        if len(records) > 0:
     471            if DC2MDA_DEBUG:
     472                    for rec in records:
     473                        print "%s: %s" % (rec['offsetHex'], rec)
     474            if self.isIndexFileName(file):
     475                index = self.parseIndexRecords(records)
     476                if DC2MDA_DEBUG:
     477                    pprint.pprint(index)
     478            elif self.isImageFileName(file):
     479                images = self.parseImageRecords(records)
     480                if DC2MDA_DEBUG:
     481                    for image in images:
     482                        pprint.pprint(image)
     483                else:
     484                    print len(images), file
     485            else:
     486                scans = self.parse1dDataRecords(records)
     487                if DC2MDA_DEBUG:
     488                    for scan in scans:
     489                        pprint.pprint(scan)
     490                else:
     491                    print len(scans), file
     492        sys.stdout.flush()
     493        pass
     494
    406495    def parseIndexRecords(self, records):
    407496        '''
    408         parse the records as read by readFileRecords(0
     497        parse the records as read by readFileRecords()
    409498        @param records: as needed by data.file.index specification
    410499        @note: this is very easy!
    … …  
    419508    def parseImageRecords(self, records):
    420509        '''
    421         parse the records as read by readFileRecords(0
     510        parse the records as read by readFileRecords()
    422511        @param records: as needed by data.file.image specification
    423512        @return: list of dictionaries, each dictionary describes an image
    … …  
    434523                'x', 'y', 'image'
    435524        '''
    436         scans = []
     525        images = []
    437526        numScans = len(records) / 5
    438527        for i in range(numScans):
    439             name = records[i*5 + 0]
    440             qno = records[i*5 + 1]
     528            name = records[i * 5 + 0]
     529            qno = records[i * 5 + 1]
    441530            dict = {
    442531                'PV inner scan': name['data'][0],
    … …  
    453542            dict['2D scanno'] = qno['data'][4]
    454543            dict['max Y height'] = qno['data'][5]
    455             dict['x'] = records[i*5 + 2]['data']
    456             dict['y'] = records[i*5 + 3]['data']
    457             dict['image'] = records[i*5 + 4]['data']
    458             scans.append(dict)
    459         return scans
    460 
    461     def parseDataRecords(self, records):
    462         '''
    463         parse the records as read by readFileRecords(0
     544            dict['x'] = records[i * 5 + 2]['data']
     545            dict['y'] = records[i * 5 + 3]['data']
     546            dict['image'] = records[i * 5 + 4]['data']
     547            #print 'DEBUG:', dict['2D scanno'], dict['1D scanno']
     548            images.append(dict)
     549        return images
     550
     551    def parse1dDataRecords(self, records):
     552        '''
     553        parse the records as read by readFileRecords()
    464554        @param records: as needed by data.file specification
    465555        @return: list of dictionaries, each dictionary describes a scan
    … …  
    472562            dict['version'] = records[recNum]['data']; recNum += 1
    473563            dict['pv'] = records[recNum]['data']; recNum += 1
    474             dict['num_pts'] = records[recNum]['data']; recNum += 1
     564            dict['npts'] = records[recNum]['data']; recNum += 1
    475565            inUse = records[recNum]['data']; recNum += 1
    476566            dict['dim'] = records[recNum]['data']; recNum += 1
    … …  
    482572            det = []
    483573            for num in range(NUM_DETECTORS):
    484                 det.append({ 'defined': inUse[NUM_POSITIONERS+num] })
     574                det.append({ 'defined': inUse[NUM_POSITIONERS + num] })
    485575                if det[num]['defined']:
    486576                    det[num]['data'] = records[recNum]['data']; recNum += 1
    … …  
    488578            for num in range(NUM_POSITIONERS):
    489579                pos[num]['pv'] = labels[num].strip()
    490                 pos[num]['description'] = labels[num+19].strip()
    491                 pos[num]['units'] = labels[num+38].strip()
     580                pos[num]['description'] = labels[num + 19].strip()
     581                pos[num]['units'] = labels[num + 38].strip()
    492582            for num in range(NUM_DETECTORS):
    493                 det[num]['pv'] = labels[NUM_POSITIONERS+num].strip()
    494                 det[num]['description'] = labels[NUM_POSITIONERS+num+(NUM_POSITIONERS+NUM_DETECTORS)].strip()
    495                 det[num]['units'] = labels[NUM_POSITIONERS+num+2*(NUM_POSITIONERS+NUM_DETECTORS)].strip()
     583                det[num]['pv'] = labels[NUM_POSITIONERS + num].strip()
     584                det[num]['description'] = labels[NUM_POSITIONERS + num + (NUM_POSITIONERS + NUM_DETECTORS)].strip()
     585                det[num]['units'] = labels[NUM_POSITIONERS + num + 2 * (NUM_POSITIONERS + NUM_DETECTORS)].strip()
    496586            dict['pos'] = pos
    497587            dict['det'] = det
    … …  
    518608                env = records[recNum]['data']; recNum += 1
    519609                for item in env:
    520                     dict['env'].append( {
     610                    dict['env'].append({
    521611                        'pv':  item[0:29].strip(),
    522612                        'value': item[29:69].strip(),
    523613                        'description': item[69:-1].strip()
    524                     } )
     614                    })
    525615            scans.append(dict)
    526616        return scans
    527617
    528 
    529 def constructMDA_1D(scan):
    530     '''
    531         parse the catcher_v1 scan dictionary
    532         and assemble the MDA structure
    533         @param dc: one item of the Python structure returned from parseDataRecords()
    534         @return: Python structure expected by mda.writeMDA()
    535     '''
    536     #------------ header
    537     header = {
    538         'sampleEntry': ("description", "unit string", "value",
    539                            "EPICS_type", "count")
    540     }
    541     header['filename'] = scan['filename']
    542     header['version'] = MDA_VERSION_FOR_MDAEXPLORER   # float
    543     header['rank'] = 1
    544     header['scan_number'] = scan['1D scan number, zero based']
    545     header['dimensions'] = scan['num_pts']
    546     header['isRegular'] = 1       # What else could it be but regular?
    547     header['ourKeys'] = ['sampleEntry', 'filename', 'version', 'scan_number',
    548                        'rank', 'dimensions', 'isRegular', 'ourKeys']
    549     header['ourKeys'].append('time')
    550     header['time'] = scan['time']
    551     for entry in scan['env']:
    552         header[entry['pv']] = (entry['description'], '', entry['value'], 0, 1)
    553     #------------ 1-D scan data_1D
    554     data_1D = mda.scanDim()
    555     data_1D.rank = 1    # this is 1-D catcher file
    556     data_1D.dim = scan['dim']
    557     data_1D.npts = scan['num_pts'][0]
    558     data_1D.name = scan['pv']
    559     data_1D.time = scan['time']
    560     number_points = None    # actual number of points
    561     for i in range(NUM_POSITIONERS):
    562         if scan['pos'][i]['defined'] == 1:
     618    def keyToPv(self, key):
     619        '''
     620            given a proposed environment variable key, returns a safe version of that key
     621            @param key: proposed key
     622            @return: safe key
     623        '''
     624        key = key.replace(" ", "_")
     625        key = key.replace(",", "_")
     626        return self.ENV_PV_TEMPLATE % key[0:27]
     627
     628    def constructMDA_1D(self, scan):
     629        '''
     630            parse the catcher_v1 scan dictionary
     631            and assemble the MDA structure
     632            @param dc: one item of the Python structure returned from parse1dDataRecords()
     633            @return: Python structure expected by mda.writeMDA()
     634        '''
     635        #------------ header
     636        header = {
     637            'sampleEntry': ("description", "unit string", "value",
     638                               "EPICS_type", "count")
     639        }
     640        header['filename'] = scan['filename']
     641        header['version'] = MDA_VERSION_FOR_MDAEXPLORER   # float
     642        header['rank'] = 1
     643        header['scan_number'] = scan['1D scan number, zero based']
     644        header['dimensions'] = scan['npts']
     645        header['isRegular'] = 1       # What else could it be but regular?
     646        header['ourKeys'] = ['sampleEntry', 'filename', 'version', 'scan_number',
     647                           'rank', 'dimensions', 'isRegular', 'ourKeys']
     648        header['ourKeys'].append('time')
     649        header['time'] = scan['time']
     650        for entry in scan['env']:
     651            header[entry['pv']] = (entry['description'], '', entry['value'], 0, 1)
     652        # add metadata from the catcher file as "environment" data
     653        EPICS_datatype = 0
     654        envKeys = ['userID', 'version', 'comment', 'time']
     655        for i in range(len(envKeys)):
     656            key = envKeys[i]
     657            value = scan[key]
     658            pv = self.keyToPv(key)
     659            header[pv] =  (key, '', value, EPICS_datatype, 1)
     660        # strings
     661        envKeys = ['Plot title', 'Plot x label', 'Plot y label', 'Scan data file name', 'pv', 'filename']
     662        for i in range(len(envKeys)):
     663            key = envKeys[i]
     664            value = scan[key]
     665            pv = self.keyToPv(key)
     666            header[pv] =  (key, '', value, EPICS_datatype, 1)
     667        header['filename_short'] =  ('short file name', '', scan['filename'], EPICS_datatype, 1)
     668        # floats
     669        EPICS_datatype = data_types.EPICS_types_dict_REVERSE['DBR_CTRL_DOUBLE']
     670        envKeys = ['Y positioner value at given 2D scan number']
     671        for i in range(len(envKeys)):
     672            key = envKeys[i]
     673            value = scan[key]
     674            pv = self.keyToPv(key)
     675            header[pv] =  (key, '', [value], EPICS_datatype, 1)
     676        # ints
     677        EPICS_datatype = data_types.EPICS_types_dict_REVERSE['DBR_CTRL_LONG']
     678        envKeys = [
     679            '1D scan number, zero based',
     680            '1D scan starting reference case number',
     681            '2D scanning sequence number, Y loop index number',
     682            '2D scan number, zero based',
     683            '2D scanning indicator',
     684            '2D scan requested number of data points',
     685            '2D scan current acquired number'
     686        ]
     687        for i in range(len(envKeys)):
     688            key = envKeys[i]
     689            value = scan[key]
     690            pv = self.keyToPv(key)
     691            header[pv] =  (key, '', [value], EPICS_datatype, 1)
     692        #------------ 1-D scan data_1D
     693        data_1D = mda.scanDim()
     694        data_1D.rank = 1    # this is 1-D catcher file
     695        data_1D.dim = scan['dim']
     696        data_1D.npts = scan['npts'][0]
     697        data_1D.name = scan['pv']
     698        data_1D.time = scan['time']
     699        curr_pt = None    # actual number of points
     700        for posNum in range(NUM_POSITIONERS):
     701            if scan['pos'][posNum]['defined'] == 1:
     702                pos = mda.scanPositioner()
     703                pos.number = posNum
     704                pos.fieldName = mda.posName(posNum)  # scan-record field (e.g., 'P1') 
     705                pos.name = scan['pos'][posNum]['pv']
     706                pos.desc = scan['pos'][posNum]['description']
     707                pos.unit = scan['pos'][posNum]['units']
     708                pos.step_mode = "LINEAR"
     709                #pos.readback_name = ""
     710                #pos.readback_desc = ""
     711                #pos.readback_unit = ""
     712                pos.data = scan['pos'][posNum]['data']
     713                if curr_pt == None:
     714                    curr_pt = len(pos.data)
     715                data_1D.p.append(pos)
     716        for detNum in range(NUM_DETECTORS):
     717            if scan['det'][detNum]['defined'] == 1:
     718                det = mda.scanDetector()
     719                det.number = detNum
     720                det.fieldName = mda.detName(detNum)  # scan-record field (e.g., 'D01')
     721                det.name = scan['det'][detNum]['pv']
     722                det.desc = scan['det'][detNum]['description']
     723                det.unit = scan['det'][detNum]['units']
     724                det.data = scan['det'][detNum]['data']
     725                data_1D.d.append(det)
     726        data_1D.np = len(data_1D.p)      # number of positioners
     727        data_1D.nd = len(data_1D.d)      # number of detectors
     728        data_1D.curr_pt = curr_pt  # number of points actually recorded
     729        if curr_pt > data_1D.npts:
     730            data_1D.npts = curr_pt
     731        #------------ final assembly
     732        return [ header, data_1D ]  # list:  0: header, 1: 1-D info
     733
     734    def translateMDA_1D(self, file):
     735        '''
     736            translate a catcher 1D file into a set of MDA files
     737            @param file: 1-D data catcher file name
     738        '''
     739        records = self.readFileRecords(dcFile)
     740        scans = self.parse1dDataRecords(records)
     741        print dcFile + ":",
     742        for scan in scans:
     743            mdaScan = self.constructMDA_1D(scan)
     744            scanNumber = scan['1D scan number, zero based'] + 1
     745            mdaFile = self.FILE_TEMPLATE_1D % (dcFile, scanNumber)
     746            mda.writeMDA(mdaScan, mdaFile)
     747            print scanNumber,
     748            sys.stdout.flush()
     749        print
     750
     751    def collateFrameSets(self, images):
     752        '''
     753            Gather the frame sets from the acquired images
     754            @param images: entries from records in data.file.image.
     755            Determine how many different 2-D scans (frameSets) we have.
     756            That is the number of MDA files we will create.
     757            @return: list frameSet dictionaries
     758        '''
     759        frameSets = {}
     760        for image_index in range(len(images)):
     761            image = images[image_index]
     762            # index of 1st 1D scan (X data)
     763            n1D = image['1D scanno'] - image['ny']
     764            n2D = image['2D scanno']        # one-based
     765            if not n2D in frameSets.keys():
     766                frameSets[n2D] = {
     767                        'first 1D scan num': n1D,
     768                        '2D scan num': n2D,
     769                        'detector pv list': [],
     770                        '1D scan list' : range(n1D, image['1D scanno']),
     771                        'image frame list': []
     772                    }
     773            detPv1 = image['PV Detector 1']
     774            frameSets[n2D]['detector pv list'].append(detPv1)
     775            frameSets[n2D]['image frame list'].append(image_index)
     776        if DC2MDA_DEBUG: pprint.pprint(frameSets)
     777        return frameSets
     778
     779    def translateMDA_2D(self, dcFile, indexFile, imageFile):
     780        '''
     781            translate a catcher 2D file into a set of MDA files
     782            @param dcFile: data.file name
     783            @param indexFile: data.file.index name
     784            @param imageFile: data.file.image name
     785        '''
     786        # data.file
     787        scans = self.parse1dDataRecords(self.readFileRecords(dcFile))
     788        print dcFile + ":",
     789   
     790        # data.file.index
     791        index = self.parseIndexRecords(self.readFileRecords(indexFile))
     792   
     793        # data.file.image
     794        images = self.parseImageRecords(self.readFileRecords(imageFile))
     795   
     796        # Determine how many different 2-D scans (frameSets) we have.
     797        # That is the number of MDA files we will create.
     798        frameSets = self.collateFrameSets(images)
     799   
     800        for frameNum in frameSets:
     801            frameSet = frameSets[frameNum]
     802            outputMdaFileName = self.FILE_TEMPLATE_2D % (dcFile, frameNum)
     803            scan1Num = frameSet['1D scan list'][0]
     804            scan1 = scans[scan1Num]
     805            image1Num = frameSet['image frame list'][0]
     806            image1 = images[image1Num]
     807            #-------------------------- MDA header ------------------------
     808            header = {
     809                'sampleEntry': ("description", "unit string", "value",
     810                                   "EPICS_type", "count")
     811            }
     812            header['filename'] = outputMdaFileName
     813            header['version'] = MDA_VERSION_FOR_MDAEXPLORER   # float
     814            header['rank'] = 2
     815            header['scan_number'] = frameSet['2D scan num']   # one-based
     816            scan1_len = image1['nx']
     817            scan2_len = image1['ny']
     818            header['dimensions'] = [scan2_len, scan1_len]
     819            header['isRegular'] = 1       # What else could it be but regular?
     820            header['ourKeys'] = ['sampleEntry', 'filename', 'version', 'scan_number',
     821                               'rank', 'dimensions', 'isRegular', 'ourKeys']
     822            header['ourKeys'].append('time')
     823            header['time'] = scan1['time']
     824            #----- environment data
     825            for entry in scan1['env']:  # env variables from first 1-D scan
     826                header[entry['pv']] = (entry['description'], '', entry['value'], 0, 1)
     827            # add metadata from the catcher files as "environment" data
     828            envKeys = ['userID', 'version', 'comment', 'time']
     829            for i in range(len(envKeys)):
     830                key = envKeys[i]
     831                value = scan1[key]
     832                pv = self.keyToPv(key)
     833                header[pv] =  (key, '', value, 0, 1)
     834            envKeys = ['nx', 'ny']
     835            for i in range(len(envKeys)):
     836                key = envKeys[i]
     837                value = [image1[key]]   # integers must be in lists
     838                pv = self.keyToPv(key)
     839                header[pv] =  (key, '', value, data_types.EPICS_types_dict_REVERSE['DBR_CTRL_LONG'], 1)
     840            del pv, key, value, i, envKeys
     841            header['filename_short'] =  ('short file name', '', scan1['Scan data file name'], 0, 1)
     842            header['filename_long'] =  ('long file name', '', index['filename'], 0, 1)
     843            header['filename_current'] =  ('current file name', '', dcFile, 0, 1)
     844            header['filename_1D_data'] =  ('1-D data file name', '', image1['file 1D data'], 0, 1)
     845            header['filename_2D_data'] =  ('2-D data file name', '', imageFile, 0, 1)
     846            header['PV_outer_scan'] =  ('outer scan record PV', '', image1['PV outer scan'], 0, 1)
     847            header['PV_inner_scan'] =  ('inner scan record PV', '', image1['PV inner scan'], 0, 1)
     848            header['PV_detector_1'] =  ('detector 1 PV', '', image1['PV Detector 1'], 0, 1)
     849            header['PV_pos_1_inner'] =  ('positioner 1 PV, inner scan', '', image1['PV 2D scan positioner 1'], 0, 1)
     850            header['PV_pos_1_outer'] =  ('positioner 1 PV, outer scan', '', image1['PV 1D scan positioner 1'], 0, 1)
     851            #-------------------------- MDA outer scan ------------------------
     852            outer = mda.scanDim()
     853            outer.rank = 2
     854            outer.dim = 1
     855            outer.name = image1['PV outer scan']
     856            outer.npts = scan2_len              # requested
     857            outer.curr_pt = len(image1['y'])    # actual number of points
     858            if outer.curr_pt > outer.npts:
     859                outer.npts = outer.curr_pt
     860            outer.time = scan1['time']
     861            # .........
     862            # only 1 positioner in outer scan is saved in catcher image file
    563863            pos = mda.scanPositioner()
    564             pos.number = i
    565             pos.fieldName = mda.posName(i)
    566             pos.name = scan['pos'][i]['pv']
    567             pos.desc = scan['pos'][i]['description']
    568             pos.unit = scan['pos'][i]['units']
    569             #pos.step_mode = ""
    570             #pos.readback_name = ""
    571             #pos.readback_desc = ""
    572             #pos.readback_unit = ""
    573             pos.data = scan['pos'][i]['data']
    574             if number_points == None:
    575                 number_points = len(pos.data)
    576             data_1D.p.append(pos)
    577     for i in range(NUM_DETECTORS):
    578         if scan['det'][i]['defined'] == 1:
    579             det = mda.scanDetector()
    580             det.number = i
    581             det.fieldName = mda.detName(i)
    582             det.name = scan['det'][i]['pv']
    583             det.desc = scan['det'][i]['description']
    584             det.unit = scan['det'][i]['units']
    585             det.data = scan['det'][i]['data']
    586             data_1D.d.append(det)
    587     data_1D.np = len(data_1D.p)      # number of positioners
    588     data_1D.nd = len(data_1D.d)      # number of detectors
    589     data_1D.npts =  number_points    # number of points requested (from above)
    590     data_1D.curr_pt = number_points  # number of points actually recorded
    591     #------------ final assembly
    592     return [ header, data_1D ]  # list:  0: header, 1: 1-D info
     864            pos.number = 0
     865            pos.fieldName = 'P1'  # scan-record field (e.g., 'P1') 
     866            pos.name = image1['PV 2D scan positioner 1']
     867            pos.desc = pos.name
     868            pos.unit = ''
     869            pos.step_mode = "LINEAR"
     870            pos.data = image1['y']
     871            outer.p.append(pos)
     872            # ..........
     873            outer.d = []
     874            # ..........
     875            outer.np = len(outer.p)
     876            outer.nd = len(outer.d)
     877            #-------------------------- MDA inner scan ------------------------
     878            inner = mda.scanDim()
     879            inner.rank = 1
     880            inner.dim = 2
     881            inner.name = image1['PV inner scan']
     882            inner.npts = scan1_len        # requested
     883            inner.time = scan1['time']
     884            inner.curr_pt = len(image1['x'])    # actual number of points
     885            if inner.curr_pt > inner.npts:
     886                inner.npts = inner.curr_pt
     887            # ..........
     888            for posNum in range(len(scan1['pos'])):
     889                if scan1['pos'][posNum]['defined'] == 1:
     890                    pos = mda.scanPositioner()
     891                    pos.number = posNum
     892                    pos.fieldName = mda.posName(posNum)  # scan-record field (e.g., 'P1') 
     893                    pos.name = scan1['pos'][posNum]['pv']
     894                    pos.desc = scan1['pos'][posNum]['description']
     895                    pos.unit = scan1['pos'][posNum]['units']
     896                    pos.step_mode = "LINEAR"
     897                    pos.data = []
     898                    for scanNum in frameSet['1D scan list']:
     899                        pos.data.append(scans[scanNum]['pos'][posNum]['data'])
     900                    inner.p.append(pos)
     901                    del pos
     902            # ..........
     903            for detNum in range(len(scan1['det'])):
     904                if scan1['det'][detNum]['defined'] == 1:
     905                    det = mda.scanDetector()
     906                    det.number = detNum
     907                    det.fieldName = mda.detName(detNum)  # scan-record field (e.g., 'D01')
     908                    det.name = scan1['det'][detNum]['pv']
     909                    det.desc = scan1['det'][detNum]['description']
     910                    det.unit = scan1['det'][detNum]['units']
     911                    det.data = []
     912                    for scanNum in frameSet['1D scan list']:
     913                        det.data.append(scans[scanNum]['det'][detNum]['data'])
     914                    inner.d.append(det)
     915            # ..........
     916            inner.np = len(inner.p)
     917            inner.nd = len(inner.d)
     918            #-------------------------- write the MDA file ------------------------
     919            dim = [header, outer, inner]
     920            mda.writeMDA(dim, outputMdaFileName)
     921            print outputMdaFileName,
     922        pass
    593923
    594924
    595925def dc2mda(file):
    596926    '''
    597         Convert one EPICS Data Catcher file to MDA files
     927        Convert one EPICS Data Catcher 1-D file to MDA files
    598928        @param file: name of data catcher file to be converted
    599929        @return: none
    … …  
    603933            called silver_0001.mda, silver_0002.mda, ...
    604934    '''
    605     fileTemplate = '%s_%04d.mda'
    606935    dc = catcher_v1()
    607     fc = dc.isCatcherV1(file)
    608     if not fc:
     936    dcFile, indexFile, imageFile = dc.getFileNames(file)
     937    if len(dcFile) == 0:
    609938        return          # not data.file
    610     records = dc.readFileRecords(file)
    611     scans = dc.parseDataRecords(records[2:])
    612     print file + ":",
    613     for scan in scans:
    614         mdaScan = constructMDA_1D(scan)
    615         scanNumber = scan['1D scan number, zero based'] + 1
    616         mdaFile = fileTemplate % (file, scanNumber)
    617         mda.writeMDA(mdaScan, mdaFile)
    618         print scanNumber,
    619         sys.stdout.flush()
    620     print
    621 
    622 
    623 def recordView(file):
    624     '''
    625         read and print the records in any of the three types of catcher files
    626     '''
    627     dc = catcher_v1()
    628     records = dc.readFileRecords(file)
    629     if len(records) > 1:
    630         isIndexFile = records[0]
    631         isImageFile = records[1]
     939    if len(imageFile) == 0:
     940        dc.translateMDA_1D(dcFile)
     941    else:
     942        dc.translateMDA_2D(dcFile, indexFile, imageFile)
     943
     944
     945def __ideas__():
     946    '''
     947        try out some ideas
     948    '''
     949    ideaNumber = 3
     950    if ideaNumber == 1:
     951        dc2mda(TEST_1D_DC_FILE)    # for code development
     952    elif ideaNumber == 2:
     953        testCases = [
     954            '../AlGe311.feb09.index',
     955            '../AlGe311.feb09.image',
     956            '../AlGe311.feb09'
     957        ]
     958        print testCases
     959        for file in testCases:
     960            #dc2mda(file)
     961            catcher_v1().recordView(file)
     962            pass
     963    elif ideaNumber == 3:
     964        # try to translate the 2-D data to MDA
    632965        if DC2MDA_DEBUG:
    633                 for rec in records[2:]:
    634                     print "%s: %s" % (rec['offsetHex'], rec)
    635         if isIndexFile:
    636             index = dc.parseIndexRecords(records[2:])
    637             if DC2MDA_DEBUG:
    638                 pprint.pprint(index)
    639         elif isImageFile:
    640             images = dc.parseImageRecords(records[2:])
    641             if DC2MDA_DEBUG:
    642                 for image in images:
    643                     pprint.pprint(image)
    644             else:
    645                 print len(images), file
    646         else:
    647             scans = dc.parseDataRecords(records[2:])
    648             if DC2MDA_DEBUG:
    649                 for scan in scans:
    650                     pprint.pprint(scan)
    651             else:
    652                 print len(scans), file
    653     sys.stdout.flush()
    654     pass
     966            # help and verbose options print stuff out
     967            mdaRef = mda.readMDA(TEST_2D_MDA_FILE, help=1, verbose=1)
     968        dc2mda(TEST_2D_DC_FILE)
    655969
    656970
    657971if __name__ == '__main__':
    658     dcFile = '../UNLV_Aug09'    # for code development
    659     if len(sys.argv) == 2:
    660         dcFile = sys.argv[1]
    661     elif not os.path.exists(dcFile):
    662         print "usage: ", sys.argv[0], " path/to/data_catcher_file"
    663         exit(1)
    664     dc2mda(dcFile)
    665     testCases = [
    666         '../UNLV_Aug09',
    667         '../UNLV_Aug09.index',
    668         '../AlGe311.feb09.index',
    669         '../AlGe311.feb09.image',
    670         '../AlGe311.feb09',
    671         '../topo/19BM2_Finger',
    672         '../topo/19BM2_Finger.image',
    673         '../topo/19BM2_Finger.index',
    674         '../topo/19BM2_NoSlot_Thin',
    675         '../topo/19BM2_NoSlot_Thin.image',
    676         '../topo/19BM2_NoSlot_Thin.index',
    677         '../topo/2020U125SEB',
    678         '../topo/2020U125SEB.index',
    679         '../topo/AlGe311.feb09',
    680         '../topo/AlGe311.feb09.image',
    681         '../topo/AlGe311.feb09.index',
    682         '../topo/AlGe333.feb08',
    683         '../topo/AlGe333.feb08.image',
    684         '../topo/AlGe333.feb08.index',
    685         '../topo/AliA.jul00',
    686         '../topo/AliA.jul00.image',
    687         '../topo/AliA.jul00.index',
    688         '../topo/AliASMLmirror#1_jan03',
    689         '../topo/AliASMLmirror#1_jan03.image',
    690         '../topo/AliASMLmirror#1_jan03.index',
    691         '../topo/AliAb.mar00',
    692         '../topo/AliAb.mar00.image',
    693         '../topo/AliAb.mar00.index',
    694         '../topo/Ali_Si220_2a.jul05',
    695         '../topo/Ali_Si220_2a.jul05.image',
    696         '../topo/Ali_Si220_2a.jul05.index'
    697     ]
    698     for file in testCases:
    699         #dc2mda(file)
    700         #recordView(file)
    701         pass
     972    print SVN_ID
     973    #__ideas__()
     974    if True:   # ignore this code while developing the 2D reader
     975        dcFile = TEST_1D_DC_FILE    # for code development
     976        dcFile = TEST_2D_DC_FILE    # for code development
     977        if len(sys.argv) == 2:
     978            dcFile = sys.argv[1]
     979        elif not os.path.exists(dcFile):
     980            print "usage: ", sys.argv[0], " path/to/data_catcher_file"
     981            exit(1)
     982        dc2mda(dcFile)
Note: See TracChangeset for help on using the changeset viewer.