Example #1
0
def ParsePDCPRATEDU(line, listOfLogObj, PREVIOUS_LAT, PREVIOUS_LONG,
                    PREVIOUS_MCC, PREVIOUS_MNC):
    dataOfPDCPRATED = ""
    length = len(line)
    if 2 < length:
        logObj = LogDT()
        logObj.lat = PREVIOUS_LAT
        logObj.longg = PREVIOUS_LONG
        logObj.mcc = PREVIOUS_MCC
        logObj.mnc = PREVIOUS_MNC
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])
        logObj.time = line[1]
        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID]
                                                   != ''):
            logObj.modeSystem = int(line[3 + NumberOfContextID])
        currentLog = LogDT()
        currentLog = copy.deepcopy(logObj)

        if currentLog.modeSystem == 'LTE TDD' or currentLog.modeSystem == 'LTE FDD':
            headerParams = 0
            if ((4 + NumberOfContextID) <
                    length) and (line[4 + NumberOfContextID] != ''):
                headerParams = int(line[4 + NumberOfContextID])
            if headerParams > 0:
                if ((5 + NumberOfContextID) <
                        length) and (line[5 + NumberOfContextID] != ''):
                    currentLog.PDCPULBitRate = int(line[5 + NumberOfContextID])
                if headerParams > 1:
                    if ((6 + NumberOfContextID) <
                            length) and (line[6 + NumberOfContextID] != ''):
                        currentLog.PDCPULBlockRate = int(
                            line[6 + NumberOfContextID])

            numberOfRBs = 0
            if ((5 + NumberOfContextID + headerParams) < length) and (
                    line[5 + NumberOfContextID + headerParams] != ''):
                numberOfRBs = int(line[5 + NumberOfContextID + headerParams])
            numberOfParamsPerRB = 0
            if ((6 + NumberOfContextID) < length + headerParams) and (
                    line[6 + NumberOfContextID + headerParams] != ''):
                numberOfParamsPerRB = int(line[6 + NumberOfContextID +
                                               headerParams])
            for c in range(0, numberOfRBs):
                currentLog = LogDT()
                currentLog = copy.deepcopy(logObj)
                for p in range(0, numberOfParamsPerRB):
                    paramNumber = 7 + NumberOfContextID + (
                        c * numberOfParamsPerRB) + p
                    if ((paramNumber) < length) and (line[paramNumber] != ''):
                        if p == 0:
                            currentLog.RBID = int(line[paramNumber])
                        elif p == 1:
                            currentLog.PDCPULBitRate = int(line[paramNumber])
                        elif p == 2:
                            currentLog.PDCPULBlockRate = int(line[paramNumber])
                listOfLogObj.append(currentLog)

        return 1
    else:
        dataOfPDCPRATED = "No of context id not found"
        return 0
Example #2
0
def ParseMACBLER(line, listOfLogObj, PREVIOUS_LAT, PREVIOUS_LONG, PREVIOUS_MCC,
                 PREVIOUS_MNC):
    length = len(line)
    if 2 < length:
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])
        logObj = LogDT()
        logObj.lat = PREVIOUS_LAT
        logObj.longg = PREVIOUS_LONG
        logObj.mcc = PREVIOUS_MCC
        logObj.mnc = PREVIOUS_MNC
        logObj.event = "Parse MAC layer Block Error Rate"
        logObj.msgType = ''
        logObj.time = line[1]
        headerParameters = 0
        numberOfTrChs = 0
        numberOfParamsPerTrCh = 0
        cellType = 0
        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID]
                                                   != ''):
            logObj.modeSystem = MeasureSysConverter(
                int(line[3 + NumberOfContextID]))
        if logObj.modeSystem == 'UMTS FDD':
            if ((4 + NumberOfContextID) <
                    length) and (line[4 + NumberOfContextID] != ''):
                headerParameters = int(line[4 + NumberOfContextID])
            if ((5 + NumberOfContextID) <
                    length) and (line[5 + NumberOfContextID] != ''):
                numberOfTrChs = int(line[5 + NumberOfContextID])
            if ((6 + NumberOfContextID) <
                    length) and (line[6 + NumberOfContextID] != ''):
                numberOfParamsPerTrCh = int(line[6 + NumberOfContextID])
            for c in range(0, numberOfTrChs):
                currentObj = LogDT()
                currentObj = copy.deepcopy(logObj)
                if ((7 + NumberOfContextID + headerParameters +
                     (c * numberOfParamsPerTrCh) + 3) < length) and (
                         line[7 + NumberOfContextID + headerParameters +
                              (c * numberOfParamsPerTrCh) + 3] != ''):
                    currentObj.MAChsBLER = float(
                        line[7 + NumberOfContextID + headerParameters +
                             (c * numberOfParamsPerTrCh) + 3])
                if ((7 + NumberOfContextID + headerParameters +
                     (c * numberOfParamsPerTrCh) + 6) < length) and (
                         line[7 + NumberOfContextID + headerParameters +
                              (c * numberOfParamsPerTrCh) + 6] != ''):
                    cellType = int(
                        line[7 + NumberOfContextID + headerParameters +
                             (c * numberOfParamsPerTrCh) + 6])
                    if cellType == 1:
                        currentObj.cellType = "Primary"
                    else:
                        currentObj.cellType = "Secondary"
                listOfLogObj.append(currentObj)
        return 1

    else:
        return 0
Example #3
0
def ParseRABA(line, listOfLogObj, PREVIOUS_LAT, PREVIOUS_LONG, PREVIOUS_MCC,
              PREVIOUS_MNC):
    length = len(line)
    if 2 < length:
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])
        dataOfRAA = ''
        numberOfRABRBs = 0
        logObj = LogDT()
        logObj.lat = PREVIOUS_LAT
        logObj.longg = PREVIOUS_LONG
        logObj.mcc = PREVIOUS_MCC
        logObj.mnc = PREVIOUS_MNC
        logObj.event = "RAB Allocation Attempt"
        logObj.msgType = 'Attempt'
        logObj.time = line[1]
        rabContextID = 0
        rabType = 0
        numberOfHeaderParam = 0
        if (3 < length) and (line[3] != ''):
            rabContextID = int(line[3])
            dataOfRAA = 'Context ID: ' + str(rabContextID) + ';'
        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID]
                                                   != ''):
            logObj.modeSystem = MeasureSysConverter(
                int(line[3 + NumberOfContextID]))
            dataOfRAA += ('Measure System: ' + logObj.modeSystem) + ';'
        if ((4 + NumberOfContextID) < length) and (line[4 + NumberOfContextID]
                                                   != ''):
            numberOfHeaderParam = int(line[4 + NumberOfContextID])
        if numberOfHeaderParam > 0:
            if ((5 + NumberOfContextID) <
                    length) and (line[5 + NumberOfContextID] != ''):
                rabType = int(line[5 + NumberOfContextID])
            if rabType == 1:
                logObj.rabType = 'CS'
                dataOfRAA += 'RAB Type: CS;'
            if rabType == 2:
                logObj.rabType = 'PS'
                dataOfRAA += 'RAB Type: PS;'
            if numberOfHeaderParam > 1:
                if ((6 + NumberOfContextID) <
                        length) and (line[6 + NumberOfContextID] != ''):
                    logObj.RABID = int(line[6 + NumberOfContextID])
        if ((5 + NumberOfContextID + numberOfHeaderParam) < length) and (
                line[5 + NumberOfContextID + numberOfHeaderParam] != ''):
            numberOfRABRBs = int(line[5 + NumberOfContextID +
                                      numberOfHeaderParam])
        logObj.eventInfo = dataOfRAA
        if numberOfRABRBs == 0:
            listOfLogObj.append(logObj)
        for i in range(0, numberOfRABRBs):
            currentObj = LogDT()
            currentObj = copy.deepcopy(logObj)
            if ((6 + NumberOfContextID + numberOfHeaderParam + i) <
                    length) and (line[6 + NumberOfContextID +
                                      numberOfHeaderParam + i] != ''):
                currentObj.RABRBID = int(line[6 + NumberOfContextID +
                                              numberOfHeaderParam + i])
            listOfLogObj.append(currentObj)
        return 1
    else:
        return 0
