phy2.c

/*
 * Copyright (c) 2008 Regents of the SIGNET lab, University of Padova.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University of Padova (SIGNET lab) nor the 
 *    names of its contributors may be used to endorse or promote products 
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

//
// ANEMURAS
//
// file: phy2.c 
//

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "../main/anemuras.h"
#include "../main/event.h"
#include "../main/packet.h"
#include "../main/fileio.h"
#include "../channel1/channel1.h"

//#define debug 1
//#define control 1

// UMTS slot time (sec.)
#define UMTS_SLOT_TIME 0.000666
// time in second of Round Trip Time
#define UMTS_RTT_VALUE 0.21
// Handover threshold (dB)
#define HANDOVER_TH_DB 1.2
// Accept Power Threshold (max rx power accepted at a BS) [linear scale]
// now used only  for congestion estimate
#define ACCEPT_POW_TH 10e-3
// number of BS active for each user
//#define BS_ACTIVE_NUM 3       //(ATT: also defined in umts.c)
// user handover is updated every N_UPDATE_HANDOVER
#define N_UPDATE_HANDOVER 150
// spreading factor init value
#define SF_INIT_VALUE 16
// max power in uplink (dBW)
#define POWER_MAX_UP -16
// min power in uplink (dBW)
#define POWER_MIN_UP -96
// max power in downlink (dBW)
#define POWER_MAX_DOWN -5
// power control step (dB)
#define DELTA 0.5
// power control delay (n° of slots, =1 ideal, >1 not ideal)
#define POWER_CONTROL_DELAY 1
// SIR target for all user (dB)
#define SIR_TARGET_DB 4.5
// margine temporale per cui il calcolo dellle potenze ricevute resta valido
#define RX_POW_VALID_TIME 1e-6
// paramter to compute Pe from SIR (see article)
#define ZETA 2.72

extern time clock;
extern ANnode *globalPtr;
extern char  OUT_FILE[STRING_MAX_LENGTH];
extern const ANid NODES_NUM;
extern const ANid AP_NODES_MAC1_NUM;
extern const ANid AP_NODES_MAC2_NUM;
extern const ANid AP_NODES_NUM;

extern flag Mac2Available(ANid id);


ANid AP_MAC2_TOT_NUM;                           // total n° of MAC2 AP (MAC2 + MAC12)
unsigned int BS_ACTIVE_NUM;                     // n° of BS active for each node (for soft- handover)

typedef struct ANidList{
        ANid id;
        struct ANidList *toNextPtr;
}ANidList;
ANidList *nodesWantSync;        // list of nodes that want sync in the next slot
ANid *BSlist;                           // list of basestation
double po0 = 49.0/225.0;                // ratio of used power when node is idle
double f0 = 1;                          // ortogonality factor
double No = 1e-32;              // thermal noise (-328 dB)


// define the accurancy in symbol test, i.e. the number of symbols every which
// have to made a test
unsigned int PHY2_SYMBOL_TEST;          // 1 is default (heuristic, every single symbol)


typedef enum{
        TX,
        RX,
        IDLE
} PBState;

typedef enum{
// substate of TX
        WAIT_SYNC,
// substate of RX
// substate of IDLE
        PB_IDLE,
} PBSubState;

typedef struct{
        unsigned long int txNo;                         // total number of pkt tx
        unsigned long int txBits;                               // total number of bits tx
} PBStats;

typedef struct{
        unsigned long int rxNo;                         // total number of pkt rx
        unsigned long int rxBits;                       // total number of bits rx
}BSStats;

typedef struct{
        flag isInCell;
        flag pktInFlyNow;
        ANpacket* pktInFly;
        ANsize currentBlockSize;
        time endRxPkt;                                  // time that BS finish to receive pkt
        ANsize bitCount;
        int fadingErrorNum;
        flag contextTransferDuringRx;
        ANtx_power rxPowLin;                    // instant rx power in linear scale (mW)
        ANtx_power SIR;                         // linear
        ANposition distance;
        time propDelay;
}PBArrayEl;

typedef struct{
        PBArrayEl *PBarray;
        time lastRxPowUpdate;                   // time of the last calculation of rx power of BS from node
        BSStats stats;
}BSStruct;

typedef struct{
        ANpacket *TxPkt;
        ANid *BSlist;
        unsigned int sf;                        // current spreading factor
        ANtx_power *BSgain;     // [dB]
        PBState state;
        PBSubState subState;
        PBStats stats;
        ANtx_power txPower;             // current tx power (dB)
}PBStruct;


// FUNCTION     Phy2NextBlockSymbolTest
// PURPOSE      calculate next block test symbol event and the size of the next block
//                              if the last must be smaller
time Phy2NextBlockSymbolTest(ANid id,ANpacket *pkt){
        BSStruct *BSptr;
        double nextTest;
                
        BSptr = (BSStruct *)NODEPTR(id)->Phy2StructPtr;
        if ((BSptr->PBarray[pkt->txId].bitCount + PHY2_SYMBOL_TEST) > pkt->size){
                // there isn't enough symbol to create a normal block -> reduced block size
                BSptr->PBarray[pkt->txId].currentBlockSize = 
                                pkt->size - BSptr->PBarray[pkt->txId].bitCount;
                nextTest = BSptr->PBarray[pkt->txId].endRxPkt;
        }else
                nextTest = clock + (PHY2_SYMBOL_TEST * (1/pkt->txRate));

        return(nextTest);       
}


// FUNCTION     Phy2UpdatePostMobility
// PURPOSE      update after a mobility event the structures that maintain the ralation between
//                      all nodes to BS indicate(distance, paropagation delay)
void Phy2UpdatePostMobility(ANid id){
ANid i;
BSStruct *BSptr;
ANid *BStemp;

        if (NODEPTR(id)->node_type==PAN_BAN){
                BStemp = BSlist;
                // update all the data relative to node id in all the BS
                for(i=0; i<AP_MAC2_TOT_NUM; i++){
                        BSptr = (BSStruct *)NODEPTR(BStemp[i])->Phy2StructPtr;
                        BSptr->PBarray[id].distance = Distance(BStemp[i],id);
                        BSptr->PBarray[id].propDelay = Channel1PropDelay(BStemp[i],id);
                }
                BStemp = BSlist;
                /* DEBUG OUTPUT
                printf("UMTS Post Mobility Update:\n");
                for(i=0; i<AP_MAC2_TOT_NUM; i++){
                        BSptr = (BSStruct *)NODEPTR(BStemp[i])->Phy2StructPtr;
                        printf("Node %d to AP %d: distance %3.3f propDelay %e\n",id,BStemp[i],BSptr->PBarray[id].distance,
                                        BSptr->PBarray[id].propDelay);
                }
                */ // END DEBUG OUTPUT
        }
}


