dnsdata.py

import sys, re
import datetime

class DNSdata:
    """
    class which describes the DNS data structure
    will be used for data read-in and write-out routines
    """
    def __init__(self):
        self.title = ""
        self.experiment_number = ""
        self.run_number = ""
        self.start_time = ""
        self.end_time = ""
        self.duration = None
        self.deterota = 0
        self.wavelength = None          # Angstrom
        self.incident_energy = None     # meV
        self.ndet = 24
        self.sample_name = ""
        self.userid = ""
        self.user_name = ""
        self.sample_description = ""
        self.coil_status = ""
        self.befilter_status = ""
        self.notes = ""
        self.monochromator_angle = None         # degree
        self.monochromator_position = None
        self.huber = None
        self.cradle_lower = None
        self.cradle_upper = None
        self.slit_i_upper_blade_position = None
        self.slit_i_lower_blade_position = None
        self.slit_i_left_blade_position = None
        self.slit_i_right_blade_position = None
        self.slit_f_upper_blade_position = None
        self.slit_f_lower_blade_position = None
        self.detector_position_vertical = None
        self.polarizer_translation = None
        self.polarizer_rotation = None
        self.flipper_precession_current = None
        self.flipper_z_compensation_current = None
        self.a_coil_current = None
        self.b_coil_current = None
        self.c_coil_current = None
        self.z_coil_current = None
        self.t1 = None       # T1
        self.t2 = None       # T2
        self.tsp = None      # T_setpoint
        self.tof_channel_number = None
        self.tof_channel_width = None
        self.tof_delay_time = None
        self.tof_elastic_channel = None
        self.chopper_rotation_speed = None
        self.chopper_slits = None
        self.monitor_counts = None


    def read_legacy(self, filename):
        """
        reads the DNS legacy ascii file into the DNS data object
        """
        with open(filename, 'r') as fhandler:
            # read file content and split it into blocks
            splitsymbol = \
                    '#--------------------------------------------------------------------------'
            unparsed = fhandler.read()
            blocks = unparsed.split(splitsymbol)

            # parse each block
            # parse block 0 (header)
            res = parse_header(blocks[0])
            #if not res: raise Exception "wrong file format" else
            try:
                self.run_number = res['file']
                self.experiment_number = res['exp']
                self.sample_name = res['sample']
                self.userid = res['userid']
            except:
                raise ValueError("The file %s does not contain valid DNS data format." % filename)
            # parse block 1 (general information)
            b1splitted = map(str.strip, blocks[1].split('#'))
            b1rest = [el for el in b1splitted]
            r_user = re.compile("User:\s*(?P<name>.*?$)")
            r_sample = re.compile("Sample:\s*(?P<sample>.*?$)")
            r_coil = re.compile("^(?P<coil>.*?)\s*xyz-coil.*")
            r_filter = re.compile("^(?P<filter>.*?)\s*Be-filter.*")
            for line in b1splitted:
                res = r_user.match(line)
                if res:
                    self.user_name = res.group("name")
                    b1rest.remove(line)
                res = r_sample.match(line)
                if res:
                    self.sample_description = res.group("sample")
                    b1rest.remove(line)
                res = r_coil.match(line)
                if res:
                    self.coil_status = res.group("coil")
                    b1rest.remove(line)
                res = r_filter.match(line)
                if res:
                    self.befilter_status = res.group("filter")
                    b1rest.remove(line)
                # the rest unparsed lines go to notes for the moment
                # [TODO]: parse more information about the sample
                self.notes = ' '.join(b1rest)

            # parse block 2 (wavelength and mochromator angle)
            # for the moment, only theta and lambda are needed
            b2splitted = map(str.strip, blocks[2].split('#'))
            # assume that theta and lambda are always on the fixed positions
            # assume theta is give in degree, lambda in nm
            line = b2splitted[2].split()
            self.monochromator_angle = float(line[2])
            self.wavelength = float(line[3])*10.0
            self.incident_energy = float(line[4])

            # parse block 3 (motors position)
            b3splitted = map(str.strip, blocks[3].split('#'))
            self.monochromator_position = float(b3splitted[2].split()[1])
            # DeteRota, angle of rotation of detector bank
            self.deterota = float(b3splitted[3].split()[1])
            # Huber default units degree
            self.huber = float(b3splitted[5].split()[1])
            self.cradle_lower = float(b3splitted[6].split()[1])
            self.cradle_upper = float(b3splitted[7].split()[1])
            # Slit_i, convert mm to meter
            self.slit_i_upper_blade_position = \
                    0.001*float(b3splitted[9].split()[2])
            self.slit_i_lower_blade_position = \
                    0.001*float(b3splitted[10].split()[1])
            self.slit_i_left_blade_position = \
                    0.001*float(b3splitted[11].split()[2])
            self.slit_i_right_blade_position = \
                    0.001*float(b3splitted[12].split()[1])
            # Slit_f
            self.slit_f_upper_blade_position = \
                    0.001*float(b3splitted[14].split()[1])
            self.slit_f_lower_blade_position = \
                    0.001*float(b3splitted[15].split()[1])
            # Detector_position vertical
            self.detector_position_vertical = \
                    0.001*float(b3splitted[16].split()[1])
            # Polarizer
            self.polarizer_translation = \
                    0.001*float(b3splitted[19].split()[1])
            self.polarizer_rotation = float(b3splitted[20].split()[1])

            # parse block 4 (B-fields), only currents in A are taken
            b4splitted = map(str.strip, blocks[4].split('#'))
            self.flipper_precession_current = float(b4splitted[2].split()[1])
            self.flipper_z_compensation_current = float(b4splitted[3].split()[1])
            self.a_coil_current = float(b4splitted[4].split()[1])
            self.b_coil_current = float(b4splitted[5].split()[1])
            self.c_coil_current = float(b4splitted[6].split()[1])
            self.z_coil_current = float(b4splitted[7].split()[1])


            # parse block 5 (Temperatures)
            # assume: T1=cold_head_temperature, T2=sample_temperature
            b5splitted = map(str.strip, blocks[5].split('#'))
            self.t1 = float(b5splitted[2].split()[1])
            self.t2 = float(b5splitted[3].split()[1])
            self.tsp = float(b5splitted[4].split()[1])

            # parse block 6 (TOF parameters)
            b6splitted = map(str.strip, blocks[6].split('#'))
            self.tof_channel_number = int(b6splitted[2].split()[2])
            self.tof_channel_width = float(b6splitted[3].split()[3])
            self.tof_delay_time = float(b6splitted[4].split()[2])
            self.tof_elastic_channel = int(b6splitted[6].split()[3])
            # chopper rotation speed
            self.chopper_rotation_speed = float(b6splitted[7].split()[2])
            # chopper number of slits
            self.chopper_slits = int(b6splitted[5].split()[2])

            # parse block 7 (Time and monitor)
            # assume everything to be at the fixed positions
            b7splitted = map(str.strip, blocks[7].split('#'))
            # duration
            line = b7splitted[2].split()
            self.duration = float(line[1]) # assume seconds [TODO]: check
            # monitor data
            line = b7splitted[3].split()
            self.monitor_counts = int(line[1])
            # start_time and end_time
            outfmt = "%Y-%m-%dT%H:%M:%S"
            sinfmt = "start   at %a %b  %d %H:%M:%S %Y"
            einfmt = "stopped at %a %b  %d %H:%M:%S %Y"
            self.start_time = datetime.datetime.strptime(b7splitted[5], sinfmt).strftime(outfmt)
            self.end_time = datetime.datetime.strptime(b7splitted[6], einfmt).strftime(outfmt)

def parse_header(h):
    """
    parses the header string and returns the parsed dictionary
    """
    d = {}
    regexp = re.compile("(\w+)=(\w+)")
    result = regexp.finditer(h)
    for r in result:
        d[r.groups()[0]] = r.groups()[1]
    return d


if __name__ == '__main__':
    fname = sys.argv[1]
    dns_data = DNSdata()
    dns_data.read_legacy(fname)
    print dns_data.__dict__