예제 #1
0
 def config_test_6(self):
   self.skipTest('hangs, issue logged at https://github.com/brendanarnold/py-fortranformat/issues/15')
   '''Custom G_INPUT_TRIAL_EDS'''
   config.G_INPUT_TRIAL_EDS = ['L']
   ff = FortranRecordReader('(G10.2)')
   result = ff.read('         0')
   self.assertEqual(result, [None])
예제 #2
0
def parse_resp_charges(f: TextIO) -> List[Charge]:
    """Parse a file in the ``resp`` charges format

    Parameters
    ----------
    f : TextIO
        File object opened in read mode containing charges in the ``resp`` format.

    Raises
    ------
    InputFormatError
        Raised when the file does not follow the expected format.

    Returns
    -------
    typing.List[Charge]
        List of charges described in the given input file.
    """
    formatter = FR("8F10.6")
    try:
        return list(
            map(
                Charge,
                filter(lambda elem: elem is not None,
                       reduce(add, [formatter.read(line) for line in f], []))))
    except ValueError as e:
        raise InputFormatError(e)
예제 #3
0
 def config_test_2(self):
     '''Test case reported on float'''
     ff = FortranRecordReader('(6g13.5)')
     result = ff.read(
         '   1.0000       9.0000       105.09       1.0000                   '
     )
     config.RET_UNWRITTEN_VARS_NONE = True
     self.assertEqual(result, [1.0, 9.0, 105.09, 1.0, 0.0, 0.0])
예제 #4
0
파일: hrb.py 프로젝트: dpo/pyorder
 def _readArray(self, fp, which, nelm, format):
     #print 'Reading %d values with format %s' % (nelm, format)
     fmt = FortranRecordReader(format)
     ind = 0
     while ind < nelm-1:
         fdata = fmt.read(fp.readline())
         ind2 = min(ind + len(fdata), nelm)
         which[ind:ind2] = fdata[:ind2-ind]
         ind = ind2
     # Read last line, if any.
     if ind < nelm:
         fdata = fmt.read(fp.readline())
         which[ind:] = fdata[:nelm-ind]
     return
예제 #5
0
 def _readArray(self, fp, which, nelm, format):
     #print 'Reading %d values with format %s' % (nelm, format)
     fmt = FortranRecordReader(format)
     ind = 0
     while ind < nelm - 1:
         fdata = fmt.read(fp.readline())
         ind2 = min(ind + len(fdata), nelm)
         which[ind:ind2] = fdata[:ind2 - ind]
         ind = ind2
     # Read last line, if any.
     if ind < nelm:
         fdata = fmt.read(fp.readline())
         which[ind:] = fdata[:nelm - ind]
     return
 def test_6(self):
     # self.skipTest(
     # 'hangs, issue logged at https://github.com/brendanarnold/py-fortranformat/issues/15')
     '''Custom G_INPUT_TRIAL_EDS'''
     config.G_INPUT_TRIAL_EDS = ['L']
     ff = FortranRecordReader('(G10.2)')
     self.assertRaises(ValueError, ff.read, '         0')
예제 #7
0
 def __init__(self, pattern, name=None,
              skip=None, strip_whitespace=True, map_values=None,
              after_read_hook=None):
     self._reader = FortranRecordReader(pattern)
     self.name = name
     self._skip = [skip] if isinstance(skip, int) else skip
     self._strip_whitespace = strip_whitespace
     self._map_values = map_values if isinstance(map_values, dict) else None
     self._after_read_hook = after_read_hook
예제 #8
0
def fort_read(fobj, formatstr, none_as=None, debug=False):

    frr = FortranRecordReader(formatstr)
    if not isinstance(fobj, str):
        fname = fobj.name
        inpline = fobj.readline()
    else:
        fname = 'console'
        inpline = fobj

    res = frr.read(inpline)
    if none_as is not None:
        res = [none_as if x is None else x for x in res]

    if debug:
        print('--- reading ---')
        print('file: ' + fname)
        print('fmt: ' + formatstr)
        print('str: ' + inpline)

    return res
예제 #9
0
    def __init__(self, format, fields, fixed_fields=(), name=None,
                 post_read_hook=None):
        self._fields = fields
        self._fixed_fields = tuple(fixed_fields)
        self._reader = FortranRecordReader(format)
        self._writer = FortranRecordWriter(format)
        self.name = name
        self.post_read_hook = post_read_hook

        self.data = {}
        for f in fields:
            if f is not None:
                self.data[f] = None
예제 #10
0
class FortranLineParser(object):
    def __init__(self, pattern, name=None,
                 skip=None, strip_whitespace=True, map_values=None,
                 after_read_hook=None):
        self._reader = FortranRecordReader(pattern)
        self.name = name
        self._skip = [skip] if isinstance(skip, int) else skip
        self._strip_whitespace = strip_whitespace
        self._map_values = map_values if isinstance(map_values, dict) else None
        self._after_read_hook = after_read_hook

    def __call__(self, line):
        data = self._reader.read(line)
        if self._skip:
            skip = self._skip
            data = [_ for i, _ in enumerate(data) if i not in skip]
        if self._strip_whitespace:
            data = [(_.strip() if isinstance(_, str) else _) for _ in data]
        if self._map_values:
            _map = self._map_values
            data = [(_map[_] if _ in _map else _) for _ in data]
        if self._after_read_hook:
            data = self._after_read_hook(data)
        return data
예제 #11
0
 def _fortranRead(self, stream, format):
     fmt = FortranRecordReader(format)
     fdata = fmt.read(stream)
     return fdata