// FUNCTION     sf2datarate
// PURPOSE      returns the physical channel datarate [bps] from the spreading factor value
double sf2datarate(unsigned int sf, linkType link)
{
        if (link==DOWNLINK) {
                switch (sf)
                {
                        case 4:         return(1966080);        // [1920 Kbps]
                        case 8: return(983040); // [960 Kbps]
                        case 16:        return(491520); // [480 Kbps]
                        case 32:        return(245760); // [240 Kbps]
                        case 64:        return(122880); // [120 Kbps]
                        case 128:       return(61440);          // [60 Kbps]
                        case 256:       return(30720);  // [30 Kbps]
                        case 512:       return(15360);  // [15 Kbps]
                }
        } else {                // UPLINK
                switch (sf)
                {
                        case 4:         return(983040); // [960 Kbps]
                        case 8: return(491520); // [480 Kbps]
                        case 16:        return(245760); // [240 Kbps]
                        case 32:        return(122880); // [120 Kbps]
                        case 64:        return(61440);          // [60 Kbps]
                        case 128:       return(30720);  // [30 Kbps]
                        case 256:       return(15360);  // [15 Kbps]
                }
        }
}



// FUNCTION     Phy2RxPowUpdateUP
// PURPOSE      calculate the rx power (linear) of BS from all nodes (0 stand for all the BS)
void Phy2RxPowUpdateUP(ANid BS){
BSStruct *BSptr;
PBStruct *PBptr;
int i;

        if (BS==0){
                // update for all the BS
                for(i=0;i<AP_MAC2_TOT_NUM; i++){
                        BSptr = (BSStruct *)NODEPTR(BSlist[i])->Phy2StructPtr;
                        if (BSptr->lastRxPowUpdate+RX_POW_VALID_TIME < clock){
                                Phy2RxPowUpdateUP(BSlist[i]);
                        }
                }
        }else{
#ifdef control
                if ((Mac2Avaiable(BS)==FALSE) && (NODEPTR(BS)->node_type!=ACCESS_PROVIDER)){
                        puts("Error Phy2RxPowUpdate, uncorrect BS");
                        exit(1);
                }
#endif
                // il controllo sulla validità del calcolo delle potenze ricevute per la singola BS si suppone venga fatto a 
                // monte, così da evitare ridondanti chiamate a funzioni.
                BSptr = (BSStruct *)NODEPTR(BS)->Phy2StructPtr;
                for(i=1; i<=NODES_NUM;i++){
                        if ((Mac2Available(i)==TRUE)&& (NODEPTR(i)->node_type==PAN_BAN)){
                                PBptr = (PBStruct *)NODEPTR(i)->Phy2StructPtr;
                                BSptr->PBarray[i].rxPowLin = FromDbToLinear(Channel1RxPower(i,BS,PBptr->txPower));
                                //printf("Nodo %d txpower%f, rxpower(dB)%f rxpower (liN)%e\n",i,PBptr->txPower,
                                //      Channel1RxPower(i,BS,PBptr->txPower),BSptr->PBarray[i].rxPowLin);
                        }
                }
                BSptr->lastRxPowUpdate = clock;
        }
}


// FUNCTION     Phy2ComputeSIR
// PURPOSE      calculate the current value of SIR in BS for the PB node, if necessary recalculate the rx pow
ANtx_power Phy2ComputeSIR(ANid BS, ANid PB){
BSStruct *BSptr;
PBStruct *PBptr;
int i;
ANtx_power util, interIntra, interExtra,rxPow,SIR;

#ifdef control
        if ( (Mac2Available(BS)==FALSE) && (NODEPTR(BS)->node_type!=ACCESS_PROVIDER)){
                puts("Error Phy2RxPowUpdate, uncorrect BS");
                exit(1);
        }
        if ((Mac2Available==FALSE) && (NODEPTR(PB)->node_type!=PAN_BAN)){
                puts("Error Phy2RxPowUpdate, uncorrect PB");
                exit(1);
        }
#endif
        BSptr = (BSStruct *)NODEPTR(BS)->Phy2StructPtr;
        PBptr = (PBStruct *)NODEPTR(PB)->Phy2StructPtr;
        // verify if necessary recalculate rx power
        if (BSptr->lastRxPowUpdate+RX_POW_VALID_TIME < clock)
                Phy2RxPowUpdateUP(BS);
        // useful power utile (used only for data)
        util = BSptr->PBarray[PB].rxPowLin * (1./(1.+po0));
        interIntra = 0.0;
        interExtra = 0.0;
        for (i=1;i<NODES_NUM;i++){
                if ((Mac2Available(i)==TRUE) && (NODEPTR(i)->node_type==PAN_BAN) && (i!=PB) ){
                        rxPow = BSptr->PBarray[i].rxPowLin;
                        if (BSptr->PBarray[i].pktInFlyNow==FALSE)
                                // node is idle -> only a ratio of tx power is used
                                rxPow *= (po0/(1.+po0));
                        if (BSptr->PBarray[i].isInCell==TRUE)
                                // intra-cell interference
                                interIntra += rxPow;
                        else
                                // extra-cell interference
                                interExtra += rxPow;
                }
        }
        SIR = (PBptr->sf * util) / (f0*interIntra + interExtra + No);
        //printf("Calcolato BS%d PB %d SIR %2.2f util%e interIntra%e interExtra%e SF %d\n",
        //      BS, PB, SIR,util,interIntra,interExtra,PBptr->sf);
        return(SIR);
}


// FUNCTION     Phy2GetUmtsSync
// PURPOSE      set level structure that the node indicate want receive the sync at the begin of next slot
void Phy2GetUmtsSync(ANid id){
ANidList *ptr;
ANidList *temp;

        ptr = nodesWantSync;
        // insert in tail
        if (nodesWantSync==NULL){
                // empty queue -> first element
                ptr = (ANidList *)malloc(sizeof(ANidList));
                if (ptr==NULL){
                        puts("Error Phy2GetUmtsSync, ptr malloc error");
                        exit(1);
                }
                ptr->id = id;
                ptr->toNextPtr = NULL;
                nodesWantSync = ptr;
        }else {
                // go to the tail and than insert
                while(ptr->toNextPtr!=NULL) ptr = ptr->toNextPtr;
                temp = (ANidList *)malloc(sizeof(ANidList));
                if (temp==NULL){
                        puts("Error Phy2GetUmtsSync, temp malloc error");
                        exit(1);
                }
                temp->id = id;
                temp->toNextPtr = NULL;
                ptr->toNextPtr = temp;
        }
        return;
}


