Align 2G CIQ output with final schema

queries/ciq_2g_final_schema.json

@@ -0,0 +1,743 @@
+{
+  "BTS": {
+    "columns": [
+      "site",
+      "bscid",
+      "cellId",
+      "bcfId",
+      "btsId",
+      "Check",
+      "bsIdentityCodeNCC",
+      "bsIdentityCodeBCC",
+      "locationAreaIdLAC",
+      "locationAreaIdMCC",
+      "locationAreaIdMNC",
+      "usedMobileAllocation",
+      "malId",
+      "name",
+      "template_name",
+      "sectorId",
+      "masterBCF",
+      "allowIMSIAttachDetach",
+      "amhLowerLoadThreshold",
+      "amhMaxLoadOfTgtCell",
+      "amhTrhoGuardTime",
+      "amhUpperLoadThreshold",
+      "btsIsHopping",
+      "btsLoadInSeg",
+      "btsLoadThreshold",
+      "btsMeasAver",
+      "callReestablishmentAllowed",
+      "cellBarQualify",
+      "cellBarred",
+      "cellLoadForChannelSearch",
+      "cellNumberInBtsHw",
+      "cellReselectHysteresis",
+      "cellReselectOffset",
+      "cellReselectParamInd",
+      "cnThreshold",
+      "diversityUsed",
+      "dlNoiseLevel",
+      "drInUse",
+      "drMethod",
+      "dtxMode",
+      "earlySendingIndication",
+      "emergencyCallRestricted",
+      "fddQMin",
+      "fddQOffset",
+      "frequencyBandInUse",
+      "hoppingMode",
+      "hoppingSequenceNumber1",
+      "hoppingSequenceNumber2",
+      "idleStateBcchAllocListId",
+      "idrCellType",
+      "idrUsed",
+      "interferenceAveragingProcessAverPeriod",
+      "interferenceAveragingProcessBoundary0",
+      "interferenceAveragingProcessBoundary1",
+      "interferenceAveragingProcessBoundary2",
+      "interferenceAveragingProcessBoundary3",
+      "interferenceAveragingProcessBoundary4",
+      "interferenceAveragingProcessBoundary5",
+      "lowPriorityThr",
+      "maioOffset",
+      "maxNumberOfRepetition",
+      "maxNumberRetransmission",
+      "maxQueueLength",
+      "maxTimeLimitDirectedRetry",
+      "measListUsedDuringMeas",
+      "measurementBCCHAllocation",
+      "minMsTxPower",
+      "minTimeLimitDirectedRetry",
+      "msMaxDistInCallSetup",
+      "msPriorityUsedInQueueing",
+      "msTxPwrMaxCCH",
+      "msTxPwrMaxCCH1x00",
+      "msTxPwrMaxGSM",
+      "msTxPwrMaxGSM1x00",
+      "multiBandCell",
+      "multiBandCellReporting",
+      "nbrOfSlotsSpreadTrans",
+      "newEstabCausesSupport",
+      "noOfBlocksForAccessGrant",
+      "noOfMFramesBetweenPaging",
+      "penaltyTime",
+      "powerOffset",
+      "prioritySearchThr",
+      "qSearchI",
+      "qSearchP",
+      "queuePriorityNonUrgentHo",
+      "queuePriorityUsed",
+      "queueingPriorityCall",
+      "queueingPriorityHandover",
+      "radioLinkTimeout",
+      "radioLinkTimeoutUlIncreaseStep",
+      "reselectionAlgorithmHysteresis",
+      "rxLevAccessMin",
+      "segmentId",
+      "smsCbUsed",
+      "stircEnabled",
+      "temporaryOffset",
+      "timeHysteresis",
+      "timeLimitCall",
+      "timeLimitHandover",
+      "timerPeriodicUpdateMs",
+      "trxPriorityInTchAlloc",
+      "ulNoiseLevel",
+      "utranQualRxLevelMargin",
+      "utranThresholdReselection",
+      "wcdmaPriority",
+      "gprsCapacityThroughputFactor",
+      "fddRscpMin",
+      "fddQMinOffset"
+    ],
+    "defaults": {
+      "locationAreaIdMCC": 610,
+      "locationAreaIdMNC": 2,
+      "masterBCF": 1,
+      "allowIMSIAttachDetach": 1,
+      "amhLowerLoadThreshold": -1,
+      "amhMaxLoadOfTgtCell": 85,
+      "amhTrhoGuardTime": 30,
+      "amhUpperLoadThreshold": 30,
+      "btsIsHopping": 1,
+      "btsLoadInSeg": 70,
+      "btsLoadThreshold": 85,
+      "btsMeasAver": 2,
+      "callReestablishmentAllowed": 1,
+      "cellBarQualify": 0,
+      "cellBarred": 0,
+      "cellLoadForChannelSearch": 0,
+      "cellNumberInBtsHw": 255,
+      "cellReselectHysteresis": 7,
+      "cellReselectOffset": 0,
+      "cellReselectParamInd": 1,
+      "cnThreshold": 0,
+      "diversityUsed": 1,
+      "dlNoiseLevel": 3,
+      "drInUse": 1,
+      "drMethod": 0,
+      "dtxMode": 1,
+      "earlySendingIndication": 1,
+      "emergencyCallRestricted": 0,
+      "fddQMin": 7,
+      "fddQOffset": 8,
+      "hoppingMode": 2,
+      "hoppingSequenceNumber2": 0,
+      "idleStateBcchAllocListId": 0,
+      "idrCellType": 0,
+      "idrUsed": 0,
+      "interferenceAveragingProcessAverPeriod": 10,
+      "interferenceAveragingProcessBoundary0": 0,
+      "interferenceAveragingProcessBoundary1": 5,
+      "interferenceAveragingProcessBoundary2": 10,
+      "interferenceAveragingProcessBoundary3": 15,
+      "interferenceAveragingProcessBoundary4": 20,
+      "interferenceAveragingProcessBoundary5": 63,
+      "lowPriorityThr": 15,
+      "maioOffset": 0,
+      "maxNumberOfRepetition": 35,
+      "maxNumberRetransmission": 2,
+      "maxQueueLength": 50,
+      "maxTimeLimitDirectedRetry": 5,
+      "measListUsedDuringMeas": 1,
+      "measurementBCCHAllocation": 1,
+      "minMsTxPower": 13,
+      "minTimeLimitDirectedRetry": 0,
+      "msMaxDistInCallSetup": 64,
+      "msPriorityUsedInQueueing": 0,
+      "msTxPwrMaxCCH": 2,
+      "msTxPwrMaxCCH1x00": 0,
+      "msTxPwrMaxGSM": 2,
+      "msTxPwrMaxGSM1x00": 0,
+      "multiBandCell": 1,
+      "multiBandCellReporting": 3,
+      "nbrOfSlotsSpreadTrans": 10,
+      "newEstabCausesSupport": 0,
+      "noOfBlocksForAccessGrant": 2,
+      "noOfMFramesBetweenPaging": 3,
+      "penaltyTime": 0,
+      "powerOffset": 0,
+      "prioritySearchThr": 15,
+      "qSearchI": 7,
+      "qSearchP": 7,
+      "queuePriorityNonUrgentHo": 9,
+      "queuePriorityUsed": 1,
+      "queueingPriorityCall": 10,
+      "queueingPriorityHandover": 9,
+      "radioLinkTimeout": 7,
+      "radioLinkTimeoutUlIncreaseStep": 2,
+      "reselectionAlgorithmHysteresis": 0,
+      "rxLevAccessMin": 8,
+      "smsCbUsed": 1,
+      "stircEnabled": 1,
+      "temporaryOffset": 0,
+      "timeHysteresis": 0,
+      "timeLimitCall": 6,
+      "timeLimitHandover": 3,
+      "timerPeriodicUpdateMs": 60,
+      "trxPriorityInTchAlloc": 0,
+      "ulNoiseLevel": 3,
+      "utranQualRxLevelMargin": 2,
+      "utranThresholdReselection": 3,
+      "wcdmaPriority": 4,
+      "gprsCapacityThroughputFactor": 80,
+      "fddRscpMin": 4,
+      "fddQMinOffset": 0
+    },
+    "formulas": {
+      "segmentId": {
+        "kind": "same_row_ref",
+        "source_column": "btsId"
+      }
+    }
+  },
+  "BTS_GPRS": {
+    "columns": [
+      "Site",
+      "bscid",
+      "cellId",
+      "bcfId",
+      "btsId",
+      "template_name",
+      "dedicatedGPRScapacity",
+      "egprsEnabled",
+      "egprsLinkAdaptEnabled",
+      "gprsEnabled",
+      "gprsMsTxPwrMaxCCH1x00",
+      "gprsMsTxpwrMaxCCH",
+      "gprsRxlevAccessMin",
+      "csAckDl",
+      "csAckUl",
+      "csUnackDl",
+      "csUnackUl",
+      "preferBCCHfreqGPRS2",
+      "raReselectHysteresis",
+      "egprsInitMcsAckMode",
+      "egprsInitMcsUnAckMode",
+      "maxGPRSCapacity",
+      "adaptiveLaAlgorithm",
+      "cs3Cs4Enabled",
+      "defaultGPRScapacity",
+      "directGPRSAccessBts",
+      "egprsMaxBlerAckMode",
+      "egprsMaxBlerUnAckMode",
+      "egprsMeanBepOffset8psk",
+      "egprsMeanBepOffsetGmsk",
+      "gprsDlPcEnabled",
+      "gprsNonBCCHRxlevLower",
+      "gprsNonBCCHRxlevUpper",
+      "hcsPriorityClass",
+      "hcsThreshold",
+      "pcuCsHopping",
+      "pcuCsNonHopping",
+      "pcuDlBlerCpHopping",
+      "pcuDlBlerCpNonHop",
+      "pcuDlLaRiskLevel",
+      "pcuUlBlerCpHopping",
+      "pcuUlBlerCpNonHop",
+      "pcuUlLaRiskLevel",
+      "throughputFactor_cs1cs4dlcs",
+      "throughputFactor_cs1cs4ulcs",
+      "throughputFactor_mcs1mcs4ulcs",
+      "throughputFactor_mcs1mcs9dlcs",
+      "throughputFactor_mcs1mcs9ulcs",
+      "inactEndTimeHour",
+      "inactEndTimeMinute",
+      "inactStartTimeHour",
+      "inactStartTimeMinute",
+      "inactWeekDays",
+      "nsei",
+      "psei",
+      "rac"
+    ],
+    "defaults": {
+      "template_name": "All",
+      "dedicatedGPRScapacity": 15,
+      "egprsEnabled": 1,
+      "egprsLinkAdaptEnabled": 2,
+      "gprsEnabled": 1,
+      "gprsMsTxPwrMaxCCH1x00": 2,
+      "gprsMsTxpwrMaxCCH": 2,
+      "gprsRxlevAccessMin": 10,
+      "csAckDl": 5,
+      "csAckUl": 5,
+      "csUnackDl": 5,
+      "csUnackUl": 5,
+      "preferBCCHfreqGPRS2": 1,
+      "raReselectHysteresis": 2,
+      "egprsInitMcsAckMode": 2,
+      "egprsInitMcsUnAckMode": 2,
+      "maxGPRSCapacity": 100,
+      "adaptiveLaAlgorithm": 0,
+      "cs3Cs4Enabled": 1,
+      "defaultGPRScapacity": 50,
+      "directGPRSAccessBts": 0,
+      "egprsMaxBlerAckMode": 90,
+      "egprsMaxBlerUnAckMode": 10,
+      "egprsMeanBepOffset8psk": 31,
+      "egprsMeanBepOffsetGmsk": 31,
+      "gprsDlPcEnabled": 1,
+      "gprsNonBCCHRxlevLower": 10,
+      "gprsNonBCCHRxlevUpper": 15,
+      "hcsPriorityClass": 0,
+      "hcsThreshold": 255,
+      "pcuCsHopping": 0,
+      "pcuCsNonHopping": 0,
+      "pcuDlBlerCpHopping": 20,
+      "pcuDlBlerCpNonHop": 90,
+      "pcuDlLaRiskLevel": 20,
+      "pcuUlBlerCpHopping": 24,
+      "pcuUlBlerCpNonHop": 90,
+      "pcuUlLaRiskLevel": 10,
+      "throughputFactor_cs1cs4dlcs": 12,
+      "throughputFactor_cs1cs4ulcs": 12,
+      "throughputFactor_mcs1mcs4ulcs": 16,
+      "throughputFactor_mcs1mcs9dlcs": 30,
+      "throughputFactor_mcs1mcs9ulcs": 30,
+      "inactEndTimeHour": 18,
+      "inactEndTimeMinute": 0,
+      "inactStartTimeHour": 8,
+      "inactStartTimeMinute": 0,
+      "inactWeekDays": 0,
+      "nsei": "",
+      "psei": 0,
+      "rac": 1
+    },
+    "formulas": {}
+  },
+  "BTS_AMR": {
+    "columns": [
+      "Site",
+      "bscId",
+      "cellId",
+      "bcfId",
+      "btsId",
+      "template_name",
+      "amrConfFrCodecModeSet",
+      "amrConfFrDlThreshold1",
+      "amrConfFrDlThreshold2",
+      "amrConfFrDlThreshold3",
+      "amrConfFrHysteresis1",
+      "amrConfFrHysteresis2",
+      "amrConfFrHysteresis3",
+      "amrConfFrInitCodecMode",
+      "amrConfFrStartMode",
+      "amrConfFrUlThreshold1",
+      "amrConfFrUlThreshold2",
+      "amrConfFrUlThreshold3",
+      "amrConfHrCodecModeSet",
+      "amrConfHrDlThreshold1",
+      "amrConfHrDlThreshold2",
+      "amrConfHrDlThreshold3",
+      "amrConfHrHysteresis1",
+      "amrConfHrHysteresis2",
+      "amrConfHrHysteresis3",
+      "amrConfHrInitCodecMode",
+      "amrConfHrStartMode",
+      "amrConfHrUlThreshold1",
+      "amrConfHrUlThreshold2",
+      "amrConfHrUlThreshold3",
+      "amrHoFrInHoThrDlRxQual",
+      "amrHoFrThrDlRxQual",
+      "amrHoFrThrUlRxQual",
+      "amrHoHrInHoThrDlRxQual",
+      "amrHoHrThrDlRxQual",
+      "amrHoHrThrUlRxQual",
+      "amrPocFrPcLThrDlRxQual",
+      "amrPocFrPcLThrUlRxQual",
+      "amrPocFrPcUThrDlRxQual",
+      "amrPocFrPcUThrUlRxQual",
+      "amrPocHrPcLThrDlRxQual",
+      "amrPocHrPcLThrUlRxQual",
+      "amrPocHrPcUThrDlRxQual",
+      "amrPocHrPcUThrUlRxQual",
+      "amrSegLoadDepTchRateLower",
+      "amrSegLoadDepTchRateUpper",
+      "radioLinkTimeoutAmrHr",
+      "radioLinkTimeoutAmr",
+      "btsSpLoadDepTchRateLower",
+      "btsSpLoadDepTchRateUpper",
+      "radioLinkTimeoutAmrHrUlIncreaseStep",
+      "radioLinkTimeoutAmrUlIncreaseStep",
+      "tchRateIntraCellHo"
+    ],
+    "defaults": {
+      "template_name": "All",
+      "amrConfFrCodecModeSet": 149,
+      "amrConfFrDlThreshold1": 14,
+      "amrConfFrDlThreshold2": 26,
+      "amrConfFrDlThreshold3": 52,
+      "amrConfFrHysteresis1": 8,
+      "amrConfFrHysteresis2": 8,
+      "amrConfFrHysteresis3": 8,
+      "amrConfFrInitCodecMode": 1,
+      "amrConfFrStartMode": 0,
+      "amrConfFrUlThreshold1": 18,
+      "amrConfFrUlThreshold2": 28,
+      "amrConfFrUlThreshold3": 46,
+      "amrConfHrCodecModeSet": 21,
+      "amrConfHrDlThreshold1": 40,
+      "amrConfHrDlThreshold2": 52,
+      "amrConfHrDlThreshold3": 52,
+      "amrConfHrHysteresis1": 8,
+      "amrConfHrHysteresis2": 8,
+      "amrConfHrHysteresis3": 8,
+      "amrConfHrInitCodecMode": 1,
+      "amrConfHrStartMode": 0,
+      "amrConfHrUlThreshold1": 40,
+      "amrConfHrUlThreshold2": 52,
+      "amrConfHrUlThreshold3": 52,
+      "amrHoFrInHoThrDlRxQual": 0,
+      "amrHoFrThrDlRxQual": 5,
+      "amrHoFrThrUlRxQual": 5,
+      "amrHoHrInHoThrDlRxQual": 5,
+      "amrHoHrThrDlRxQual": 5,
+      "amrHoHrThrUlRxQual": 5,
+      "amrPocFrPcLThrDlRxQual": 3,
+      "amrPocFrPcLThrUlRxQual": 3,
+      "amrPocFrPcUThrDlRxQual": 1,
+      "amrPocFrPcUThrUlRxQual": 1,
+      "amrPocHrPcLThrDlRxQual": 3,
+      "amrPocHrPcLThrUlRxQual": 3,
+      "amrPocHrPcUThrDlRxQual": 1,
+      "amrPocHrPcUThrUlRxQual": 1,
+      "amrSegLoadDepTchRateLower": 100,
+      "amrSegLoadDepTchRateUpper": 0,
+      "radioLinkTimeoutAmrHr": 7,
+      "radioLinkTimeoutAmr": 7,
+      "btsSpLoadDepTchRateLower": 100,
+      "btsSpLoadDepTchRateUpper": 0,
+      "radioLinkTimeoutAmrHrUlIncreaseStep": 2,
+      "radioLinkTimeoutAmrUlIncreaseStep": 2,
+      "tchRateIntraCellHo": 0
+    },
+    "formulas": {}
+  },
+  "HOC": {
+    "columns": [
+      "Site",
+      "bscid",
+      "cellId",
+      "bcfId",
+      "btsId",
+      "hocId",
+      "template_name",
+      "averagingWindowSizeAdjCell",
+      "ddeThresholdsLevRxLevel",
+      "enableIntraHoDl",
+      "enableIntraHoUl",
+      "enableMsDistance",
+      "enablePowerBudgetHo",
+      "enableSddchHandover",
+      "hoAvaragingLevDLWeighting",
+      "hoAvaragingLevDlWindowSize",
+      "hoAveragingLevUlWeighting",
+      "hoAveragingLevUlWindowSize",
+      "hoAveragingQualDlWeighting",
+      "hoAveragingQualDlWindowSize",
+      "hoAveragingQualUl",
+      "hoAveragingQualUlWindowSize",
+      "hoPeriodPbgt",
+      "hoTLDlRxLevel",
+      "hoTLUlRxLevel",
+      "hoTQDlRxQual",
+      "hoTQUlRxQual",
+      "hoThresholdsInterferenceDlRxLevel",
+      "hoThresholdsInterferenceULRxLevel",
+      "minIntBetweenUnsuccHoAttempt",
+      "msDistanceAveragingParamHreqave",
+      "msDistanceHoThresholdParamMsRangeMax",
+      "qSearchC",
+      "allAdjacentCellsAveraged",
+      "allUtranAdjAver",
+      "amhTrafficControlIUO",
+      "amhTrafficControlMCN",
+      "amhTrhoPbgtMargin",
+      "ddeThresholdsLevNx",
+      "ddeThresholdsLevPx",
+      "ddeWindow",
+      "enaFastAveCallSetup",
+      "enaFastAveHo",
+      "enaFastAvePc",
+      "enaHierCellHo",
+      "erfdEnabled",
+      "erfdOver",
+      "failMoveThreshold",
+      "gsmPlmnPriorisation",
+      "hoPeriodUmbrella",
+      "hoTLDlPx",
+      "hoTLUlNx",
+      "hoTLUlPx",
+      "hoTQDlNx",
+      "hoTQDlPx",
+      "hoTQUlNx",
+      "hoTQUlPx",
+      "hoThrInterferenceDlNx",
+      "hoThrInterferenceDlPx",
+      "hoThresholdsInterferenceULNx",
+      "hoThresholdsInterferenceULPx",
+      "hoThresholdsLevDLNx",
+      "hoThresholdsRapidLevUl",
+      "hoThresholdsRapidLevUlN",
+      "interSystemDa",
+      "intraHoLoRxLevLimAmrHr",
+      "intraHoLoRxQualLimAmr",
+      "intraHoUpRxLevLimAmrHr",
+      "lowerSpeedLimit",
+      "minIntBetweenHoReq",
+      "minIntUnsuccIsHo",
+      "modifiedAveWinNCell",
+      "modifiedNoz",
+      "msDHoThrParamN8",
+      "msDistanceHoThresholdParamP8",
+      "msSpeedAveraging",
+      "msSpeedDetectionState",
+      "msSpeedThresholdNx",
+      "msSpeedThresholdPx",
+      "multiratRep",
+      "noOfZeroResUtran",
+      "numberOfZeroResults",
+      "upperSpeedLimit",
+      "utranAveragingNumber",
+      "utranHoThScTpdc",
+      "wcdmaRanCellPenalty",
+      "enableUmbrellaHo"
+    ],
+    "defaults": {
+      "hocId": 1,
+      "averagingWindowSizeAdjCell": 10,
+      "ddeThresholdsLevRxLevel": 10,
+      "enableIntraHoDl": 0,
+      "enableIntraHoUl": 0,
+      "enableMsDistance": 0,
+      "enablePowerBudgetHo": 1,
+      "enableSddchHandover": "",
+      "hoAvaragingLevDLWeighting": 2,
+      "hoAvaragingLevDlWindowSize": 5,
+      "hoAveragingLevUlWeighting": 2,
+      "hoAveragingLevUlWindowSize": 5,
+      "hoAveragingQualDlWeighting": 3,
+      "hoAveragingQualDlWindowSize": 5,
+      "hoAveragingQualUl": "",
+      "hoAveragingQualUlWindowSize": 5,
+      "hoPeriodPbgt": 6,
+      "hoTLDlRxLevel": 15,
+      "hoTLUlRxLevel": 15,
+      "hoTQDlRxQual": 4,
+      "hoTQUlRxQual": 4,
+      "hoThresholdsInterferenceDlRxLevel": 12,
+      "hoThresholdsInterferenceULRxLevel": 3,
+      "minIntBetweenUnsuccHoAttempt": 20,
+      "msDistanceAveragingParamHreqave": 4,
+      "msDistanceHoThresholdParamMsRangeMax": 63,
+      "qSearchC": 15,
+      "allAdjacentCellsAveraged": 0,
+      "allUtranAdjAver": 0,
+      "amhTrafficControlIUO": 0,
+      "amhTrafficControlMCN": 0,
+      "amhTrhoPbgtMargin": -2,
+      "ddeThresholdsLevNx": 3,
+      "ddeThresholdsLevPx": 2,
+      "ddeWindow": 2,
+      "enaFastAveCallSetup": 0,
+      "enaFastAveHo": 1,
+      "enaFastAvePc": 1,
+      "enaHierCellHo": 0,
+      "erfdEnabled": 0,
+      "erfdOver": 10,
+      "failMoveThreshold": 50,
+      "gsmPlmnPriorisation": 0,
+      "hoPeriodUmbrella": 0,
+      "hoTLDlPx": 1,
+      "hoTLUlNx": 1,
+      "hoTLUlPx": 1,
+      "hoTQDlNx": 6,
+      "hoTQDlPx": 4,
+      "hoTQUlNx": 6,
+      "hoTQUlPx": 4,
+      "hoThrInterferenceDlNx": 1,
+      "hoThrInterferenceDlPx": 1,
+      "hoThresholdsInterferenceULNx": 1,
+      "hoThresholdsInterferenceULPx": 1,
+      "hoThresholdsLevDLNx": 1,
+      "hoThresholdsRapidLevUl": 0,
+      "hoThresholdsRapidLevUlN": 0,
+      "interSystemDa": 0,
+      "intraHoLoRxLevLimAmrHr": 63,
+      "intraHoLoRxQualLimAmr": 0,
+      "intraHoUpRxLevLimAmrHr": 0,
+      "lowerSpeedLimit": 0,
+      "minIntBetweenHoReq": 5,
+      "minIntUnsuccIsHo": 3,
+      "modifiedAveWinNCell": 2,
+      "modifiedNoz": 1,
+      "msDHoThrParamN8": 1,
+      "msDistanceHoThresholdParamP8": 1,
+      "msSpeedAveraging": 4,
+      "msSpeedDetectionState": 0,
+      "msSpeedThresholdNx": 6,
+      "msSpeedThresholdPx": 3,
+      "multiratRep": 2,
+      "noOfZeroResUtran": 5,
+      "numberOfZeroResults": 2,
+      "upperSpeedLimit": 0,
+      "utranAveragingNumber": 6,
+      "utranHoThScTpdc": 80,
+      "wcdmaRanCellPenalty": 127,
+      "enableUmbrellaHo": 1
+    },
+    "formulas": {}
+  },
+  "POC": {
+    "columns": [
+      "Site",
+      "bscid",
+      "cellId",
+      "bcfId",
+      "btsId",
+      "hocId",
+      "template_name",
+      "alpha",
+      "bepPeriod",
+      "bsTxPwrMax",
+      "bsTxPwrMax1x00",
+      "bsTxPwrMin",
+      "gamma",
+      "pcALDlWeighting",
+      "pcALDlWindowSize",
+      "pcALUlWeighting",
+      "pcALUlWindowSize",
+      "pcAQLDlWeighting",
+      "pcAQLDlWindowSize",
+      "pcAQLUlWeighting",
+      "pcAQLUlWindowSize",
+      "pcControlEnabled",
+      "pcControlInterval",
+      "pcIncrStepSize",
+      "pcLowerThresholdsLevDLRxLevel",
+      "pcLowerThresholsLevULRxLevel",
+      "pcRedStepSize",
+      "pcUpperThresholdsLevDLRxLevel",
+      "pcUpperThresholdsLevULRxLevel",
+      "tAvgT",
+      "tAvgW",
+      "pcLTQualDlRxQual",
+      "pcLTQualUlRxQual",
+      "pcUTQualDlRxQual",
+      "pcUTQualUlRxQual",
+      "dlPcPowerReduction",
+      "dlPcWindowSize",
+      "enableAla",
+      "maxPwrCompensation",
+      "minIntBetweenAla",
+      "pcLTLevDlNx",
+      "pcLTLevDlPx",
+      "pcLTLevUlNx",
+      "pcLTLevUlPx",
+      "pcLTQual144Nx",
+      "pcLTQual144Px",
+      "pcLTQual144RxQual",
+      "pcLTQualDlNx",
+      "pcLTQualDlPx",
+      "pcLTQualUlNx",
+      "pcLTQualUlPx",
+      "pcUTLevDlNx",
+      "pcUTLevDlPx",
+      "pcUTLevUlNx",
+      "pcUTLevUlPx",
+      "pcUTQualDlNx",
+      "pcUTQualDlPx",
+      "pcUTQualUlNx",
+      "pcUTQualUlPx",
+      "powerDecrQualFactor",
+      "powerLimitAla",
+      "pwrDecrLimitBand0",
+      "pwrDecrLimitBand1",
+      "pwrDecrLimitBand2",
+      "transmitPowerReduction"
+    ],
+    "defaults": {
+      "hocId": 1,
+      "alpha": 10,
+      "bepPeriod": 6,
+      "bsTxPwrMax": 0,
+      "bsTxPwrMax1x00": 0,
+      "bsTxPwrMin": 15,
+      "gamma": 15,
+      "pcALDlWeighting": 1,
+      "pcALDlWindowSize": 1,
+      "pcALUlWeighting": 1,
+      "pcALUlWindowSize": 4,
+      "pcAQLDlWeighting": 1,
+      "pcAQLDlWindowSize": 1,
+      "pcAQLUlWeighting": 1,
+      "pcAQLUlWindowSize": 4,
+      "pcControlEnabled": 1,
+      "pcControlInterval": 1,
+      "pcIncrStepSize": 1,
+      "pcLowerThresholdsLevDLRxLevel": 25,
+      "pcLowerThresholsLevULRxLevel": 20,
+      "pcRedStepSize": 1,
+      "pcUpperThresholdsLevDLRxLevel": 35,
+      "pcUpperThresholdsLevULRxLevel": 30,
+      "tAvgT": 10,
+      "tAvgW": 20,
+      "pcLTQualDlRxQual": 3,
+      "pcLTQualUlRxQual": 3,
+      "pcUTQualDlRxQual": 1,
+      "pcUTQualUlRxQual": 0,
+      "dlPcPowerReduction": 4,
+      "dlPcWindowSize": 8,
+      "enableAla": 0,
+      "maxPwrCompensation": 10,
+      "minIntBetweenAla": 10,
+      "pcLTLevDlNx": 1,
+      "pcLTLevDlPx": 1,
+      "pcLTLevUlNx": 1,
+      "pcLTLevUlPx": 1,
+      "pcLTQual144Nx": 4,
+      "pcLTQual144Px": 3,
+      "pcLTQual144RxQual": 2,
+      "pcLTQualDlNx": 1,
+      "pcLTQualDlPx": 1,
+      "pcLTQualUlNx": 4,
+      "pcLTQualUlPx": 3,
+      "pcUTLevDlNx": 1,
+      "pcUTLevDlPx": 1,
+      "pcUTLevUlNx": 1,
+      "pcUTLevUlPx": 1,
+      "pcUTQualDlNx": 1,
+      "pcUTQualDlPx": 1,
+      "pcUTQualUlNx": 1,
+      "pcUTQualUlPx": 1,
+      "powerDecrQualFactor": 1,
+      "powerLimitAla": 3,
+      "pwrDecrLimitBand0": 0,
+      "pwrDecrLimitBand1": 19,
+      "pwrDecrLimitBand2": 19,
+      "transmitPowerReduction": 4
+    },
+    "formulas": {}
+  }
+}