예제 #12
0
class Parser(object):
    URLTEMPLATE = "https://ruc.noaa.gov/raobs/GetRaobs.cgi?shour=All+Times&ltype=All+Levels&wunits=Tenths+of+Meters&bdate={bdate}&edate={edate}&access=WMO+Station+Identifier&view=NO&StationIDs={stationID}&osort=Station+Series+Sort&oformat=FSL+format+(ASCII+text)"
    HEADER = FortranRecordReader("(3i7,6x,a4,i7)")
    IDENT = FortranRecordReader("(3i7,f7.2,a1,f6.2,a1,i6,i7)")
    IDENT2 = FortranRecordReader("(i7,10x,a4,14x,i7,5x,a2)")
    VALS = FortranRecordReader("(7i7)")
    LINEIDENT = FortranRecordReader("(i7)")
    SPLIT_REGEX = re.compile("^    254", re.M)

    def __init__(self, bdate, edate, stationID):
        self.bdate = bdate
        self.edate = edate
        self.stationID = stationID
        self.ur = self.URLTEMPLATE.format(bdate=self.bdate,
                                          edate=self.edate,
                                          stationID=self.stationID)
        self.soundings = []

    def parse(self):
        req = requests.get(self.url)
        if "Sorry" in req.text or "ERROR" in req.text:
            print("ERROR, Something is wrong in your request")
            print(req.text)
            return
        content = [
            "    254" + x for x in re.split(self.SPLIT_REGEX, req.text)
        ][1:]
        #content = ["    254" + x for x in req.text.split("    254")][1:]
        for snd in content:
            snd_obj = Sounding()
            data = []
            for line in snd.splitlines():
                linecode = self.LINEIDENT.read(line)
                if linecode[0] == 254:
                    header = self.HEADER.read(line)
                    try:
                        date = datetime.datetime.strptime(
                            "{}-{}-{} {}:00:00".format(header[4],
                                                       header[3].strip(),
                                                       header[2], header[1]),
                            "%Y-%b-%d %H:%M:%S")
                    except ValueError:
                        print(
                            "Something has gone wrong with datetime parsing...."
                        )
                    snd_obj.datetime = date
                elif linecode[0] == 1:
                    ident = self.IDENT.read(line)
                    snd_obj.wban, snd_obj.wmo, snd_obj.lat, snd_obj.lat_dir, snd_obj.lon, snd_obj.lon_dir, snd_obj_elev, snd_obj.rtime = ident[
                        1], ident[2], ident[3], ident[4], ident[5], ident[
                            6], ident[7], ident[8]
                    print(snd_obj.lon, snd_obj.lat)
                elif linecode[0] == 2:
                    checks = self.VALS.read(line)
                    snd_obj.hydro, snd_obj.mxwd, snd_obj.tropl, snd_obj.lines, snd_obj.tindex, snd_obj.source = checks[
                        1], checks[2], checks[3], checks[4], checks[5], checks[
                            6]
                elif linecode[0] == 3:
                    ident2 = self.IDENT2.read(line)
                    snd_obj.staid, snd_obj.sonde, snd_obj.wsunits = ident2[
                        1], ident2[2], ident2[3]
                elif 4 <= linecode[0] <= 9:
                    vals = self.VALS.read(line)
                    data.append(vals)
                else:
                    raise ValueError
            snd_obj.data = pd.DataFrame(data=data, columns=Sounding.COLUMNS)
            snd_obj.data = snd_obj.data.replace(99999, np.nan)
            # print(snd_obj.data)
            self.soundings.append(snd_obj)
예제 #13
0
파일: hrb.py 프로젝트: dpo/pyorder
 def _fortranRead(self, stream, format):
     fmt = FortranRecordReader(format)
     fdata = fmt.read(stream)
     return fdata