// FUNCTION     Phy2Synchronization
// PURPOSE      tell sync to nodes who want
void Phy2Synchronization(ANid id){
ANidList *ptr;
ANidList *last;
int counter=0;

        ptr = nodesWantSync;
        while(ptr!=NULL){
                EventNew(ptr->id, PHY2, UMTS_SLOT_BEGIN, clock, (void *)NULL);
                last = ptr;
                ptr = ptr->toNextPtr;
                free(last);
        }
        nodesWantSync = NULL;
        EventNew(id, PHY2, UMTS_SYNC,clock + UMTS_SLOT_TIME, (void *) NULL);
}


void PrintfList(ANid *BSlist, ANtx_power *gainlist){
int i;

        for(i=0; i<AP_MAC2_TOT_NUM;i++)
                printf("( %d, %2.1f)", BSlist[i],gainlist[i]);
        printf("\n");
}

// FUNCTION     Phy2UpdateBS
// PURPOSE      find service BSs set of all user and tell to do contest transfer if necessary
void Phy2HandoverUpdate(ANid id){
PBStruct *PBptr;
ANid *BStemp;
BSStruct *BSptr;
ANid idtemp;
ANtx_power gaintemp;
ANtx_power *BSgainTemp;
double *vectValue;
int i,j,k,dum,counter;
HandoverStruct *HSptr;


        /* DEBUG OUTPUT (BS active nodes set)
        for(j=0;j<AP_MAC2_TOT_NUM;j++){
                BSptr = (BSStruct *)NODEPTR(BSlist[j])->Phy2StructPtr;
                printf("AP %d active set: ",BSlist[j]);
                for(k=1;k<=NODES_NUM;k++)
                        if(BSptr->PBarray[k].isInCell==TRUE) printf(" %d",k);
                printf("\n");
        }*/
        for(i=1; i<=NODES_NUM; i++){
                PBptr = (PBStruct *)NODEPTR(i)->Phy2StructPtr;
                if ((Mac2Available(i)==TRUE) && (NODEPTR(i)->node_type==PAN_BAN)){
                        vectValue = (double *)malloc(sizeof(double)*AP_MAC2_TOT_NUM);
                        if (vectValue==NULL){
                                puts("Error Phy2UpdateBS, vaectValue malloc error");
                                exit(1);
                        }
                        for(j=0; j<AP_MAC2_TOT_NUM; j++)
                                vectValue[j] = Phy2ComputeSIR(BSlist[j],i);
                        //printf("Nodo %d Generata lista: ",i);
                        //PrintfList(BSlist, vectValue);
                        if (PBptr->BSlist==NULL){
                                // init procedure -> only copy, not context transfer
                                // ordinate gain vector
                                for(j=0; j<AP_MAC2_TOT_NUM -1; j++)
                                        for(k=j; k<AP_MAC2_TOT_NUM; k++)
                                                if (vectValue[j]<vectValue[k]){
                                                        gaintemp = vectValue[k];
                                                        idtemp = BSlist[k];
                                                        vectValue[k] = vectValue[j];
                                                        BSlist[k] = BSlist[j];
                                                        vectValue[j] = gaintemp;
                                                        BSlist[j] = idtemp;
                                                }
                                //printf("Prima volta, ordinata: ");
                                //PrintfList(BSlist,vectValue);
                                BStemp = (ANid *)malloc(sizeof(ANid)*AP_MAC2_TOT_NUM);
                                BSgainTemp = (ANtx_power *)malloc(sizeof(ANtx_power)*AP_MAC2_TOT_NUM);
                                if ((BStemp==NULL)||(BSgainTemp==NULL)){
                                        puts("Error Phy2UpdateBs, BStemp BSgainTemp malloc error");
                                        exit(1);
                                }
                                for(j=0; j<AP_MAC2_TOT_NUM; j++){
                                        BStemp[j] = BSlist[j];
                                        BSgainTemp[j] = vectValue[j];
                                }
                                PBptr->BSlist = BStemp;
                                PBptr->BSgain = BSgainTemp;
                                //printf("Nodo %d save BS list:",i);
                                //PrintfList(PBptr->BSlist, PBptr->BSgain);
                                // Update BS structure with node BS active set
                                for(j=0;j<BS_ACTIVE_NUM;j++){
                                        BSptr = (BSStruct *)NODEPTR(PBptr->BSlist[j])->Phy2StructPtr;
                                        BSptr->PBarray[i].isInCell = TRUE;
                                }
                        }else{
                                // update BS list
                                BStemp = (ANid *)malloc(sizeof(ANid)*AP_MAC2_TOT_NUM);
                                if ((BStemp==NULL)||(BSgainTemp==NULL)){
                                        puts("Error Phy2UpdateBs, BStemp BSgainTemp malloc error");
                                        exit(1);
                                }
                                //printf("Nodo %d old BS list:",i);
                                //PrintfList(PBptr->BSlist, PBptr->BSgain);
                                //printf("Nodo %d new BS list:",i);
                                //PrintfList(BSlist, vectValue);
                                for(j=0;j<AP_MAC2_TOT_NUM;j++){
                                        dum = 0;
                                        for(k=0;k<AP_MAC2_TOT_NUM;k++)
                                                if ((PBptr->BSlist[k]==BSlist[j])&&(k<BS_ACTIVE_NUM)) {
                                                        dum=1;
                                                        break;
                                                }
                                        if (dum)
                                                // this bs was previously in the bs active set -> add hysteresys threshold to gain
                                                vectValue[j] = vectValue[j] + HANDOVER_TH_DB;
                                }
                                // ordinare il vettore dei guadagni
                                for(j=0; j<AP_MAC2_TOT_NUM -1; j++)
                                        for(k=j; k<AP_MAC2_TOT_NUM; k++)
                                                if (vectValue[j]<vectValue[k]){
                                                        gaintemp = vectValue[k];
                                                        idtemp = BSlist[k];
                                                        vectValue[k] = vectValue[j];
                                                        BSlist[k] = BSlist[j];
                                                        vectValue[j] = gaintemp;
                                                        BSlist[j] = idtemp;
                                                }
                                // verificare se necessario context transfert
                                //printf("Nodo %d new BS list:",i);
                                //PrintfList(BSlist, vectValue);
                                counter = 0;
                                for(j=0; j<BS_ACTIVE_NUM; j++){
                                        dum = 0;
                                        for(k=0; k<BS_ACTIVE_NUM;k++)
                                                if (PBptr->BSlist[j]==BSlist[k]){
                                                        dum = 1;
                                                        break;
                                                }
                                        if (!dum){
                                                // memorizzo le BS uscite dall'active set
                                                BStemp[counter] = PBptr->BSlist[j];
                                                counter++;
                                        }
                                }
                                while(counter>0){
                                        for(j=0; j<BS_ACTIVE_NUM; j++){
                                                dum = 0;
                                                for(k=0; k<BS_ACTIVE_NUM;k++)
                                                        if(BSlist[j]==PBptr->BSlist[k]){
                                                                dum = 1;
                                                                break;
                                                        }
                                                if (!dum){
                                                        //context transfer fra BStemp[counter-1] e BSlist[j]
                                                        HSptr = (HandoverStruct *)malloc(sizeof(HandoverStruct));
                                                        HSptr->oldBS = BStemp[counter-1];
                                                        HSptr->newBS = BSlist[j];
                                                        HSptr->node = i;
                                                        EventNew(BSlist[j], MAC2L, CONTEXT_TRANSFER, clock, (void *)HSptr);
                                                        //Phy2ContextTransfer(BStemp[counter - 1], BSlist[j], i);
#ifdef debug
                                                        printf("Context Transfer nodo %d from AP %d to AP %d\n",i,
                                                                BStemp[counter-1],BSlist[j]);
#endif
                                                        // update Bs table after context transfer
                                                        BSptr = (BSStruct *)NODEPTR(BStemp[counter - 1])->Phy2StructPtr;
                                                        BSptr->PBarray[i].isInCell = FALSE;
                                                        BSptr = (BSStruct *)NODEPTR(BSlist[j])->Phy2StructPtr;
                                                        BSptr->PBarray[i].isInCell = TRUE;
                                                        counter--;
                                                }
                                        }
                                }//end while BS to context transfer
                                free(BStemp);
                                // save into node structure new BS list
                                for(j=0; j<AP_MAC2_TOT_NUM; j++)
                                        PBptr->BSlist[j] = BSlist[j];
                        }// end if PBptr->BSlist==NULL (init or not)
                }// end if node is mac2
        }// end for
        // generate next update handover event
        EventNew(id, PHY2, HANDOVER_UPDATE, clock + ((double)(N_UPDATE_HANDOVER*UMTS_SLOT_TIME)), 
                        (void *)NULL);
        /*
        // DEBUG OUTPUT (BS active nodes set)
        for(j=0;j<AP_MAC2_TOT_NUM;j++){
                BSptr = (BSStruct *)NODEPTR(BSlist[j])->Phy2StructPtr;
                printf("AP %d active set: ",BSlist[j]);
                for(k=1;k<=NODES_NUM;k++)
                        if(BSptr->PBarray[k].isInCell==TRUE) printf(" %d",k);
                printf("\n");
        }*/
        return;
}