Example #4
0
def ParsePILOTSCAN(line, listOfLogObj, PREVIOUS_LAT, PREVIOUS_LONG,
                   PREVIOUS_MCC, PREVIOUS_MNC):
    length = len(line)
    if 2 < length:
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])
        logObj = LogDT()
        logObj.lat = PREVIOUS_LAT
        logObj.longg = PREVIOUS_LONG
        logObj.mcc = PREVIOUS_MCC
        logObj.mnc = PREVIOUS_MNC
        logObj.event = "Pilot Scanning results"
        logObj.msgType = ''
        logObj.time = line[1]
        numberOfHeaderParameters = 0
        channelType = -1
        numberOfCells = 0
        parameterPerCell = 0
        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID]
                                                   != ''):
            logObj.modeSystem = MeasureSysConverter(
                int(line[3 + NumberOfContextID]))
        if logObj.modeSystem == "UMTS FDD":
            if ((4 + NumberOfContextID) <
                    length) and (line[4 + NumberOfContextID] != ''):
                numberOfHeaderParameters = int(line[4 + NumberOfContextID])
            if numberOfHeaderParameters > 0:
                if ((5 + NumberOfContextID) <
                        length) and (line[5 + NumberOfContextID] != ''):
                    logObj.ChannelNum = int(line[5 + NumberOfContextID])  #add
            if numberOfHeaderParameters > 1:
                if ((6 + NumberOfContextID) <
                        length) and (line[6 + NumberOfContextID] != ''):
                    channelType = int(line[6 + NumberOfContextID])  #add
                    if channelType == 1:
                        logObj.channelType = 'CPICH'
                    elif channelType == 2:
                        logObj.channelType = 'P SCH'
                    elif channelType == 3:
                        logObj.channelType = 'S SCH'
                    elif channelType == 4:
                        logObj.channelType = 'CPICH (TX diversity)'
                    elif channelType == 5:
                        logObj.channelType = 'PPCH'
            if numberOfHeaderParameters > 2:
                if ((7 + NumberOfContextID) <
                        length) and (line[7 + NumberOfContextID] != ''):
                    logObj.RSSI = float(line[7 + NumberOfContextID])  #add
            if numberOfHeaderParameters > 3:
                if ((8 + NumberOfContextID) <
                        length) and (line[8 + NumberOfContextID] != ''):
                    logObj.Band = parseCellMeasuresParseBand(
                        int(line[8 + NumberOfContextID]))  #add

            if ((5 + NumberOfContextID + numberOfHeaderParameters) <
                    length) and (line[5 + NumberOfContextID +
                                      numberOfHeaderParameters] != ''):
                numberOfCells = int(line[5 + NumberOfContextID +
                                         numberOfHeaderParameters])
            if ((6 + NumberOfContextID + numberOfHeaderParameters) <
                    length) and (line[6 + NumberOfContextID +
                                      numberOfHeaderParameters] != ''):
                parameterPerCell = int(line[6 + NumberOfContextID +
                                            numberOfHeaderParameters])
            if numberOfCells == 0:
                listOfLogObj.append(logObj)

            for i in range(0, numberOfCells):
                currentObj = LogDT()
                currentObj = copy.deepcopy(logObj)
                if (
                    (7 + NumberOfContextID + numberOfHeaderParameters +
                     (i * parameterPerCell) + 0) < length
                ) and (line[7 + NumberOfContextID + numberOfHeaderParameters +
                            (i * parameterPerCell) + 0] != ''):
                    currentObj.scramblingCode = float(
                        line[7 + NumberOfContextID + numberOfHeaderParameters +
                             (i * parameterPerCell) + 0])
                if (
                    (7 + NumberOfContextID + numberOfHeaderParameters +
                     (i * parameterPerCell) + 1) < length
                ) and (line[7 + NumberOfContextID + numberOfHeaderParameters +
                            (i * parameterPerCell) + 1] != ''):
                    currentObj.ServingCPICHEcNo = float(
                        line[7 + NumberOfContextID + numberOfHeaderParameters +
                             (i * parameterPerCell) + 1])
                if (
                    (7 + NumberOfContextID + numberOfHeaderParameters +
                     (i * parameterPerCell) + 2) < length
                ) and (line[7 + NumberOfContextID + numberOfHeaderParameters +
                            (i * parameterPerCell) + 2] != ''):
                    currentObj.ServingCPICHRSCP = float(
                        line[7 + NumberOfContextID + numberOfHeaderParameters +
                             (i * parameterPerCell) + 2])
                if (
                    (7 + NumberOfContextID + numberOfHeaderParameters +
                     (i * parameterPerCell) + 3) < length
                ) and (line[7 + NumberOfContextID + numberOfHeaderParameters +
                            (i * parameterPerCell) + 3] != ''):
                    currentObj.SIR = float(
                        line[7 + NumberOfContextID + numberOfHeaderParameters +
                             (i * parameterPerCell) + 3])

                listOfLogObj.append(currentObj)
        return 1

    else:
        return 0