예제 #14
0
def import_qeinput(fname):
    """
    This function imports a AiiDA structure from a Quantum ESPRESSO
    input file.
    
    :param fname: the file name that should be read
    """
    import aiida.orm.data.structure as struct

    bohr = 0.52917720859
    one_over_bohr = 1.0 / bohr

    cell_types = ["alat", "bohr", "angstrom"]
    pos_types = ["alat", "bohr", "angstrom", "crystal"]

    def generate_cell(ibrav, parameters):

        cellAlat = np.zeros((3, 3))

        if ibrav == 1:
            cellAlat[0][0] = 1
            cellAlat[0][1] = 0
            cellAlat[0][2] = 0
            cellAlat[1][0] = 0
            cellAlat[1][1] = 1
            cellAlat[1][2] = 0
            cellAlat[2][0] = 0
            cellAlat[2][1] = 0
            cellAlat[2][2] = 1

        elif ibrav == 2:
            cellAlat[0][0] = -0.5
            cellAlat[0][1] = 0
            cellAlat[0][2] = 0.5
            cellAlat[1][0] = 0
            cellAlat[1][1] = 0.5
            cellAlat[1][2] = 0.5
            cellAlat[2][0] = -0.5
            cellAlat[2][1] = 0.5
            cellAlat[2][2] = 0

        elif ibrav == 3:
            cellAlat[0][0] = 0.5
            cellAlat[0][1] = 0.5
            cellAlat[0][2] = 0.5
            cellAlat[1][0] = -0.5
            cellAlat[1][1] = 0.5
            cellAlat[1][2] = 0.5
            cellAlat[2][0] = -0.5
            cellAlat[2][1] = -0.5
            cellAlat[2][2] = 0.5

        elif ibrav == 4:
            cellAlat[0][0] = 1
            cellAlat[0][1] = 0
            cellAlat[0][2] = 0
            cellAlat[1][0] = -0.5
            cellAlat[1][1] = np.sqrt(3) / 2
            cellAlat[1][2] = 0
            cellAlat[2][0] = 0
            cellAlat[2][1] = 0
            cellAlat[2][2] = parameters[2]

        elif ibrav == 5:

            tx = np.sqrt((1 - parameters[3]) / 2)
            ty = np.sqrt((1 - parameters[3]) / 6)
            tz = np.sqrt((1 + 2 * parameters[3]) / 3)

            cellAlat[0][0] = tx
            cellAlat[0][1] = -ty
            cellAlat[0][2] = tz
            cellAlat[1][0] = 0
            cellAlat[1][1] = 2 * ty
            cellAlat[1][2] = tz
            cellAlat[2][0] = -tx
            cellAlat[2][1] = -ty
            cellAlat[2][2] = tz

        elif ibrav == -5:

            tx = np.sqrt((1 - parameters[3]) / 2)
            ty = np.sqrt((1 - parameters[3]) / 6)
            tz = np.sqrt((1 + 2 * parameters[3]) / 3)

            u = tz - 2.0 * np.sqrt(2.0) * ty
            v = tz + np.sqrt(2.0) * ty
            a1 = 1 / np.sqrt(3.0)

            cellAlat[0][0] = a1 * u
            cellAlat[0][1] = a1 * v
            cellAlat[0][2] = a1 * v
            cellAlat[1][0] = a1 * v
            cellAlat[1][1] = a1 * u
            cellAlat[1][2] = a1 * v
            cellAlat[2][0] = a1 * v
            cellAlat[2][1] = a1 * v
            cellAlat[2][2] = a1 * u

        elif ibrav == 6:

            cellAlat[0][0] = 1
            cellAlat[0][1] = 0
            cellAlat[0][2] = 0
            cellAlat[1][0] = 0
            cellAlat[1][1] = 1
            cellAlat[1][2] = 0
            cellAlat[2][0] = 0
            cellAlat[2][1] = 0
            cellAlat[2][2] = parameters[2]

        elif ibrav == 7:

            cellAlat[0][0] = 0.5
            cellAlat[0][1] = -0.5
            cellAlat[0][2] = parameters[2] / 2
            cellAlat[1][0] = 0.5
            cellAlat[1][1] = 0.5
            cellAlat[1][2] = parameters[2] / 2
            cellAlat[2][0] = -0.5
            cellAlat[2][1] = -0.5
            cellAlat[2][2] = parameters[2] / 2

        elif ibrav == 8:

            cellAlat[0][0] = 1
            cellAlat[0][1] = 0
            cellAlat[0][2] = 0
            cellAlat[1][0] = 0
            cellAlat[1][1] = parameters[1]
            cellAlat[1][2] = 0
            cellAlat[2][0] = 0
            cellAlat[2][1] = 0
            cellAlat[2][2] = parameters[2]

        elif ibrav == 9:

            cellAlat[0][0] = 0.5
            cellAlat[0][1] = parameters[1] / 2
            cellAlat[0][2] = 0
            cellAlat[1][0] = -0.5
            cellAlat[1][1] = parameters[1] / 2
            cellAlat[1][2] = 0
            cellAlat[2][0] = 0
            cellAlat[2][1] = 0
            cellAlat[2][2] = parameters[1]

        elif ibrav == -9:

            cellAlat[0][0] = 0.5
            cellAlat[0][1] = -parameters[1] / 2
            cellAlat[0][2] = 0
            cellAlat[1][0] = 0.5
            cellAlat[1][1] = -parameters[1] / 2
            cellAlat[1][2] = 0
            cellAlat[2][0] = 0
            cellAlat[2][1] = 0
            cellAlat[2][2] = parameters[1]

        elif ibrav == 10:

            cellAlat[0][0] = 0.5
            cellAlat[0][1] = 0
            cellAlat[0][2] = parameters[2] / 2
            cellAlat[1][0] = 0.5
            cellAlat[1][1] = parameters[1] / 2
            cellAlat[1][2] = 0
            cellAlat[2][0] = 0
            cellAlat[2][1] = parameters[1] / 2
            cellAlat[2][2] = parameters[1] / 2

        elif ibrav == 11:

            cellAlat[0][0] = 0.5
            cellAlat[0][1] = parameters[1] / 2
            cellAlat[0][2] = parameters[2] / 2
            cellAlat[1][0] = -0.5
            cellAlat[1][1] = parameters[1] / 2
            cellAlat[1][2] = parameters[2] / 2
            cellAlat[2][0] = -0.5
            cellAlat[2][1] = -parameters[1] / 2
            cellAlat[2][2] = parameters[2] / 2

        elif ibrav == 12:

            gamma = np.arccos(parameters[3])

            cellAlat[0][0] = 1
            cellAlat[0][1] = 0
            cellAlat[0][2] = 0
            cellAlat[1][0] = parameters[1] * np.cos(gamma)
            cellAlat[1][1] = parameters[1] * np.sin(gamma)
            cellAlat[1][2] = 0
            cellAlat[2][0] = 0
            cellAlat[2][1] = 0
            cellAlat[2][2] = parameters[2]

        elif ibrav == -12:

            beta = np.arccos(parameters[4])

            cellAlat[0][0] = 1
            cellAlat[0][1] = 0
            cellAlat[0][2] = 0
            cellAlat[1][0] = 0
            cellAlat[1][1] = parameters[1]
            cellAlat[1][2] = 0
            cellAlat[2][0] = parameters[2] * np.sin(beta)
            cellAlat[2][1] = 0
            cellAlat[2][2] = parameters[2] * np.cos(beta)

        elif ibrav == 13:

            gamma = np.arccos(parameters[3])

            cellAlat[0][0] = 0.5
            cellAlat[0][1] = 0
            cellAlat[0][2] = -parameters[2] / 2
            cellAlat[1][0] = parameters[1] * np.cos(gamma)
            cellAlat[1][1] = parameters[1] * np.sin(gamma)
            cellAlat[1][2] = 0
            cellAlat[2][0] = 0.5
            cellAlat[2][1] = 0
            cellAlat[2][2] = parameters[2] / 2

        elif ibrav == 14:

            alpha = np.arccos(parameters[3])
            beta = np.arccos(parameters[4])
            gamma = np.arccos(parameters[5])

            cellAlat[0][0] = 1
            cellAlat[0][1] = 0
            cellAlat[0][2] = 0
            cellAlat[1][0] = parameters[1] * np.cos(gamma)
            cellAlat[1][1] = parameters[1] * np.sin(gamma)
            cellAlat[1][2] = 0

            cellAlat[2][0] = parameters[2] * np.cos(beta)
            cellAlat[2][1] = parameters[2] * (
                np.cos(alpha) - np.cos(beta) * np.cos(gamma)) / (np.sin(gamma))
            cellAlat[2][2] = parameters[2] * np.sqrt(
                1 + 2 * np.cos(alpha) * np.cos(beta) * np.cos(gamma) -
                (np.cos(beta) * np.cos(beta)) -
                (np.cos(alpha) * np.cos(alpha)) -
                (np.cos(gamma) * np.cos(gamma))) / (np.sin(gamma))

        else:
            raise Exception("ibrav [{0}] is not defined !".format(ibrav))

        cell_angstrom = cellAlat * parameters[0] * bohr
        return cell_angstrom

    def get_pos(pos, coord_type, alat, cell):

        if coord_type == pos_types[0]: return np.array(pos) * alat * bohr
        if coord_type == pos_types[1]: return np.array(pos) * alat
        if coord_type == pos_types[3]:
            return np.dot(np.array(pos), np.array(cell))

        return pos

    def get_num_from_name(name):
        """
        Return the atomic number given a symbol string, or return zero if
        the symbol is not recognized
        """
        from aiida.orm.data.structure import _atomic_numbers

        return _atomic_numbers.get(name, 0)

    def get_name_from_num(num):
        """
        Return the atomic symbol given an atomic number (if num=0, return "X")
        
        :raise ValueError: if the number is not valid
        """
        from aiida.common.constants import elements

        try:
            return elements[num]['symbol']
        except (IndexError, TypeError):
            raise ValueError("'{}' is not a valid atomic number".format(num))

    def sanitize(line_raw, sec=None):
        if sec is not None:
            return line_raw.split("!")[0].split(sec)[0]
        else:
            return line_raw.split("!")[0]

    import re
    import numpy as np
    from fortranformat import FortranRecordReader

    nat = 0
    ntyp = 0
    ibrav = 0

    celldm = None
    a = None
    b = None
    c = None
    cosab = None
    cosac = None
    cosbc = None

    cell = None

    atomic_raw_kinds = None
    atomic_kinds = None
    atomic_kindnames = None
    atomic_pos = None
    atomic_masses_table = None

    #group(3)
    nat_search = re.compile(
        r'(?:^|[^A-Za-z0-9_])nat([\t ]+)?=([\t ]+)?([0-9]+)', re.IGNORECASE)
    ntyp_search = re.compile(
        r'(?:^|[^A-Za-z0-9_])ntyp([\t ]+)?=([\t ]+)?([0-9]+)', re.IGNORECASE)
    ibrav_search = re.compile(
        r'(?:^|[^A-Za-z0-9_])ibrav([\t ]+)?=([\t ]+)?(-?[0-9]+)',
        re.IGNORECASE)

    celldm_search = re.compile(
        r'(?:^|[^A-Za-z0-9_])celldm([\t ]+)?\(([\t ]+)?([0-9]+)([\t ]+)?\)([\t ]+)?=([\t ]+)?([0-9\.DdeE-]*)',
        re.IGNORECASE)

    a_search = re.compile(r'(?:^|[^A-Za-z0-9_])a([\t ]+)?=([\t ]+)?(-?[0-9]+)',
                          re.IGNORECASE)
    b_search = re.compile(r'(?:^|[^A-Za-z0-9_])b([\t ]+)?=([\t ]+)?(-?[0-9]+)',
                          re.IGNORECASE)
    c_search = re.compile(r'(?:^|[^A-Za-z0-9_])c([\t ]+)?=([\t ]+)?(-?[0-9]+)',
                          re.IGNORECASE)
    cosab_search = re.compile(
        r'(?:^|[^A-Za-z0-9_])cosab([\t ]+)?=([\t ]+)?(-?[0-9]+)',
        re.IGNORECASE)
    cosac_search = re.compile(
        r'(?:^|[^A-Za-z0-9_])cosac([\t ]+)?=([\t ]+)?(-?[0-9]+)',
        re.IGNORECASE)
    cosbc_search = re.compile(
        r'(?:^|[^A-Za-z0-9_])cosbc([\t ]+)?=([\t ]+)?(-?[0-9]+)',
        re.IGNORECASE)

    atomic_species = re.compile(r'ATOMIC_SPECIES', re.IGNORECASE)
    atomic_position = re.compile(r'ATOMIC_POSITIONS', re.IGNORECASE)
    cell_parameters = re.compile(r'CELL_PARAMETERS', re.IGNORECASE)

    #group(3) e group(7)

    ff_float = FortranRecordReader('F15.9')

    f = open(fname, "rw+")
    line = sanitize(f.readline())
    while line:

        if nat_search.search(line): nat = int(nat_search.search(line).group(3))
        if ntyp_search.search(line):
            ntyp = int(ntyp_search.search(line).group(3))
        if ibrav_search.search(line):
            ibrav = int(ibrav_search.search(line).group(3))

        if celldm_search.search(line) and cell is None:

            if celldm is None: celldm = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
            for c in celldm_search.findall(line):
                celldm[int(c[2]) - 1] = ff_float.read(c[6])[0]

        if a_search.search(line): a = float(a_search.search(line).group(3))
        if b_search.search(line): b = float(b_search.search(line).group(3))
        if c_search.search(line): c = float(c_search.search(line).group(3))
        if cosab_search.search(line):
            cosab = float(cosab_search.search(line).group(3))
        if cosac_search.search(line):
            cosac = float(cosac_search.search(line).group(3))
        if cosbc_search.search(line):
            cosbc = float(cosbc_search.search(line).group(3))

        if cell_parameters.search(
                line) and nat > 0 and ibrav == 0 and cell is None:

            if celldm is not None and a is not None:
                raise Exception(
                    "Cannot declare both celldm and A, B, C, cosAB, cosAC, cosBC (a={}, celldm={})"
                    .format(a, celldm))

            if a is not None:
                alat = a
            else:
                if celldm is None:
                    celldm = [one_over_bohr, 0.0, 0.0, 0.0, 0.0, 0.0]
                alat = celldm[0]

            cell_type = cell_types[0]  #Alat
            for ct in cell_types:
                if ct in line.lower(): cell_type = ct

            cell = np.zeros((3, 3))
            cell_ax = 0
            while cell_ax < 3:
                line = sanitize(f.readline())
                while (line.strip() == ""
                       or line.strip().startswith("!")) == "":
                    line = sanitize(f.readline(), sec="#")
                cell_ax_val = np.array(
                    [ff_float.read(p)[0] for p in line.strip().split()])

                if cell_type == cell_types[0]: cell_ax_val *= alat * bohr
                if cell_type == cell_types[1]: cell_ax_val *= alat

                cell[cell_ax] = cell_ax_val
                cell_ax += 1

        if atomic_species.search(line) and ntyp > 0:
            atomic_raw_kinds = [None] * ntyp
            atomic_kinds = [None] * ntyp
            atomic_masses_table = {}

            type_count = 0
            while type_count < ntyp:
                line = sanitize(f.readline())
                while (line.strip() == "" or line.strip().startswith("!")):
                    line = sanitize(f.readline(), sec="#")
                p = line.strip().split()

                raw = {
                    'symbols': p[0],
                    'weights': 1.0,
                    'name': p[0],
                    'mass': float(p[1])
                }

                _n = get_num_from_name(p[0])
                atomic_masses_table[_n] = float(p[1])

                atomic_raw_kinds[type_count] = raw
                atomic_kinds[type_count] = struct.Kind(symbols=p[0],
                                                       weights=1.0,
                                                       name=p[0],
                                                       mass=float(p[1]))

                type_count += 1

        if atomic_position.search(line) and nat > 0:
            pos_type = "alat"
            for pt in pos_types:
                if pt in line.lower(): pos_type = pt

            atomic_pos = [[0] * 3] * nat
            atomic_kindnames = [0] * nat

            pos_count = 0
            while pos_count < nat:

                line = sanitize(f.readline())
                while (line.strip() == "" or line.strip().startswith("!")):
                    line = sanitize(f.readline(), sec="#")

                p = line.strip().split()
                atomic_kindnames[pos_count] = p[0]
                atomic_pos[pos_count] = [
                    ff_float.read(p[i])[0] for i in range(1, 4)
                ]

                pos_count += 1

        line = sanitize(f.readline())

    # Cell generation
    if celldm is not None and a is not None:
        raise Exception(
            "Cannot declare both celldm and A, B, C, cosAB, cosAC, cosBC (a={}, celldm={})"
            .format(a, celldm))

    if a is not None and \
       b is not None and \
       c is not None and \
       cosbc is not None and \
       cosac is not None and \
       cosbc is not None and \
       cell is None:

        celldm = [a, b / a, c / a, cosab, cosac, cosbc, 0.0]
        cell = generate_cell(ibrav, celldm)

    if celldm is not None and ibrav > 0 and cell is None:
        cell = generate_cell(ibrav, celldm)

    # Positions generation
    for i in range(len(atomic_pos)):
        atomic_pos[i] = get_pos(atomic_pos[i], pos_type, celldm[0], cell)

    the_struc = struct.StructureData(cell=cell, pbc=True)
    for k in atomic_kinds:
        the_struc.append_kind(k)

    sites = zip(atomic_kindnames, atomic_pos)

    for kindname, pos in sites:
        the_struc.append_site(struct.Site(kind_name=kindname, position=pos))

    return the_struc