// FUNCTION     Phy2Init
// PURPOSE      initialize level paramters and structures
void Phy2Init(){
ANid i,j,k;
BSStruct *BSptr;
PBStruct *PBptr;
PBArrayEl *array;
ANid *AParray;
int counter;

        // Read paramters
        if(ReadUInt("BS_ACTIVE_NUM",&(BS_ACTIVE_NUM))==FALSE) {
                puts("UMTS_MacInit: BS_ACTIVE_NUM not defined in configuration file");
                exit(1);
        }
        AP_MAC2_TOT_NUM = AP_NODES_NUM - AP_NODES_MAC1_NUM;
        if (BS_ACTIVE_NUM>AP_MAC2_TOT_NUM){
                puts("Error Phy2Init, BS_ACTIVE_NUM>AP_MAC2_TOT_NUM");
                exit(1);
        }
        if ((AP_MAC2_TOT_NUM>0)&&(BS_ACTIVE_NUM<=0)){
                puts("Error Phy2Init, there's mac2 node but any BS");
                exit(1);
        }
        if(ReadUInt("PHY2_SYMBOL_TEST",&(PHY2_SYMBOL_TEST))==FALSE)
                PHY2_SYMBOL_TEST = 1;   // default value (heuristic, every single symbol)
        if (PHY2_SYMBOL_TEST < 1){
                puts("Error Phy2Init, PHY2_SYMBOL_TEST must be an integer equal or greater than 1");
                exit(1);
        }
        printf("PHY2_SYMBOL_TEST = %d\n",PHY2_SYMBOL_TEST);     
        nodesWantSync = NULL;
        // create an array that contain the id of Access Provider
        AParray = (ANid *)malloc(sizeof(ANid)*AP_MAC2_TOT_NUM);
        if (AParray==NULL){
                puts("Error Phy2Init, AParray malloc error");
                exit(1);
        }
        counter = 0;
        i = 1;
        while ((counter<AP_MAC2_TOT_NUM)&&(i<=NODES_NUM)){
                if ((NODEPTR(i)->node_type==ACCESS_PROVIDER) && (Mac2Available(i)==TRUE) ){
                        AParray[counter] = i;
                        counter ++;
                }
                i++;
        }
        if (counter!=AP_MAC2_TOT_NUM){
                puts("Error Phy2Init, doesn't find all the mac2 Access Provider");
                exit(1);
        }
        BSlist = AParray;
#ifdef debug
        printf("Generata lista AP:");
        for(i=0; i<AP_MAC2_TOT_NUM; i++)
                printf(" %d",BSlist[i]);
        printf("\n");
#endif
        // initialize phy2 level structurtes for all nodes
        for(i=1; i<=NODES_NUM; i++){
                if (Mac2Available(i)==TRUE){
                        switch(NODEPTR(i)->node_type){
                        case PAN_BAN:
                                PBptr = (PBStruct *)malloc(sizeof(PBStruct));
                                if (PBptr==NULL){
                                        puts("Error Phy2Init, PBptr malloc error");
                                        exit(1);
                                }
                                PBptr->TxPkt = NULL;
                                PBptr->state = IDLE;
                                PBptr->subState = PB_IDLE;
                                PBptr->BSlist = NULL;
                                PBptr->BSgain = NULL;
                                PBptr->txPower = POWER_MAX_UP;          // begin with max value
                                PBptr->sf = SF_INIT_VALUE;
                                PBptr->stats.txNo = 0;
                                PBptr->stats.txBits = 0;
                                NODEPTR(i)->Phy2StructPtr = (void *)PBptr;
                                break;
                        case ACCESS_PROVIDER:
                                BSptr = (BSStruct *)malloc(sizeof(BSStruct));
                                if (BSptr==NULL){
                                        puts("Error Phy2Init, BSptr malloc error");
                                        exit(1);
                                }
                                // ne alloco uno in più per semplificare la gestione dell'array, visto che la numerazione
                                // dei nodi va da 1 a NODES_NUM, la mantengo e lascio il primo elemento del vettore "vuoto"
                                array = (PBArrayEl *)malloc(sizeof(PBArrayEl)*(NODES_NUM+1));
                                if (array==NULL){
                                        puts("Phy2Init: array malloc error");
                                        exit(1);
                                }
                                for(j=1; j<=NODES_NUM;j++){
                                        array[j].isInCell = FALSE;
                                        array[j].pktInFlyNow = FALSE;
                                        array[j].pktInFly = NULL;
                                        array[j].bitCount = 0;
                                        array[j].currentBlockSize = PHY2_SYMBOL_TEST;
                                        array[j].endRxPkt = 0.0;
                                        array[j].rxPowLin = 0.0;
                                        array[j].contextTransferDuringRx = FALSE;
                                        array[j].SIR = 0.0;
                                        array[j].distance = Distance(i,j);
                                        array[j].propDelay = Channel1PropDelay(i,j);
                                }
                                BSptr->PBarray = array;
                                // init to -1 value for forcing function "Phy2RxPowUpdateUP" in the
                                // first calling (after in this function)
                                BSptr->lastRxPowUpdate = -1.0;
                                BSptr->stats.rxNo = 0;
                                BSptr->stats.rxBits = 0;
                                NODEPTR(i)->Phy2StructPtr = (void *)BSptr;
                                break;
                        default:
                                puts("Error Phy2Init, node type not recognized");
                                exit(1);
                        }
                        
                }
        }
        /*
        // DEBUG OUTPUT
        for(i=1; i<=NODES_NUM; i++){
                if (NODEPTR(i)->Phy2StructPtr!=NULL){
                        printf("Nodo %d è mac2",i);
                        switch (NODEPTR(i)->node_type){
                        case PAN_BAN:
                                printf(" PAN BAN\n");
                                break;
                        case ACCESS_PROVIDER:
                                printf("ACCESS_PROVIDER\n");
                                BSptr = (BSStruct *)NODEPTR(i)->Phy2StructPtr;
                                for(j=1; j<=NODES_NUM; j++){
                                        printf("Dest %d, distanza %f, propDelay %e, rxpowerlin %e ",j,
                                                BSptr->PBarray[j].distance,
                                                BSptr->PBarray[j].propDelay, BSptr->PBarray[j].rxPowLin);
                                        if (BSptr->PBarray[j].isInCell==TRUE) printf("IN_CELL\n");
                                        else printf("NOT_IN_CELL\n");
                                }
                                break;
                        }
                }else printf("Nodo %d non è mac2\n",i);
        }
        // END DEBUG OUTPUT
        */
        // ATTENZIONE!!!
        // per effettuare l'operazione  UpdateInterNodesRelationship è necessario che 
        // il livello CHANNEL1 sia già stato inizializzato
        //Phy2UpdateInterNodesRelationship(0);
        // generate synchronization periodic event
        // eleggo una basestation come generatrice dei sync per tutti (comprese le altre bs),
        // come manager dell'handover e del power control
        if (AP_MAC2_TOT_NUM>0){
#ifdef debug
                printf("SYNC generato da AP %d\n",AParray[0]);
#endif
                EventNew(AParray[0], PHY2, UMTS_SYNC,clock + UMTS_SLOT_TIME, (void *) NULL);
                EventNew(AParray[0], PHY2, HANDOVER_UPDATE, clock, (void *)NULL);
                EventNew(AParray[0], PHY2, POWER_CONTROL, clock + 
                        ((double)(POWER_CONTROL_DELAY*UMTS_SLOT_TIME)), (void *)NULL);
        }
        return;
}