Example #5
0
def ParsePLAIUV27(line, listOfLogObj, PREVIOUS_LAT, PREVIOUS_LONG,
                  PREVIOUS_MCC, PREVIOUS_MNC):
    dataOfCELLMEAS = ""
    length = len(line)
    if 2 < length:
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])
        contextID = 'Unknown'
        numberOfHeaderParamters = 0
        numberOfCells = 0
        numberOfParametersPerCell = 0
        measureSystem = 'Unknown'
        if (3 < length) and (line[3] != ''):
            contextID = line[3]

        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID]
                                                   != ''):
            measureSystem = line[3 + NumberOfContextID]
            measureSystem = MeasureSysConverter(int(measureSystem))
            if measureSystem == '"UMTS FDD':
                if ((4 + NumberOfContextID) <
                        length) and (line[4 + NumberOfContextID] != ''):
                    numberOfHeaderParamters = int(line[4 + NumberOfContextID])

                currentLog = LogDT()
                dataOfCELLMEAS = "Context ID:" + contextID
                currentLog.eventInfo = dataOfCELLMEAS
                currentLog.modeSystem = measureSystem
                currentLog.event = 'Packet link adaptation info for uplink'
                currentLog.lat = PREVIOUS_LAT
                currentLog.longg = PREVIOUS_LONG
                currentLog.mcc = PREVIOUS_MCC
                currentLog.mnc = PREVIOUS_MNC

                for header in range(1, numberOfHeaderParamters):
                    if ((4 + NumberOfContextID + header) < length) and (
                            line[4 + NumberOfContextID + header] != ''):
                        celltype = line[4 + NumberOfContextID + header]
                        if header == 2:  #E-DPDCH Rate
                            currentLog.EDPDCHRate = int(
                                line[4 + NumberOfContextID + header])
                        if header == 8:
                            if celltype == '1':
                                currentLog.cellType = "Primary"
                            elif celltype == '2':
                                currentLog.cellType = "Secondary"

                numberOfPLASets = 0
                if ((5 + NumberOfContextID + numberOfHeaderParamters) <
                        length) and (line[5 + NumberOfContextID +
                                          numberOfHeaderParamters] != ''):
                    numberOfPLASets = int(line[5 + NumberOfContextID +
                                               numberOfHeaderParamters])
                parametersPerPLASet = 0
                if ((6 + NumberOfContextID + numberOfHeaderParamters) <
                        length) and (line[6 + NumberOfContextID +
                                          numberOfHeaderParamters] != ''):
                    numberOfPLASets = int(line[6 + NumberOfContextID +
                                               numberOfHeaderParamters])
                original = currentLog

                for channel in range(0, numberOfPLASets):
                    currentLog = LogDT()
                    currentLog = copy.deepcopy(original)

                    for parameter in range(0, parametersPerPLASet):
                        if ((NumberOfContextID + 7 + numberOfHeaderParamters +
                             parameter) < length) and (
                                 line[NumberOfContextID + 7 +
                                      numberOfHeaderParamters + parameter]):
                            value = int(
                                line[NumberOfContextID + 7 +
                                     numberOfHeaderParamters + parameter])
                        if parameter == 1:  #Modulation
                            currentLog.Modulation = parseModulation(
                                value, 'HSUPA')
                        elif parameter == 4:  #SFs
                            if value == 1:
                                currentLog.SFs = "SF 256"
                            elif value == 2:
                                currentLog.SFs = "SF 128"
                            elif value == 3:
                                currentLog.SFs = "SF 64"
                            elif value == 4:
                                currentLog.SFs = "SF 32"
                            elif value == 5:
                                currentLog.SFs = "SF 16"
                            elif value == 6:
                                currentLog.SFs = "SF 8"
                            elif value == 7:
                                currentLog.SFs = "SF 4"
                            elif value == 8:
                                currentLog.SFs = "2 * SF 4"
                            elif value == 9:
                                currentLog.SFs = "2 * SF 2"
                            elif value == 10:
                                currentLog.SFs = "2 * SF 4 and 2 * SF 2"

                        elif parameter == 5:  #retransmission rate per LA
                            currentLog.ReTransmissionPerLA = float(value)

                    listOfLogObj.append(currentLog)

            elif measureSystem == "LTE FDD" or measureSystem == "LTE TDD":

                currentLog = LogDT()
                dataOfCELLMEAS = "Context ID:" + contextID
                currentLog.eventInfo = dataOfCELLMEAS
                currentLog.modeSystem = measureSystem
                currentLog.event = 'Packet link adaptation info for uplink'
                currentLog.lat = PREVIOUS_LAT
                currentLog.longg = PREVIOUS_LONG
                currentLog.mcc = PREVIOUS_MCC
                currentLog.mnc = PREVIOUS_MNC
                original = currentLog
                numberOfHeaderParamters = 0
                if ((4 + NumberOfContextID) <
                        length) and (line[4 + NumberOfContextID] != ''):
                    numberOfHeaderParamters = int(line[4 + NumberOfContextID])

                numberOfPLASets = 0
                if ((5 + NumberOfContextID + numberOfHeaderParamters) <
                        length) and (line[5 + NumberOfContextID +
                                          numberOfHeaderParamters] != ''):
                    numberOfPLASets = int(line[5 + NumberOfContextID +
                                               numberOfHeaderParamters])
                if ((6 + NumberOfContextID + numberOfHeaderParamters) <
                        length) and (line[6 + NumberOfContextID +
                                          numberOfHeaderParamters] != ''):
                    parametersPerPLASet = int(line[6 + NumberOfContextID +
                                                   numberOfHeaderParamters])

                for channel in range(0, numberOfPLASets):
                    currentLog = LogDT()
                    currentLog = copy.deepcopy(original)

                    for parameter in range(0, parametersPerPLASet):
                        if ((NumberOfContextID + 7 + numberOfHeaderParamters +
                             parameter) < length) and (
                                 line[NumberOfContextID + 7 +
                                      numberOfHeaderParamters + parameter]):
                            value = line[NumberOfContextID + 7 +
                                         numberOfHeaderParamters + parameter]
                        if parameter == 2:
                            currentLog.Modulation = parseModulation(
                                value, 'PUSCH')
                        elif parameter == 3:  #MCS0
                            currentLog.MCS0 = int(value)
                    listOfLogObj.append(currentLog)

        return 1
    else:
        dataOfCELLMEAS = "No of context id not found"
        currentLog.eventInfo = dataOfCELLMEAS
        listOfLogObj.append(currentLog)

        return 1
Example #6
0
def ParseMACRATE(line, listOfLogObj, PREVIOUS_LAT, PREVIOUS_LONG, PREVIOUS_MCC,
                 PREVIOUS_MNC):

    dataOfMACRATE = ""
    length = len(line)
    if 2 < length:
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])
        logObj = LogDT()
        logObj.lat = PREVIOUS_LAT
        logObj.longg = PREVIOUS_LONG
        logObj.mcc = PREVIOUS_MCC
        logObj.mnc = PREVIOUS_MNC
        logObj.event = "Parse MAC layer throughput downlink"
        logObj.msgType = ''
        logObj.time = line[1]
        headerParameters = 0
        numberOfTrChs = 0
        numberOfParamsPerTrCh = 0
        cellType = 0
        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID]
                                                   != ''):
            logObj.modeSystem = MeasureSysConverter(
                int(line[3 + NumberOfContextID]))
            dataOfMACRATE += ('Measure System: ' + logObj.modeSystem) + ';'
        headerParameters = 0
        if logObj.modeSystem == 'UMTS FDD':
            if ((4 + NumberOfContextID) <
                    length) and (line[4 + NumberOfContextID] != ''):
                headerParameters = int(line[4 + NumberOfContextID])
            if ((5 + NumberOfContextID) < length) and (
                    line[5 + NumberOfContextID + headerParameters] != ''):
                numberOfTrChs = int(line[5 + NumberOfContextID])
            if ((6 + NumberOfContextID) < length) and (
                    line[6 + NumberOfContextID + headerParameters] != ''):
                numberOfParamsPerTrCh = int(line[6 + NumberOfContextID])
            for c in range(0, numberOfTrChs):
                currentObj = LogDT()
                currentObj = copy.deepcopy(logObj)
                if ((7 + NumberOfContextID + headerParameters +
                     (c * numberOfParamsPerTrCh) + 2) < length) and (
                         line[7 + NumberOfContextID + headerParameters +
                              (c * numberOfParamsPerTrCh) + 2] != ''):
                    currentObj.MAChsBitRate = int(
                        line[7 + NumberOfContextID + headerParameters +
                             (c * numberOfParamsPerTrCh) + 2])
                if ((7 + NumberOfContextID + headerParameters +
                     (c * numberOfParamsPerTrCh) + 8) < length) and (
                         line[7 + NumberOfContextID + headerParameters +
                              (c * numberOfParamsPerTrCh) + 8] != ''):
                    cellType = int(
                        line[7 + NumberOfContextID + headerParameters +
                             (c * numberOfParamsPerTrCh) + 8])
                    if cellType == 1:
                        currentObj.cellType = "Primary"
                    else:
                        currentObj.cellType = "Secondary"
                listOfLogObj.append(currentObj)
        elif logObj.modeSystem == 'LTE FDD' or logObj.modeSystem == 'LTE TDD':

            if ((4 + NumberOfContextID) <
                    length) and (line[4 + NumberOfContextID] != ''):
                logObj.MACDLBitRate = int(line[4 + NumberOfContextID])
            if ((6 + NumberOfContextID) <
                    length) and (line[6 + NumberOfContextID] != ''):
                logObj.MACDLBLER = float(line[6 + NumberOfContextID])
            if ((13 + NumberOfContextID) <
                    length) and (line[13 + NumberOfContextID] != ''):
                cellType = int(line[13 + NumberOfContextID])
                if cellType == 0:
                    logObj.cellType = 'PCell'
                elif cellType == 1:
                    logObj.cellType = 'SCell 0'
                elif cellType == 2:
                    logObj.cellType = 'SCell 1'
            listOfLogObj.append(logObj)
        return 1

    else:
        dataOfMACRATE = "No of context id not found"
        return 0