queries/ciq_2g_schema_loader.py

@@ -0,0 +1,32 @@
+import json
+from pathlib import Path
+
+
+_SCHEMA_PATH = Path(__file__).with_name("ciq_2g_final_schema.json")
+
+
+def _load_schema() -> dict[str, dict[str, object]]:
+    return json.loads(_SCHEMA_PATH.read_text(encoding="utf-8"))
+
+
+_SCHEMA = _load_schema()
+
+BTS_FINAL_COLUMNS = _SCHEMA["BTS"]["columns"]
+BTS_FINAL_DEFAULTS = _SCHEMA["BTS"]["defaults"]
+BTS_FINAL_FORMULAS = _SCHEMA["BTS"]["formulas"]
+
+BTS_GPRS_FINAL_COLUMNS = _SCHEMA["BTS_GPRS"]["columns"]
+BTS_GPRS_FINAL_DEFAULTS = _SCHEMA["BTS_GPRS"]["defaults"]
+BTS_GPRS_FINAL_FORMULAS = _SCHEMA["BTS_GPRS"]["formulas"]
+
+BTS_AMR_FINAL_COLUMNS = _SCHEMA["BTS_AMR"]["columns"]
+BTS_AMR_FINAL_DEFAULTS = _SCHEMA["BTS_AMR"]["defaults"]
+BTS_AMR_FINAL_FORMULAS = _SCHEMA["BTS_AMR"]["formulas"]
+
+HOC_FINAL_COLUMNS = _SCHEMA["HOC"]["columns"]
+HOC_FINAL_DEFAULTS = _SCHEMA["HOC"]["defaults"]
+HOC_FINAL_FORMULAS = _SCHEMA["HOC"]["formulas"]
+
+POC_FINAL_COLUMNS = _SCHEMA["POC"]["columns"]
+POC_FINAL_DEFAULTS = _SCHEMA["POC"]["defaults"]
+POC_FINAL_FORMULAS = _SCHEMA["POC"]["formulas"]