// FUNCTION     Phy2PowerControl
// PURPOSE      manage the power control algorithm for all the user
void Phy2PowerControl(ANid id){
PBStruct *PBptr;
ANid *qptr;
int deltaSum,i,j;
double SIR;
static int count=0;
FILE *fd;
char filename[STRING_MAX_LENGTH];

        Phy2RxPowUpdateUP(0);
#ifdef debug
        count++;
#endif
        /*if (count==150){
                strcpy(filename,OUT_FILE);
                strcat(filename,"SIRtrace.out");
                fd = fopen(filename,"a");
                fprintf(fd,"%.3f\t",clock);
        }*/
        for(i=1;i<=NODES_NUM;i++){
                if ((Mac2Available(i)==TRUE) &&(NODEPTR(i)->node_type==PAN_BAN)){
                        PBptr = (PBStruct *)NODEPTR(i)->Phy2StructPtr;
#ifdef debug
                        if (count==500) printf("POW CONTROL PB %d ",i);
#endif
                        deltaSum = 0;
                        for(j=0;j<BS_ACTIVE_NUM;j++){
                                if ((SIR=Phy2ComputeSIR(PBptr->BSlist[j],i))>SIR_TARGET_DB)
                                        deltaSum--;
                                else deltaSum++;
                                //printf("BS %d SIR %2.2f deltaSum%d ",BSlist[j],SIR,deltaSum);
                        }
                        if (deltaSum>0){
                                if (PBptr->txPower<POWER_MAX_UP) PBptr->txPower += DELTA;
                        }else 
                                if (PBptr->txPower>POWER_MIN_UP) PBptr->txPower -= DELTA;
                        //if (deltaSum>0) printf(" (+)");
                        //else printf(" (-)");
                        //if (count==150) fprintf(fd,"(%4.2f,%4.2f,%3.1f)\t",SIR,Channel1RxPower(i,PBptr->BSlist[0],
                        //      PBptr->txPower),PBptr->txPower);
#ifdef debug
                        if (count==500) printf(" txPow %2.2f\n",PBptr->txPower);
#endif
                }
        }
        /*
        if(count==150){
                fprintf(fd,"\n");
                fclose(fd);
                count = 0;
        }*/
        EventNew(id, PHY2, POWER_CONTROL, clock + 
                        ((double)(POWER_CONTROL_DELAY*UMTS_SLOT_TIME)), (void *)NULL);
#ifdef debug
        if (count==500) count=0;
#endif
}

// FUNCTION     Phy2UmtsSlotBegin
// PURPOSE      begin the tx of pkt
void Phy2UmtsSlotBegin(ANid id){
PBStruct *temp;
ANid *AParray;
ANpacket *pktDup;
BSStruct *BSptr;
double endTx;
int i;

        temp = (PBStruct *)NODEPTR(id)->Phy2StructPtr;
#ifdef control
        if ((temp->state!=TX)||(temp->subState!=WAIT_SYNC)){
                puts("Error Phy2UmtsSlotBegin, uncorrect state");
                exit(1);
        }
#endif
        // send pkt to all bs
#ifdef debug
                printf("2- Node %d in sending umts pkt %d to all AP time %.10f\n",id, temp->TxPkt->UMTSpktId, clock);
#endif
        for(i=0; i<AP_MAC2_TOT_NUM; i++){
                pktDup = PacketDuplicate(temp->TxPkt);
                pktDup->nextHop = temp->BSlist[i];
                BSptr = (BSStruct *)NODEPTR(BSlist[i])->Phy2StructPtr;
                EventNew(temp->BSlist[i], PHY2, BS_RX_UMTS_PKT, clock + 
                                BSptr->PBarray[pktDup->txId].propDelay,(void *)pktDup);
        }
        endTx = ((double)(pktDup->size))/pktDup->txRate;
        EventNew(id, MAC2L, PACKET_TXED, clock + endTx, (void *)NULL);
        PacketFree(temp->TxPkt);
        temp->TxPkt = NULL;
}