예제 #15
0
import pandas as pd
from fortranformat import FortranRecordReader
fline=FortranRecordReader('(a1,i3,i5,i5,i5,1x,a3,a4,1x,f13.5,f11.5,f11.3,f9.3,1x,a2,f11.3,f9.3,1x,i3,1x,f12.5,f11.5)')
from collections import namedtuple

filename="mass16.txt"
# filename="mass.mas12"

df_cols=["NZ", "N", "Z", "A", "el","o", "massexcess", "uncmassex", "binding", "uncbind","B", "beta", "uncbeta", "am_int", "am_float", "uncatmass"]

record=namedtuple('nucleo','cc NZ  N  Z  A    el  o     massexcess  uncmassex binding uncbind     B  beta  uncbeta    am_int am_float   uncatmass')

df = pd.DataFrame(columns=df_cols)

f=open(filename,'r')
print("converting...")
for line_i, line in enumerate(f):
    nucl=record._make(fline.read(line))
    df2 = pd.DataFrame([[nucl.NZ, nucl.N, nucl.Z, nucl.A, nucl.el, nucl.o, nucl.massexcess, nucl.uncmassex, nucl.binding,
    nucl.uncbind, nucl.B, nucl.beta, nucl.uncbeta, nucl.am_int ,nucl.am_float, nucl.uncatmass]], columns=df_cols)
    df= df.append(df2, ignore_index=True)