Example #7
0
def ParseTUS(line, listOfLogObj, PREVIOUS_LAT, PREVIOUS_LONG, PREVIOUS_MCC,
             PREVIOUS_MNC):

    dataOfTUS = ""
    length = len(line)
    if 2 < length:
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])
        TUSContextID = 0
        numberOfTAC = 0
        parameterPerTAC = 0
        logObj = LogDT()
        logObj.lat = PREVIOUS_LAT
        logObj.longg = PREVIOUS_LONG
        logObj.mcc = PREVIOUS_MCC
        logObj.mnc = PREVIOUS_MNC
        logObj.event = "Tracking Area Update Succcesful"
        logObj.msgType = 'Succces'
        logObj.time = line[1]
        if (3 < length) and (line[3] != ''):
            TUSContextID = line[3]
            dataOfTUS = "TAU Context ID: " + TUSContextID + ';'
        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID]
                                                   != ''):
            logObj.modeSystem = MeasureSysConverter(
                int(line[3 + NumberOfContextID]))
            dataOfTUS += ('Measure System: ' + logObj.modeSystem) + ';'
        if ((4 + NumberOfContextID) < length) and (line[4 + NumberOfContextID]
                                                   != ''):
            numberOfTAC = int(line[4 + NumberOfContextID])
        if ((5 + NumberOfContextID) < length) and (line[5 + NumberOfContextID]
                                                   != ''):
            parameterPerTAC = int(line[5 + NumberOfContextID])
        for c in range(0, numberOfTAC):
            if c > 0:
                dataOfTUS += (", [")
            else:
                dataOfTUS += ("Parameters: [")
            currentObj = LogDT()
            currentObj = copy.deepcopy(logObj)

            if ((6 + NumberOfContextID + (c * parameterPerTAC) + 0) <
                    length) and (line[6 + NumberOfContextID +
                                      (c * parameterPerTAC) + 0] != ''):
                currentObj.mcc = int(line[6 + NumberOfContextID +
                                          (c * parameterPerTAC) + 0])
                dataOfTUS += ("MCC: " + str(currentObj.mcc))
            if ((6 + NumberOfContextID + (c * parameterPerTAC) + 1) <
                    length) and (line[6 + NumberOfContextID +
                                      (c * parameterPerTAC) + 1] != ''):
                currentObj.mnc = int(line[6 + NumberOfContextID +
                                          (c * parameterPerTAC) + 1])
                dataOfTUS += ("MNC: " + str(currentObj.mnc))
            if ((6 + NumberOfContextID + (c * parameterPerTAC) + 2) <
                    length) and (line[6 + NumberOfContextID +
                                      (c * parameterPerTAC) + 2] != ''):
                currentObj.TAC = int(line[6 + NumberOfContextID +
                                          (c * parameterPerTAC) + 2])  #add
                dataOfTUS += ("TAC: " + str(currentObj.TAC))
            dataOfTUS += (']')
            if c < (numberOfTAC - 1):
                listOfLogObj.append(currentObj)
            else:
                currentObj.eventInfo = dataOfTUS
                listOfLogObj.append(currentObj)
        return 1

    else:
        dataOfTUS = "No of context id not found"
        return 0
