void ClingyPath::FitToTerrain (size_t idx, float width, iMeshWrapper* thisMesh)
{
const csVector3& pos = points[idx].pos;
csVector3 right = (width / 2.0) * (points[idx].front % points[idx].up);
csVector3 rightPos = pos + right;
csVector3 leftPos = pos - right;
float dyL, dy, dyR;
bool hL = HeightDiff (leftPos, thisMesh, dyL);
bool h = HeightDiff (pos, thisMesh, dy);
bool hR = HeightDiff (rightPos, thisMesh, dyR);
if ((hL && dyL > TOP_MARGIN) || (hR && dyR > TOP_MARGIN))
{
// First we lower the segment. After that we check if it is
// not too low.
float lowerY = cmax (hL, dyL-TOP_MARGIN, hR, dyR-TOP_MARGIN);
points[idx].pos.y -= lowerY;
dy -= lowerY;
dyL -= lowerY;
dyR -= lowerY;
# if VERBOSE
printf (" FitToTerrain %d, dy=%g/%g/%g, lowerY=%g\n",
idx, dyL, dy, dyR, lowerY);
fflush (stdout);
# endif
}
if ((hL && dyL < BOTTOM_MARGIN) || (h && dy < BOTTOM_MARGIN) || (hR && dyR < BOTTOM_MARGIN))
{
// Some part of this point gets (almost) under the terrain. Need to raise
// everything.
float raiseY = cmax (hL, BOTTOM_MARGIN-dyL, hR, BOTTOM_MARGIN-dyR);
raiseY = cmax (true, raiseY, h, BOTTOM_MARGIN-dy);
points[idx].pos.y += raiseY;
# if VERBOSE
printf (" FitToTerrain %d, dy=%g/%g/%g, raiseY=%g\n",
idx, dyL, dy, dyR, raiseY);
fflush (stdout);
# endif
}
else
{
# if VERBOSE
printf (" FitToTerrain %d, dy=%g/%g/%g\n", idx, dyL, dy, dyR);
fflush (stdout);
# endif
}
}
/*
Returns dmatrix with pow of each element in m raised to the exponent e.
\param m dmatrix
\param e floating point exponent
*/
dmatrix pow(const dmatrix& m, const double e)
{
ivector cmin(m.rowmin(), m.rowmax());
ivector cmax(m.rowmin(), m.rowmax());
for (int i = m.rowmin(); i <= m.rowmax(); ++i)
{
cmin(i) = m(i).indexmin();
cmax(i) = m(i).indexmax();
}
dmatrix tmp(m.rowmin(), m.rowmax(), cmin, cmax);
for (int i = m.rowmin(); i <= m.rowmax(); ++i)
{
tmp(i) = pow(m(i), e);
}
return tmp;
}
/**
Returns dmatrix with each of element in m is squared.
\param m dmatrix
*/
dmatrix sqr(const dmatrix& m)
{
ivector cmin(m.rowmin(), m.rowmax());
ivector cmax(m.rowmin(), m.rowmax());
for (int i = m.rowmin(); i <= m.rowmax(); ++i)
{
cmin(i) = m(i).indexmin();
cmax(i) = m(i).indexmax();
}
dmatrix tmp(m.rowmin(), m.rowmax(), cmin, cmax);
for (int i = m.rowmin(); i <= m.rowmax(); ++i)
{
tmp(i) = sqr(m(i));
}
return tmp;
}
/**
* Description not yet available.
* \param
*/
dmatrix elem_div(const dmatrix& m, const dmatrix& m2)
{
ivector cmin(m.rowmin(),m.rowmax());
ivector cmax(m.rowmin(),m.rowmax());
int i;
for (i=m.rowmin();i<=m.rowmax();i++)
{
cmin(i)=m(i).indexmin();
cmax(i)=m(i).indexmax();
}
dmatrix tmp(m.rowmin(),m.rowmax(),cmin,cmax);
for (i=m.rowmin();i<=m.rowmax();i++)
{
tmp(i)=elem_div(m(i),m2(i));
}
return tmp;
}
/**
* Description not yet available.
* \param
*/
dmatrix log(const dmatrix& m)
{
ivector cmin(m.rowmin(),m.rowmax());
ivector cmax(m.rowmin(),m.rowmax());
int i;
for (i=m.rowmin();i<=m.rowmax();i++)
{
cmin(i)=m(i).indexmin();
cmax(i)=m(i).indexmax();
}
dmatrix tmp(m.rowmin(),m.rowmax(),cmin,cmax);
for (i=m.rowmin();i<=m.rowmax();i++)
{
tmp(i)=log(m(i));
}
return tmp;
}
void ulsch_extract_rbs_single(int **rxdataF,
int **rxdataF_ext,
unsigned int first_rb,
unsigned int nb_rb,
unsigned char l,
unsigned char Ns,
LTE_DL_FRAME_PARMS *frame_parms) {
unsigned short nb_rb1,nb_rb2;
unsigned char aarx;
int *rxF,*rxF_ext;
//unsigned char symbol = l+Ns*frame_parms->symbols_per_tti/2;
unsigned char symbol = l+((7-frame_parms->Ncp)*(Ns&1)); ///symbol within sub-frame
for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++) {
nb_rb1 = cmin(cmax((int)(frame_parms->N_RB_UL) - (int)(2*first_rb),(int)0),(int)(2*nb_rb)); // 2 times no. RBs before the DC
nb_rb2 = 2*nb_rb - nb_rb1; // 2 times no. RBs after the DC
#ifdef DEBUG_ULSCH
msg("ulsch_extract_rbs_single: 2*nb_rb1 = %d, 2*nb_rb2 = %d\n",nb_rb1,nb_rb2);
#endif
rxF_ext = &rxdataF_ext[aarx][(symbol*frame_parms->N_RB_UL*12)*2];
if (nb_rb1) {
rxF = &rxdataF[aarx][(first_rb*12 + frame_parms->first_carrier_offset + symbol*frame_parms->ofdm_symbol_size)*2];
memcpy(rxF_ext, rxF, nb_rb1*12*sizeof(int));
rxF_ext += nb_rb1*12;
if (nb_rb2) {
#ifdef OFDMA_ULSCH
rxF = &rxdataF[aarx][(1 + symbol*frame_parms->ofdm_symbol_size)*2];
#else
rxF = &rxdataF[aarx][(symbol*frame_parms->ofdm_symbol_size)*2];
#endif
memcpy(rxF_ext, rxF, nb_rb2*12*sizeof(int));
rxF_ext += nb_rb2*12;
}
}
else { //there is only data in the second half
#ifdef OFDMA_ULSCH
rxF = &rxdataF[aarx][(1 + 6*(2*first_rb - frame_parms->N_RB_UL) + symbol*frame_parms->ofdm_symbol_size)*2];
#else
rxF = &rxdataF[aarx][(6*(2*first_rb - frame_parms->N_RB_UL) + symbol*frame_parms->ofdm_symbol_size)*2];
#endif
memcpy(rxF_ext, rxF, nb_rb2*12*sizeof(int));
rxF_ext += nb_rb2*12;
}
}
_mm_empty();
_m_empty();
}
int chello()
{
float MYPI = acos(-1);
float MYE = exp(1);
printf("Hello World\n");
printf("%f %f\n", MYPI, MYE);
printf("max of e and pi is approximately %f\n", cmax(MYPI, MYE));
return 0;
}
/// Sort colors by abosolute value in their 16 bit representation.
void ColorBlock::sortColorsByAbsoluteValue()
{
// Dummy selection sort.
for( uint a = 0; a < 16; a++ ) {
uint max = a;
Color16 cmax(m_color[a]);
for( uint b = a+1; b < 16; b++ ) {
Color16 cb(m_color[b]);
if( cb.u > cmax.u ) {
max = b;
cmax = cb;
}
}
swap( m_color[a], m_color[max] );
}
}
// This function stores the downlink buffer for all the logical channels
void store_dlsch_buffer (module_id_t Mod_id,
frame_t frameP,
sub_frame_t subframeP){
int UE_id,i;
rnti_t rnti;
mac_rlc_status_resp_t rlc_status;
UE_list_t *UE_list = &eNB_mac_inst[Mod_id].UE_list;
UE_TEMPLATE *UE_template;
for (UE_id=UE_list->head;UE_id>=0;UE_id=UE_list->next[UE_id]){
UE_template = &UE_list->UE_template[UE_PCCID(Mod_id,UE_id)][UE_id];
// clear logical channel interface variables
UE_template->dl_buffer_total = 0;
UE_template->dl_pdus_total = 0;
for(i=0;i< MAX_NUM_LCID; i++) {
UE_template->dl_buffer_info[i]=0;
UE_template->dl_pdus_in_buffer[i]=0;
UE_template->dl_buffer_head_sdu_creation_time[i]=0;
UE_template->dl_buffer_head_sdu_remaining_size_to_send[i]=0;
}
rnti = UE_RNTI(Mod_id,UE_id);
for(i=0;i< MAX_NUM_LCID; i++){ // loop over all the logical channels
rlc_status = mac_rlc_status_ind(Mod_id,UE_id, frameP,ENB_FLAG_YES,MBMS_FLAG_NO,i,0 );
UE_template->dl_buffer_info[i] = rlc_status.bytes_in_buffer; //storing the dlsch buffer for each logical channel
UE_template->dl_pdus_in_buffer[i] = rlc_status.pdus_in_buffer;
UE_template->dl_buffer_head_sdu_creation_time[i] = rlc_status.head_sdu_creation_time ;
UE_template->dl_buffer_head_sdu_creation_time_max = cmax(UE_template->dl_buffer_head_sdu_creation_time_max,
rlc_status.head_sdu_creation_time );
UE_template->dl_buffer_head_sdu_remaining_size_to_send[i] = rlc_status.head_sdu_remaining_size_to_send;
UE_template->dl_buffer_head_sdu_is_segmented[i] = rlc_status.head_sdu_is_segmented;
UE_template->dl_buffer_total += UE_template->dl_buffer_info[i];//storing the total dlsch buffer
UE_template->dl_pdus_total += UE_template->dl_pdus_in_buffer[i];
#ifdef DEBUG_eNB_SCHEDULER
/* note for dl_buffer_head_sdu_remaining_size_to_send[i] :
* 0 if head SDU has not been segmented (yet), else remaining size not already segmented and sent
*/
if (UE_template->dl_buffer_info[i]>0)
LOG_D(MAC,"[eNB %d] Frame %d Subframe %d : RLC status for UE %d in LCID%d: total of %d pdus and size %d, head sdu queuing time %d, remaining size %d, is segmeneted %d \n",
Mod_id, frameP, subframeP, UE_id,
i, UE_template->dl_pdus_in_buffer[i],UE_template->dl_buffer_info[i],
UE_template->dl_buffer_head_sdu_creation_time[i],
UE_template->dl_buffer_head_sdu_remaining_size_to_send[i],
UE_template->dl_buffer_head_sdu_is_segmented[i]
);
#endif
}
//#ifdef DEBUG_eNB_SCHEDULER
if ( UE_template->dl_buffer_total>0)
LOG_D(MAC,"[eNB %d] Frame %d Subframe %d : RLC status for UE %d : total DL buffer size %d and total number of pdu %d \n",
Mod_id, frameP, subframeP, UE_id,
UE_template->dl_buffer_total,
UE_template->dl_pdus_total
);
//#endif
}
}
void phy_scope_eNB(FD_lte_phy_scope_enb *form,
PHY_VARS_eNB *phy_vars_enb,
int UE_id) {
int eNB_id = 0;
int i,arx,atx,ind,k;
LTE_DL_FRAME_PARMS *frame_parms = &phy_vars_enb->lte_frame_parms;
int nsymb_ce = 12*frame_parms->N_RB_UL*frame_parms->symbols_per_tti;
uint8_t nb_antennas_rx = frame_parms->nb_antennas_rx;
uint8_t nb_antennas_tx = 1; // frame_parms->nb_antennas_tx; // in LTE Rel. 8 and 9 only a single transmit antenna is assumed at the UE
int16_t **rxsig_t;
int16_t **chest_t;
int16_t **chest_f;
int16_t *pusch_llr;
int16_t *pusch_comp;
float Re,Im,ymax;
float *llr, *bit;
float I[nsymb_ce*2], Q[nsymb_ce*2];
float rxsig_t_dB[nb_antennas_rx][FRAME_LENGTH_COMPLEX_SAMPLES];
float chest_t_abs[nb_antennas_rx][frame_parms->ofdm_symbol_size];
float *chest_f_abs;
float time[FRAME_LENGTH_COMPLEX_SAMPLES];
float freq[nsymb_ce*nb_antennas_rx*nb_antennas_tx];
int frame = phy_vars_enb->proc[0].frame_tx;
uint32_t total_dlsch_bitrate = phy_vars_enb->total_dlsch_bitrate;
int coded_bits_per_codeword = 0;
uint8_t harq_pid; // in TDD config 3 it is sf-2, i.e., can be 0,1,2
int mcs = 0;
// choose max MCS to compute coded_bits_per_codeword
if (phy_vars_enb->ulsch_eNB[UE_id]!=NULL) {
for (harq_pid=0;harq_pid<3;harq_pid++) {
mcs = cmax(phy_vars_enb->ulsch_eNB[UE_id]->harq_processes[harq_pid]->mcs,mcs);
}
}
coded_bits_per_codeword = frame_parms->N_RB_UL*12*get_Qm(mcs)*frame_parms->symbols_per_tti;
chest_f_abs = (float*) calloc(nsymb_ce*nb_antennas_rx*nb_antennas_tx,sizeof(float));
llr = (float*) calloc(coded_bits_per_codeword,sizeof(float)); // init to zero
bit = malloc(coded_bits_per_codeword*sizeof(float));
rxsig_t = (int16_t**) phy_vars_enb->lte_eNB_common_vars.rxdata[eNB_id];
chest_t = (int16_t**) phy_vars_enb->lte_eNB_pusch_vars[UE_id]->drs_ch_estimates_time[eNB_id];
chest_f = (int16_t**) phy_vars_enb->lte_eNB_pusch_vars[UE_id]->drs_ch_estimates[eNB_id];
pusch_llr = (int16_t*) phy_vars_enb->lte_eNB_pusch_vars[UE_id]->llr;
pusch_comp = (int16_t*) phy_vars_enb->lte_eNB_pusch_vars[UE_id]->rxdataF_comp[eNB_id][0];
// Received signal in time domain of receive antenna 0
if (rxsig_t != NULL) {
if (rxsig_t[0] != NULL) {
for (i=0; i<FRAME_LENGTH_COMPLEX_SAMPLES; i++) {
rxsig_t_dB[0][i] = 10*log10(1.0+(float) ((rxsig_t[0][2*i])*(rxsig_t[0][2*i])+(rxsig_t[0][2*i+1])*(rxsig_t[0][2*i+1])));
time[i] = (float) i;
}
fl_set_xyplot_data(form->rxsig_t,time,rxsig_t_dB[0],FRAME_LENGTH_COMPLEX_SAMPLES,"","","");
}
for (arx=1;arx<nb_antennas_rx;arx++) {
if (rxsig_t[arx] != NULL) {
for (i=0; i<FRAME_LENGTH_COMPLEX_SAMPLES; i++) {
rxsig_t_dB[arx][i] = 10*log10(1.0+(float) ((rxsig_t[arx][2*i])*(rxsig_t[arx][2*i])+(rxsig_t[arx][2*i+1])*(rxsig_t[arx][2*i+1])));
}
fl_add_xyplot_overlay(form->rxsig_t,arx,time,rxsig_t_dB[arx],FRAME_LENGTH_COMPLEX_SAMPLES,rx_antenna_colors[arx]);
}
}
}
// Channel Impulse Response (still repeated format)
if (chest_t != NULL) {
ymax = 0;
if (chest_t[0] !=NULL) {
for (i=0; i<(frame_parms->ofdm_symbol_size); i++) {
chest_t_abs[0][i] = (float) (chest_t[0][4*i]*chest_t[0][4*i]+chest_t[0][4*i+1]*chest_t[0][4*i+1]);
if (chest_t_abs[0][i] > ymax)
ymax = chest_t_abs[0][i];
}
fl_set_xyplot_data(form->chest_t,time,chest_t_abs[0],(frame_parms->ofdm_symbol_size),"","","");
}
for (arx=1;arx<nb_antennas_rx;arx++) {
if (chest_t[arx] !=NULL) {
for (i=0; i<(frame_parms->ofdm_symbol_size>>3); i++) {
chest_t_abs[arx][i] = (float) (chest_t[arx][4*i]*chest_t[arx][4*i]+chest_t[arx][4*i+1]*chest_t[arx][4*i+1]);
if (chest_t_abs[arx][i] > ymax)
ymax = chest_t_abs[arx][i];
}
fl_add_xyplot_overlay(form->chest_t,arx,time,chest_t_abs[arx],(frame_parms->ofdm_symbol_size>>3),rx_antenna_colors[arx]);
fl_set_xyplot_overlay_type(form->chest_t,arx,FL_DASHED_XYPLOT);
}
}
// Avoid flickering effect
// fl_get_xyplot_ybounds(form->chest_t,&ymin,&ymax);
fl_set_xyplot_ybounds(form->chest_t,0,ymax);
}
void rx_ulsch(LTE_eNB_COMMON *eNB_common_vars,
LTE_eNB_ULSCH *eNB_ulsch_vars,
LTE_DL_FRAME_PARMS *frame_parms,
unsigned int subframe,
unsigned char eNB_id, // this is the effective sector id
LTE_eNB_ULSCH_t *ulsch,
u8 cooperation_flag) {
unsigned int l,i;
int avgs;
unsigned char log2_maxh,aarx;
int avgs_0,avgs_1;
unsigned log2_maxh_0,log2_maxh_1;
// unsigned char harq_pid = ( ulsch->RRCConnRequest_flag== 0) ? subframe2harq_pid_tdd(frame_parms->tdd_config,subframe) : 0;
unsigned char harq_pid = subframe2harq_pid(frame_parms,subframe);
unsigned char Qm = get_Qm(ulsch->harq_processes[harq_pid]->mcs);
unsigned short rx_power_correction;
#ifdef DEBUG_ULSCH
debug_msg("rx_ulsch: eNB_id %d, harq_pid %d, nb_rb %d first_rb %d, cooperation %d\n",eNB_id,harq_pid,ulsch->harq_processes[harq_pid]->nb_rb,ulsch->harq_processes[harq_pid]->first_rb, cooperation_flag);
#endif //DEBUG_ULSCH
if ( (frame_parms->ofdm_symbol_size == 128) ||
(frame_parms->ofdm_symbol_size == 512) )
rx_power_correction = 2;
else
rx_power_correction = 1;
for (l=0;l<frame_parms->symbols_per_tti-1;l++) {
#ifdef DEBUG_ULSCH
msg("rx_ulsch : symbol %d (first_rb %d,nb_rb %d), rxdataF %p, rxdataF_ext %p\n",l,
ulsch->harq_processes[harq_pid]->first_rb,
ulsch->harq_processes[harq_pid]->nb_rb,
eNB_common_vars->rxdataF[eNB_id],
eNB_ulsch_vars->rxdataF_ext[eNB_id]);
#endif //DEBUG_ULSCH
ulsch_extract_rbs_single(eNB_common_vars->rxdataF[eNB_id],
eNB_ulsch_vars->rxdataF_ext[eNB_id],
ulsch->harq_processes[harq_pid]->first_rb,
ulsch->harq_processes[harq_pid]->nb_rb,
l%(frame_parms->symbols_per_tti/2),
l/(frame_parms->symbols_per_tti/2),
frame_parms);
lte_ul_channel_estimation(eNB_ulsch_vars->drs_ch_estimates[eNB_id],
eNB_ulsch_vars->drs_ch_estimates_time[eNB_id],
eNB_ulsch_vars->drs_ch_estimates_0[eNB_id],
eNB_ulsch_vars->drs_ch_estimates_1[eNB_id],
eNB_ulsch_vars->rxdataF_ext[eNB_id],
frame_parms,
l%(frame_parms->symbols_per_tti/2),
l/(frame_parms->symbols_per_tti/2),
ulsch->harq_processes[harq_pid]->nb_rb,
ulsch->cyclicShift,
cooperation_flag);
ulsch_correct_ext(eNB_ulsch_vars->rxdataF_ext[eNB_id],
eNB_ulsch_vars->rxdataF_ext2[eNB_id],
l,
frame_parms,
ulsch->harq_processes[harq_pid]->nb_rb);
if(cooperation_flag == 2)
{
for (i=0;i<frame_parms->nb_antennas_rx;i++){
eNB_ulsch_vars->ulsch_power_0[i] = signal_energy_nodc(eNB_ulsch_vars->drs_ch_estimates_0[eNB_id][i],
ulsch->harq_processes[harq_pid]->nb_rb*12)*rx_power_correction;
eNB_ulsch_vars->ulsch_power_1[i] = signal_energy_nodc(eNB_ulsch_vars->drs_ch_estimates_1[eNB_id][i],
ulsch->harq_processes[harq_pid]->nb_rb*12)*rx_power_correction;
}
}
else
{
for (i=0;i<frame_parms->nb_antennas_rx;i++)
eNB_ulsch_vars->ulsch_power[i] = signal_energy_nodc(eNB_ulsch_vars->drs_ch_estimates[eNB_id][i],
ulsch->harq_processes[harq_pid]->nb_rb*12)*rx_power_correction;
}
}
if(cooperation_flag == 2)
{
ulsch_channel_level(eNB_ulsch_vars->drs_ch_estimates_0[eNB_id],
frame_parms,
avgU_0,
ulsch->harq_processes[harq_pid]->nb_rb);
// msg("[ULSCH] avg_0[0] %d\n",avgU_0[0]);
avgs_0 = 0;
for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++)
avgs_0 = cmax(avgs_0,avgU_0[(aarx<<1)]);
log2_maxh_0 = 4+(log2_approx(avgs_0)/2);
#ifdef DEBUG_ULSCH
msg("[ULSCH] log2_maxh_0 = %d (%d,%d)\n",log2_maxh_0,avgU_0[0],avgs_0);
#endif
ulsch_channel_level(eNB_ulsch_vars->drs_ch_estimates_1[eNB_id],
frame_parms,
avgU_1,
ulsch->harq_processes[harq_pid]->nb_rb);
// msg("[ULSCH] avg_1[0] %d\n",avgU_1[0]);
avgs_1 = 0;
for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++)
avgs_1 = cmax(avgs_1,avgU_1[(aarx<<1)]);
log2_maxh_1 = 4+(log2_approx(avgs_1)/2);
#ifdef DEBUG_ULSCH
msg("[ULSCH] log2_maxh_1 = %d (%d,%d)\n",log2_maxh_1,avgU_1[0],avgs_1);
#endif
}
else
{
ulsch_channel_level(eNB_ulsch_vars->drs_ch_estimates[eNB_id],
frame_parms,
avgU,
ulsch->harq_processes[harq_pid]->nb_rb);
// msg("[ULSCH] avg[0] %d\n",avgU[0]);
avgs = 0;
for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++)
avgs = cmax(avgs,avgU[(aarx<<1)]);
log2_maxh = 2+(log2_approx(avgs)/2);
#ifdef DEBUG_ULSCH
msg("[ULSCH] log2_maxh = %d (%d,%d)\n",log2_maxh,avgU[0],avgs);
#endif
}
for (l=0;l<frame_parms->symbols_per_tti-1;l++) {
if (((frame_parms->Ncp == 0) && ((l==3) || (l==10)))|| // skip pilots
((frame_parms->Ncp == 1) && ((l==2) || (l==8)))) {
l++;
}
if(cooperation_flag == 2)
{
ulsch_channel_compensation_alamouti(eNB_ulsch_vars->rxdataF_ext2[eNB_id],
eNB_ulsch_vars->drs_ch_estimates_0[eNB_id],
eNB_ulsch_vars->drs_ch_estimates_1[eNB_id],
eNB_ulsch_vars->ul_ch_mag_0[eNB_id],
eNB_ulsch_vars->ul_ch_magb_0[eNB_id],
eNB_ulsch_vars->ul_ch_mag_1[eNB_id],
eNB_ulsch_vars->ul_ch_magb_1[eNB_id],
eNB_ulsch_vars->rxdataF_comp_0[eNB_id],
eNB_ulsch_vars->rxdataF_comp_1[eNB_id],
frame_parms,
l,
Qm,
ulsch->harq_processes[harq_pid]->nb_rb,
log2_maxh_0,
log2_maxh_1); // log2_maxh+I0_shift
ulsch_alamouti(frame_parms,
eNB_ulsch_vars->rxdataF_comp[eNB_id],
eNB_ulsch_vars->rxdataF_comp_0[eNB_id],
eNB_ulsch_vars->rxdataF_comp_1[eNB_id],
eNB_ulsch_vars->ul_ch_mag[eNB_id],
eNB_ulsch_vars->ul_ch_magb[eNB_id],
eNB_ulsch_vars->ul_ch_mag_0[eNB_id],
eNB_ulsch_vars->ul_ch_magb_0[eNB_id],
eNB_ulsch_vars->ul_ch_mag_1[eNB_id],
eNB_ulsch_vars->ul_ch_magb_1[eNB_id],
l,
ulsch->harq_processes[harq_pid]->nb_rb);
}
else
{
ulsch_channel_compensation(eNB_ulsch_vars->rxdataF_ext2[eNB_id],
eNB_ulsch_vars->drs_ch_estimates[eNB_id],
eNB_ulsch_vars->ul_ch_mag[eNB_id],
eNB_ulsch_vars->ul_ch_magb[eNB_id],
eNB_ulsch_vars->rxdataF_comp[eNB_id],
frame_parms,
l,
Qm,
ulsch->harq_processes[harq_pid]->nb_rb,
log2_maxh); // log2_maxh+I0_shift
}
if (frame_parms->nb_antennas_rx > 1)
ulsch_detection_mrc(frame_parms,
eNB_ulsch_vars->rxdataF_comp[eNB_id],
eNB_ulsch_vars->ul_ch_mag[eNB_id],
eNB_ulsch_vars->ul_ch_magb[eNB_id],
l,
ulsch->harq_processes[harq_pid]->nb_rb);
#ifndef OFDMA_ULSCH
freq_equalization(frame_parms,
eNB_ulsch_vars->rxdataF_comp[eNB_id],
eNB_ulsch_vars->ul_ch_mag[eNB_id],
eNB_ulsch_vars->ul_ch_magb[eNB_id],
l,
ulsch->harq_processes[harq_pid]->nb_rb*12,
Qm);
#endif
}
#ifndef OFDMA_ULSCH
//#ifdef DEBUG_ULSCH
// Inverse-Transform equalized outputs
// msg("Doing IDFTs\n");
lte_idft(frame_parms,
eNB_ulsch_vars->rxdataF_comp[eNB_id][0],
ulsch->harq_processes[harq_pid]->nb_rb*12);
// msg("Done\n");
//#endif //DEBUG_ULSCH
#endif
for (l=0;l<frame_parms->symbols_per_tti-1;l++) {
if (((frame_parms->Ncp == 0) && ((l==3) || (l==10)))|| // skip pilots
((frame_parms->Ncp == 1) && ((l==2) || (l==8)))) {
l++;
}
switch (Qm) {
case 2 :
ulsch_qpsk_llr(frame_parms,
eNB_ulsch_vars->rxdataF_comp[eNB_id],
eNB_ulsch_vars->llr,
l,
ulsch->harq_processes[harq_pid]->nb_rb);
break;
case 4 :
ulsch_16qam_llr(frame_parms,
eNB_ulsch_vars->rxdataF_comp[eNB_id],
eNB_ulsch_vars->llr,
eNB_ulsch_vars->ul_ch_mag[eNB_id],
l,ulsch->harq_processes[harq_pid]->nb_rb);
break;
case 6 :
ulsch_64qam_llr(frame_parms,
eNB_ulsch_vars->rxdataF_comp[eNB_id],
eNB_ulsch_vars->llr,
eNB_ulsch_vars->ul_ch_mag[eNB_id],
eNB_ulsch_vars->ul_ch_magb[eNB_id],
l,ulsch->harq_processes[harq_pid]->nb_rb);
break;
default:
#ifdef DEBUG_ULSCH
msg("ulsch_demodulation.c (rx_ulsch): Unknown Qm!!!!\n");
#endif //DEBUG_ULSCH
break;
}
}
}
void
CellConservativeLinear::interp (const FArrayBox& crse,
int crse_comp,
FArrayBox& fine,
int fine_comp,
int ncomp,
const Box& fine_region,
const IntVect& ratio,
const Geometry& crse_geom,
const Geometry& fine_geom,
Array<BCRec>& bcr,
int actual_comp,
int actual_state)
{
BL_PROFILE("CellConservativeLinear::interp()");
BL_ASSERT(bcr.size() >= ncomp);
//
// Make box which is intersection of fine_region and domain of fine.
//
Box target_fine_region = fine_region & fine.box();
//
// crse_bx is coarsening of target_fine_region, grown by 1.
//
Box crse_bx = CoarseBox(target_fine_region,ratio);
//
// Slopes are needed only on coarsening of target_fine_region.
//
Box cslope_bx(crse_bx);
cslope_bx.grow(-1);
//
// Make a refinement of cslope_bx
//
Box fine_version_of_cslope_bx = BoxLib::refine(cslope_bx,ratio);
//
// Get coarse and fine edge-centered volume coordinates.
//
Array<Real> fvc[BL_SPACEDIM];
Array<Real> cvc[BL_SPACEDIM];
int dir;
for (dir = 0; dir < BL_SPACEDIM; dir++)
{
fine_geom.GetEdgeVolCoord(fvc[dir],fine_version_of_cslope_bx,dir);
crse_geom.GetEdgeVolCoord(cvc[dir],crse_bx,dir);
}
//
// alloc tmp space for slope calc.
//
// In ucc_slopes and lcc_slopes , there is a slight abuse of
// the number of compenents argument
// --> there is a slope for each component in each coordinate
// direction
//
FArrayBox ucc_slopes(cslope_bx,ncomp*BL_SPACEDIM);
FArrayBox lcc_slopes(cslope_bx,ncomp*BL_SPACEDIM);
FArrayBox slope_factors(cslope_bx,BL_SPACEDIM);
FArrayBox cmax(cslope_bx,ncomp);
FArrayBox cmin(cslope_bx,ncomp);
FArrayBox alpha(cslope_bx,ncomp);
Real* fdat = fine.dataPtr(fine_comp);
const Real* cdat = crse.dataPtr(crse_comp);
Real* ucc_xsldat = ucc_slopes.dataPtr(0);
Real* lcc_xsldat = lcc_slopes.dataPtr(0);
Real* xslfac_dat = slope_factors.dataPtr(0);
#if (BL_SPACEDIM>=2)
Real* ucc_ysldat = ucc_slopes.dataPtr(ncomp);
Real* lcc_ysldat = lcc_slopes.dataPtr(ncomp);
Real* yslfac_dat = slope_factors.dataPtr(1);
#endif
#if (BL_SPACEDIM==3)
Real* ucc_zsldat = ucc_slopes.dataPtr(2*ncomp);
Real* lcc_zsldat = lcc_slopes.dataPtr(2*ncomp);
Real* zslfac_dat = slope_factors.dataPtr(2);
#endif
const int* flo = fine.loVect();
const int* fhi = fine.hiVect();
const int* clo = crse.loVect();
const int* chi = crse.hiVect();
const int* fblo = target_fine_region.loVect();
const int* fbhi = target_fine_region.hiVect();
const int* csbhi = cslope_bx.hiVect();
const int* csblo = cslope_bx.loVect();
int lin_limit = (do_linear_limiting ? 1 : 0);
const int* cvcblo = crse_bx.loVect();
const int* fvcblo = fine_version_of_cslope_bx.loVect();
int slope_flag = 1;
int cvcbhi[BL_SPACEDIM];
int fvcbhi[BL_SPACEDIM];
for (dir=0; dir<BL_SPACEDIM; dir++)
{
cvcbhi[dir] = cvcblo[dir] + cvc[dir].size() - 1;
fvcbhi[dir] = fvcblo[dir] + fvc[dir].size() - 1;
}
D_TERM(Real* voffx = new Real[fvc[0].size()]; ,
void ClingyPath::CalcMinMaxDY (size_t segIdx, float width, iMeshWrapper* thisMesh,
float& maxRaiseY, float& maxLowerY)
{
csPath path (1);
GeneratePath (path);
float startTime, endTime;
GetSegmentTime (path, segIdx, startTime, endTime);
maxRaiseY = -1.0f;
maxLowerY = -1.0f;
float dist = sqrt (csSquaredDist::PointPoint (points[segIdx].pos, points[segIdx+1].pos));
int steps = int (dist / PATH_STEP);
if (steps <= 1) return; // Segment is too small. Don't do anything.
float timeStep = (endTime-startTime) / float (steps);
if (timeStep < 0.0001) return; // Segment is too small. Don't do anything.
# if VERBOSE
printf (" CalcMinMaxDY: segIdx=%d dist=%g steps=%d time:%g/%g timeStep=%g\n",
segIdx, dist, steps, startTime, endTime, timeStep);
Dump (10);
# endif
for (float t = startTime ; t <= endTime ; t += timeStep)
{
path.CalculateAtTime (t);
csVector3 pos, front, up;
path.GetInterpolatedPosition (pos);
path.GetInterpolatedForward (front);
path.GetInterpolatedUp (up);
csVector3 right = (width / 2.0) * (front % up);
csVector3 rightPos = pos + right;
csVector3 leftPos = pos - right;
float dyL, dy, dyR;
bool hL = HeightDiff (leftPos, thisMesh, dyL);
bool h = HeightDiff (pos, thisMesh, dy);
bool hR = HeightDiff (rightPos, thisMesh, dyR);
if ((hL && dyL > LOOSE_TOP_MARGIN) || (hR && dyR > LOOSE_TOP_MARGIN))
{
float lowerY = cmax (hL, dyL-LOOSE_TOP_MARGIN, hR, dyR-LOOSE_TOP_MARGIN);
if (lowerY > 0.0f)
{
if (hL && dyL-lowerY < LOOSE_BOTTOM_MARGIN)
lowerY = dyL - LOOSE_BOTTOM_MARGIN;
if (hR && dyR-lowerY < LOOSE_BOTTOM_MARGIN)
lowerY = dyR - LOOSE_BOTTOM_MARGIN;
if (h && dy-lowerY < LOOSE_BOTTOM_MARGIN)
lowerY = dy - LOOSE_BOTTOM_MARGIN;
}
if (lowerY > maxLowerY) maxLowerY = lowerY;
# if VERBOSE
printf (" CalcMinMaxDY %g, dy=%g/%g/%g, lowerY=%g\n",
t, dyL, dy, dyR, lowerY);
fflush (stdout);
# endif
}
if ((hL && dyL < LOOSE_BOTTOM_MARGIN) || (h && dy < LOOSE_BOTTOM_MARGIN) || (hR && dyR < LOOSE_BOTTOM_MARGIN))
{
// Some part of this point gets (almost) under the terrain. Need to raise
// everything.
float raiseY = cmax (hL, LOOSE_BOTTOM_MARGIN-dyL, hR, LOOSE_BOTTOM_MARGIN-dyR);
raiseY = cmax (true, raiseY, h, LOOSE_BOTTOM_MARGIN-dy);
if (raiseY > maxRaiseY) maxRaiseY = raiseY;
# if VERBOSE
printf (" CalcMinMaxDY %g, dy=%g/%g/%g, raiseY=%g\n",
t, dyL, dy, dyR, raiseY);
fflush (stdout);
# endif
}
else
{
# if VERBOSE
printf (" CalcMinMaxDY %g, dy=%g/%g/%g\n",
t, dyL, dy, dyR);
fflush (stdout);
# endif
}
}
}
int suml(int arr[],int len){
int i,sum = 0;
for (i = 0;i < len ; i++ ) if(cmax(i,arr,len)) sum += arr[i];
return sum;
}