print(df)
df.to_csv("ame2016.csv")
예제 #16
0
class DataCard:
    """ Class to implement a line of generalized ATP/Fortran style input records
        format is a format string suitable for the fortranformat module.
        fields is a list of field names for indexing the data dict. Field names
            will usually be strings, but could be integers or floats in the
            case of matching fixed_fields.
        fixed_fields is an iterable of field indices that have fixed values.
            The expected value for the field should be the field name in the
            fields  list.
        post_read_hook is an optional parameter indicating a function to be
            called after reading lines into the DataCard.
        Data in the line is internally represented using a dict.

        format and fields should not be changed after initialization.

        Reads only one line, but should be passed an interable of lines.
    """

    def __init__(self, format, fields, fixed_fields=(), name=None,
                 post_read_hook=None):
        self._fields = fields
        self._fixed_fields = tuple(fixed_fields)
        self._reader = FortranRecordReader(format)
        self._writer = FortranRecordWriter(format)
        self.name = name
        self.post_read_hook = post_read_hook

        self.data = {}
        for f in fields:
            if f is not None:
                self.data[f] = None

    def read(self, lines):
        """ Read in datalines with validation prior to populating data. """
        if not self.match(lines):
            # This should raise an exception and will help
            # identify where in the stack the exception occured.
            tmp = copy.deepcopy(self)
            tmp._read(lines)
        self._read(lines)


    def _read(self, lines):
        line = lines[0]
        data = self._reader.read(line)
        for f in self._fixed_fields:
            if data[f] != self._fields[f]:
                raise ValueError('Fixed field with wrong value: ' + data[f] +
                                 '/' + self._fields[f])

        for f, d in zip(self._fields, data):
            if f is not None:
                self.data[f] = d

        if self.post_read_hook is not None:
            self.post_read_hook(self)

        return self

    def write(self):
        data = [self.data[f] if f is not None else None for f in self._fields]
        return self._writer.write(data)

    def match(self, lines):
        """ Checks if text lines match record type. Does not modify card data.
        """
        tmp = copy.deepcopy(self)
        try:
            tmp._read(lines)
        except ValueError:
            return False

        return True

    def num_lines(self):
        return 1
예제 #17
0
 def config_test_2(self):
   '''Default G_INPUT_TRIAL_EDS'''
   ff = FortranRecordReader('(G10.2)')
   result = ff.read('       .T.')
   self.assertEqual(result, [True])
