Putting byte2bit operations within polar coders

openair1/PHY/CODING/TESTBENCH/polartest.c

@@ -7,8 +7,6 @@
 #include <time.h>
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
-#include "PHY/NR_TRANSPORT/nr_dci.h"
-#include "PHY/defs_gNB.h"
 #include "SIMULATION/TOOLS/sim.h"
 
 //#define DEBUG_POLAR_PARAMS
@@ -22,16 +20,6 @@ int main(int argc, char *argv[]) {
 	reset_meas(&timeEncoder);
 	reset_meas(&timeDecoder);
 
-	//gNB scheduler
-	/*PHY_VARS_gNB *gNB = RC.gNB[0][0];
-	NR_DL_FRAME_PARMS *fp = &gNB->frame_parms;
-	nfapi_nr_config_request_t *cfg = &gNB->gNB_config;
-
-	nfapi_nr_dl_config_request_pdu_t *pdu;
-	nfapi_nr_dl_config_pdcch_parameters_rel15_t *params_rel15 = &pdu->dci_dl_pdu.pdcch_params_rel15;
-	params_rel15->rnti_type = NFAPI_NR_RNTI_RA;
-	params_rel15->dci_format = NFAPI_NR_DL_DCI_FORMAT_1_0;*/
-
 	randominit(0);
 	//Default simulation values (Aim for iterations = 1000000.)
 	int itr, iterations = 1000, arguments, polarMessageType = 0; //0=PBCH, 1=DCI, -1=UCI
@@ -42,8 +30,7 @@ int main(int argc, char *argv[]) {
 	int8_t decoderState=0, blockErrorState=0; //0 = Success, -1 = Decoding failed, 1 = Block Error.
 	uint16_t testLength = 0, coderLength = 0, blockErrorCumulative=0, bitErrorCumulative=0;
 	double timeEncoderCumulative = 0, timeDecoderCumulative = 0;
-
+	uint8_t aggregation_level;
-	uint8_t aggregation_level, decoderListSize = 8, pathMetricAppr = 0; //0 --> eq. (8a) and (11b), 1 --> eq. (9) and (12)
 
 	while ((arguments = getopt (argc, argv, "s:d:f:m:i:l:a:")) != -1)
 	switch (arguments)
@@ -171,16 +158,24 @@ int main(int argc, char *argv[]) {
 				modulatedInput[i]=(-1)/sqrt(2);
 
 			channelOutput[i] = modulatedInput[i] + (gaussdouble(0.0,1.0) * (1/sqrt(2*SNR_lin)));
+			printf("%f\n",channelOutput[i]);
 		}
 
 
+
 		start_meas(&timeDecoder);
-		decoderState = polar_decoder(channelOutput,
+		/*decoderState = polar_decoder(channelOutput,
 									 estimatedOutput,
 									 currentPtr,
-									 decoderListSize,
+									 NR_POLAR_DECODER_LISTSIZE,
 									 aPrioriArray,
-									 pathMetricAppr);
+									 NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION);*/
+		decoderState = polar_decoder_aPriori(channelOutput,
+											 estimatedOutput,
+											 currentPtr,
+											 NR_POLAR_DECODER_LISTSIZE,
+											 NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION,
+											 aPrioriArray);
 		stop_meas(&timeDecoder);
 
 		//calculate errors

openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c

@@ -19,6 +19,17 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_decoder.c
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
 /*
  * Return values:
  *  0 --> Success
@@ -26,16 +37,255 @@
  */
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
-#include "PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h"
 
 int8_t polar_decoder(
 		double *input,
-		uint8_t *output,
+		uint32_t *out,
 		t_nrPolar_paramsPtr polarParams,
 		uint8_t listSize,
-		double *aPrioriPayload,
 		uint8_t pathMetricAppr)
 {
+	//Assumes no a priori knowledge.
+
+	uint8_t ***bit = nr_alloc_uint8_t_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
+	uint8_t **bitUpdated = nr_alloc_uint8_t_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
+	uint8_t **llrUpdated = nr_alloc_uint8_t_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
+	double ***llr = nr_alloc_double_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
+	uint8_t **crcChecksum = nr_alloc_uint8_t_2D_array(polarParams->crcParityBits, 2*listSize);
+	double *pathMetric = malloc(sizeof(double)*(2*listSize));
+	uint8_t *crcState = malloc(sizeof(uint8_t)*(2*listSize)); //0=False, 1=True
+
+	for (int i=0; i<(2*listSize); i++) {
+		pathMetric[i] = 0;
+		crcState[i]=1;
+	}
+	for (int i=0; i<polarParams->N; i++) {
+		llrUpdated[i][polarParams->n]=1;
+		bitUpdated[i][0]=((polarParams->information_bit_pattern[i]+1) % 2);
+	}
+
+	uint8_t **extended_crc_generator_matrix = malloc(polarParams->K * sizeof(uint8_t *)); //G_P3
+	uint8_t **tempECGM = malloc(polarParams->K * sizeof(uint8_t *)); //G_P2
+	for (int i = 0; i < polarParams->K; i++){
+		extended_crc_generator_matrix[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
+		tempECGM[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
+	}
+
+	for (int i=0; i<polarParams->payloadBits; i++) {
+		for (int j=0; j<polarParams->crcParityBits; j++) {
+			tempECGM[i][j]=polarParams->crc_generator_matrix[i][j];
+		}
+	}
+	for (int i=polarParams->payloadBits; i<polarParams->K; i++) {
+			for (int j=0; j<polarParams->crcParityBits; j++) {
+				if( (i-polarParams->payloadBits) == j ){
+					tempECGM[i][j]=1;
+				} else {
+					tempECGM[i][j]=0;
+				}
+			}
+	}
+
+	for (int i=0; i<polarParams->K; i++) {
+		for (int j=0; j<polarParams->crcParityBits; j++) {
+			extended_crc_generator_matrix[i][j]=tempECGM[polarParams->interleaving_pattern[i]][j];
+		}
+	}
+
+	//The index of the last 1-valued bit that appears in each column.
+	uint16_t last1ind[polarParams->crcParityBits];
+	for (int j=0; j<polarParams->crcParityBits; j++) {
+			for (int i=0; i<polarParams->K; i++) {
+				if (extended_crc_generator_matrix[i][j]==1) last1ind[j]=i;
+			}
+	}
+
+	double *d_tilde = malloc(sizeof(double) * polarParams->N);
+	nr_polar_rate_matching(input, d_tilde, polarParams->rate_matching_pattern, polarParams->K, polarParams->N, polarParams->encoderLength);
+	for (int j = 0; j < polarParams->N; j++) llr[j][polarParams->n][0]=d_tilde[j];
+
+
+	/*
+	 * SCL polar decoder.
+	 */
+
+	uint32_t nonFrozenBit=0;
+	uint8_t currentListSize=1;
+	uint8_t decoderIterationCheck=0;
+	int16_t checkCrcBits=-1;
+	uint8_t listIndex[2*listSize], copyIndex;
+
+	for (uint16_t currentBit=0; currentBit<polarParams->N; currentBit++){
+		updateLLR(llr, llrUpdated, bit, bitUpdated, currentListSize, currentBit, 0, polarParams->N, (polarParams->n+1), pathMetricAppr);
+		if (polarParams->information_bit_pattern[currentBit]==0) { //Frozen bit.
+			updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit, pathMetricAppr); //approximation=0 --> 11b, approximation=1 --> 12
+		} else { //Information or CRC bit.
+			updatePathMetric2(pathMetric, llr, currentListSize, currentBit, pathMetricAppr);
+
+			for (int i = 0; i < currentListSize; i++) {
+				for (int j = 0; j < polarParams->N; j++) {
+					for (int k = 0; k < (polarParams->n+1); k++) {
+						bit[j][k][i+currentListSize]=bit[j][k][i];
+						llr[j][k][i+currentListSize]=llr[j][k][i];}}}
+			for (int i = 0; i < currentListSize; i++) {
+				bit[currentBit][0][i]=0;
+				crcState[i+currentListSize]=crcState[i];
+			}
+			for (int i = currentListSize; i < 2*currentListSize; i++) bit[currentBit][0][i]=1;
+			bitUpdated[currentBit][0]=1;
+			updateCrcChecksum2(crcChecksum, extended_crc_generator_matrix, currentListSize, nonFrozenBit, polarParams->crcParityBits);
+			currentListSize*=2;
+
+			//Keep only the best "listSize" number of entries.
+			if (currentListSize > listSize) {
+				for (uint8_t i = 0; i < 2*listSize; i++) listIndex[i]=i;
+				nr_sort_asc_double_1D_array_ind(pathMetric, listIndex, currentListSize);
+
+				//sort listIndex[listSize, ..., 2*listSize-1] in descending order.
+				uint8_t swaps, tempInd;
+				for (uint8_t i = 0; i < listSize; i++) {
+					swaps = 0;
+					for (uint8_t j = listSize; j < (2*listSize - i) - 1; j++) {
+						if (listIndex[j+1] > listIndex[j]) {
+							tempInd = listIndex[j];
+							listIndex[j] = listIndex[j + 1];
+							listIndex[j + 1] = tempInd;
+							swaps++;
+						}
+					}
+					if (swaps == 0)
+						break;
+				}
+
+				//First, backup the best "listSize" number of entries.
+				for (int k=(listSize-1); k>0; k--) {
+					for (int i=0; i<polarParams->N; i++) {
+						for (int j=0; j<(polarParams->n+1); j++) {
+							bit[i][j][listIndex[(2*listSize-1)-k]]=bit[i][j][listIndex[k]];
+							llr[i][j][listIndex[(2*listSize-1)-k]]=llr[i][j][listIndex[k]];
+						}
+					}
+				}
+				for (int k=(listSize-1); k>0; k--) {
+					for (int i = 0; i < polarParams->crcParityBits; i++) {
+						crcChecksum[i][listIndex[(2*listSize-1)-k]] = crcChecksum[i][listIndex[k]];
+					}
+				}
+				for (int k=(listSize-1); k>0; k--) crcState[listIndex[(2*listSize-1)-k]]=crcState[listIndex[k]];
+
+				//Copy the best "listSize" number of entries to the first indices.
+				for (int k = 0; k < listSize; k++) {
+					if (k > listIndex[k]) {
+						copyIndex = listIndex[(2*listSize-1)-k];
+					} else { //Use the backup.
+						copyIndex = listIndex[k];
+					}
+					for (int i = 0; i < polarParams->N; i++) {
+						for (int j = 0; j < (polarParams->n + 1); j++) {
+							bit[i][j][k] = bit[i][j][copyIndex];
+							llr[i][j][k] = llr[i][j][copyIndex];
+						}
+					}
+				}
+				for (int k = 0; k < listSize; k++) {
+					if (k > listIndex[k]) {
+						copyIndex = listIndex[(2*listSize-1)-k];
+					} else { //Use the backup.
+						copyIndex = listIndex[k];
+					}
+					for (int i = 0; i < polarParams->crcParityBits; i++) {
+						crcChecksum[i][k]=crcChecksum[i][copyIndex];
+					}
+				}
+				for (int k = 0; k < listSize; k++) {
+					if (k > listIndex[k]) {
+						copyIndex = listIndex[(2*listSize-1)-k];
+					} else { //Use the backup.
+						copyIndex = listIndex[k];
+					}
+					crcState[k]=crcState[copyIndex];
+				}
+				currentListSize = listSize;
+				}
+
+
+			for (int i=0; i<polarParams->crcParityBits; i++) {
+				if (last1ind[i]==nonFrozenBit) {
+					checkCrcBits=i;
+					break;
+				}
+			}
+
+			if ( checkCrcBits > (-1) ) {
+				for (uint8_t i = 0; i < currentListSize; i++) {
+					if (crcChecksum[checkCrcBits][i]==1) {
+						crcState[i]=0; //0=False, 1=True
+					}
+				}
+			}
+
+			for (uint8_t i = 0; i < currentListSize; i++) decoderIterationCheck+=crcState[i];
+			if (decoderIterationCheck==0) {
+				//perror("[SCL polar decoder] All list entries have failed the CRC checks.");
+				free(d_tilde);
+				free(pathMetric);
+				free(crcState);
+				nr_free_uint8_t_3D_array(bit, polarParams->N, (polarParams->n+1));
+				nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
+				nr_free_uint8_t_2D_array(crcChecksum, polarParams->crcParityBits);
+				return(-1);
+			}
+
+			nonFrozenBit++;
+			decoderIterationCheck=0;
+			checkCrcBits=-1;
+		}
+	}
+
+	for (uint8_t i = 0; i < 2*listSize; i++) listIndex[i]=i;
+	nr_sort_asc_double_1D_array_ind(pathMetric, listIndex, currentListSize);
+
+	for (uint8_t i = 0; i < fmin(listSize, (pow(2,polarParams->crcCorrectionBits)) ); i++) {
+		if ( crcState[listIndex[i]] == 1 ) {
+			for (int j = 0; j < polarParams->N; j++) polarParams->nr_polar_u[j]=bit[j][0][listIndex[i]];
+
+			//Extract the information bits (û to ĉ)
+			nr_polar_info_bit_extraction(polarParams->nr_polar_u, polarParams->nr_polar_cPrime, polarParams->information_bit_pattern, polarParams->N);
+
+			//Deinterleaving (ĉ to b)
+			nr_polar_deinterleaver(polarParams->nr_polar_cPrime, polarParams->nr_polar_b, polarParams->interleaving_pattern, polarParams->K);
+
+			//Remove the CRC (â)
+			for (int j = 0; j < polarParams->payloadBits; j++) polarParams->nr_polar_a[j]=polarParams->nr_polar_b[j];
+
+			break;
+		}
+	}
+
+	free(d_tilde);
+	free(pathMetric);
+	free(crcState);
+	nr_free_uint8_t_3D_array(bit, polarParams->N, (polarParams->n+1));
+	nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
+	nr_free_uint8_t_2D_array(crcChecksum, polarParams->crcParityBits);
+	nr_free_uint8_t_2D_array(extended_crc_generator_matrix, polarParams->K);
+	nr_free_uint8_t_2D_array(tempECGM, polarParams->K);
+
+	/*
+	 * Return bits.
+	 */
+	nr_byte2bit_uint8_32_t(polarParams->nr_polar_a, polarParams->payloadBits, out);
+	return(0);
+}
+
+int8_t polar_decoder_aPriori(
+		double *input,
+		uint32_t *out,
+		t_nrPolar_paramsPtr polarParams,
+		uint8_t listSize,
+		uint8_t pathMetricAppr,
+		double *aPrioriPayload)
+{
 
 	uint8_t ***bit = nr_alloc_uint8_t_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
 	uint8_t **bitUpdated = nr_alloc_uint8_t_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
@@ -110,11 +360,13 @@ int8_t polar_decoder(
 		if (polarParams->information_bit_pattern[currentBit]==0) { //Frozen bit.
 			updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit, pathMetricAppr); //approximation=0 --> 11b, approximation=1 --> 12
 		} else { //Information or CRC bit.
-			if ( (polarParams->interleaving_pattern[nonFrozenBit] <= polarParams->payloadBits) && (aPrioriPayload[polarParams->interleaving_pattern[nonFrozenBit]] == 0) ) {
+			if ( (polarParams->interleaving_pattern[nonFrozenBit] <= polarParams->payloadBits) &&
+					(aPrioriPayload[polarParams->interleaving_pattern[nonFrozenBit]] == 0) ) {
 				//Information bit with known value of "0".
 				updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit, pathMetricAppr);
 				bitUpdated[currentBit][0]=1; //0=False, 1=True
-			} else if ( (polarParams->interleaving_pattern[nonFrozenBit] <= polarParams->payloadBits) && (aPrioriPayload[polarParams->interleaving_pattern[nonFrozenBit]] == 1) ) {
+			} else if ( (polarParams->interleaving_pattern[nonFrozenBit] <= polarParams->payloadBits) &&
+					(aPrioriPayload[polarParams->interleaving_pattern[nonFrozenBit]] == 1) ) {
 				//Information bit with known value of "1".
 				updatePathMetric(pathMetric, llr, currentListSize, 1, currentBit, pathMetricAppr);
 				for (uint8_t i=0; i<currentListSize; i++) bit[currentBit][0][i]=1;
@@ -257,7 +509,7 @@ int8_t polar_decoder(
 			nr_polar_deinterleaver(polarParams->nr_polar_cPrime, polarParams->nr_polar_b, polarParams->interleaving_pattern, polarParams->K);
 
 			//Remove the CRC (â)
-			for (int j = 0; j < polarParams->payloadBits; j++) output[j]=polarParams->nr_polar_b[j];
+			for (int j = 0; j < polarParams->payloadBits; j++) polarParams->nr_polar_a[j]=polarParams->nr_polar_b[j];
 
 			break;
 		}
@@ -271,5 +523,10 @@ int8_t polar_decoder(
 	nr_free_uint8_t_2D_array(crcChecksum, polarParams->crcParityBits);
 	nr_free_uint8_t_2D_array(extended_crc_generator_matrix, polarParams->K);
 	nr_free_uint8_t_2D_array(tempECGM, polarParams->K);
+
+	/*
+	 * Return bits.
+	 */
+	nr_byte2bit_uint8_32_t(polarParams->nr_polar_a, polarParams->payloadBits, out);
 	return(0);
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h

@@ -19,6 +19,17 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_defs.h
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
 #ifndef __NR_POLAR_DEFS__H__
 #define __NR_POLAR_DEFS__H__
 
@@ -32,6 +43,9 @@
 #include "PHY/CODING/nrPolar_tools/nr_polar_uci_defs.h"
 #include "PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h"
 
+#define NR_POLAR_DECODER_LISTSIZE 8 //uint8_t
+#define NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION 0 //uint8_t; 0 --> eq. (8a) and (11b), 1 --> eq. (9) and (12)
+
 static const uint8_t nr_polar_subblock_interleaver_pattern[32] = { 0, 1, 2, 4, 3, 5, 6, 7, 8, 16, 9, 17, 10, 18, 11, 19, 12, 20, 13, 21, 14, 22, 15, 23, 24, 25, 26, 28, 27, 29, 30, 31 };
 
 struct nrPolar_params {
@@ -65,20 +79,33 @@ struct nrPolar_params {
 	uint8_t **crc_generator_matrix; //G_P
 	uint8_t **G_N;
 
-	//polar_encoder vectors:
+	//polar_encoder vectors
 	uint8_t *nr_polar_crc;
-	uint8_t *nr_polar_b;
-	uint8_t *nr_polar_cPrime;
-	uint8_t *nr_polar_u;
 	uint8_t *nr_polar_d;
+	uint8_t *nr_polar_e;
+
+	//Polar Coding vectors
+	uint8_t *nr_polar_a;
+	uint8_t *nr_polar_cPrime;
+	uint8_t *nr_polar_b;
+	uint8_t *nr_polar_u;
 } __attribute__ ((__packed__));
 typedef struct nrPolar_params t_nrPolar_params;
 typedef t_nrPolar_params *t_nrPolar_paramsPtr;
 
-void polar_encoder(uint8_t *input, uint8_t *output, t_nrPolar_paramsPtr polarParams);
+void polar_encoder(uint32_t *input, uint32_t *output, t_nrPolar_paramsPtr polarParams);
 
-int8_t polar_decoder(double *input, uint8_t *output, t_nrPolar_paramsPtr polarParams,
+int8_t polar_decoder(double *input,
-		uint8_t listSize, double *aPrioriPayload, uint8_t pathMetricAppr);
+		 	 	 	 uint32_t *output,
+					 t_nrPolar_paramsPtr polarParams,
+					 uint8_t listSize,
+					 uint8_t pathMetricAppr);
+int8_t polar_decoder_aPriori(double *input,
+							 uint32_t *output,
+							 t_nrPolar_paramsPtr polarParams,
+							 uint8_t listSize,
+							 uint8_t pathMetricAppr,
+							 double *aPrioriPayload);
 
 void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 				   int8_t messageType,

openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c

@@ -19,40 +19,75 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_encoder.c
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
-void polar_encoder(
+void polar_encoder(uint32_t *in,
-		uint8_t *input,
+				   uint32_t *out,
-		uint8_t *output,
+				   t_nrPolar_paramsPtr polarParams)
-		t_nrPolar_paramsPtr polarParams)
 {
+	nr_bit2byte_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_a);
 
 	/*
 	 * Bytewise operations
 	 */
-
 	//Calculate CRC.
-	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(input, polarParams->crc_generator_matrix,
+	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_a,
-			polarParams->nr_polar_crc, polarParams->payloadBits, polarParams->crcParityBits);
+												   polarParams->crc_generator_matrix,
-	for (uint8_t i = 0; i < polarParams->crcParityBits; i++) polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
+												   polarParams->nr_polar_crc,
+												   polarParams->payloadBits,
+												   polarParams->crcParityBits);
+	for (uint8_t i = 0; i < polarParams->crcParityBits; i++)
+		polarParams->nr_polar_crc[i] = (polarParams->nr_polar_crc[i] % 2);
 
 	//Attach CRC to the Transport Block. (a to b)
-	for (uint16_t i = 0; i < polarParams->payloadBits; i++) polarParams->nr_polar_b[i] = input[i];
+	for (uint16_t i = 0; i < polarParams->payloadBits; i++) polarParams->nr_polar_b[i] = polarParams->nr_polar_a[i];
 	for (uint16_t i = polarParams->payloadBits; i < polarParams->K; i++)
 		polarParams->nr_polar_b[i]= polarParams->nr_polar_crc[i-(polarParams->payloadBits)];
 
 	//Interleaving (c to c')
-	nr_polar_interleaver(polarParams->nr_polar_b, polarParams->nr_polar_cPrime, polarParams->interleaving_pattern, polarParams->K);
+	nr_polar_interleaver(polarParams->nr_polar_b,
+						 polarParams->nr_polar_cPrime,
+						 polarParams->interleaving_pattern,
+						 polarParams->K);
 
 	//Bit insertion (c' to u)
-	nr_polar_bit_insertion(polarParams->nr_polar_cPrime, polarParams->nr_polar_u, polarParams->N, polarParams->K,
+	nr_polar_bit_insertion(polarParams->nr_polar_cPrime,
-			polarParams->Q_I_N, polarParams->Q_PC_N, polarParams->n_pc);
+						   polarParams->nr_polar_u,
+						   polarParams->N,
+						   polarParams->K,
+						   polarParams->Q_I_N,
+						   polarParams->Q_PC_N,
+						   polarParams->n_pc);
 
 	//Encoding (u to d)
-	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_u, polarParams->G_N, polarParams->nr_polar_d, polarParams->N, polarParams->N);
+	nr_matrix_multiplication_uint8_t_1D_uint8_t_2D(polarParams->nr_polar_u,
-	for (uint16_t i = 0; i < polarParams->N; i++) polarParams->nr_polar_d[i] = (polarParams->nr_polar_d[i] % 2);
+												   polarParams->G_N,
+												   polarParams->nr_polar_d,
+												   polarParams->N,
+												   polarParams->N);
+	for (uint16_t i = 0; i < polarParams->N; i++)
+		polarParams->nr_polar_d[i] = (polarParams->nr_polar_d[i] % 2);
 
 	//Rate matching
 	//Sub-block interleaving (d to y) and Bit selection (y to e)
-	nr_polar_rate_matcher(polarParams->nr_polar_d, output, polarParams->rate_matching_pattern, polarParams->encoderLength);
+	nr_polar_rate_matcher(polarParams->nr_polar_d,
+						  polarParams->nr_polar_e,
+						  polarParams->rate_matching_pattern,
+						  polarParams->encoderLength);
+
+	/*
+	 * Return bits.
+	 */
+	nr_byte2bit_uint8_32_t(polarParams->nr_polar_e, polarParams->encoderLength, out);
 }

openair1/PHY/CODING/nrPolar_tools/nr_polar_pbch_defs.h

@@ -19,15 +19,15 @@
  *      contact@openairinterface.org
  */
 
-/*! \file PHY/CODING/nrPolar_tools/nr_polar_dci_defs.h
+/*!\file PHY/CODING/nrPolar_tools/nr_polar_defs.h
-* \brief Defines the constant variables for polar coding of the PBCH from 38-212, V15.1.1 2018-04.
+ * \brief Defines the constant variables for polar coding of the PBCH from 38-212, V15.1.1 2018-04.
-* \author
+ * \author Turker Yilmaz
-* \date 2018
+ * \date 2018
-* \version 0.1
+ * \version 0.1
-* \company Eurecom
+ * \company EURECOM
-* \email:
+ * \email turker.yilmaz@eurecom.fr
-* \note
+ * \note
-* \warning
+ * \warning
 */
 
 #ifndef __NR_POLAR_PBCH_DEFS__H__
@@ -52,9 +52,6 @@
 #define NR_POLAR_PBCH_I_BIL 0 //uint8_t
 #define NR_POLAR_PBCH_E 864   //uint16_t
 
-//#define NR_POLAR_PBCH_L 5 //uint8_t
-#define NR_POLAR_PBCH_PATH_METRIC_APPROXIMATION 0 //uint8_t; 0 --> eq. (8a) and (11b), 1 --> eq. (9) and (12)
-
 /*
  * TEST CODE
  */

openair1/PHY/CODING/nr_polar_init.c

@@ -19,6 +19,17 @@
  *      contact@openairinterface.org
  */
 
+/*!\file PHY/CODING/nr_polar_init.h
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2018
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
 #include "nrPolar_tools/nr_polar_defs.h"
 #include "PHY/CODING/nrPolar_tools/nr_polar_dci_defs.h"
 #include "PHY/CODING/nrPolar_tools/nr_polar_uci_defs.h"
@@ -83,13 +94,15 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 
 		//polar_encoder vectors:
 		newPolarInitNode->nr_polar_crc = malloc(sizeof(uint8_t) * newPolarInitNode->crcParityBits);
-		newPolarInitNode->nr_polar_cPrime = malloc(sizeof(uint8_t) * newPolarInitNode->K);
 		newPolarInitNode->nr_polar_d = malloc(sizeof(uint8_t) * newPolarInitNode->N);
+		newPolarInitNode->nr_polar_e = malloc(sizeof(uint8_t) * newPolarInitNode->encoderLength);
 
 		//Polar Coding vectors
 		newPolarInitNode->nr_polar_u = malloc(sizeof(uint8_t) * newPolarInitNode->N); //Decoder: nr_polar_uHat
 		newPolarInitNode->nr_polar_cPrime = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_cHat
 		newPolarInitNode->nr_polar_b = malloc(sizeof(uint8_t) * newPolarInitNode->K); //Decoder: nr_polar_bHat
+		newPolarInitNode->nr_polar_a = malloc(sizeof(uint8_t) * newPolarInitNode->payloadBits); //Decoder: nr_polar_aHat
+
 
 
 		newPolarInitNode->Q_0_Nminus1 = nr_polar_sequence_pattern(newPolarInitNode->n);

openair1/PHY/NR_UE_TRANSPORT/nr_pbch.c

@@ -501,13 +501,13 @@ uint16_t nr_rx_pbch( PHY_VARS_NR_UE *ue,
   unsigned short idx_demod =0;
   int8_t decoderState=0;
   uint8_t decoderListSize = 8, pathMetricAppr = 0;
-  double aPrioriArray[frame_parms->pbch_polar_params.payloadBits];  // assume no a priori knowledge available about the payload.
 
   memset(&pbch_a[0], 0, sizeof(uint8_t) * NR_POLAR_PBCH_PAYLOAD_BITS);
 
   //printf("nr_pbch_ue nid_cell %d\n",frame_parms->Nid_cell);
 
-  for (int i=0; i<frame_parms->pbch_polar_params.payloadBits; i++) aPrioriArray[i] = NAN;
+  /*double aPrioriArray[frame_parms->pbch_polar_params.payloadBits];  // assume no a priori knowledge available about the payload.
+  for (int i=0; i<frame_parms->pbch_polar_params.payloadBits; i++) aPrioriArray[i] = NAN;*/
 
   int subframe_rx = proc->subframe_rx;
 
@@ -605,7 +605,8 @@ uint16_t nr_rx_pbch( PHY_VARS_NR_UE *ue,
 
 		
   //polar decoding de-rate matching
-  decoderState = polar_decoder(demod_pbch_e, pbch_a, &frame_parms->pbch_polar_params, decoderListSize, aPrioriArray, pathMetricAppr);
+  decoderState = polar_decoder(demod_pbch_e, pbch_a, &frame_parms->pbch_polar_params, decoderListSize, pathMetricAppr);
+  //decoderState = polar_decoder_aPriori(demod_pbch_e, pbch_a, &frame_parms->pbch_polar_params, decoderListSize, aPrioriArray, pathMetricAppr);
 
   //for (i=0; i<NR_POLAR_PBCH_PAYLOAD_BITS; i++)
   // printf("pbch_a[%d] = %u \n", i,pbch_a[i]);