queries/process_ciq_2g.py

@@ -1,3 +1,4 @@
+import importlib.util
 import io
 import re
 from dataclasses import dataclass
@@ -5,6 +6,23 @@ from typing import Optional
 
 import pandas as pd
 
+from queries.ciq_2g_schema_loader import (
+    BTS_AMR_FINAL_COLUMNS,
+    BTS_AMR_FINAL_DEFAULTS,
+    BTS_AMR_FINAL_FORMULAS,
+    BTS_FINAL_COLUMNS,
+    BTS_FINAL_DEFAULTS,
+    BTS_FINAL_FORMULAS,
+    BTS_GPRS_FINAL_COLUMNS,
+    BTS_GPRS_FINAL_DEFAULTS,
+    BTS_GPRS_FINAL_FORMULAS,
+    HOC_FINAL_COLUMNS,
+    HOC_FINAL_DEFAULTS,
+    HOC_FINAL_FORMULAS,
+    POC_FINAL_COLUMNS,
+    POC_FINAL_DEFAULTS,
+    POC_FINAL_FORMULAS,
+)
 from utils.ciq_excel import read_ciq_excel
 from utils.dump_excel import detect_dump_header_row
 from utils.utils_vars import UtilsVars
@@ -28,6 +46,8 @@ BTS_EXPORT_COLUMNS = [
     "name",
     "template_name",
     "sectorId",
+    "frequencyBandInUse",
+    "hoppingSequenceNumber1",
 ]
 
 