예제 #18
0
class FortranFormat(object):
    """
    Processes Fortran format strings according to the Fortran specification for
    such formats. This object handles reading and writing data with any valid
    Fortran format. It does this by using the `fortranformat` project
    [https://bitbucket.org/brendanarnold/py-fortranformat].

    However, while `fortranformat` is very general and adheres well to the
    standard, it is very slow. As a result, simple, common format strings have
    been optimized and processes reads and writes between 3 and 5 times faster.
    The format strings (case-insensitive) of the following form (where # can be
    replaced by any number) are optimized:
        - #E#.#
        - #D#.#
        - #F#.#
        - #(F#.#)
        - #a#
        - #I#

    Parameters
    ----------
    format_string : str
        The Fortran Format string to process
    strip_strings : bool=True
        If True, strings are stripped before being processed by stripping
        (only) trailing whitespace
    """

    strre = re.compile(r'(\d+)?a(\d+)$', re.I)
    intre = re.compile(r'(\d+)?i(\d+)$', re.I)
    floatre = re.compile(r'(\d+)?[edf](\d+)\.(\d+)$', re.I)
    floatre2 = re.compile(r'(\d+)?\([edf](\d+)\.(\d+)\)$', re.I)

    #===================================================

    def __init__(self, format_string, strip_strings=True):
        """
        Sets the format string and determines how we will read and write
        strings using this format
        """
        self.format = format_string
        self.strip_strings = strip_strings  # for ease of copying

        # Define a function that processes all arguments prior to adding them to
        # the returned list. By default, do nothing, but this allows us to
        # optionally strip whitespace from strings.
        self.process_method = lambda x: x

        if FortranFormat.strre.match(format_string):
            rematch = FortranFormat.strre.match(format_string)
            # replace our write() method with write_string to force left-justify
            self.type, self.write = str, self._write_string
            nitems, itemlen = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.fmt = '%s'
            # See if we want to strip the strings
            if strip_strings: self.process_method = lambda x: x.strip()

        elif FortranFormat.intre.match(format_string):
            self.type = int
            rematch = FortranFormat.intre.match(format_string)
            nitems, itemlen = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.fmt = '%%%dd' % self.itemlen

        elif FortranFormat.floatre.match(format_string):
            self.type = float
            rematch = FortranFormat.floatre.match(format_string)
            nitems, itemlen, num_decimals = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.num_decimals = int(num_decimals)
            if 'F' in format_string.upper():
                self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
            else:
                self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)

        elif FortranFormat.floatre2.match(format_string):
            self.type = float
            rematch = FortranFormat.floatre2.match(format_string)
            nitems, itemlen, num_decimals = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.num_decimals = int(num_decimals)
            if 'F' in format_string.upper():
                self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
            else:
                self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)

        else:
            # We tried... now just use the fortranformat package
            self._reader = FortranRecordReader(format_string)
            self._writer = FortranRecordWriter(format_string)
            self.write = self._write_ffwriter
            self.read = self._read_ffreader

    #===================================================

    def __copy__(self):
        return type(self)(self.format, self.strip_strings)

    #===================================================

    def __str__(self):
        return self.format

    #===================================================

    def write(self, items, dest):
        """
        Writes an iterable of data (or a single item) to the passed file-like
        object

        Parameters
        ----------
        items : iterable or single float/str/int
            These are the objects to write in this format. The types of each
            item should match the type specified in this Format for that
            argument
        dest : file or file-like
            This is the file to write the data to. It must have a `write` method
            or an AttributeError will be raised

        Notes
        -----
        This method may be replaced with _write_string (for #a#-style formats)
        or _write_ffwriter in the class initializer if no optimization is
        provided for this format, but the call signatures and behavior are the
        same for each of those functions.
        """
        if hasattr(items, '__iter__') and not isinstance(items, basestring):
            mod = self.nitems - 1
            for i, item in enumerate(items):
                dest.write(self.fmt % item)
                if i % self.nitems == mod:
                    dest.write('\n')
            if i % self.nitems != mod:
                dest.write('\n')
        else:
            dest.write(self.fmt % item)
            dest.write('\n')

    #===================================================

    def _write_string(self, items, dest):
        """ Writes a list/tuple of strings """
        if hasattr(items, '__iter__') and not isinstance(items, basestring):
            mod = self.nitems - 1
            for i, item in enumerate(items):
                dest.write((self.fmt % item).ljust(self.itemlen))
                if i % self.nitems == mod:
                    dest.write('\n')
            if i % self.nitems != mod:
                dest.write('\n')
        else:
            dest.write((self.fmt % item).ljust(self.itemlen))
            dest.write('\n')

    #===================================================

    def _read_nostrip(self, line):
        """
        Reads the line and returns converted data. Special-cased for flags that
        may contain 'blank' data. ugh.
        """
        line = line.rstrip('\n')
        nitems = int(ceil(len(line) / self.itemlen))
        ret = [0 for i in xrange(nitems)]
        start, end = 0, self.itemlen
        for i in xrange(nitems):
            ret[i] = self.process_method(self.type(line[start:end]))
            start = end
            end += self.itemlen
        return ret

    #===================================================

    def read(self, line):
        """ Reads the line and returns the converted data """
        line = line.rstrip()
        nitems = int(ceil(len(line) / self.itemlen))
        ret = [0 for i in xrange(nitems)]
        start, end = 0, self.itemlen
        for i in xrange(nitems):
            ret[i] = self.process_method(self.type(line[start:end]))
            start = end
            end += self.itemlen
        return ret

    #===================================================

    def _read_ffreader(self, line):
        """ Reads the line and returns the converted data """
        return self._reader.read(line.rstrip())

    #===================================================

    def _write_ffwriter(self, items, dest):
        dest.write('%s\n' % self._writer.write(items))