Example #8
0
def ParseCQI(line, listOfLogObj, PREVIOUS_LAT, PREVIOUS_LONG, PREVIOUS_MCC,
             PREVIOUS_MNC):
    length = len(line)
    if 2 < length:
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])
        logObj = LogDT()
        logObj.lat = PREVIOUS_LAT
        logObj.longg = PREVIOUS_LONG
        logObj.mcc = PREVIOUS_MCC
        logObj.mnc = PREVIOUS_MNC
        logObj.event = "Channel quality indicator"
        measureSystems = ''
        numberOfCQIValues = 0
        numberOfHeaderParamters = 0
        numberOfParametersPerCQI = 0
        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID]
                                                   != ''):
            measureSystems = int(line[3 + NumberOfContextID])
            logObj.modeSystem = MeasureSysConverter(measureSystems)

        if logObj.modeSystem == 'UMTS FDD':
            if ((4 + NumberOfContextID) <
                    length) and (line[4 + NumberOfContextID] != ''):
                numberOfHeaderParamters = int(line[4 + NumberOfContextID])
            if ((5 + NumberOfContextID + numberOfHeaderParamters) <
                    length) and (line[5 + NumberOfContextID +
                                      numberOfHeaderParamters] != ''):
                numberOfCQIValues = int(line[5 + NumberOfContextID +
                                             numberOfHeaderParamters])
            if ((6 + NumberOfContextID + numberOfHeaderParamters) <
                    length) and (line[6 + NumberOfContextID +
                                      numberOfHeaderParamters] != ''):
                numberOfParametersPerCQI = int(line[6 + NumberOfContextID +
                                                    numberOfHeaderParamters])

            for cqi in range(0, numberOfCQIValues):
                for param in range(1, numberOfParametersPerCQI):

                    if param == 2:  #CQI
                        if ((6 + NumberOfContextID + numberOfHeaderParamters +
                             param) < length) and (
                                 line[6 + NumberOfContextID +
                                      numberOfHeaderParamters + param] != ''):
                            logObj.CQI = int(
                                line[6 + NumberOfContextID +
                                     numberOfHeaderParamters + param])
                    if param == 3:  #CQI Type
                        if ((6 + NumberOfContextID + numberOfHeaderParamters +
                             param) < length) and (
                                 line[6 + NumberOfContextID +
                                      numberOfHeaderParamters + param] != ''):
                            cqiType = int(
                                line[6 + NumberOfContextID +
                                     numberOfHeaderParamters + param])
                        if cqiType == 1:
                            logObj.CQIType = 'CQI type A'
                        elif cqiType == 2:
                            logObj.CQIType = 'CQI type B'
                    if param == 5:  #Cell Type
                        if ((6 + NumberOfContextID + numberOfHeaderParamters +
                             param) < length) and (
                                 line[6 + NumberOfContextID +
                                      numberOfHeaderParamters + param] != ''):
                            cqiType = int(
                                line[6 + NumberOfContextID +
                                     numberOfHeaderParamters + param])
                            if cqiType == 1:
                                logObj.cellType = 'Primary'
                            else:
                                logObj.cellType = 'Secondary'
                listOfLogObj.append(logObj)

        elif logObj.modeSystem == 'LTE FDD' or logObj.modeSystem == 'LTE TDD':
            numberOfParameters = 0
            if ((4 + NumberOfContextID) <
                    length) and (line[4 + NumberOfContextID] != ''):
                numberOfParameters = int(line[4 + NumberOfContextID])

            if numberOfParameters > 2:
                if ((6 + NumberOfContextID) <
                        length) and (line[6 + NumberOfContextID] != ''):
                    logObj.WBCQI0 = int(line[6 + NumberOfContextID])

                if numberOfParameters > 3:
                    if ((7 + NumberOfContextID) <
                            length) and (line[7 + NumberOfContextID] != ''):
                        logObj.WBCQI1 = int(line[7 + NumberOfContextID])

                    if numberOfParameters > 4:
                        if ((8 + NumberOfContextID) < length) and (
                                line[8 + NumberOfContextID] != ''):
                            logObj.SBCQI0 = int(line[8 + NumberOfContextID])

                        if numberOfParameters > 5:
                            if ((9 + NumberOfContextID) < length) and (
                                    line[9 + NumberOfContextID] != ''):
                                logObj.SBCQI1 = int(line[9 +
                                                         NumberOfContextID])

                            if numberOfParameters > 7:
                                if ((11 + NumberOfContextID) < length) and (
                                        line[11 + NumberOfContextID] != ''):
                                    cellType = int(line[11 +
                                                        NumberOfContextID])

                                    if cellType == 0:
                                        logObj.cellType = 'PCell'
                                    elif cellType == 1:
                                        logObj.cellType = 'SCell 0'
                                    elif cellType == 2:
                                        logObj.cellType = 'SCell 1'

                listOfLogObj.append(logObj)
        return 1
    else:
        return 0
Example #9
0
def ParseNLIST (line, listOfLogObj, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC):
    dataOfNLIST = ""
    length = len(line)
    if 2 < length:
        logObj = LogDT()
        logObj.lat = PREVIOUS_LAT
        logObj.longg = PREVIOUS_LONG
        logObj.mcc = PREVIOUS_MCC
        logObj.mnc = PREVIOUS_MNC
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])
        headerParams = 0
        
        logObj.time = line[1]  
        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID] != ''):
            headerParams = int(line[3 + NumberOfContextID])
            currentLog = LogDT()
            currentLog = copy.deepcopy(logObj)
        for h in range(0,headerParams):
            paramNumber = h + 4 + NumberOfContextID
            if ((paramNumber) < length) and (line[paramNumber] != '') :
                if h == 0:
                    currentLog.cellType = "Serving";
                    currentLog.modeSystem = MeasureSysConverter(line[paramNumber]) 
                elif h == 1:
                    currentLog.Band = parseCellMeasuresParseBand(items[paramNumber])
                elif h == 2:
                    currentLog.ChannelNum = int(line[paramNumber]); 
                elif h == 3:
                    if currentLog.modeSystem == 'GSM':
                        currentLog.BSIC = int(items[paramNumber])
                    elif currentLog.modeSystem == 'UMTS FDD':
                        currentLog.SC = int(items[paramNumber])
                    elif currentLog.modeSystem == 'UMTS TD-SCDMA':
                        currentLog.CellParameterID = int(items[paramNumber])
        listOfLogObj.append(currentLog)
            
            
        numberOfNeighbourChannels = 0
        if ((4 + NumberOfContextID + headerParams) < length) and (line[4 + NumberOfContextID + headerParams] != '') :
            numberOfNeighbourChannels = int(line[4 + NumberOfContextID + headerParams])
            
            for c in range (0, numberOfNeighbourChannels):
                numberOfParamsPerChannel = 0
                if ((5 + NumberOfContextID + headerParams) < length) and (line[5 + NumberOfContextID + headerParams] != '') :
                    numberOfParamsPerChannel = int(line[5 + NumberOfContextID + headerParams])
                currentLog = LogDT()
                currentLog = copy.deepcopy(logObj)
                for p in range(0,numberOfParamsPerChannel):
                    paramNumber = 6 + NumberOfContextID + headerParams + (c * numberOfParamsPerChannel) + p
                    
                    if ((paramNumber) < length) and (line[paramNumber] != '') :
                        if p == 0:
                            currentLog.cellType = "Neighbor";
                            currentLog.modeSystem = MeasureSysConverter(line[paramNumber]) 
                        elif p == 1:
                            if currentLog.modeSystem == 'GSM':
                                currentLog.NeighbourARFCN = int(line[paramNumber])
                            elif currentLog.modeSystem == 'UMTS TD-SCDMA' or currentLog.modeSystem == 'UMTS FDD':
                                currentLog.UARFCN = int(line[paramNumber])    
                        elif p == 2:
                            if currentLog.modeSystem == 'GSM':
                                currentLog.BSIC = int(items[paramNumber])
                            elif currentLog.modeSystem == 'UMTS FDD':
                                currentLog.SC = int(items[paramNumber])
                            elif currentLog.modeSystem == 'UMTS TD-SCDMA':
                                currentLog.CellParameterID = int(items[paramNumber])
                        elif p== 3:
                            currentLog.Band = parseCellMeasuresParseBand(line[paramNumber])
                        elif p== 4:
                            currentLog.NeighbourCellIndex = int(line[paramNumber])
                listOfLogObj.append(currentLog)

        return 1
    else:
        dataOfNLIST = "No of context id not found"
        return 0