// FUNCTION     Phy2PBSendPacket
// PURPOSE      for debug mac 2 level: generate end tx event and randomly nack event
void Phy2PBSendPacket(ANid id){
ANpacket *pktPtr;
PBStruct *temp;

        pktPtr = (ANpacket *)NODEPTR(id)->eventQPtr->extraStructPtr;
        temp = (PBStruct *)NODEPTR(id)->Phy2StructPtr;
        // set level paramters
        temp->state = TX;
        temp->subState = WAIT_SYNC;
        temp->TxPkt = pktPtr;
        // ask for sync
        Phy2GetUmtsSync(id);
        return;
}


// FUNCTION     Phy2SendPacketInfo
// PURPOSE      send pkt info in error free channel (tell to BS that have receive corrupt packet info about these ones)
void Phy2SendPacketInfo(ANid id){
ANpacket *pktPtr;
PBStruct *temp;
ANpacket *pktDup;
int i;

        pktPtr = (ANpacket *)NODEPTR(id)->eventQPtr->extraStructPtr;
        temp = (PBStruct *)NODEPTR(id)->Phy2StructPtr;
        for(i=0; i<BS_ACTIVE_NUM; i++){
                pktDup = PacketDuplicate(pktPtr);
#ifdef debug
                printf("2- Node %d in sending info abuot umts pkt %d to AP %d, time %.10f\n",id, pktDup->UMTSpktId,
                        temp->BSlist[i], clock);
#endif
                pktDup->nextHop = temp->BSlist[i];
                EventNew(temp->BSlist[i], MAC2L, RX_PACKET_INFO, clock ,(void *)pktDup);
        }
        PacketFree(pktPtr);
}

// FUNCTION     Phy2EndRxPacket
// PURPOSE
void Phy2EndRxPacket(ANid id){
BSStruct *BSptr;
ANid *sorgPtr;
ANid sorg;
ANpacket *pktRx;
unsigned long int *pktIdptr;

        sorgPtr = (ANid *)NODEPTR(id)->eventQPtr->extraStructPtr;
        sorg = *sorgPtr;
        free(sorgPtr);
        BSptr = (BSStruct *)NODEPTR(id)->Phy2StructPtr;
        BSptr->PBarray[sorg].pktInFlyNow = FALSE;
        if (BSptr->PBarray[sorg].contextTransferDuringRx==TRUE){
                pktRx = BSptr->PBarray[sorg].pktInFly;
                if (pktRx==NULL)
                        printf("BS %d nothing to discared...\n",id);
                        // condizione che si verifica nel caso in cui il context transfer avvenga un instante prima
                        // della tx, così da trovare già aggiornata la lista delle BS attive
                else {
                        printf("BS %d discared pkt %d.%d,%d for context transfer\n",id,pktRx->sourceId,
                                pktRx->packetId,pktRx->UMTSpktId);
                        PacketFree(BSptr->PBarray[sorg].pktInFly);
                        BSptr->PBarray[sorg].pktInFly = NULL;
                }
                BSptr->PBarray[sorg].contextTransferDuringRx=FALSE;
                return;
        }
        if (BSptr->PBarray[sorg].pktInFly!=NULL){
                // this BS is receiving this pkt
                pktRx = BSptr->PBarray[sorg].pktInFly;
                pktRx->lastTech = MAC2;
                if (pktRx->fadingErrorNum==0){
                        // rx correct
                        if (pktRx->nextHop!=id){
                                // pkt not for this BS
                                printf("BS %d rx pkt not for me from %d pkt (%d.%d)\n",id, pktRx->txId,
                                        pktRx->sourceId,pktRx->packetId);
                                PacketFree(pktRx);
                                return;
                        }
                        if (BSptr->PBarray[sorg].isInCell==FALSE){
                                // rx pkt from a node out of BS cell
                                printf("BS %d rx pkt from other cell from %d pkt (%d.%d)\n",id, pktRx->txId,
                                        pktRx->sourceId,pktRx->packetId);
                                PacketFree(pktRx);
                                return;
                        }
                        // pkt for this BS and from a node in its own cell -> update it
#ifdef debug
                        printf("BS %d rx pkt pkt %d.%d(%d)\n",id, pktRx->sourceId,
                                         pktRx->packetId, pktRx->UMTSpktId);
#endif
                        EventNew(id, MAC2L, RX_UMTS_PACKET, clock, (void *)pktRx);
                }else {
                        // pkt corrupt
                        if ((pktRx->nextHop==id)&&(BSptr->PBarray[sorg].isInCell==TRUE)){
                                // pkt is for this BS ->NACK
                                pktIdptr = (unsigned long int *)malloc(sizeof(unsigned long int));
                                *pktIdptr = pktRx->UMTSpktId;
                                EventNew(pktRx->txId, MAC2L, NACK_ARRIVED, clock + UMTS_RTT_VALUE, (void *)pktIdptr);
#ifdef debug
                                printf("BS %d rx corrupt pkt %d.%d,%d at %.10f\n",id, pktRx->sourceId,
                                        pktRx->packetId, pktRx->UMTSpktId, clock);
#endif
                        }
                        PacketFree(pktRx);
                }
                BSptr->PBarray[sorg].pktInFly = NULL;
        }
        return;
}