예제 #19
0
class FortranFormat(object):
    """
    Processes Fortran format strings according to the Fortran specification for
    such formats. This object handles reading and writing data with any valid
    Fortran format. It does this by using the `fortranformat` project
    [https://bitbucket.org/brendanarnold/py-fortranformat].

    However, while `fortranformat` is very general and adheres well to the
    standard, it is very slow. As a result, simple, common format strings have
    been optimized and processes reads and writes between 3 and 5 times faster.
    The format strings (case-insensitive) of the following form (where # can be
    replaced by any number) are optimized:
        - #E#.#
        - #D#.#
        - #F#.#
        - #(F#.#)
        - #a#
        - #I#

    Parameters
    ----------
    format_string : str
        The Fortran Format string to process
    strip_strings : bool=True
        If True, strings are stripped before being processed by stripping
        (only) trailing whitespace
    """

    strre = re.compile(r'(\d+)?a(\d+)$', re.I)
    intre = re.compile(r'(\d+)?i(\d+)$', re.I)
    floatre = re.compile(r'(\d+)?[edf](\d+)\.(\d+)$', re.I)
    floatre2 = re.compile(r'(\d+)?\([edf](\d+)\.(\d+)\)$', re.I)

    #===================================================

    def __init__(self, format_string, strip_strings=True):
        """
        Sets the format string and determines how we will read and write
        strings using this format
        """
        self.format = format_string
        self.strip_strings = strip_strings # for ease of copying

        # Define a function that processes all arguments prior to adding them to
        # the returned list. By default, do nothing, but this allows us to
        # optionally strip whitespace from strings.
        self.process_method = lambda x: x

        if FortranFormat.strre.match(format_string):
            rematch = FortranFormat.strre.match(format_string)
            # replace our write() method with write_string to force left-justify
            self.type, self.write = str, self._write_string
            nitems, itemlen = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.fmt = '%s'
            # See if we want to strip the strings
            if strip_strings: self.process_method = lambda x: x.strip()

        elif FortranFormat.intre.match(format_string):
            self.type = int
            rematch = FortranFormat.intre.match(format_string)
            nitems, itemlen = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.fmt = '%%%dd' % self.itemlen

        elif FortranFormat.floatre.match(format_string):
            self.type = float
            rematch = FortranFormat.floatre.match(format_string)
            nitems, itemlen, num_decimals = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.num_decimals = int(num_decimals)
            if 'F' in format_string.upper():
                self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
            else:
                self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)

        elif FortranFormat.floatre2.match(format_string):
            self.type = float
            rematch = FortranFormat.floatre2.match(format_string)
            nitems, itemlen, num_decimals = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.num_decimals = int(num_decimals)
            if 'F' in format_string.upper():
                self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
            else:
                self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)

        else:
            # We tried... now just use the fortranformat package
            self._reader = FortranRecordReader(format_string)
            self._writer = FortranRecordWriter(format_string)
            self.write = self._write_ffwriter
            self.read = self._read_ffreader

    #===================================================

    def __copy__(self):
        return type(self)(self.format, self.strip_strings)

    #===================================================

    def __str__(self):
        return self.format

    #===================================================

    def write(self, items, dest):
        """
        Writes an iterable of data (or a single item) to the passed file-like
        object

        Parameters
        ----------
        items : iterable or single float/str/int
            These are the objects to write in this format. The types of each
            item should match the type specified in this Format for that
            argument
        dest : file or file-like
            This is the file to write the data to. It must have a `write` method
            or an AttributeError will be raised

        Notes
        -----
        This method may be replaced with _write_string (for #a#-style formats)
        or _write_ffwriter in the class initializer if no optimization is
        provided for this format, but the call signatures and behavior are the
        same for each of those functions.
        """
        if hasattr(items, '__iter__') and not isinstance(items, string_types):
            mod = self.nitems - 1
            for i, item in enumerate(items):
                dest.write(self.fmt % item)
                if i % self.nitems == mod:
                    dest.write('\n')
            if i % self.nitems != mod:
                dest.write('\n')
        else:
            dest.write(self.fmt % item)
            dest.write('\n')

    #===================================================

    def _write_string(self, items, dest):
        """ Writes a list/tuple of strings """
        if hasattr(items, '__iter__') and not isinstance(items, string_types):
            mod = self.nitems - 1
            for i, item in enumerate(items):
                dest.write((self.fmt % item).ljust(self.itemlen))
                if i % self.nitems == mod:
                    dest.write('\n')
            if i % self.nitems != mod:
                dest.write('\n')
        else:
            dest.write((self.fmt % item).ljust(self.itemlen))
            dest.write('\n')

    #===================================================

    def _read_nostrip(self, line):
        """
        Reads the line and returns converted data. Special-cased for flags that
        may contain 'blank' data. ugh.
        """
        line = line.rstrip('\n')
        nitems = int(ceil(len(line) / self.itemlen))
        ret = [0 for i in range(nitems)]
        start, end = 0, self.itemlen
        for i in range(nitems):
            ret[i] = self.process_method(self.type(line[start:end]))
            start = end
            end += self.itemlen
        return ret

    #===================================================

    def read(self, line):
        """ Reads the line and returns the converted data """
        line = line.rstrip()
        nitems = int(ceil(len(line) / self.itemlen))
        ret = [0 for i in range(nitems)]
        start, end = 0, self.itemlen
        for i in range(nitems):
            ret[i] = self.process_method(self.type(line[start:end]))
            start = end
            end += self.itemlen
        return ret

    #===================================================

    def _read_ffreader(self, line):
        """ Reads the line and returns the converted data """
        return self._reader.read(line.rstrip())

    #===================================================

    def _write_ffwriter(self, items, dest):
        dest.write('%s\n' % self._writer.write(items))
 def test_5(self):
     '''Custom G_INPUT_TRIAL_EDS'''
     config.G_INPUT_TRIAL_EDS = ['A']
     ff = FortranRecordReader('(G10.2)')
     result = ff.read('         0')
     self.assertEqual(result, ['         0'])
 def test_4(self):
     '''Default G_INPUT_TRIAL_EDS'''
     ff = FortranRecordReader('(G10.2)')
     result = ff.read('       STR')
     self.assertEqual(result, ['       STR'])
 def test_3(self):
     '''Default G_INPUT_TRIAL_EDS'''
     ff = FortranRecordReader('(G10.2)')
     result = ff.read('       .F.')
     self.assertEqual(result, [False])
예제 #23
0
    def __init__(self, format_string, strip_strings=True):
        """
        Sets the format string and determines how we will read and write
        strings using this format
        """
        self.format = format_string
        self.strip_strings = strip_strings # for ease of copying

        # Define a function that processes all arguments prior to adding them to
        # the returned list. By default, do nothing, but this allows us to
        # optionally strip whitespace from strings.
        self.process_method = lambda x: x

        if FortranFormat.strre.match(format_string):
            rematch = FortranFormat.strre.match(format_string)
            # replace our write() method with write_string to force left-justify
            self.type, self.write = str, self._write_string
            nitems, itemlen = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.fmt = '%s'
            # See if we want to strip the strings
            if strip_strings: self.process_method = lambda x: x.strip()

        elif FortranFormat.intre.match(format_string):
            self.type = int
            rematch = FortranFormat.intre.match(format_string)
            nitems, itemlen = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.fmt = '%%%dd' % self.itemlen

        elif FortranFormat.floatre.match(format_string):
            self.type = float
            rematch = FortranFormat.floatre.match(format_string)
            nitems, itemlen, num_decimals = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.num_decimals = int(num_decimals)
            if 'F' in format_string.upper():
                self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
            else:
                self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)

        elif FortranFormat.floatre2.match(format_string):
            self.type = float
            rematch = FortranFormat.floatre2.match(format_string)
            nitems, itemlen, num_decimals = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.num_decimals = int(num_decimals)
            if 'F' in format_string.upper():
                self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
            else:
                self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)

        else:
            # We tried... now just use the fortranformat package
            self._reader = FortranRecordReader(format_string)
            self._writer = FortranRecordWriter(format_string)
            self.write = self._write_ffwriter
            self.read = self._read_ffreader
 def config_test_1(self):
     '''Default RET_UNWRITTEN_VARS_NONE (True)'''
     ff = FortranRecordReader('(3G10.2)')
     result = ff.read('         0         0')
     self.assertEqual(result, [0.0, 0.0, None])