Example #10
0
def ParseRBI(line, listOfLogObj, PREVIOUS_LAT, PREVIOUS_LONG, PREVIOUS_MCC,
             PREVIOUS_MNC):
    dataOfRBI = ""
    length = len(line)
    if 2 < length:
        logObj = LogDT()
        logObj.lat = PREVIOUS_LAT
        logObj.longg = PREVIOUS_LONG
        logObj.mcc = PREVIOUS_MCC
        logObj.mnc = PREVIOUS_MNC
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])

        logObj.time = line[1]
        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID]
                                                   != ''):
            logObj.modeSystem = line[3 + NumberOfContextID]

        headerParams = 0
        if ((4 + NumberOfContextID) < length) and (line[4 + NumberOfContextID]
                                                   != ''):
            headerParams = int(line[4 + NumberOfContextID])
        numberOfParamsPerRB = 0
        if ((5 + NumberOfContextID + headerParams) <
                length) and (line[5 + NumberOfContextID + headerParams] != ''):
            numberOfParamsPerRB = int(line[5 + NumberOfContextID +
                                           headerParams])
        numberOfRBs = 0
        if ((6 + NumberOfContextID + headerParams) <
                length) and (line[6 + NumberOfContextID + headerParams] != ''):
            numberOfRBs = int(line[6 + NumberOfContextID + headerParams])

        for c in range(0, numberOfRBs):
            currentLog = LogDT()
            currentLog = copy.deepcopy(logObj)

            for p in range(0, numberOfParamsPerRB):
                paramNumber = 6 + NumberOfContextID + (c *
                                                       numberOfParamsPerRB) + p
                if ((paramNumber) < length) and (line[paramNumber] != ''):
                    if p == 0:  #RB ID
                        if currentLog.modeSystem == 'UMTS FDD':
                            currentLog.RBID = int(line[paramNumber])
                    elif p == 3:  #Direction
                        if currentLog.modeSystem == 'UMTS FDD':
                            if int(line[paramNumber]) == 0:
                                currentLog.direction = 'Uplink'
                            elif int(line[paramNumber]) == 1:
                                currentLog.direction = 'Downlink'
                    elif p == 4:  #Logical Channel
                        if currentLog.modeSystem == 'UMTS FDD':
                            if int(line[paramNumber]) == 0:
                                currentLog.direction = 'BCCH'
                            elif int(line[paramNumber]) == 1:
                                currentLog.direction = 'PCCH'
                            elif int(line[paramNumber]) == 2:
                                currentLog.direction = 'CCCH'
                            elif int(line[paramNumber]) == 3:
                                currentLog.direction = 'DCCH'
                            elif int(line[paramNumber]) == 4:
                                currentLog.direction = 'CTCH'
                            elif int(line[paramNumber]) == 5:
                                currentLog.direction = 'DTCH'
                            elif int(line[paramNumber]) == 6:
                                currentLog.direction = 'SHCCH'
                    elif p == 5:  #RLC mode
                        if currentLog.modeSystem == 'UMTS FDD':
                            if int(line[paramNumber]) == 0:
                                currentLog.RLCMode = 'TM'
                            elif int(line[paramNumber]) == 1:
                                currentLog.RLCMode = 'UM'
                            elif int(line[paramNumber]) == 2:
                                currentLog.RLCMode = 'AM'
                    elif p == 6:  #Radio Bearer Ciphering
                        if currentLog.modeSystem == 'UMTS FDD':
                            if int(line[paramNumber]) == 0:
                                currentLog.RBCiphering = 'Disabled'
                            elif int(line[paramNumber]) == 1:
                                currentLog.RBCiphering = 'Enabled'
                    elif p == 7:  #TrCh Type
                        if currentLog.modeSystem == 'UMTS FDD':
                            if int(line[paramNumber]) == 0:
                                currentLog.TrChType = 'BCH'
                            elif int(line[paramNumber]) == 1:
                                currentLog.TrChType = 'CPCH'
                            elif int(line[paramNumber]) == 2:
                                currentLog.TrChType = 'DCH'
                            elif int(line[paramNumber]) == 3:
                                currentLog.TrChType = 'HS-DSCH'
                            elif int(line[paramNumber]) == 4:
                                currentLog.TrChType = 'PCH'
                            elif int(line[paramNumber]) == 5:
                                currentLog.TrChType = 'FACH'
                            elif int(line[paramNumber]) == 6:
                                currentLog.TrChType = 'RACH'
                            elif int(line[paramNumber]) == 7:
                                currentLog.TrChType = 'E-DCH'

            listOfLogObj.append(currentLog)

        return 1
    else:
        dataOfRBI = "No of context id not found"
        return 0
Example #11
0
def ParseTRCHI(line, listOfLogObj, PREVIOUS_LAT, PREVIOUS_LONG, PREVIOUS_MCC,
               PREVIOUS_MNC):
    dataOfTRCHI = ""
    length = len(line)
    if 2 < length:
        logObj = LogDT()
        logObj.lat = PREVIOUS_LAT
        logObj.longg = PREVIOUS_LONG
        logObj.mcc = PREVIOUS_MCC
        logObj.mnc = PREVIOUS_MNC
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])

        logObj.time = line[1]
        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID]
                                                   != ''):
            logObj.modeSystem = MeasureSysConverter(
                int(line[3 + NumberOfContextID]))

        headerParams = 0
        if ((4 + NumberOfContextID) < length) and (line[4 + NumberOfContextID]
                                                   != ''):
            headerParams = int(line[4 + NumberOfContextID])
        numberOfParamsPerTrCh = 0
        if ((5 + NumberOfContextID + headerParams) <
                length) and (line[5 + NumberOfContextID + headerParams] != ''):
            numberOfParamsPerTrCh = int(line[5 + NumberOfContextID +
                                             headerParams])
        numberOfTrChs = 0
        if ((6 + NumberOfContextID + headerParams) <
                length) and (line[6 + NumberOfContextID + headerParams] != ''):
            numberOfTrChs = int(line[6 + NumberOfContextID + headerParams])

        for c in range(0, numberOfTrChs):
            currentLog = LogDT()
            currentLog = copy.deepcopy(logObj)

            for p in range(0, numberOfParamsPerTrCh):
                paramNumber = 6 + NumberOfContextID + (
                    c * numberOfParamsPerTrCh) + p
                if ((paramNumber) < length) and (line[paramNumber] != ''):
                    if p == 0:  #TrCh ID
                        if currentLog.modeSystem == 'UMTS FDD':
                            currentLog.TrChID = int(line[paramNumber])
                    elif p == 2:  #Direction
                        if currentLog.modeSystem == 'UMTS FDD':
                            if int(line[paramNumber]) == 0:
                                currentLog.direction = 'Uplink'
                            elif int(line[paramNumber]) == 1:
                                currentLog.direction = 'Downlink'
                            elif int(line[paramNumber]) == 2:
                                currentLog.direction = 'Relay-link'
                    elif p == 3:  #TrCh Type
                        if currentLog.modeSystem == 'UMTS FDD':
                            if int(line[paramNumber]) == 0:
                                currentLog.TrChType = 'BCH'
                            elif int(line[paramNumber]) == 1:
                                currentLog.TrChType = 'CPCH'
                            elif int(line[paramNumber]) == 2:
                                currentLog.TrChType = 'DCH'
                            elif int(line[paramNumber]) == 3:
                                currentLog.TrChType = 'HS-DSCH'
                            elif int(line[paramNumber]) == 4:
                                currentLog.TrChType = 'PCH'
                            elif int(line[paramNumber]) == 5:
                                currentLog.TrChType = 'FACH'
                            elif int(line[paramNumber]) == 6:
                                currentLog.TrChType = 'RACH'
                            elif int(line[paramNumber]) == 7:
                                currentLog.TrChType = 'E-DCH'
                    elif p == 4:  #TrCh Coding
                        if currentLog.modeSystem == 'UMTS FDD':
                            if int(line[paramNumber]) == 0:
                                currentLog.TrChCoding = '1/2 and convolutional'
                            elif int(line[paramNumber]) == 1:
                                currentLog.TrChCoding = '1/3 and convolutional'
                            elif int(line[paramNumber]) == 2:
                                currentLog.TrChCoding = '1/3 and turbo'
                            elif int(line[paramNumber]) == 3:
                                currentLog.TrChCoding = 'No coding'
                    elif p == 6:  #TTI
                        if currentLog.modeSystem == 'UMTS FDD':
                            currentLog.TTI = int(line[paramNumber])

            listOfLogObj.append(currentLog)

        return 1
    else:
        dataOfTRCHI = "No of context id not found"
        return 0
