Receiver Chain

This class performs receiver chain of Upper Physical Processing of Physical Uplink Shared Channel which involves the following algorithms.

  • Symbol De-Mapping

    The estimated symbols are then demodulated based on the concept specified in the Section 6.3.1.2 of [3GPPTS38211_pusch]

  • Code Block Segregation | Opposite to Concatenation

    The demodulated symbols are then segregated according to the description given in the Section 6.2.6 of [3GPPTS38212_pusch]

  • De-Rate Matching

    De-Rate matching of code blocks involves two process as described in the Section 6.2.5 of [3GPPTS38212_pusch]

    • Bit De-Interleaver

    • Bit De-Selection

  • Channel Decoding (LDPC)

    The code blocks then undergoes LDPC decoding as described in the Section 6.2.4 of [3GPPTS38212_pusch]

  • Code Block Aggregation | Opposite to Segmentation

    The LDPC decoded code blocks are then converted into a single transport block of data as described in the Section 6.2.3 of [3GPPTS38212_pusch]

  • Transport Block Processing (CRC Detachment)

    Detachment of CRC bits to the transport block as described in the Section 6.2.1 of [3GPPTS38212_pusch]

Example:

symbolsPerSlot     = 10 #Number of Symbols per slot
numRB              = 50 #Number of Resource Blocks
scalingField       = '00' #Scaling field
mcsIndex           = 5 #Modulation Coding scheme index
additionalOverhead = 12 #Additional Overheads
numlayers          = [4, 0] #Number of layers
numTBs             = 1 #Number of Transport Blocks
rvid1              = [1] #Redundancy Version ID for transport block
dmrsREs            = 3 #Number of Resource Elements allocated for the additional DMRS
verbose            = False #Provide information regarding the progress in the execution
enableLBRM         = [False] #Disabling the Limited Buffer Rate Matching
snr                = 1000
verbose            = False ##Disabling from displaying information about the progress in the execution of the modules.
#symbolEstimates ---> Equalized Data

puschRx            = PUSCHDecoderUpperPhy(numTBs, mcsIndex, symbolsPerSlot, numRB, numlayers, scalingField, rvid1, additionalOverhead, dmrsREs, enableLBRM, verbose ) #Object processing the receiver chain of Upper Physial Layer processing of PUSCH
puschDataRx        = puschRx(symbolEstimates, snr) # returns the Information bits and CRC check
class toolkit5G.PhysicalChannels.PUSCHDecoderUpperPhy(numTBs, mcsIndex, symbolsPerSlot, numRB, numLayers, scalingField, rvID, additionalOverhead=0, dmrsREs=3, enableLBRM=[False], verbose=True)[source]

This class performs receiver chain of Upper Physical Processing of Physical Uplink Shared Channel

Parameters:

  • symbolsPerSlot (int) – Number of symbols allocated per Slot. It takes a scalar or numpy integer. It can take values between 1 and 14.

  • numRB (int) – Number of Physical Resource Blocks allocated. It takes a positive scalar or numpy integer.

  • mcsIndex (int) – Modulation and Coding Scheme (MCS) Index. It takes scalar or numpy integer. It can take any values between 0 and 28.

  • numlayers (numpy array) – Number of MIMO layers (the number of layers is equal to the number of allocated DMRS Ports). It takes numpy array containing integers of length 2. As the number of Transport Blocks processed is 1, it can take any value between 1 and 4.

  • scalingField (str) – Transport Block Scaling Field. It accepts a string. Valid strings are ‘00’, ‘01’, ‘10’.

  • additionalOverhead (int) – Additional Overheads that results in reduced number of available resource elements for data transfer. It takes a scalar or numpy integer. Valid values are 0, 6, 12 or 18.

  • numTBs (int) – The Physical layer processes 1 Transport Block for each resource allocation in the uplink direction. It represents number of Transport Blocks to be processed.

  • verbose (bool) – By enabling verbose, it displays information about the progress in the execution of the modules. Such as, the size of input/output vectors inputed to the modules and the parameters being passed. By default, set to ‘True’.

  • rvID; list of integer(s) – Redundancy Version ID which selects the starting position for extracting the bits from the buffer for the corresponding Transport Block processing. The length of the list is either 1 or 2 depending upon the number of transport blocks tha is processed.

  • dmrsREs (int) – Number of Resource Elements per Resource Block allocated to Demodulation Reference Signal(DMRS).

  • enableLBRM (list containing a bool) – Enable / Disable Limited Buffer Rate Matching(LBRM). The concept of LBRM is to help in reducing the requirement for buffering large code blocks, thus minimalizing the memory required. The length of the list is 1 based on the number of transport block that can be processed in the uplink direction. By default, it set to [‘False’]