예제 #25
0
    def __init__(self, format_string, strip_strings=True):
        """
        Sets the format string and determines how we will read and write
        strings using this format
        """
        self.format = format_string
        self.strip_strings = strip_strings  # for ease of copying

        # Define a function that processes all arguments prior to adding them to
        # the returned list. By default, do nothing, but this allows us to
        # optionally strip whitespace from strings.
        self.process_method = lambda x: x

        if FortranFormat.strre.match(format_string):
            rematch = FortranFormat.strre.match(format_string)
            # replace our write() method with write_string to force left-justify
            self.type, self.write = str, self._write_string
            nitems, itemlen = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.fmt = '%s'
            # See if we want to strip the strings
            if strip_strings: self.process_method = lambda x: x.strip()

        elif FortranFormat.intre.match(format_string):
            self.type = int
            rematch = FortranFormat.intre.match(format_string)
            nitems, itemlen = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.fmt = '%%%dd' % self.itemlen

        elif FortranFormat.floatre.match(format_string):
            self.type = float
            rematch = FortranFormat.floatre.match(format_string)
            nitems, itemlen, num_decimals = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.num_decimals = int(num_decimals)
            if 'F' in format_string.upper():
                self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
            else:
                self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)

        elif FortranFormat.floatre2.match(format_string):
            self.type = float
            rematch = FortranFormat.floatre2.match(format_string)
            nitems, itemlen, num_decimals = rematch.groups()
            if nitems is None:
                self.nitems = 1
            else:
                self.nitems = int(nitems)
            self.itemlen = int(itemlen)
            self.num_decimals = int(num_decimals)
            if 'F' in format_string.upper():
                self.fmt = '%%%s.%sF' % (self.itemlen, self.num_decimals)
            else:
                self.fmt = '%%%s.%sE' % (self.itemlen, self.num_decimals)

        else:
            # We tried... now just use the fortranformat package
            self._reader = FortranRecordReader(format_string)
            self._writer = FortranRecordWriter(format_string)
            self.write = self._write_ffwriter
            self.read = self._read_ffreader
 def config_test_3(self):
     '''RET_WRITTEN_VARS_ONLY = False'''
     config.RET_UNWRITTEN_VARS_NONE = False
     ff = FortranRecordReader('(3G10.2)')
     result = ff.read('         1         1')
     self.assertEqual(result, [0.01, 0.01, 0.0])
 def config_test_4(self):
     '''RET_WRITTEN_VARS_ONLY = True'''
     config.RET_UNWRITTEN_VARS_NONE = True
     ff = FortranRecordReader('(3G10.2)')
     result = ff.read('         0         0')
     self.assertEqual(result, [0.0, 0.0, None])
예제 #28
0
def processsolar():

    solarfile = '/var/lib/odindata/' + 'sw.txt'
    solar = open(solarfile, 'r')
    line = solar.readline(-1)
    while line != "BEGIN OBSERVED\n":
        line = solar.readline(-1)

    res = FortranRecordReader(
        'I4,I3,I3,I5,I3,8I3,I4,8I4,I4,F4.1,I2,I4,F6.1,I2,5F6.1')
    solardata = []
    line = solar.readline(-1)
    while line != "END OBSERVED\n":
        solardata.append(res.read(line))
        line = solar.readline(-1)

    solardata = np.array(solardata)
    dates = []
    for i in range(solardata.shape[0]):
        dates.append(
            DT.date(
                solardata[i, 0].astype(int),
                solardata[i, 1].astype(int),
                solardata[i, 2].astype(int),
            ), )

    # solardata 13=Kpsum 22=APavg 26=f10.7
    while line != "BEGIN DAILY_PREDICTED\n":
        line = solar.readline(-1)
    solardatapred = []
    line = solar.readline(-1)
    while line != "END DAILY_PREDICTED\n":
        solardatapred.append(res.read(line))
        line = solar.readline(-1)
    while line != "BEGIN MONTHLY_PREDICTED\n":
        line = solar.readline(-1)
    line = solar.readline(-1)
    while line != "END MONTHLY_PREDICTED\n":
        solardatapred.append(res.read(line))
        line = solar.readline(-1)
    solardatapred = np.array(solardatapred)

    datespred = []
    for i in range(solardatapred.shape[0]):
        datespred.append(
            DT.date(
                solardatapred[i, 0].astype(int),
                solardatapred[i, 1].astype(int),
                solardatapred[i, 2].astype(int),
            ))

    solar.close()
    dbfile = '/var/lib/odindata/' + 'Solardata2.db'
    db = sqlite.connect(dbfile)
    cur = db.cursor()

    # cur.execute('create table solardata (ID BIGINT, yy shortint, mm shortint,
    # dd shortint, BSRN shortint, ND shortint, Kp1 shortint, Kp2 shortint,
    # Kp3 shortint, Kp4 shortint, Kp5 shortint, Kp6 shortint, Kp7 short int,
    # Kp8 shortint, KpSum shortint, 	Ap1 shortint,  Ap2 shortint,
    # Ap3 shortint,  Ap4 shortint,  Ap5 shortint,  Ap6 shortint,
    # Ap7 shortint,  Ap8 shortint,  ApAvg shortint,	Cp float, C9 shortint,
    # ISN Integer,  AdjF10_7 float, Q shortint,  AdjCtr81 float,
    # AdjLst81 float, ObsF10_7 float, ObsCtr81 float, ObsLst81 float )')
    instr = 'insert or replace into solardata values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )'  # noqa
    for i in range(solardata.shape[0]):
        ids = (solardata[i, 0].astype(int) * 10000 +
               solardata[i, 1].astype(int) * 100 + solardata[i, 2].astype(int))
        cur.execute(instr, np.r_[ids, solardata[i, :]])

    # cur.execute('create table solardatapred (ID BIGINT, pred_date bigint,
    # yy shortint, mm shortint, dd shortint, BSRN shortint, ND shortint,
    # Kp1 shortint, Kp2 shortint, Kp3 shortint, Kp4 shortint, Kp5 shortint
    # Kp6 shortint, Kp7 short int, Kp8 shortint, KpSum shortint, Ap1 shortint,
    # Ap2 shortint, Ap3 shortint,  Ap4 shortint,  Ap5 shortint,  Ap6 shortint,
    # Ap7 shortint,  Ap8 shortint,  ApAvg shortint,  Cp float, C9 shortint,
    # ISN Integer,  AdjF10_7 float, Q shortint, AdjCtr81 float,
    # AdjLst81 float, ObsF10_7 float, ObsCtr81 float, ObsLst81 float )')
    instr = 'insert or replace into solardatapred values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )'  # noqa
    idp = ids
    for i in range(solardatapred.shape[0]):
        ids = (idp * 100000000 + solardatapred[i, 0].astype(int) * 10000 +
               solardatapred[i, 1].astype(int) * 100 +
               solardatapred[i, 2].astype(int))
        cur.execute(instr, np.r_[ids, idp, solardatapred[i, :]])

    db.commit()
    db.close()