def setup_parsers(self): # Data are organized in tables of positions (and sometimes velocities) header_parser = parser.define_parser( end_marker=lambda _l, _ln, nextline: nextline[0:2].isnumeric(), label=lambda line, _ln: line[0:2].upper(), parser_def={ "H1": { "parser": self.parse_default, "fields": { "cpf": (3, 6), "format_version": (7, 9), "ephemeris_source": (11, 14), "year_of_ephemeris_production": (15, 19), "month_of_ephemeris_production": (20, 22), }, }, "H2": { "parser": self.parse_default, "fields": { "satellite_id": (3, 11) } }, }, ) # Each line contains information about the satellite at a given time. orbit_parser = parser.define_parser( end_marker=lambda _l, _ln, nextline: nextline[0:2] == "99", label=lambda line, _ln: line[0:2], parser_def={ "10": { "parser": self.parse_position, "fields": [ "record_type", "direction_flag", "mjd", "seconds_of_day", "leap_second_flag", "pos_x", "pos_y", "pos_z", ], }, "20": { "parser": self.parse_velocity, "fields": [ "record_type", "direction_flag", "vel_x", "vel_y", "vel_z" ], }, }, ) return itertools.chain([header_parser], itertools.repeat(orbit_parser))
def setup_parsers(self): # Each line contains data for a given station and period of time. com_parser = parser.define_parser( end_marker=lambda _l, _ln, _n: True, label=lambda line, _ln: line[0:4].isnumeric(), parser_def={ True: { "parser": self.parse_com_line, "fields": { "station": (0, 4), "start_day": (5, 7), "start_month": (8, 10), "start_year": (11, 15), "end_day": (16, 18), "end_month": (19, 21), "end_year": (22, 26), "pulse_width": (27, 30), "detector_type": (30, 35), "op_mod": (35, 39), "e_lev": (40, 44), "dummy1": (44, 48), "dummy2": (49, 52), "lcmh": (53, 56), "lcml": (57, 60), "lcm": (61, 64), "iflg": (65, 67), }, } }, ) return itertools.repeat(com_parser)
def setup_parsers(self): """Define parsers for reading RINEX clock file """ data_parser = parser.define_parser( end_marker=lambda _l, _ln, n: n.startswith("*"), label=lambda line, _ln: line[0:3], parser_def={ "AS ": { "parser": self.parse_sat_clk, "fields": [ None, "satellite", "year", "month", "day", "hour", "minute", "seconds", "num_val", "sat_clock_bias", "sat_clock_bias_sigma", ], } }, ) return itertools.repeat(data_parser)
def setup_parsers(self): flux_parser = parser.define_parser( end_marker=lambda _l, _ln, nextline: nextline[0:1].isdigit(), label=lambda line, _ln: line[0:1].isdigit(), parser_def={ True: {"parser": self.parse_header, "fields": {"year": (0, 4)}}, False: { "parser": self.parse_flux, "fields": { "day": (3, 5), "01": (6, 11), "02": (12, 17), "03": (18, 23), "04": (24, 29), "05": (30, 35), "06": (36, 41), "07": (42, 47), "08": (48, 53), "09": (54, 59), "10": (60, 65), "11": (66, 71), "12": (72, 77), }, }, }, ) return itertools.repeat(flux_parser)
def setup_parsers(self): header_parser = parser.define_parser( end_marker=lambda line, _ln, _n: line.startswith("end_of_head"), label=lambda line, _ln: (line + " .").split()[0], parser_def={ "earth_gravity_constant": {"parser": self.parse_constant, "fields": [None, "GM"]}, "radius": {"parser": self.parse_constant, "fields": [None, "a"]}, }, ) coefficient_parser = parser.define_parser( end_marker=lambda _l, _ln, _n: np.all(self.coeff_read), label=lambda line, _ln: (line + " .").split()[0], parser_def={ "gfc": {"parser": self.parse_coeff, "fields": [None, "degree", "order", "coeff_C", "coeff_S"]} }, ) return itertools.chain([header_parser, coefficient_parser])
def setup_parsers(self): # Each line contains data for a given station and period of time. handling_parser = parser.define_parser( end_marker=lambda _l, _ln, _n: True, label=lambda line, _ln: line[1:5].isnumeric() and line[18:19].isnumeric(), parser_def={ True: { "parser": self.parse_handling_line, "fields": { "station": (1, 5), "unit": (10, 12), "start_time": (17, 29), "end_time": (30, 42), "code": (43, 44), }, } }, ) return itertools.repeat(handling_parser)
def setup_parsers(self): # Each line contains identifiers for a station station_parser = parser.define_parser( end_marker=lambda _l, _ln, _n: True, label=lambda line, ln: not (line.startswith("$") or line.startswith("#")), parser_def={ True: { "parser": self.parse_station, "fields": { "name": (2, 10), "site_id": (11, 16), "start": (17, 34), "end": (35, 52), "v1": (53, 64), "v2": (64, 75), "v3": (75, 85), "type": (87, 91), }, } }, ) return itertools.chain(itertools.repeat(station_parser))
def setup_parsers(self): """Parsers defined for reading GNSS receiver type file line by line. """ file_parser = parser.define_parser( end_marker=lambda _l, _ln, _n: True, label=lambda line, _ln: not re. match("^#|^\s*$", line ), # skip comments starting with '#' and empty lines parser_def={ # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9 # ALTUS APS-3 P Y # GPS L1/L2+L2C, GLO L1/L2, SBAS integrated rcvr/antenna # ALTUS APS-3L P Y # GPS L1/L2+L2C, GLO L1/L2, SBAS, L-Band rcvr/antenna True: { "parser": self.parse_string, "fields": { "name": (0, 20), "type": (20, 22), "igs_format": (22, 25) }, } }, ) return itertools.repeat(file_parser)
def setup_parsers(self): # Each line contains identifiers for a station station_parser = parser.define_parser( end_marker=lambda _l, _ln, _n: True, label=lambda line, ln: (not (line.startswith("$") or line.startswith("#") or line. startswith("*")) and line[42:45] == "XYZ"), parser_def={ True: { "parser": self.parse_station, "fields": { "site_id": (1, 5), "start": (16, 28), "end": (29, 41), "type": (42, 45), "v1": (45, 54), "v2": (54, 63), "v3": (63, 72), }, } }, ) return itertools.chain(itertools.repeat(station_parser))
def setup_parsers(self): """Parsers defined for reading RINEX observation file line by line. First the RINEX header information are read and afterwards the RINEX observation. """ # Parser for RINEX header header_parser = parser.define_parser( end_marker=lambda line, _ln, _n: line[60:73] == "END OF HEADER", label=lambda line, _ln: line[60:].strip(), parser_def={ # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 2.11 OBSERVATION DATA M (MIXED) RINEX VERSION / TYPE "RINEX VERSION / TYPE": { "parser": self.parse_rinex_version_type, "fields": { "version": (0, 20), "file_type": (20, 21), "sat_sys": (40, 41) }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # XXRINEXO V9.9 AIUB 24-MAR-01 14:43 PGM / RUN BY / DATE "PGM / RUN BY / DATE": { "parser": self.parse_string, "fields": { "program": (0, 20), "run_by": (20, 40), "file_created": (40, 60) }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # G = GPS R = GLONASS E = GALILEO S = GEO M = MIXED COMMENT "COMMENT": { "parser": self.parse_comment, "fields": { "comment": (0, 60) } }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # A 9080 MARKER NAME "MARKER NAME": { "parser": self.parse_string, "fields": { "marker_name": (0, 60) } }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 9080.1.34 MARKER NUMBER "MARKER NUMBER": { "parser": self.parse_string, "fields": { "marker_number": (0, 20) } }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # BILL SMITH ABC INSTITUTE OBSERVER / AGENCY "OBSERVER / AGENCY": { "parser": self.parse_string, "fields": { "observer": (0, 20), "agency": (20, 60) }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # X1234A123 XX ZZZ REC # / TYPE / VERS "REC # / TYPE / VERS": { "parser": self.parse_string, "fields": { "receiver_number": (0, 20), "receiver_type": (20, 40), "receiver_version": (40, 60) }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 234 YY ANT # / TYPE "ANT # / TYPE": { "parser": self.parse_string, "fields": { "antenna_number": (0, 20), "antenna_type": (20, 40) }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 4375274. 587466. 4589095. APPROX POSITION XYZ "APPROX POSITION XYZ": { "parser": self.parse_approx_position, "fields": { "pos_x": (0, 14), "pos_y": (14, 28), "pos_z": (28, 42) }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # .9030 .0000 .0000 ANTENNA: DELTA H/E/N "ANTENNA: DELTA H/E/N": { "parser": self.parse_float, "fields": { "antenna_height": (0, 14), "antenna_east": (14, 28), "antenna_north": (28, 42) }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 1 1 WAVELENGTH FACT L1/2 # 1 2 6 G14 G15 G16 G17 G18 G19 WAVELENGTH FACT L1/2 "WAVELENGTH FACT L1/2": { "parser": self.parse_wavelength_fact, "fields": { "l1_wave_fact": (0, 6), "l2_wave_fact": (6, 12), "num_satellite": (12, 18), "prn_1": (21, 24), "prn_2": (27, 30), "prn_3": (33, 36), "prn_4": (39, 42), "prn_5": (45, 48), "prn_6": (51, 54), "prn_7": (57, 60), }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 14 C1 C2 C5 P1 P2 L1 L2 L5 D1# / TYPES OF OBSERV # D2 D5 S1 S2 S5 # / TYPES OF OBSERV "# / TYPES OF OBSERV": { "parser": self.parse_types_of_observ, "fields": { "num_obstypes": (0, 6), "type_1": (6, 12), "type_2": (12, 18), "type_3": (18, 24), "type_4": (24, 30), "type_5": (30, 36), "type_6": (36, 42), "type_7": (42, 48), "type_8": (48, 54), "type_9": (54, 60), }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 18.000 INTERVAL "INTERVAL": { "parser": self.parse_float, "fields": { "interval": (0, 10) } }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 2005 3 24 13 10 36.0000000 TIME OF FIRST OBS "TIME OF FIRST OBS": { "parser": self.parse_time_of_first_obs, "fields": { "year": (0, 6), "month": (6, 12), "day": (12, 18), "hour": (18, 24), "minute": (24, 30), "second": (30, 43), "time_sys": (48, 51), }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 2005 3 24 23 59 59.0000000 TIME OF LAST OBS "TIME OF LAST OBS": { "parser": self.parse_time_of_last_obs, "fields": { "year": (0, 6), "month": (6, 12), "day": (12, 18), "hour": (18, 24), "minute": (24, 30), "second": (30, 43), "time_sys": (48, 51), }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 0 RCV CLOCK OFFS APPL "RCV CLOCK OFFS APPL": { "parser": self.parse_string, "fields": { "rcv_clk_offset_flag": (0, 6) } }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 13 LEAP SECONDS "LEAP SECONDS": { "parser": self.parse_leap_seconds, "fields": { "leap_seconds": (0, 6) } }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 71 # OF SATELLITES "# OF SATELLITES": { "parser": self.parse_integer, "fields": { "num_satellites": (0, 6) } }, # TODO: 'PRN / # OF OBS' }, ) # Parser for RINEX observation blocks # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # 16 3 1 0 0 0.0000000 0 19G07G27G20G21G26G15G10G16G08G18G30R06 .000000000 # R22R21R04R13R20R11R05 # 1 2 2 G 9 G12 WAVELENGTH FACT L1/2 # *** WAVELENGTH FACTOR CHANGED FOR 2 SATELLITES *** COMMENT # 23522570.266 23522573.871 .000 23522570.500 23522573.969 # 123611978.15417 96321063.91253 .000 932.031 726.258 obs_parser = parser.define_parser( end_marker=lambda _l, _ln, next_line: (next_line[2:3].isdigit() and next_line[3:4].isspace()), label=lambda line, _ln: ((line[10:11] == "." or line[0:16].isspace() ) # Accepting of value or blank entry and not line[32:33].isalpha() # Continuation of satellite list and not (line[34:35].isnumeric() and line[35:36].isspace( )) # Continuation of satellite list with blank satellite system identifier (GPS only) and not line[60:61].isalpha()), # Comment line parser_def={ False: { "parser": self.parse_observation_epoch, "strip": "\n", # Remove only newline '\n' leading and trailing characters from line. "fields": { "year": (0, 3), "month": (3, 6), "day": (6, 9), "hour": (9, 12), "minute": (12, 15), "second": (15, 26), "epoch_flag": (26, 29), "num_sat": (29, 32), "sat_list": (32, 68), "rcv_clk_offset": (68, 80), }, }, True: { "parser": self.parse_observation, "strip": "\n", # Remove only newline '\n' leading and trailing characters from line. "fields": { "obs_1": (0, 16), "obs_2": (16, 32), "obs_3": (32, 48), "obs_4": (48, 64), "obs_5": (64, 80), }, }, }, ) return itertools.chain([header_parser], itertools.repeat(obs_parser))
def setup_parsers(self): """Setup parser definition """ # Parser for SP3 header header_parser = parser.define_parser( end_marker=lambda _l, _ln, next_line: next_line.startswith("*"), # end_marker=lambda _l, line_num, _n: line_num == 22, label=lambda _l, line_num: line_num, parser_def={ # ----+----1----+----2----+----3----+----4----+----5----+----6 # #cP2016 3 1 0 0 0.00000000 96 ORBIT IGb08 HLM IGS 1: { "parser": self._parse_string, "fields": { "version": (1, 2), "pv_flag": (2, 3), "year": (3, 7), "month": (8, 10), "day": (11, 13), "hour": (14, 16), "minute": (17, 19), "second": (20, 31), "num_epoch": (32, 39), "data_used": (40, 45), "coord_sys": (46, 51), "orb_type": (52, 55), "agency": (56, 60), }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6 # ## 1886 172800.00000000 900.00000000 57448 0.0000000000000 2: { "parser": self._parse_string, "fields": { "gpsweek": (3, 7), "gpssec": (8, 23), "epoch_interval": (24, 38), "mjd_int": (39, 44), "mjd_frac": (45, 60), }, }, # ----+----1----+----2----+----3----+----4----+----5----+----6 # %c G cc GPS ccc cccc cccc cccc cccc ccccc ccccc ccccc ccccc 13: { "parser": self._parse_string, "fields": { "file_type": (3, 5), "time_sys": (9, 12) } }, # ----+----1----+----2----+----3----+----4----+----5----+----6 # %f 1.2500000 1.025000000 0.00000000000 0.000000000000000 15: { "parser": self._parse_float, "fields": { "base_posvel": (3, 13), "base_clkrate": (14, 26) } }, }, ) # Parser for SP3 data block # * 2016 3 1 0 0 0.00000000 # PG01 10138.887745 -20456.557725 -13455.830128 13.095853 7 6 4 137 # PG02 -21691.921884 13338.131173 -6326.904893 599.417359 10 7 8 114 # PG03 1061.483783 -15622.426751 -21452.532447 -30.693182 7 6 10 125 # PG04 25398.213954 6966.881030 4188.487313 999999.999999 # PG05 -20431.536257 5143.439387 16220.688245 -141.634044 9 8 7 101 # PG06 -19896.425641 760.039334 -17564.616810 153.322562 12 10 13 104 # PG07 -5499.233721 -14614.719047 21564.675152 467.390140 7 10 7 123 # PG08 7359.468852 -20268.667422 15550.334189 -25.778533 8 6 8 113 data_parser = parser.define_parser( end_marker=lambda _l, _ln, next_line: next_line.startswith("*"), label=lambda line, _ln: line[0], parser_def={ "*": { "parser": self._parse_date, "fields": [None, "year", "month", "day", "hour", "minute", "second"], }, "P": { "parser": self._parse_position, "fields": { "sat": (1, 4), "pos_x": (4, 18), "pos_y": (18, 32), "pos_z": (32, 46), "clk_bias": (46, 60), "sig_pos_x": (61, 63), "sig_pos_y": (64, 66), "sig_pos_z": (67, 69), "sig_clk_bias": (70, 73), "clk_event_flag": (74, 75), "clk_pred_flag": (75, 76), "maneuver_flag": (78, 79), "orb_pred_flag": (79, 80), }, }, "V": { "parser": self._parse_velocity, "fields": { "sat": (1, 4), "vel_x": (4, 18), "vel_y": (18, 32), "vel_z": (32, 46), "clk_rate": (46, 60), "sig_vel_x": (61, 63), "sig_vel_y": (64, 66), "sig_vel_z": (67, 69), "sig_clk_rate": (70, 73), }, }, }, ) return itertools.chain([header_parser], itertools.repeat(data_parser))
def setup_parsers(self): """Parsers defined for reading GNSS raw data file line by line. """ file_parser = parser.define_parser( end_marker=lambda _l, _ln, _n: True, label=lambda line, _ln: line[0:3].strip(), parser_def={ # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8 # Fix,gps,37.422541,-122.081659,-33.000000,0.000000,3.000000,1467321969000 "Fix": { "parser": self.parse_fix, "fields": [ "dummy", "provider", "latitude", "longitude", "altitude", "speed", "accuracy", "time_utc", ], }, # ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0 # Raw,72065126,72076939000000,,,-1151285108458178048,0.0,26.542398700257763,-0.634638974724185, ... "Raw": { "parser": self.parse_raw, "delimiter": ",", "fields": [ "dummy", "ElapsedRealtimeMillis", "TimeNanos", "LeapSecond", "TimeUncertaintyNanos", "FullBiasNanos", "BiasNanos", "BiasUncertaintyNanos", "DriftNanosPerSecond", "DriftUncertaintyNanosPerSecond", "HardwareClockDiscontinuityCount", "Svid", "TimeOffsetNanos", "State", "ReceivedSvTimeNanos", "ReceivedSvTimeUncertaintyNanos", "Cn0DbHz", "PseudorangeRateMetersPerSecond", "PseudorangeRateUncertaintyMetersPerSecond", "AccumulatedDeltaRangeState", "AccumulatedDeltaRangeMeters", "AccumulatedDeltaRangeUncertaintyMeters", "CarrierFrequencyHz", "CarrierCycles", "CarrierPhase", "CarrierPhaseUncertainty", "MultipathIndicator", "SnrInDb", "ConstellationType", ], }, }, ) return itertools.repeat(file_parser)
def setup_parsers(self): header_parser = parser.define_parser( end_marker=lambda line, _ln, _n: line[60:73] == "END OF HEADER", label=lambda line, _ln: line[60:].strip(), parser_def={ "REC # / TYPE / VERS": {"parser": self._parse_default, "fields": {"receiver": (20, 40)}}, "ANT # / TYPE": {"parser": self._parse_default, "fields": {"antenna_type": (20, 40)}}, "APPROX POSITION XYZ": { "parser": self._parse_xyz, "fields": {"antenna_pos_x": (0, 14), "antenna_pos_y": (14, 28), "antenna_pos_z": (28, 42)}, }, "CENTER OF MASS: XYZ": { "parser": self._parse_xyz, "fields": { "center_of_mass_x": (0, 14), "center_of_mass_y": (14, 28), "center_of_mass_z": (28, 42), }, }, "SYS / SCALE FACTOR": { "parser": self._parse_default, "fields": {"scale_factor": (2, 6), "fields": (10, 58)}, }, "L2 / L1 DATE OFFSET": {"parser": self._parse_float, "fields": {"date_offset": (3, 17)}}, "STATION REFERENCE": { "parser": self._parse_station, "fields": { "station_key": (0, 3), "site_id": (5, 9), "site_name": (10, 40), "domes": (40, 50), "type": (51, 52), "freq_shift": (53, 56), }, }, "TIME REF STATION": { "parser": self._parse_timeref_station, "fields": {"station_key": (0, 3), "bias": (5, 19), "shift": (21, 35)}, }, "TIME REF STAT DATE": { "parser": self._parse_float, "fields": { "timeref_year": (0, 6), "timeref_month": (6, 12), "timeref_day": (12, 18), "timeref_hour": (18, 24), "timeref_minute": (24, 30), "timeref_second": (30, 43), }, }, }, ) """Definition of the observation data of the input file. This dictionary defines how to parse the data part of the input file, and is based on the "Rinex Doris 3.0"-document (Appendix A). """ obs_parser = parser.define_parser( end_marker=lambda _l, _ln, next_line: next_line.startswith(">"), label=lambda line, _ln: line[0:1], parser_def={ ">": { "parser": self._parse_epoch, "fields": { "year": (2, 6), "month": (7, 9), "day": (10, 12), "hour": (13, 15), "minute": (16, 18), "second": (19, 21), "fracsec": (21, 31), "epoch_flag": (33, 34), "numrecords": (34, 37), "clock_offset": (43, 56), "clock_offset_flag": (57, 58), }, }, "D": { "parser": self._parse_observation_line_1, "fields": { "station_key": (0, 3), "l1": (3, 17), "l1_flag": (17, 19), "l2": (19, 33), "l2_flag": (33, 35), "c1": (35, 49), "c1a_flag": (49, 50), "c1b_flag": (50, 51), "c2": (51, 65), "c2a_flag": (65, 66), "c2b_flag": (66, 67), "w1": (67, 81), "w1_flag": (81, 83), }, }, " ": { "parser": self._parse_observation_line_2, "fields": { "w2": (3, 17), "w2_flag": (17, 19), "f": (19, 33), "f_flag": (33, 35), "p": (35, 49), "p_flag": (49, 51), "t": (51, 65), "t_flag": (65, 67), "h": (67, 81), "h_flag": (81, 83), }, }, }, ) return itertools.chain([header_parser], itertools.repeat(obs_parser))
def setup_parsers(self): # Data are organized in sessions session_parser = parser.define_parser( end_marker=lambda line, _ln, _n: line[0:2].upper() == "H8", label=lambda line, _ln: line[0:2].upper(), parser_def={ "H2": { "parser": self.parse_station, "fields": { "cdp": (14, 18), "system_number": (19, 21), "occupancy_number": (22, 24), "epoch_time_scale": (25, 27), }, }, "H3": { "parser": self.parse_satellite, "fields": { "satellite_id": (14, 22), "sic": (23, 27), "norad_id": (28, 36), "spacecraft_epoch_time_scale": (37, 38), "target_type": (39, 40), }, }, "H4": { "parser": self.parse_session, "fields": { "data_type": (3, 5), "starting_year": (6, 10), "starting_month": (11, 13), "starting_day": (14, 16), "starting_hour": (17, 19), "starting_minute": (20, 22), "starting_second": (23, 25), "ending_year": (26, 30), "ending_month": (31, 33), "ending_day": (34, 36), "ending_hour": (37, 39), "ending_minute": (40, 42), "ending_second": (43, 45), "data_release": (46, 48), "trop_refr_corr_applied": (49, 50), "center_of_mass_corr_applied": (51, 52), "receive_ampl_corr_applied": (53, 54), "station_syst_del_appl": (55, 56), "spacecraft_syst_del_appl": (57, 58), "range_type_indicator": (59, 60), "data_quality_alert": (61, 62), }, }, "C0": { "parser": self.parse_config, "fields": ["record_type", "detail_type", "wavelength", None] }, "C2": { "parser": self.parse_config2, "fields": [ "record_type", "detail_type", "detector_configuration_id", "detector_type", "applicable_wavelength", "quantum_efficiency", "applied_voltage", "dark_count", "output_pulse_type", "output_pulse_width", "spectral_filter", None, ], }, "11": { "parser": self.parse_obs_normal, "fields": [None, "second", "time_of_flight"] }, "20": { "parser": self.parse_meteorology, "fields": [None, "seconds", "pressure", "temperature", "humidity"], }, }, ) return itertools.repeat(session_parser)