Example #12
0
def ParseMACI(line, listOfLogObj, PREVIOUS_LAT, PREVIOUS_LONG, PREVIOUS_MCC,
              PREVIOUS_MNC):
    dataOfMACI = ""
    length = len(line)
    if 2 < length:
        NumberOfContextID = 0
        if line[2] != '':
            NumberOfContextID = int(line[2])
        contextID = 'Unknown'
        measureSystem = 'Unknown'
        logDTObj = LogDT()
        logDTObj.lat = PREVIOUS_LAT
        logDTObj.longg = PREVIOUS_LONG
        logDTObj.mcc = PREVIOUS_MCC
        logDTObj.mnc = PREVIOUS_MNC
        logDTObj.event = 'Parse MAC layer info'
        if (3 < length) and (line[3] != ''):
            contextID = line[3]

        if ((3 + NumberOfContextID) < length) and (line[3 + NumberOfContextID]
                                                   != ''):
            measureSystem = line[3 + NumberOfContextID]
            logDTObj.modeSystem = MeasureSysConverter(int(measureSystem))

        numberOfCells = 0
        if ((4 + NumberOfContextID) < length) and (line[4 + NumberOfContextID]
                                                   != ''):
            numberOfCells = int(line[4 + NumberOfContextID])
        if ((5 + NumberOfContextID) < length) and (line[5 + NumberOfContextID]
                                                   != ''):
            numberOfParameterPerCell = int(line[5 + NumberOfContextID])

        for cell in range(0, numberOfCells):
            currentLog = LogDT()
            currentLog = copy.deepcopy(logDTObj)

            for parameter in range(0, numberOfParameterPerCell):
                paramNumber = NumberOfContextID + 6 + (
                    cell * numberOfParameterPerCell) + parameter
                if ((paramNumber) < length) and (line[paramNumber] != ''):

                    if parameter == 0:
                        if currentLog.modeSystem == 'UMTS FDD':
                            if line[paramNumber] == '2':
                                currentLog.cellType = 'Secondary'
                        elif currentLog.modeSystem == 'LTE FDD' or currentLog.modeSystem == 'LTE TDD':
                            currentLog.cellType = ParseCellTypeJ(
                                line[paramNumber], currentLog.modeSystem)

                    elif parameter == 1:
                        if line[paramNumber] == '0':
                            currentLog.cellState = 'Deactivate'
                        elif line[paramNumber] == '1':
                            currentLog.cellState = 'Activate'
            listOfLogObj.append(currentLog)

        return 1
    else:
        return 0