@@ -87,6 +107,22 @@ TRX_STATIC_DEFAULTS = {
     "trxRfPower": 20000,
 }
 
+FINAL_SCHEMA = {
+    "BTS": (BTS_FINAL_COLUMNS, BTS_FINAL_DEFAULTS, BTS_FINAL_FORMULAS),
+    "BTS_GPRS": (
+        BTS_GPRS_FINAL_COLUMNS,
+        BTS_GPRS_FINAL_DEFAULTS,
+        BTS_GPRS_FINAL_FORMULAS,
+    ),
+    "BTS_AMR": (
+        BTS_AMR_FINAL_COLUMNS,
+        BTS_AMR_FINAL_DEFAULTS,
+        BTS_AMR_FINAL_FORMULAS,
+    ),
+    "HOC": (HOC_FINAL_COLUMNS, HOC_FINAL_DEFAULTS, HOC_FINAL_FORMULAS),
+    "POC": (POC_FINAL_COLUMNS, POC_FINAL_DEFAULTS, POC_FINAL_FORMULAS),
+}
+
 
 def _normalize_col(col: object) -> str:
     return re.sub(r"[^0-9A-Za-z]", "", str(col))
@@ -98,6 +134,79 @@ def _clean_columns(df: pd.DataFrame) -> pd.DataFrame:
     return df
 
 