Input:

  • symbolEstimates ([k, ], list where k is 1) – Returns a list of estimated symbols for respective User Equipments. The dimension is […, \(\text{N}_\text{EstSymb}\)] where \(\text{N}_\text{EstSymb}\) is the number of Symbol Estimates.

  • snr (int) – It is the Signal to Noise Ratio and takes any positive value.

  • demapperType (str) – It is the demapping method. By default set to ‘app’

Attributes:

  • Symbol DeMapping –

    :numpy ndarray, […, \(\text{N}_\text{llrs}\)], np.float32

    Return an array of demodulated symbols corresponding to the User Equipments. The dimension is where \(\text{N}_\text{llrs}\) is the number Log-Likelihood Ratios which is equal to \(\text{G}\), where \(\text{G}\) is the number of target bits.

  • Code block Segregation –

    :[k, ], list where k is 1, np.float32

    Return a list of Log-Likelihood Ratios. The dimension is […, \(\text{N}_\text{cb}\), \(\text{E}_\text{r}\)] where \(\text{N}_\text{cb}\) is the number code blocks and \(\text{E}_\text{r}\) is the rate matching output sequence length.

  • Bit DeInterleaver –

    :[k, ], list where k is 1, np.float32

    Return a list of code segments. The dimension is […, \(\text{N}_\text{cb}\), \(\text{E}_\text{r}\)] where, \(\text{N}_\text{cb}\) is the number code blocks and \(\text{E}_\text{r}\) is the rate matching output sequence length.

  • Bit DeSelection –

    : numpy ndarray […, \(\text{N}_\text{cb}\), \(\text{N}_\text{LDPC}\)], np.float64

    Return an array of Deselected bits of size \(\text{N}_\text{LDPC}\) where \(\text{N}_\text{cb}\) is the number code blocks and \(\text{N}_\text{LDPC}\) is the number of LDPC encoded bits.

  • LDPC Decoder –

    : numpy ndarray […, \(\text{N}_\text{cb}\), \(\text{K}_\text{cb}\)], np.float32

    Return an array of Channel decoded bits of size, \(\text{K}_\text{cb}\) where \(\text{N}_\text{cb}\) is the number code blocks and \(\text{K}_\text{cb}\) is the number segmented bits.

  • Code Block Aggregation –

    : numpy ndarray […, \(\text{Tb}_\text{size}\) + \(\text{N}_\text{crc}\)], np.float32

    where, \(\text{Tb}_\text{size}\) is the transport block size and \(\text{N}_\text{crc}\) is number of CRC bits

  • Transport Block Processing –

    : numpy ndarray […, \(\text{Tb}_\text{size}\)], np.float32

    where, \(\text{Tb}_\text{size}\) is the transport block size

Output:

[k,], list where k is 1, np.float 32 – It returns a list of array of Transport Block and its CRC check. the dimension […, \(\text{Tb}_\text{size}\)] where \(\text{Tb}_\text{size}\) is the Transport Block Size

References

[1]. 5G NR in Bullets, edition 1, Chris Jhonson.

[2]. 3GPP TS 38.212 version 16 Section 6.2

[3]. 3GPP TS 38.212 version 16 Section 6.3.1.2