// FUNCTION     Phy2TestPktSymbol
// PURPOSE      test current symbol txed from node indicate
void Phy2TestPktSymbol(ANid id){
BSStruct *BSptr;
ANid *sorgPtr;
ANid sorg;
ANtx_power SIR;
ANpacket *pkt;
double random,Pe,PeBlock;
unsigned int error=0;
double endRx,nextTest;
 
        sorgPtr = (ANid *)NODEPTR(id)->eventQPtr->extraStructPtr;
        sorg = *sorgPtr;
        BSptr = (BSStruct *)NODEPTR(id)->Phy2StructPtr;
        BSptr->PBarray[sorg].bitCount += BSptr->PBarray[sorg].currentBlockSize;
        if (BSptr->lastRxPowUpdate+RX_POW_VALID_TIME < clock)
                                Phy2RxPowUpdateUP(id);
        SIR = Phy2ComputeSIR(id,sorg);
        // Pe : single symbol error probability
        Pe = 0.5*erfc(sqrt(pow(SIR,ZETA)));
        random = ((float)rand())/((float)RAND_MAX);
        if (BSptr->PBarray[sorg].pktInFly==NULL){
                printf("Error Phy2TestPktSymbol, doesn't find pkt to test in structure\n");
                exit(1);
        }
        if (BSptr->PBarray[sorg].currentBlockSize==1)
                // single symbol test
                error = (random<Pe?1:0);
        else{
                // block of symbol test
                PeBlock = 1 - pow(1 - Pe,BSptr->PBarray[sorg].currentBlockSize);
                error = (random<PeBlock?1:0);
        }
        if (error==1){
                BSptr->PBarray[sorg].pktInFly->fadingErrorNum++;
                endRx = clock + ( ((double)(BSptr->PBarray[sorg].pktInFly->size - BSptr->PBarray[sorg].bitCount)) * 
                                (1/BSptr->PBarray[sorg].pktInFly->txRate) );
                //pkt = BSptr->PBarray[sorg].pktInFly;
                //printf("Node %d errore in pkt %d.%d,%d on bit %d -> now %.10f fine Rx %.10f\n",id,pkt->sourceId,
                //      pkt->packetId,pkt->UMTSpktId,BSptr->PBarray[sorg].bitCount,clock,endRx);
                EventNew(id, PHY2, END_RX_PACKET, endRx, (void *)sorgPtr);
                return;
        }
        //DEBUG
        /*if (error==1)
                printf("#2-BS %d rx pkt %d.%d,%d da %d, SIR %f Pe%f #bit_error %d\n", 
                        id,BSptr->PBarray[sorg].pktInFly->sourceId, BSptr->PBarray[sorg].pktInFly->packetId,
                        BSptr->PBarray[sorg].pktInFly->UMTSpktId,BSptr->PBarray[sorg].pktInFly->txId,SIR, Pe,
                        BSptr->PBarray[sorg].bitCount);
        */
        if (BSptr->PBarray[sorg].bitCount==BSptr->PBarray[sorg].pktInFly->size){
                // end RX pkt
                EventNew(id, PHY2, END_RX_PACKET, clock, (void *)sorgPtr);
                //printf("BS %d clock %.10f EndRxPkt %.10f, diff %e BitCount %d\n",     id,clock, BSptr->PBarray[sorg].endRxPkt,
                //              clock - BSptr->PBarray[sorg].endRxPkt, BSptr->PBarray[sorg].bitCount);
        }else{  // generate next test pkt symbol event
                if (BSptr->PBarray[sorg].currentBlockSize==1)
                        // single symbol test mode
                        EventNew(id, PHY2, TEST_PKT_SYMBOL, clock + 
                                        (1/BSptr->PBarray[sorg].pktInFly->txRate), (void *)sorgPtr);
                else {
                        nextTest = Phy2NextBlockSymbolTest(id,BSptr->PBarray[sorg].pktInFly);
                        EventNew(id, PHY2, TEST_PKT_SYMBOL, nextTest, (void *)sorgPtr);
                        //printf("BS %d clock %.10f next symbol %d at %.10f\n",id,clock,BSptr->PBarray[sorg].bitCount,
                        //      clock + (1/BSptr->PBarray[sorg].pktInFly->txRate));
                }
        }
}


// FUNCTION     Phy2BSRxUmtsPkt
// PURPOSE      begin rx session of BS
void Phy2BSRxUmtsPkt(ANid id){
BSStruct *BSptr;
ANpacket *pktptr;
ANid *sorgPtr;
time endRx;
double nextTest;

#ifdef control
        if ((Mac2Available(i)==FALSE) || (NODEPTR(id)->node_type!=ACCESS_PROVIDER)){
                puts("Error Phy2BSRxUmtsPkt, the node isn't a BS");
                exit(1);
        }
#endif
        BSptr = (BSStruct *)NODEPTR(id)->Phy2StructPtr;
        pktptr = (ANpacket *)NODEPTR(id)->eventQPtr->extraStructPtr;
#ifdef control
        if (BSptr->PBarray[pktptr->txId].pktInFlyNow==TRUE){
                puts("Error Phy2BSRxUmtsPkt, BS is receiving two pkt from the same PB");
                exit(1);
        }
#endif
        pktptr->fadingErrorNum = 0;
        if (BSptr->PBarray[pktptr->txId].isInCell==TRUE){
                // the tx node is in BS cell -> have to receive the pkt
                BSptr->PBarray[pktptr->txId].pktInFly = pktptr;
                BSptr->PBarray[pktptr->txId].bitCount = 0;
                BSptr->PBarray[pktptr->txId].currentBlockSize = PHY2_SYMBOL_TEST;
                BSptr->PBarray[pktptr->txId].endRxPkt = clock + ((double)(pktptr->size))/pktptr->txRate;
                // genrate event for testing symbol
                sorgPtr = (ANid *)malloc(sizeof(ANid));
                *sorgPtr = pktptr->txId;
                if (PHY2_SYMBOL_TEST==1)
                        EventNew(id, PHY2, TEST_PKT_SYMBOL, clock + (1.0/pktptr->txRate),
                                                (void *)sorgPtr);
                else{
                        nextTest = Phy2NextBlockSymbolTest(id,
                                                                                        BSptr->PBarray[pktptr->txId].pktInFly);
                        EventNew(id, PHY2, TEST_PKT_SYMBOL, nextTest, (void *)sorgPtr);
                }
        }else {
                // generate event of end rx pkt
                endRx = ((double)(pktptr->size))/pktptr->txRate;
                sorgPtr = (ANid *)malloc(sizeof(ANid));
                *sorgPtr = pktptr->txId;
                EventNew(id, PHY2, END_RX_PACKET, clock + endRx, (void *)sorgPtr);
        }
        BSptr->PBarray[pktptr->txId].pktInFlyNow = TRUE;
}

// FUNCTION     Phy2ContextTransfer
// PURPOSE      message from mac level that say this BS is rx pkt during context transfer 
//                      so have to discared the pkt in rx becuase is the old BS
void Phy2ContextTransfer(ANid id){
BSStruct *BSptr;
ANid *nodePtr;
ANid node;

        BSptr = (BSStruct *)NODEPTR(id)->Phy2StructPtr;
        nodePtr = (ANid *)NODEPTR(id)->eventQPtr->extraStructPtr;
        node = *nodePtr;
        free(nodePtr);
        BSptr->PBarray[node].contextTransferDuringRx = TRUE;
}


