itpp::TDL_Channel Class Reference
[Channel Modeling]

Tapped Delay Line (TDL) channel model. More...

#include <channel.h>

List of all members.

Public Member Functions

 TDL_Channel (const vec &avg_power_dB="0", const ivec &delay_prof="0")
 Default constructor.
 TDL_Channel (const Channel_Specification &channel_spec, double sampling_time)
 Constructor with defined Channel_Specification. Delay profile will be discretized with sampling_time in seconds.
virtual ~TDL_Channel ()
 Destructor.
void set_channel_profile (const vec &avg_power_dB, const ivec &delay_prof)
 Set both average power profile in dB and power delay profile in samples.
void set_channel_profile_uniform (int no_taps)
 Set channel profile to uniform with no_taps taps.
void set_channel_profile_exponential (int no_taps)
 Set channel profile to exponential with no_taps taps.
void set_channel_profile (const Channel_Specification &channel_spec, double sampling_time)
 Set channel profile using Channel_Specification. Delay profile will be discretized with sampling_time in seconds.
void set_correlated_method (CORRELATED_METHOD method)
 Set the fading generation method to method.
void set_fading_type (FADING_TYPE fading_type)
 Set fading type to one of Independent, Static or Correlated.
void set_norm_doppler (double norm_doppler)
 Set normalized Doppler rate. A Correlated fading type will be used.
void set_LOS (const vec &relative_power, const vec &relative_doppler="")
 Set LOS parameters for each tap. LOS Doppler will be set to 0.7 by default.
void set_LOS_power (const vec &relative_power)
 Set LOS power for each tap. LOS Doppler will be set to 0.7 by default.
void set_LOS_doppler (const vec &relative_doppler)
 Set LOS doppler for each tap. A Correlated fading type will be used.
void set_doppler_spectrum (const DOPPLER_SPECTRUM *tap_spectrum)
 Set doppler spectrum for each tap in the channel profile. Rice_MEDS method will be used.
void set_doppler_spectrum (int tap_number, DOPPLER_SPECTRUM tap_spectrum)
 Set doppler spectrum of tap tap_number. Rice_MEDS method will be used.
void set_no_frequencies (int no_freq)
 Set number of sine frequencies. Rice_MEDS method will be used.
void set_time_offset (int offset)
 Set fading generators' time offset in samples. A Correlated fading type will be used.
void shift_time_offset (int no_samples)
 Shift fading generators' time offset. A Correlated fading type will be used.
void set_filter_length (int filter_length)
 Set fading generator filter length. FIR method will be used.
int taps () const
 Return the number of channel taps.
void get_channel_profile (vec &avg_power_dB, ivec &delay_prof) const
 Get both average power profile in dB and power delay profile in samples.
vec get_avg_power_dB () const
 Return power profile in dB.
ivec get_delay_prof () const
 Return delay profile in samples.
CORRELATED_METHOD get_correlated_method () const
 Return fading generation method.
FADING_TYPE get_fading_type () const
 Return fading type.
double get_norm_doppler () const
 Return normalized doppler rate.
vec get_LOS_power () const
 Get relative power (Rice factor) for each tap.
vec get_LOS_doppler () const
 Get relative Doppler (to the maximum Doppler) for each tap.
double get_LOS_power (int tap_number) const
 Get relative power (Rice factor) for tap tap_number.
double get_LOS_doppler (int tap_number) const
 Get relative Doppler (to the maximum Doppler) for tap tap_number.
int get_no_frequencies () const
 Get the minimum number of frequencies used in Rice MEDS fading generator.
double get_time_offset () const
 Get fading generators' time ofset.
double calc_mean_excess_delay () const
 Calculate mean excess delay in samples.
double calc_rms_delay_spread () const
 Calculate RMS delay spread in samples.
void init ()
 Initialize all fading generators. Automatically invoked in generate() or filter() functions.
void generate (int no_samples, Array< cvec > &channel_coeff)
 Generate no_samples values of the channel.
void generate (int no_samples, cmat &channel_coeff)
 Generate no_samples values of the channel. Returns the matrix with one tap per column.
void filter_known_channel (const cvec &input, cvec &output, const Array< cvec > &channel_coeff)
 Filter the input with the known channel values channel_coeff (e.g. from the generate function).
void filter_known_channel (const cvec &input, cvec &output, const cmat &channel_coeff)
 Filter the input with the known channel values channel_coeff (e.g. from the generate function).
void filter (const cvec &input, cvec &output, Array< cvec > &channel_coeff)
 Generate channel coefficients and filter the input. Return output and channel coefficients.
void filter (const cvec &input, cvec &output, cmat &channel_coeff)
 Generate channel coefficients and filter the input. Return output and channel coefficients.
cvec filter (const cvec &input, Array< cvec > &channel_coeff)
 Generate channel coefficients and filter the input. Return output and channel coefficients.
cvec filter (const cvec &input, cmat &channel_coeff)
 Generate channel coefficients and filter the input. Return output and channel coefficients.
void filter (const cvec &input, cvec &output)
 Generate channel coefficients and filter the input. Only return the output.
cvec filter (const cvec &input)
 Generate channel coefficients and filter the input. Only return output.
void operator() (const cvec &input, cvec &output, Array< cvec > &channel_coeff)
 Generate channel coefficients and filter the input. Return output and channel coefficients.
void operator() (const cvec &input, cvec &output, cmat &channel_coeff)
 Generate channel coefficients and filter the input. Return output and channel coefficients.
cvec operator() (const cvec &input, Array< cvec > &channel_coeff)
 Generate channel coefficients and filter the input. Return output and channel coefficients.
cvec operator() (const cvec &input, cmat &channel_coeff)
 Generate channel coefficients and filter the input. Return output and channel coefficients.