Example #13
0
def main(fileName):
    global PREVIOUS_LAT
    global PREVIOUS_LONG
    global PREVIOUS_MNC
    global PREVIOUS_MCC
    global PREVIOUS_APPLICATION_TYPE
    global LOGDT_LIST
    global CALL_INFO_DICTIONARY
    global DATA_INFO_DICTIONARY
    global SCAN_INFO_DICT
    global RADIO_RESOURCE_INFO_DICT
    global ATTACHMENT_EVENT_INFO_DICT 
    global PACKET_SESSION_INFO_DICT 
    
    

    with open(fileName, 'r') as reader:
        fileContent = reader.read()

    lines = fileContent.split('\n')    
    colInLines=[]
    
    fileNameCsv = fileName[:-4]
    fileNameCsv += ".csv"
    
    G = LogDT()
    
    file_object = open(fileNameCsv, 'w')
    csv_file_writer = csv.writer(file_object)
    csv_file_writer.writerow(list(vars(G).keys()))

    for i in range (0,len(lines)):
        colInLines.append (lines[i].split(','))

    for i in range (0,len(colInLines)):
        status = 0
        LOGDT_LIST = []
        listAppended = 0
        if colInLines[i][0] == '#FF':
            global version
            version = ParseFF(colInLines[i])
        elif colInLines[i][0] == '#START':
            global startDate
            startDate = ParseStart(colInLines[i]) 
        elif colInLines[i][0] == '#STOP':
            global stopDate
            stopDate = ParseStop(colInLines[i]) 
        elif colInLines[i][0] == 'CAA':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseCAA(colInLines[i],logDTObj,CALL_INFO_DICTIONARY)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CAC':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseCAC(colInLines[i],logDTObj,CALL_INFO_DICTIONARY)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CAF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseCAF(colInLines[i],logDTObj,CALL_INFO_DICTIONARY)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CAD':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseCAD(colInLines[i],logDTObj,CALL_INFO_DICTIONARY)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'VOIPI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseVOIPI(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CARE':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseCARE(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CALLMODI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseCALLMODI(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'DAA':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseDAA(colInLines[i],logDTObj,DATA_INFO_DICTIONARY)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'DAC':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseDAC(colInLines[i],logDTObj,DATA_INFO_DICTIONARY)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'DAF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseDAF(colInLines[i],logDTObj,DATA_INFO_DICTIONARY)
            PREVIOUS_APPLICATION_TYPE=''
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'DAD':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseDAD(colInLines[i],logDTObj,DATA_INFO_DICTIONARY)
            PREVIOUS_APPLICATION_TYPE=''
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'DREQ':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseDREQ(colInLines[i],logDTObj,DATA_INFO_DICTIONARY)
            PREVIOUS_APPLICATION_TYPE=logDTObj.applicationProtocol
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'DCOMP':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseDCOMP(colInLines[i],logDTObj,DATA_INFO_DICTIONARY)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'DRATE':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseDRATE(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'PER':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParsePER(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RTT':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRTT(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'JITTER':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseJITTER(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'DSS':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseDSS(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'DCONTENT':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            if version == '2.27':
                status = ParseDCONTENTV27(colInLines[i],logDTObj)
            else:
                status = ParseDCONTENT(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'DTRACE':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseDTRACE(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'TCPSTAT':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseTCPSTAT(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CELLMEAS':    
            status = ParseCELLMEAS(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
                   
        elif colInLines[i][0] == 'MIMOMEAS':
            listOfLogObj = []
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status, listOfLogObj = ParseMIMOMEAS(colInLines[i],listOfLogObj)
            if status == 1:
                for i in range(0,len(listOfLogObj)):
                    LOGDT_LIST.append(listOfLogObj[i])
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'FER':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseFER(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RLT':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRLT(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'TAD':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseTAD(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseCI(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'TXPC':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseTXPC(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RXPC':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRXPC(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'BER':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseBER(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'PHRATE':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParsePHRATE(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'PPPRATE':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParsePPPRATE(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'MEI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseMEI(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'POSI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParsePOSI(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CQI':
            status = ParseCQI(colInLines[i],LOGDT_LIST,PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'HARQI':
            status = ParseHARQI(colInLines[i],LOGDT_LIST,PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'HSSCCHI':
            status = ParseHSSCCHI(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'PLAID':
            status = ParsePLAID(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'PLAIU':
            if version == '2.27':
                status = ParsePLAIUV27(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            else:
                status = ParsePLAIU(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)      
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'MACERATE':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            if version == '2.27':
                status = ParseMACERATEV27(colInLines[i],logDTObj)
            else:
                status = ParseMACERATE(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'MACI':
            status = ParseMACI(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'EDCHI':
            status = ParseEDCHI(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'STARTSCAN':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseSTARTSCAN(colInLines[i],logDTObj,SCAN_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'STOPSCAN':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseSTOPSCAN(colInLines[i],logDTObj,SCAN_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'FREQSCAN':
            status = ParseFREQSCAN(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'SPECTRUMSCAN':
            status = ParseSPECTRUMSCAN(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'HOA':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseHOA(colInLines[i],logDTObj,SCAN_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'HOS':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseHOS(colInLines[i],logDTObj,SCAN_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'HOI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseHOI(colInLines[i],logDTObj,SCAN_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CREL':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseCREL(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'SHO':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseSHO(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'LUA':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseLUA(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'LUS':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mnc = PREVIOUS_MNC
            logDTObj.mcc = PREVIOUS_MCC
            status = ParseLUS(colInLines[i],logDTObj)
            PREVIOUS_MCC = logDTObj.mcc
            PREVIOUS_MNC = logDTObj.mnc
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'LUF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mnc = PREVIOUS_MNC
            logDTObj.mcc = PREVIOUS_MCC
            status = ParseLUF(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CHI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mnc = PREVIOUS_MNC
            logDTObj.mcc = PREVIOUS_MCC
            status = ParseCHI(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'GPS':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mnc = PREVIOUS_MNC
            logDTObj.mcc = PREVIOUS_MCC
            status = ParseGPS(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'VCHI':
            ParseVCHI(colInLines[i])
        elif colInLines[i][0] == 'HOF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseHOF(colInLines[i],logDTObj,SCAN_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'SEI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseSEI(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'ROAM':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseROAM(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)          
        elif colInLines[i][0] == 'DCHI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseDCHI(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'HOP':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseHOP(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CELLINFO':
            status = ParseCELLINFO(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'NLIST':
            status = ParseNLIST(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'NMISS':
            status = ParseNMISS(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'ANRI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mnc = PREVIOUS_MNC
            logDTObj.mcc = PREVIOUS_MCC
            status = ParseANRI(colInLines[i],logDTObj)
            PREVIOUS_MCC = logDTObj.mcc
            PREVIOUS_MNC = logDTObj.mnc
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'CELLPOLLUTION':
            status = ParseCELLPOLLUTION(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'RBI':
            status = ParseRBI(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'TRCHI':
            status = ParseTRCHI(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'RRA':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC           
            status = ParseRRA(colInLines[i],logDTObj,RADIO_RESOURCE_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RRC':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC           
            status = ParseRRC(colInLines[i],logDTObj,RADIO_RESOURCE_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RRF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC           
            status = ParseRRF(colInLines[i],logDTObj,RADIO_RESOURCE_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RRD':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParseRRD(colInLines[i],logDTObj,RADIO_RESOURCE_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RRRE':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParseRRRE(colInLines[i],logDTObj,RADIO_RESOURCE_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'PBA':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParsePBA(colInLines[i],logDTObj,RADIO_RESOURCE_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'PBC':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParsePBC(colInLines[i],logDTObj,RADIO_RESOURCE_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'PBF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParsePBF(colInLines[i],logDTObj,RADIO_RESOURCE_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'PBD':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParsePBD(colInLines[i],logDTObj,RADIO_RESOURCE_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'L3SM':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseL3SM(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'PCHI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParsePCHI(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'GAA':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParseGAA(colInLines[i],logDTObj,ATTACHMENT_EVENT_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'GAF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            if version == '2.27':
                status = ParseGAFV27(colInLines[i],logDTObj,ATTACHMENT_EVENT_INFO_DICT)
            else:
                status = ParseGAF(colInLines[i],logDTObj,ATTACHMENT_EVENT_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'GAC':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParseGAC(colInLines[i],logDTObj,ATTACHMENT_EVENT_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'GAD':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            if version == '2.27':
                status = ParseGADV27(colInLines[i],logDTObj,ATTACHMENT_EVENT_INFO_DICT)
            else:
                status = ParseGAD(colInLines[i],logDTObj,ATTACHMENT_EVENT_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RLCBLER':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParseRLCBLER(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RLCRATE':
            status = ParseRLCRATE(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'RLCRATEU':
            status = ParseRLCRATEU(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'PDCPRATED':
            status = ParsePDCPRATED(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'PDCPRATEU':
            status = ParsePDCPRATEDU(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'LLCRATE':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseLLCRATE(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RUA':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRUA(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RUS':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRUS(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RUF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRUF(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'TUA':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseTUA(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'TUS':
            status = ParseTUS(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'TUF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseTUF(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'MACRATE':
            status = ParseMACRATE(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'MACRATEU':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseMACRATEU(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'MACBLER':
            status = ParseMACBLER(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'AMRI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseAMRI(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'AMRS':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseAMRS(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'AQUL':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseAQUL(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'AQDL':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseAQDL(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'AQI':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseAQI(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)           
        elif colInLines[i][0] == 'MSGA':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseMSGA(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj) 
        elif colInLines[i][0] == 'MSGF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseMSGF(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj) 
        elif colInLines[i][0] == 'RXQ':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRXQ(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'MSGS':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseMSGS(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj) 
        elif colInLines[i][0] == 'PAUSE':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParsePAUSE(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RESUME':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRESUME(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'LOCK':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseLOCK(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'PILOTSCAN':
            status = ParsePILOTSCAN(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'PAA':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParsePAA(colInLines[i],logDTObj,PACKET_SESSION_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj)   
        elif colInLines[i][0] == 'PAC':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParsePAC(colInLines[i],logDTObj,PACKET_SESSION_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj) 
        elif colInLines[i][0] == 'PAF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParsePAF(colInLines[i],logDTObj,PACKET_SESSION_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj) 
        elif colInLines[i][0] == 'PAD':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC  
            status = ParsePAD(colInLines[i],logDTObj,PACKET_SESSION_INFO_DICT)
            if status == 1:
                LOGDT_LIST.append(logDTObj) 
        elif colInLines[i][0] == 'RRCSM':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRRCSM(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RABA':
            status = ParseRABA(colInLines[i],LOGDT_LIST, PREVIOUS_LAT,PREVIOUS_LONG,PREVIOUS_MCC,PREVIOUS_MNC)
            status = 0
            listAppended = 1
        elif colInLines[i][0] == 'RABC':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRABC(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RABF':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRABF(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
        elif colInLines[i][0] == 'RABD':
            logDTObj = LogDT()
            logDTObj.lat = PREVIOUS_LAT
            logDTObj.longg = PREVIOUS_LONG
            logDTObj.mcc = PREVIOUS_MCC
            logDTObj.mnc = PREVIOUS_MNC
            status = ParseRABD(colInLines[i],logDTObj)
            if status == 1:
                LOGDT_LIST.append(logDTObj)
                
        if status == 1:
            csv_file_writer.writerow(list(vars(logDTObj).values()))
        if listAppended == 1:
            for i in LOGDT_LIST:
                csv_file_writer.writerow(list(vars(i).values()))