// FUNCTION     Phy2SendSink
// PURPOSE      send SINK pkt on control channel (error free)
void Phy2SendSink(ANid id){
ANpacket *pktPtr;
BSStruct *temp;
ANpacket *pktDup;
int i;

#ifdef control
        if ((Mac2Available(i)==FALSE) || (NODEPTR(id)->node_type!=ACCESS_PROVIDER)){
                puts("Error Phy2SendSink, the node isn't a BS");
                exit(1);
        }
#endif
        pktPtr = (ANpacket *)NODEPTR(id)->eventQPtr->extraStructPtr;
        pktPtr->txId = id;
        pktPtr->lastTech = MAC2;
        temp = (BSStruct *)NODEPTR(id)->Phy2StructPtr;
        for(i=1; i<=NODES_NUM; i++){
                // BS send sink to all terminal in its cell
                if (temp->PBarray[i].isInCell==TRUE){
                        pktDup = PacketDuplicate(pktPtr);
#ifdef debug
                        printf("2- BS %d in sending SINK pkt %d to PB %d, time %.10f\n",id, pktDup->UMTSpktId,
                                i, clock);
#endif
                        pktDup->nextHop = i;
                        // send into control channel (errror-free) -> directly to ROUTING
                        EventNew(i, ROUTING, NEW_SINK_FOR_ROUTING, clock ,(void *)pktDup);
                }
        }
        PacketFree(pktPtr);
}



// FUNCTION     Phy2EventHandler
// PURPOSE
void Phy2EventHandler(ANid id) {
// id = 0 for internal level event
if (Mac2Available(id)==TRUE){
        switch(NODEPTR(id)->eventQPtr->eventType) {
        case PB_SEND_PACKET:
#ifdef debug
                printf("Nodo %d PHY2, event PB_SEND_PACKET time:%.10f\n", id, clock);
#endif
                Phy2PBSendPacket(id);
                break;
        case UMTS_SYNC:
#ifdef debug
                //printf("Nodo %d PHY2, event UMTS_SYNC time:%.10f\n", id, clock);
#endif
                Phy2Synchronization(id);
                break;
        case UMTS_SLOT_BEGIN:
#ifdef debug
                printf("Nodo %d PHY2, event UMTS_SLOT_BEGIN time:%.10f\n", id, clock);
#endif
                Phy2UmtsSlotBegin(id);
                break;
        case BS_RX_UMTS_PKT:
#ifdef debug
                //printf("Nodo %d PHY2, event BS_RX_UMTS_PKT time:%.10f\n", id, clock);
#endif
                Phy2BSRxUmtsPkt(id);
                break;
        case TEST_PKT_SYMBOL:
#ifdef debug
                //printf("Nodo %d PHY2, event TEST_PKT_SYMBOL time:%.10f\n", id, clock);
#endif
                Phy2TestPktSymbol(id);
                break;
        case END_RX_PACKET:
#ifdef debug
                printf("Nodo %d PHY2, event END_RX_PACKET time:%.10f\n", id, clock);
#endif
                Phy2EndRxPacket(id);
                break;
        case HANDOVER_UPDATE:
#ifdef debug
                printf("Nodo %d PHY2, event HANDOVER_UPDATE time:%.10f\n", id, clock);
#endif
                Phy2HandoverUpdate(id);
                break;
        case UPDATE_POST_MOBILITY:
#ifdef debug
                //printf("Nodo %d PHY2, event UPDATE_POST_MOBILITY time:%.10f\n", id, clock);
#endif
                Phy2UpdatePostMobility(id);
                break;
        case POWER_CONTROL:
#ifdef debug
                printf("Nodo %d PHY2, event POWER_CONTROL time:%.10f\n", id, clock);
#endif
                Phy2PowerControl(id);
                break;
                case SEND_PACKET_INFO:
#ifdef debug
                printf("Nodo %d PHY2, event SEND_PACKET_INFO:%.10f\n", id, clock);
#endif
                Phy2SendPacketInfo(id);
                break;
        case CONTEXT_TRANSFER:
#ifdef debug
                printf("Nodo %d PHY2, event CONTEXT_TRANSFER:%.10f\n", id, clock);
#endif
                Phy2ContextTransfer(id);
                break;
        case SEND_SINK:
#ifdef debug
                printf("Nodo %d PHY2, event SEND_SINK:%.10f\n", id, clock);
#endif
                Phy2SendSink(id);
                break;
        default:
                puts("Error Phy2EventHandler, unreocgnized type of event");
                exit(1);
        }// end switch event
}// end if mac_type
}



// FUNCTION     Phy2SARAReadParameters
// PURPOSE      get congetsion state of this BS (ratio between tot rx power at BS, from all its user, 
//                      and acception power threshold)
double Phy2SARAReadParameters(ANid id){
BSStruct *BSptr;
double Beff,Pe,SIR;
int i,howManyInCell;

        if (NODEPTR(id)->node_type!=ACCESS_PROVIDER){
                puts("Error Phy2SARAReadParameters, request node isn't AP");
                exit(1);
        }
        BSptr = (BSStruct *)NODEPTR(id)->Phy2StructPtr;
        // verify if necessary to calculate rx pow
        if (BSptr->lastRxPowUpdate+RX_POW_VALID_TIME < clock)
                Phy2RxPowUpdateUP(id);
        Beff = 0.0;
        howManyInCell = 0;
        for (i=1;i<NODES_NUM;i++){
                if ((Mac2Available(i)==TRUE) && (NODEPTR(i)->node_type==PAN_BAN) ){
                        if (BSptr->PBarray[i].isInCell==TRUE){
                                howManyInCell++;
                                SIR = Phy2ComputeSIR(id, i);
                                Pe = 0.5*erfc(sqrt(pow(SIR,ZETA)));
                                // datarate is calculate for speading factor init value (now it's the only value assumed)
                                Beff += ((1-Pe)*sf2datarate(SF_INIT_VALUE,UPLINK));
                        }// end is in cell
                }//end if mac PB
        }//end for
        // calculate Mean Effective Bandwidth
        Beff = floor(Beff/((double)howManyInCell));
        return(Beff);
}

// FUNCTION     Phy2ReadBs
// PURPOSE              return best BS connetct to this umts node
ANid Phy2ReadBestBs(ANid id){
PBStruct *PBptr;

        PBptr = (PBStruct *)NODEPTR(id)->Phy2StructPtr;
        // first BS in list is the one eith the best SIR
        return(PBptr->BSlist[0]);
}

// FUNCTION     Phy2Finalize
// PURPOSE
//
void Phy2Finalize() {
PBStruct *PBptr;
int i;

#ifdef debug
        for(i=1;i<=NODES_NUM;i++){
                if ((Mac2Available(i)==TRUE) && (NODEPTR(i)->node_type==PAN_BAN)){
                        PBptr = (PBStruct *)NODEPTR(i)->Phy2StructPtr;
                        printf("PB %d has tx power %f\n",i,PBptr->txPower);
                }
        }
#endif
}

---