+def _raise_missing_hsn_error() -> None:
+    raise ValueError(
+        "CIQ brut is missing required column: HSN. "
+        "The 2G final export uses HSN to populate BTS.hoppingSequenceNumber1."
+    )
+
+
+def _get_excel_writer_engine() -> str:
+    for engine_name in ("xlsxwriter", "openpyxl"):
+        if importlib.util.find_spec(engine_name) is not None:
+            return engine_name
+    raise RuntimeError(
+        "Excel export requires 'xlsxwriter' or 'openpyxl' to be installed."
+    )
+
+
+def _excel_column_name(index: int) -> str:
+    if index < 1:
+        raise ValueError("Excel column index must be >= 1")
+
+    result = ""
+    while index > 0:
+        index, remainder = divmod(index - 1, 26)
+        result = chr(65 + remainder) + result
+    return result
+
+
+def apply_final_schema(df: pd.DataFrame, sheet_name: str) -> pd.DataFrame:
+    if sheet_name not in FINAL_SCHEMA:
+        raise ValueError(f"Unsupported 2G CIQ sheet '{sheet_name}'")
+
+    final_columns, default_values, formula_specs = FINAL_SCHEMA[sheet_name]
+    final_df = df.copy()
+    missing_columns = [column for column in final_columns if column not in final_df.columns]
+
+    if missing_columns:
+        if final_df.empty:
+            additions = pd.DataFrame(
+                {column: pd.Series(dtype="object") for column in missing_columns}
+            )
+        else:
+            additions = pd.DataFrame(
+                {
+                    column: [default_values.get(column, "")] * len(final_df)
+                    for column in missing_columns
+                },
+                index=final_df.index,
+            )
+        final_df = pd.concat([final_df, additions], axis=1)
+
+    final_df = final_df.loc[:, final_columns]
+
+    if final_df.empty or not formula_specs:
+        return final_df
+
+    for formula_column, spec in formula_specs.items():
+        kind = spec.get("kind")
+        if kind != "same_row_ref":
+            raise ValueError(
+                f"Unsupported formula kind '{kind}' for 2G sheet '{sheet_name}'"
+            )
+
+        source_column = spec["source_column"]
+        source_col_idx = final_columns.index(source_column) + 1
+        source_col_letter = _excel_column_name(source_col_idx)
+        final_df[formula_column] = [
+            f"={source_col_letter}{row_number}"
+            for row_number in range(2, len(final_df) + 2)
+        ]
+
+    return final_df
+
+
 def _read_dump_bts_required_columns(dump_file) -> pd.DataFrame:
     if hasattr(dump_file, "seek"):
         dump_file.seek(0)