cvec operator() (const cvec &input)
 Generate channel coefficients and filter the input. Only return output.
void calc_impulse_response (const Array< cvec > &channel_coeff, Array< cvec > &impulse_response)
 Calculate impulse-response on the supplied channel coefficients (produced by the generate() function).
void calc_frequency_response (const Array< cvec > &channel_coeff, Array< cvec > &frequency_response, const int fft_size)
 Calculate frequency-response on the supplied channel coefficients (produced by the generate() function).
void calc_frequency_response (const cmat &channel_coeff, cmat &frequency_response, const int fft_size)
 Calculate frequency-response on the supplied channel coefficients (produced by the generate() function).
double get_sampling_time () const
 Return channel sampling time (used for discretization).

Protected Member Functions

void discretize (const vec &delay_profile)
 Discretize the delay profile with discrete_Ts (Ts). All taps within ((i-0.5)Ts,(i+0.5)Ts] belong to the ith discrete tap.

Protected Attributes

bool init_flag
 Channel ready to produce data.
vec a_prof
 Average amplitude of each tap.
ivec d_prof
 Delay in samples for each tap.
vec los_power
 Relative power for each Rice component.
vec los_dopp
 Relative LOS Doppler for each Rice component.
int N_taps
 Number of taps.
double n_dopp
 Normalized Doppler of the correlated fading.
FADING_TYPE fading_type
 Fading type: Independent (default), Static or Correlated.
CORRELATED_METHOD method
 Correlated fading generation method: Rice_MEDS (default), IFFT or FIR.
Array< DOPPLER_SPECTRUM > tap_doppler_spectrum
 Doppler spectrum for each tap.
Array< Fading_Generator * > fading_gen
 Fading generators for each tap.
int filter_length
 Filter length of FIR fading generator.
int nrof_freq
 Number of sine frequencies in the Rice MEDS fading generator.
double discrete_Ts
 Sampling time of discretization.

Detailed Description

Tapped Delay Line (TDL) channel model.

Author:
Tony Ottosson, Adam Piatyszek and Zbigniew Dlugaszewski
A time invariant (or at least wide-sense stationary) channel have an impulse response that can be modeled as:

\[ h(t) = \sum_{k=0}^{N_\mathrm{taps}-1} a_k \exp (-j \theta_k ) \delta(t-\tau_k), \]

where $ N_{taps} $ is the number of channel taps, $ a_k $ is the average amplitude at delay $ \tau_k $, and $ \theta_k $ is the channel phase of the $ k^{th} $ channel tap. The average power profile, and delay profile are defined as:

\[ \mathbf{a} = [a_0, a_1, \ldots, a_{N_\mathrm{taps}-1}] \]

and

\[ \mathbf{\tau} = [\tau_0, \tau_1, \ldots, \tau_{N_\mathrm{taps}-1}], \]

respectively. We assume without loss of generality that $ \tau_0 = 0 $ and $ \tau_0 < \tau_1 < \ldots < \tau_{N_\mathrm{taps}-1} $.

To initialize the channel profile the following parameters should be defined:

In the case of correlated channel, the correlation in time is decided by the normalized Doppler frequency and Doppler spectrum. The normalized Doppler frequency is calculated as $ f_\mathrm{max} T_s $, where $ f_\mathrm{max} $ is the maximum Doppler frequency and $ T_s $ is the sample duration.

Two main types of generation methods exist: the filter method and Rice method. In the filter method the correlated fading process is generated with a filtering of the complex Gaussian process to achieve a given Doppler spectrum (Jakes by default). Currently there are two filter implementations:

The preferred method for generating the correlated fading process is the Rice method that approximate the fading process as a sum of sinusoids. Currently there is only one implementation, the Rice Method of Exact Doppler Spread (Rice_MEDS), which is also the default choice.

To summarize, the currently supported correlated fading generation methods are:

Beside the above described correlated methods, two additional fading generators exists: the Independent_Fading_Generator and Static_Fading_Generator ones. Their names are self-explanatory. The only optional parameter of these two generators is a relative_power of the LOS component.

Example: Simulation of WCDMA 

 #include <itpp/itcomm.h>
 using namespace itpp;

 int main() {
   // set sampling time at a half of chip rate (0.5 / 3.84e6)
   double Ts = 130.2e-9;
   // select the COST259 Rural Area model
   Channel_Specification channel_spec(COST259_RAx);
   // initialize with the predefined channel profile
   TDL_Channel channel(channel_spec, Ts);
   // set the normalized Doppler; fading type will be set to Correlated
   // and Rice_MEDS method will be used (default settings)
   channel.set_norm_doppler(0.01);

   cvec transmitted_signal;
   // -----------------------------------------------
   // Your code here generates the transmitted signal
   // -----------------------------------------------

   // Channel coefficients are returned in the 'coeff' array of complex values
   Array<cvec> coeff;
   cvec received_signal = channel(transmitted_signal, coeff);
 }

References:

Member Function Documentation

void itpp::TDL_Channel::discretize ( const vec &  delay_profile  )  [protected]

Discretize the delay profile with discrete_Ts (Ts). All taps within ((i-0.5)Ts,(i+0.5)Ts] belong to the ith discrete tap.

Parameters:
delay_profile Delay profile in seconds.

References a_prof, d_prof, discrete_Ts, it_assert, it_warning, los_dopp, los_power, N_taps, itpp::round_i(), itpp::Array< T >::set_size(), itpp::Array< T >::size(), itpp::sqr(), itpp::sqrt(), and tap_doppler_spectrum.

Referenced by set_channel_profile().

The documentation for this class was generated from the following files:
Generated on Tue Jun 2 10:02:19 2009 for mixpp by  doxygen 1.5.8