@@ -734,6 +843,66 @@ def _build_trx_sheet_from_assigned_sites(
     return df_trx
 
 
+def _build_bts_gprs_sheet_from_bts(df_bts: pd.DataFrame) -> pd.DataFrame:
+    if df_bts.empty:
+        return pd.DataFrame(
+            columns=["Site", "bscid", "cellId", "bcfId", "btsId", "template_name"]
+        )
+
+    df_bts_gprs = df_bts[["site", "bscid", "cellId", "bcfId", "btsId"]].rename(
+        columns={"site": "Site"}
+    )
+    df_bts_gprs["template_name"] = "All"
+    return df_bts_gprs[
+        ["Site", "bscid", "cellId", "bcfId", "btsId", "template_name"]
+    ]
+
+
+def _build_bts_amr_sheet_from_bts(df_bts: pd.DataFrame) -> pd.DataFrame:
+    if df_bts.empty:
+        return pd.DataFrame(
+            columns=["Site", "bscId", "cellId", "bcfId", "btsId", "template_name"]
+        )
+
+    df_bts_amr = df_bts[["site", "bscid", "cellId", "bcfId", "btsId"]].rename(
+        columns={"site": "Site", "bscid": "bscId"}
+    )
+    df_bts_amr["template_name"] = "All"
+    return df_bts_amr[
+        ["Site", "bscId", "cellId", "bcfId", "btsId", "template_name"]
+    ]
+
+
+def _build_hoc_sheet_from_bts(df_bts: pd.DataFrame) -> pd.DataFrame:
+    if df_bts.empty:
+        return pd.DataFrame(
+            columns=["Site", "bscid", "cellId", "bcfId", "btsId", "hocId", "template_name"]
+        )
+
+    df_hoc = df_bts[
+        ["site", "bscid", "cellId", "bcfId", "btsId", "template_name"]
+    ].rename(columns={"site": "Site"})
+    df_hoc.insert(5, "hocId", 1)
+    return df_hoc[
+        ["Site", "bscid", "cellId", "bcfId", "btsId", "hocId", "template_name"]
+    ]
+
+
+def _build_poc_sheet_from_bts(df_bts: pd.DataFrame) -> pd.DataFrame:
+    if df_bts.empty:
+        return pd.DataFrame(
+            columns=["Site", "bscid", "cellId", "bcfId", "btsId", "hocId", "template_name"]
+        )
+
+    df_poc = df_bts[
+        ["site", "bscid", "cellId", "bcfId", "btsId", "template_name"]
+    ].rename(columns={"site": "Site"})
+    df_poc.insert(5, "hocId", 1)
+    return df_poc[
+        ["Site", "bscid", "cellId", "bcfId", "btsId", "hocId", "template_name"]
+    ]
+
+
 def build_bts_sheet(
     dump_file, ciq_file, mcc: int = 610, mnc: int = 2, forbidden_file=None
 ) -> pd.DataFrame:
@@ -755,6 +924,9 @@ def _build_bts_sheet_from_assigned_sites(
 ) -> pd.DataFrame:
     assigned_by_site = {s.site_name: s for s in assigned_sites}
 
+    if "HSN" not in ciq_df.columns:
+        _raise_missing_hsn_error()
+
     required = [
         "Sites",
         "NOM_CELLULE",
@@ -785,6 +957,7 @@ def _build_bts_sheet_from_assigned_sites(
         lac = pd.to_numeric(r.get("LAC"), errors="coerce")
         ncc = pd.to_numeric(r.get("NCC"), errors="coerce")
         bcc = pd.to_numeric(r.get("BCC"), errors="coerce")
+        hsn = pd.to_numeric(r.get("HSN"), errors="coerce")
 
         rows.append(
             {
@@ -804,6 +977,8 @@ def _build_bts_sheet_from_assigned_sites(
                 "name": f"{str(r.get('NOM_CELLULE'))}_NA",
                 "template_name": _template_name_from_band(r.get("band")),
                 "sectorId": int(sector_id),
+                "frequencyBandInUse": _frequency_band_in_use_from_band(r.get("band")),
+                "hoppingSequenceNumber1": int(hsn) if not pd.isna(hsn) else None,
             }
         )
 
@@ -904,6 +1079,8 @@ def generate_ciq_2g_excel(
 ) -> tuple[dict[str, pd.DataFrame], bytes]:
     dump_bts = _read_dump_bts_required_columns(dump_file)
     ciq_df = _read_ciq_df(ciq_file, ciq_sheet_name=ciq_sheet_name)
+    if "HSN" not in ciq_df.columns:
+        _raise_missing_hsn_error()
     planned_sites = _parse_ciq_sites(ciq_df)
     forbidden_by_bsc, forbidden_df = _read_forbidden_bcfs(forbidden_file)
     assigned_sites = _assign_bcfs(
@@ -912,40 +1089,23 @@ def generate_ciq_2g_excel(
 
     df_bcf = _build_bcf_sheet_from_assigned_sites(assigned_sites)
     df_bcf_free = _build_free_bcf_sheet(dump_bts, forbidden_by_bsc=forbidden_by_bsc)
-    df_bts = _build_bts_sheet_from_assigned_sites(
+    df_bts_base = _build_bts_sheet_from_assigned_sites(
         ciq_df, assigned_sites, mcc=mcc, mnc=mnc
     )
+    df_bts = apply_final_schema(df_bts_base, "BTS")
     df_mal = _build_mal_sheet_from_assigned_sites(ciq_df, assigned_sites)
     df_trx = _build_trx_sheet_from_assigned_sites(ciq_df, assigned_sites)
 
-    df_bts_min = pd.DataFrame()
-    if not df_bts.empty:
-        df_bts_min = df_bts[["site", "bscid", "cellId", "bcfId", "btsId"]].rename(
-            columns={"site": "Site"}
-        )
-
-    df_hoc = pd.DataFrame()
-    df_poc = pd.DataFrame()
-    if not df_bts.empty:
-        base = df_bts[
-            ["site", "bscid", "cellId", "bcfId", "btsId", "template_name"]
-        ].rename(columns={"site": "Site"})
-
-        df_hoc = base.copy()
-        df_hoc.insert(5, "hocId", 1)
-        df_hoc = df_hoc[
-            ["Site", "bscid", "cellId", "bcfId", "btsId", "hocId", "template_name"]
-        ]
-
-        df_poc = base.copy()
-        df_poc.insert(5, "pocId", 1)
-        df_poc = df_poc[
-            ["Site", "bscid", "cellId", "bcfId", "btsId", "pocId", "template_name"]
-        ]
+    df_bts_gprs = apply_final_schema(
+        _build_bts_gprs_sheet_from_bts(df_bts_base), "BTS_GPRS"
+    )
+    df_bts_amr = apply_final_schema(_build_bts_amr_sheet_from_bts(df_bts_base), "BTS_AMR")
+    df_hoc = apply_final_schema(_build_hoc_sheet_from_bts(df_bts_base), "HOC")
+    df_poc = apply_final_schema(_build_poc_sheet_from_bts(df_bts_base), "POC")
 
     df_plmn_permitted = pd.DataFrame()
-    if not df_bts.empty:
-        base_plmn = df_bts[["bscid", "cellId", "bcfId", "btsId"]].rename(
+    if not df_bts_base.empty:
+        base_plmn = df_bts_base[["bscid", "cellId", "bcfId", "btsId"]].rename(
             columns={"bscid": "BSCId"}
         )
         df_plmn_permitted = base_plmn.loc[base_plmn.index.repeat(8)].reset_index(
@@ -961,8 +1121,8 @@ def generate_ciq_2g_excel(
         "BCF": df_bcf,
         "BCF_LIBRE": df_bcf_free,
         "BTS": df_bts,
-        "BTS_GPRS": df_bts_min,
-        "BTS_AMR": df_bts_min,
+        "BTS_GPRS": df_bts_gprs,
+        "BTS_AMR": df_bts_amr,
         "HOC": df_hoc,
         "POC": df_poc,
         "MAL": df_mal,
@@ -973,8 +1133,9 @@ def generate_ciq_2g_excel(
     if not forbidden_df.empty:
         sheets["BCF_FORBIDDEN"] = forbidden_df
 
+    engine_name = _get_excel_writer_engine()
     bytes_io = io.BytesIO()
-    with pd.ExcelWriter(bytes_io, engine="xlsxwriter") as writer:
+    with pd.ExcelWriter(bytes_io, engine=engine_name) as writer:
         for sheet_name, df in sheets.items():
             df.to_excel(writer, sheet_name=sheet_name, index=False)
 

tests/test_process_ciq_2g_final_schema.py

@@ -0,0 +1,303 @@
+import io
+from numbers import Integral
+from unittest.mock import patch
+
+import pandas as pd
+from openpyxl import load_workbook
+
+from queries.ciq_2g_schema_loader import (
+    BTS_AMR_FINAL_COLUMNS,
+    BTS_AMR_FINAL_DEFAULTS,
+    BTS_FINAL_COLUMNS,
+    BTS_FINAL_DEFAULTS,
+    BTS_GPRS_FINAL_COLUMNS,
+    BTS_GPRS_FINAL_DEFAULTS,
+    HOC_FINAL_COLUMNS,
+    HOC_FINAL_DEFAULTS,
+    POC_FINAL_COLUMNS,
+    POC_FINAL_DEFAULTS,
+)
+from queries.process_ciq_2g import (
+    _PlannedSite,
+    _build_bts_amr_sheet_from_bts,
+    _build_bts_gprs_sheet_from_bts,
+    _build_bts_sheet_from_assigned_sites,
+    _build_hoc_sheet_from_bts,
+    _build_poc_sheet_from_bts,
+    _get_excel_writer_engine,
+    apply_final_schema,
+    generate_ciq_2g_excel,
+)
+
+
+def _sample_ciq_df() -> pd.DataFrame:
+    return pd.DataFrame(
+        [
+            {
+                "Sites": "0273_TBC_DIRE-HAMDALLAYE_2G",
+                "NOM_CELLULE": "0273_TBC_DIRE-HAMDALLAYE_1_900",
+                "Nbre_TRE_DR": 4,
+                "LAC": 30802,
+                "RAC": 1,
+                "CI": 2731,
+                "Frequence": "GSM900",
+                "BCCH": 5,
+                "TRX": "47,51,58",
+                "NCC": 5,
+                "BCC": 5,
+                "HSN": 56,
+                "MAIO": 0,
+                "Nom BSC": "ASBSCMSC3",
+                "BSC ID": 403703,
+                "band": "G9",
+                "sector": 1,
+                "site_number": 273,
+            },
+            {
+                "Sites": "0273_TBC_DIRE-HAMDALLAYE_2G",
+                "NOM_CELLULE": "0273_TBC_DIRE-HAMDALLAYE_1_1800",
+                "Nbre_TRE_DR": 3,
+                "LAC": 30802,
+                "RAC": 1,
+                "CI": 2734,
+                "Frequence": "GSM1800",
+                "BCCH": 879,
+                "TRX": "859,864",
+                "NCC": 3,
+                "BCC": 6,
+                "HSN": 54,
+                "MAIO": 0,
+                "Nom BSC": "ASBSCMSC3",
+                "BSC ID": 403703,
+                "band": "G18",
+                "sector": 1,
+                "site_number": 273,
+            },
+        ]
+    )
+
+
+def _sample_assigned_sites() -> list[_PlannedSite]:
+    return [
+        _PlannedSite(
+            site_name="0273_TBC_DIRE-HAMDALLAYE_2G",
+            site_number=273,
+            bsc=403703,
+            bsc_name="ASBSCMSC3",
+            name="0273_TBC_DIRE-HAMDALLAYE_2G_NA",
+            configuration="G9-4, G18-3",
+            assigned_bcf=200,
+            needed_bts_ids=(201, 204),
+        )
+    ]
+
+
+def _sample_bts_base_df() -> pd.DataFrame:
+    return _build_bts_sheet_from_assigned_sites(
+        _sample_ciq_df(), _sample_assigned_sites(), mcc=610, mnc=2
+    )
+
+
+def test_apply_final_schema_bts_keeps_core_values_and_adds_formula_and_derived_fields():
+    df_bts = _sample_bts_base_df()
+
+    final_df = apply_final_schema(df_bts, "BTS")
+
+    assert list(final_df.columns) == BTS_FINAL_COLUMNS
+    assert len(final_df.columns) == 109
+    assert list(final_df["site"]) == [273, 273]
+    assert list(final_df["btsId"]) == [201, 204]
+    assert list(final_df["template_name"]) == ["GSM900", "GSM1800"]
+    assert list(final_df["frequencyBandInUse"]) == [0, 1]
+    assert list(final_df["hoppingSequenceNumber1"]) == [56, 54]
+    assert list(final_df["segmentId"]) == ["=E2", "=E3"]
+    assert final_df.loc[0, "masterBCF"] == BTS_FINAL_DEFAULTS["masterBCF"]
+    assert (
+        final_df.loc[0, "gprsCapacityThroughputFactor"]
+        == BTS_FINAL_DEFAULTS["gprsCapacityThroughputFactor"]
+    )
+    assert isinstance(final_df.loc[0, "fddRscpMin"], Integral)
+
+
+def test_apply_final_schema_bts_gprs_adds_defaults_without_overriding_base_columns():
+    final_df = apply_final_schema(
+        _build_bts_gprs_sheet_from_bts(_sample_bts_base_df()), "BTS_GPRS"
+    )
+
+    assert list(final_df.columns) == BTS_GPRS_FINAL_COLUMNS
+    assert len(final_df.columns) == 56
+    assert list(final_df["Site"]) == [273, 273]
+    assert list(final_df["btsId"]) == [201, 204]
+    assert list(final_df["template_name"]) == ["All", "All"]
+    assert (
+        final_df.loc[0, "dedicatedGPRScapacity"]
+        == BTS_GPRS_FINAL_DEFAULTS["dedicatedGPRScapacity"]
+    )
+    assert final_df.loc[0, "nsei"] == ""
+    assert final_df.loc[0, "rac"] == BTS_GPRS_FINAL_DEFAULTS["rac"]
+
+
+def test_apply_final_schema_bts_amr_keeps_bscid_renamed_as_bscid_final_name():
+    final_df = apply_final_schema(
+        _build_bts_amr_sheet_from_bts(_sample_bts_base_df()), "BTS_AMR"
+    )
+
+    assert list(final_df.columns) == BTS_AMR_FINAL_COLUMNS
+    assert len(final_df.columns) == 53
+    assert list(final_df["bscId"]) == [403703, 403703]
+    assert list(final_df["template_name"]) == ["All", "All"]
+    assert (
+        final_df.loc[0, "amrConfFrCodecModeSet"]
+        == BTS_AMR_FINAL_DEFAULTS["amrConfFrCodecModeSet"]
+    )
+    assert (
+        final_df.loc[0, "radioLinkTimeoutAmr"]
+        == BTS_AMR_FINAL_DEFAULTS["radioLinkTimeoutAmr"]
+    )
+
+
+def test_apply_final_schema_hoc_and_poc_keep_identifiers_and_defaults():
+    df_bts = _sample_bts_base_df()
+    hoc_df = apply_final_schema(_build_hoc_sheet_from_bts(df_bts), "HOC")
+    poc_df = apply_final_schema(_build_poc_sheet_from_bts(df_bts), "POC")
+
+    assert list(hoc_df.columns) == HOC_FINAL_COLUMNS
+    assert len(hoc_df.columns) == 87
+    assert list(hoc_df["hocId"]) == [1, 1]
+    assert hoc_df.loc[0, "enableSddchHandover"] == ""
+    assert hoc_df.loc[0, "enableUmbrellaHo"] == HOC_FINAL_DEFAULTS["enableUmbrellaHo"]
+
+    assert list(poc_df.columns) == POC_FINAL_COLUMNS
+    assert len(poc_df.columns) == 65
+    assert "pocId" not in poc_df.columns
+    assert list(poc_df["hocId"]) == [1, 1]
+    assert poc_df.loc[0, "alpha"] == POC_FINAL_DEFAULTS["alpha"]
+    assert (
+        poc_df.loc[0, "transmitPowerReduction"]
+        == POC_FINAL_DEFAULTS["transmitPowerReduction"]
+    )
+
+
+def test_get_excel_writer_engine_prefers_xlsxwriter_then_openpyxl():
+    with patch("queries.process_ciq_2g.importlib.util.find_spec") as mock_find_spec:
+        mock_find_spec.side_effect = lambda name: object() if name == "xlsxwriter" else None
+        assert _get_excel_writer_engine() == "xlsxwriter"
+
+    with patch("queries.process_ciq_2g.importlib.util.find_spec") as mock_find_spec:
+        mock_find_spec.side_effect = lambda name: object() if name == "openpyxl" else None
+        assert _get_excel_writer_engine() == "openpyxl"
+
+
+def test_get_excel_writer_engine_raises_clear_error_when_missing():
+    with patch("queries.process_ciq_2g.importlib.util.find_spec", return_value=None):
+        try:
+            _get_excel_writer_engine()
+        except RuntimeError as exc:
+            assert "xlsxwriter" in str(exc)
+            assert "openpyxl" in str(exc)
+        else:
+            raise AssertionError("Expected RuntimeError when no Excel writer engine is installed")
+
+
+def test_generate_ciq_2g_excel_raises_clear_error_when_hsn_is_missing():
+    ciq_df = _sample_ciq_df().drop(columns=["HSN"])
+
+    with (
+        patch(
+            "queries.process_ciq_2g._read_dump_bts_required_columns",
+            return_value=pd.DataFrame(columns=["BSC", "BCF", "BTS", "usedMobileAllocation"]),
+        ),
+        patch("queries.process_ciq_2g._read_ciq_df", return_value=ciq_df),
+    ):
+        try:
+            generate_ciq_2g_excel(io.BytesIO(b"dump"), io.BytesIO(b"ciq"))
+        except ValueError as exc:
+            assert "missing required column: HSN" in str(exc)
+            assert "BTS.hoppingSequenceNumber1" in str(exc)
+        else:
+            raise AssertionError("Expected ValueError when HSN is missing")
+
+
+def test_generate_ciq_2g_excel_returns_finalized_target_sheets_only():
+    captured_sheet_names = []
+    captured_engine = None
+
+    class DummyWriter:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+    def _capture_excel_writer(*args, **kwargs):
+        nonlocal captured_engine
+        captured_engine = kwargs.get("engine")
+        return DummyWriter()
+
+    def _capture_to_excel(self, writer, sheet_name=None, index=True, **kwargs):
+        captured_sheet_names.append(sheet_name)
+
+    with (
+        patch(
+            "queries.process_ciq_2g._read_dump_bts_required_columns",
+            return_value=pd.DataFrame(columns=["BSC", "BCF", "BTS", "usedMobileAllocation"]),
+        ),
+        patch("queries.process_ciq_2g._read_ciq_df", return_value=_sample_ciq_df()),
+        patch("queries.process_ciq_2g._read_forbidden_bcfs", return_value=({}, pd.DataFrame())),
+        patch("queries.process_ciq_2g._assign_bcfs", return_value=_sample_assigned_sites()),
+        patch("queries.process_ciq_2g.importlib.util.find_spec") as mock_find_spec,
+        patch("queries.process_ciq_2g.pd.ExcelWriter", side_effect=_capture_excel_writer),
+        patch.object(pd.DataFrame, "to_excel", autospec=True, side_effect=_capture_to_excel),
+    ):
+        mock_find_spec.side_effect = lambda name: object() if name == "xlsxwriter" else None
+        sheets, excel_bytes = generate_ciq_2g_excel(io.BytesIO(b"dump"), io.BytesIO(b"ciq"))
+
+    assert list(sheets["BTS"].columns) == BTS_FINAL_COLUMNS
+    assert list(sheets["BTS_GPRS"].columns) == BTS_GPRS_FINAL_COLUMNS
+    assert list(sheets["BTS_AMR"].columns) == BTS_AMR_FINAL_COLUMNS
+    assert list(sheets["HOC"].columns) == HOC_FINAL_COLUMNS
+    assert list(sheets["POC"].columns) == POC_FINAL_COLUMNS
+    assert len(sheets["MAL"].columns) == 16
+    assert len(sheets["TRX"].columns) == 78
+    assert captured_sheet_names == [
+        "BCF",
+        "BCF_LIBRE",
+        "BTS",
+        "BTS_GPRS",
+        "BTS_AMR",
+        "HOC",
+        "POC",
+        "MAL",
+        "BTS_PLMNPERMITTED",
+        "TRX",
+    ]
+    assert captured_engine == "xlsxwriter"
+    assert isinstance(excel_bytes, bytes)
+    assert list(sheets["BTS"]["segmentId"]) == ["=E2", "=E3"]
+
+
+def test_generate_ciq_2g_excel_writes_real_workbook_with_segmentid_formula():
+    with (
+        patch(
+            "queries.process_ciq_2g._read_dump_bts_required_columns",
+            return_value=pd.DataFrame(columns=["BSC", "BCF", "BTS", "usedMobileAllocation"]),
+        ),
+        patch("queries.process_ciq_2g._read_ciq_df", return_value=_sample_ciq_df()),
+        patch("queries.process_ciq_2g._read_forbidden_bcfs", return_value=({}, pd.DataFrame())),
+        patch("queries.process_ciq_2g._assign_bcfs", return_value=_sample_assigned_sites()),
+    ):
+        sheets, excel_bytes = generate_ciq_2g_excel(io.BytesIO(b"dump"), io.BytesIO(b"ciq"))
+
+    assert isinstance(excel_bytes, bytes)
+    assert len(excel_bytes) > 0
+    assert list(sheets["BTS"]["segmentId"]) == ["=E2", "=E3"]
+
+    workbook = load_workbook(io.BytesIO(excel_bytes), data_only=False)
+    ws_bts = workbook["BTS"]
+    headers = [cell.value for cell in ws_bts[1]]
+    segment_col_idx = headers.index("segmentId") + 1
+    btsid_col_idx = headers.index("btsId") + 1
+    btsid_col_letter = ws_bts.cell(1, btsid_col_idx).column_letter
+
+    assert ws_bts.cell(2, segment_col_idx).value == f"={btsid_col_letter}2"
+    assert ws_bts.cell(3, segment_col_idx).value == f"={btsid_col_letter}3"