diff --git a/src/buildings/doc/source/buildings-design.rst b/src/buildings/doc/source/buildings-design.rst index 08af2bddf..d4760ecb8 100644 --- a/src/buildings/doc/source/buildings-design.rst +++ b/src/buildings/doc/source/buildings-design.rst @@ -1,4 +1,4 @@ -.. include:: replace.txt +cd .. include:: replace.txt ++++++++++++++++++++++++++++++++++++++ @@ -52,10 +52,10 @@ The ``Building`` class is included in ``BuildingsMobilityModel`` class, which in The class ``BuildingsMobilityModel`` is used by ``BuildingsPropagationLossModel`` class, which inherits from the ns3 class ``PropagationLossModel`` and manages the pathloss computation of the single components and their composition according to the nodes' positions. Moreover, it implements also the shadowing, that is the loss due to obstacles in the main path (i.e., vegetation, buildings, etc.). -Pathloss models available in BuildingsPropagationLossModel -++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +Pathloss model elements ++++++++++++++++++++++++ -In the following we present the pathloss models that are included in the BuildingsPropagationLossModel +In the following we describe the pathloss model elements that are included in the BuildingsPropagationLossModel and available to implement different pathloss logics. Okumura Hata (OH) ----------------- @@ -313,35 +313,69 @@ where: -External Walls Penetration Loss (BEL) -------------------------------------- +External Wall Loss (EWL) +------------------------- This component models the penetration loss through walls for indoor to outdoor communications and vice-versa. The values are taken from the [cost231]_ model. * Wood ~ 4 dB - * Concrete with windows (no metallised) ~ 7 dB + * Concrete with windows (not metallized) ~ 7 dB * Concrete without windows ~ 15 dB (spans between 10 and 20 in COST231) * Stone blocks ~ 12 dB +Internal Walls Loss (IWL) +------------------------- + +This component models the penetration loss occurring in indoor-to-indoor communications within the same building. The total loss is calculated assuming that each single internal wall has a constant penetration loss :math:`L_{siw}`, and approximating the number of walls that are penetrated with the manhattan distance (in number of rooms) between the transmitter and the receiver. In detail, let :math:`x_1`, :math:`y_1`, :math:`x_2`, :math:`y_2` denote the room number along the :math:`x` and :math:`y` axis respectively for user 1 and 2; the total loss :math:`L_{IWL}` is calculated as + +.. math:: + + L_{IWL} = L_{siw} (|x_1 -x_2| + |y_1 - y_2|) + + + + + Height Gain Model (HG) ----------------------- This component model the gain due to the fact that the transmitting device is on a floor above the ground. In literature [turkmani]_ this gain has been evaluated as about 2 dB per floor. This gain can be applied to all the indoor to outdoor communications and vice-versa. +Shadowing Model +--------------- -Hybrid Model Indoor<->Outdoor ------------------------------ +The shadowing is modeled according to a log-normal distribution with variable standard deviation as function of the connection characteristics. In the implementation we considered three main possible scenarios which correspond to three standard deviations (i.e., the mean is always 0), in detail: -The pathloss model characterizes the hybrid cases (i.e., when an outdoor node transmit to an indoor one and vice-versa) by adding to the proper model, evaluated according to correspond distance, the external wall penetration loss due to the building (see Section BEL). + * outdoor (``m_shadowingSigmaOutdoor``, defaul value of 7 dB) :math:`\rightarrow X_\mathrm{O} \sim N(\mu_\mathrm{O}, \sigma_\mathrm{O}^2)`. + * indoor (``m_shadowingSigmaIndoor``, defaul value of 10 dB) :math:`\rightarrow X_\mathrm{I} \sim N(\mu_\mathrm{I}, \sigma_\mathrm{I}^2)`. + * external walls penetration (``m_shadowingSigmaExtWalls``, default value 5 dB) :math:`\rightarrow X_\mathrm{W} \sim N(\mu_\mathrm{W}, \sigma_\mathrm{W}^2)` + +The simulator generates a shadowing value per each active link according to nodes' position the first time the link is used for transmitting. In case of transmissions from outdoor nodes to indoor ones, and vice-versa, the standard deviation (:math:`\sigma_\mathrm{IO}`) has to be calculated as the square root of the sum of the quadratic values of the standard deviatio in case of outdoor nodes and the one for the external walls penetration. This is due to the fact that that the components producing the shadowing are independent of each other; therefore, the variance of a distribution resulting from the sum of two independent normal ones is the sum of the variances. + +.. math:: + + X \sim N(\mu,\sigma^2) \mbox{ and } Y \sim N(\nu,\tau^2) + + Z = X + Y \sim Z (\mu + \nu, \sigma^2 + \tau^2) + + \Rightarrow \sigma_\mathrm{IO} = \sqrt{\sigma_\mathrm{O}^2 + \sigma_\mathrm{W}^2} -Pathloss Model Logic of HybridBuildingsPropagationLossModel -+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -The following pseudo-code illustrates how the different pathloss models described above are integrated in the ``HybridBuildingsPropagationLossModel``:: + +Pathloss logics ++++++++++++++++ + +In the following we describe the different pathloss logic that are implemented by inheriting from BuildingsPropagationLossModel. + + +HybridBuildingsPropagationLossModel +----------------------------------- + +The following pseudo-code illustrates how the different pathloss model elements described above are integrated in the ``HybridBuildingsPropagationLossModel``:: if (txNode is outdoor) then @@ -360,37 +394,40 @@ The following pseudo-code illustrates how the different pathloss models describe if (distance > 1 km) then if (rxNode or txNode is below the rooftop) - L = I1411 + BEL + HG + L = I1411 + EWL + HG else - L = OH + BEL + HG + L = OH + EWL + HG else - L = I1411 + BEL + HG + L = I1411 + EWL + HG else (txNode is indoor) if (rxNode is indoor) then if (same building) then - L = I1238 + L = I1238 + IWL else - L = I1411 + 2*BEL + L = I1411 + 2*EWL else (rxNode is outdoor) if (distance > 1 km) then if (rxNode or txNode is below the rooftop) then - L = I1411 + BEL + HG + L = I1411 + EWL + HG else - L = OH + BEL + HG + L = OH + EWL + HG else - L = I1411 + BEL + L = I1411 + EWL We note that, for the case of communication between two nodes below rooftop level with distance is greater then 1 km, we still consider the I1411 model, since OH is specifically designed for macro cells and therefore for antennas above the roof-top level. Finally, we introduced a threshold called ``m_itu1411DistanceThreshold``) for pruning the communications between nodes below rooftop when the distance is too large (the default values is 2 km). -Pathloss Model Logic of OhBuildingsPropagationLossModel -+++++++++++++++++++++++++++++++++++++++++++++++++++++++ +We also note that the use of different propagation models (OH, I1411, I1238 with their variants) in HybridBuildingsPropagationLossModel can result in discontinuities of the pathloss with respect to distance. A proper tuning of the attributes (especially the distance threshold attributes) can avoid these discontinuities. However, since the behavior of each model depends on several other parameters (frequency, node heigth, etc), there is no default value of these thresholds that can avoid the discontinuities in all possible configurations. Hence, an appropriate tuning of these parameters is left to the user. -The following pseudo-code illustrates how the different pathloss models described above are integrated in the ``OhBuildingsPropagationLossModel``:: + +OhBuildingsPropagationLossModel +------------------------------- + +The following pseudo-code illustrates how the different pathloss model elements described above are integrated in the ``OhBuildingsPropagationLossModel``:: if (txNode is outdoor) then @@ -398,37 +435,17 @@ The following pseudo-code illustrates how the different pathloss models describe then L = OH else (rxNode is indoor) - L = OH + BEL + L = OH + EWL else (txNode is indoor) if (rxNode is indoor) then if (same building) then - L = OH + L = OH + IWL else - L = OH + 2*BEL + L = OH + 2*EWL else (rxNode is outdoor) - L = OH + BEL + L = OH + EWL - - - -Shadowing Model -+++++++++++++++ - -The shadowing is modeled according to a log-normal distribution with variable standard deviation as function of the connection characteristics. In the implementation we considered three main possible scenarios which correspond to three standard deviations (i.e., the mean is always 0), in detail: - - * outdoor (``m_shadowingSigmaOutdoor``, defaul value of 7 dB) :math:`\rightarrow X_\mathrm{O} \sim N(\mu_\mathrm{O}, \sigma_\mathrm{O}^2)`. - * indoor (``m_shadowingSigmaIndoor``, defaul value of 10 dB) :math:`\rightarrow X_\mathrm{I} \sim N(\mu_\mathrm{I}, \sigma_\mathrm{I}^2)`. - * external walls penetration (``m_shadowingSigmaExtWalls``, default value 5 dB) :math:`\rightarrow X_\mathrm{W} \sim N(\mu_\mathrm{W}, \sigma_\mathrm{W}^2)` - -The simulator generates a shadowing value per each active link according to nodes' position the first time the link is used for transmitting. In case of transmissions from outdoor nodes to indoor ones, and vice-versa, the standard deviation (:math:`\sigma_\mathrm{IO}`) has to be calculated as the square root of the sum of the quadratic values of the standard deviatio in case of outdoor nodes and the one for the external walls penetration. This is due to the fact that that the components producing the shadowing are independent of each other; therefore, the variance of a distribution resulting from the sum of two independent normal ones is the sum of the variances. - -.. math:: - - X \sim N(\mu,\sigma^2) \mbox{ and } Y \sim N(\nu,\tau^2) - - Z = X + Y \sim Z (\mu + \nu, \sigma^2 + \tau^2) - - \Rightarrow \sigma_\mathrm{IO} = \sqrt{\sigma_\mathrm{O}^2 + \sigma_\mathrm{W}^2} +We note that OhBuildingsPropagationLossModel is a significant simplification with respect to HybridBuildingsPropagationLossModel, due to the fact that OH is used always. While this gives a less accurate model in some scenarios (especially below rooftop and indoor), it effectively avoids the issue of pathloss discontinuities that affects HybridBuildingsPropagationLossModel. diff --git a/src/buildings/model/buildings-propagation-loss-model.cc b/src/buildings/model/buildings-propagation-loss-model.cc index 028500194..04932ebce 100644 --- a/src/buildings/model/buildings-propagation-loss-model.cc +++ b/src/buildings/model/buildings-propagation-loss-model.cc @@ -15,7 +15,8 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - * Author: Marco Miozzo + * Author: Marco Miozzo , + * Nicola Baldo * */ @@ -69,8 +70,6 @@ BuildingsPropagationLossModel::GetTypeId (void) .SetParent () - //.AddConstructor () - .AddAttribute ("Lambda", "The wavelength (default is 2.106 GHz at 300 000 km/s).", DoubleValue (300000000.0 / 2160e6), @@ -112,12 +111,6 @@ BuildingsPropagationLossModel::GetTypeId (void) MakeDoubleAccessor (&BuildingsPropagationLossModel::m_itu1411NlosThreshold), MakeDoubleChecker ()) - .AddAttribute ("ITU1411DistanceThr", - " Threshold for ITU 1411 [m].", - DoubleValue (2000.0), - MakeDoubleAccessor (&BuildingsPropagationLossModel::m_itu1411DistanceThreshold), - MakeDoubleChecker ()) - .AddAttribute ("MinDistance", "The distance under which the propagation model refuses to give results (m) ", DoubleValue (0.5), @@ -165,13 +158,6 @@ BuildingsPropagationLossModel::~BuildingsPropagationLossModel () { } -// void -// BuildingsPropagationLossModel::SetLambda (double frequency, double speed) -// { -// m_lambda = speed / frequency; -// m_frequency = frequency; -// } - void BuildingsPropagationLossModel::SetLambda (double lambda) { @@ -212,18 +198,6 @@ BuildingsPropagationLossModel::GetMinDistance (void) const void BuildingsPropagationLossModel::SetEnvironment (Environment env) { -// if (env==Urban) -// { -// NS_LOG_INFO (this << " Urban"); -// } -// else if (env==SubUrban) -// { -// NS_LOG_INFO (this << " SubUrban"); -// } -// else if (env==OpenAreas) -// { -// NS_LOG_INFO (this << " OpenAreas"); -// } m_environment = env; } @@ -477,44 +451,13 @@ BuildingsPropagationLossModel::ItuR1411NlosOverRooftop (Ptr a, Ptr b) const -// { -// NS_LOG_INFO (this); -// // reflection pathloss -// double x1 = a->GetStreetCrossingDistence (); -// double x2 = b->GetStreetCrossingDistence (); -// double f_alpha = 0.0; -// if (m_cornerAngle<= 0.33) -// { -// f_alpha = -41.0 + 110*m_cornerAngle; -// } -// else if (m_cornerAngle<= 0.42) -// { -// f_alpha = -13.94 + 28*m_cornerAngle; -// } -// else if (m_cornerAngle<= 0.71) -// { -// f_alpha = -5.33 + 7.51*m_cornerAngle; -// } -// double pi = 3.141592653589793; -// double Lr = -20*log10 (x1+x2) + (x1*x2*f_alpha/(m_streetsWidth*m_streetsWidth)) - 20*log10 (4*pi/m_lambda); -// -// // diffraction pathloss -// double Da = -1*(40/(2*pi))*(atan (x2/m_streetsWidth) + atan (x1/m_streetsWidth) - (pi/2)); -// double Ld = -10*log10 (x2*x1*(x1+x2)) + 2*Da + 0.1*(90 - m_cornerAngle*(180/pi)) - 20*log10 (4*pi/m_lambda); -// -// double loss = -10*log10 (pow (10, Lr/10) + pow (10, Ld/10)); -// return (loss); -// } - double BuildingsPropagationLossModel::ItuR1238 (Ptr a, Ptr b) const { double N = 0.0; int n = abs (a->GetFloorNumber () - b->GetFloorNumber ()); -// NS_LOG_INFO (this << " A floor " << (uint16_t)a->GetFloorNumber () << " B floor " << (uint16_t)b->GetFloorNumber () << " n " << n); + NS_LOG_LOGIC (this << " A floor " << (uint16_t)a->GetFloorNumber () << " B floor " << (uint16_t)b->GetFloorNumber () << " n " << n); double Lf = 0.0; Ptr aBuilding = a->GetBuilding (); if (aBuilding->GetBuildingType () == Building::Residential) @@ -524,7 +467,7 @@ BuildingsPropagationLossModel::ItuR1238 (Ptr a, PtrGetBuildingType () == Building::Office) { @@ -533,7 +476,7 @@ BuildingsPropagationLossModel::ItuR1238 (Ptr a, PtrGetBuildingType () == Building::Commercial) { @@ -542,15 +485,14 @@ BuildingsPropagationLossModel::ItuR1238 (Ptr a, PtrGetPosition () << " <-> " << b->GetPosition ()); double loss = 20 * log10 (m_frequency / 1e6 /*MHz*/) + N*log10 (a->GetDistanceFrom (b)) + Lf - 28.0; - + NS_LOG_INFO (this << " Node " << a->GetPosition () << " <-> " << b->GetPosition () << " loss = " << loss << " dB"); return (loss); } @@ -600,186 +542,6 @@ BuildingsPropagationLossModel::InternalWallsLoss (Ptr a, -// double -// BuildingsPropagationLossModel::GetLoss (Ptr a, Ptr b) const -// { -// NS_ASSERT_MSG ((a->GetPosition ().z > 0) && (b->GetPosition ().z > 0), "BuildingsPropagationLossModel does not support underground nodes (placed at z < 0)"); -// -// -// double distance = a->GetDistanceFrom (b); -// if (distance <= m_minDistance) -// { -// return 0.0; -// } -// -// // get the BuildingsMobilityModel pointers -// Ptr a1 = DynamicCast (a); -// Ptr b1 = DynamicCast (b); -// NS_ASSERT_MSG ((a1 != 0) && (b1 != 0), "BuildingsPropagationLossModel only works with BuildingsMobilityModel"); -// -// double loss = 0.0; -// -// if (a1->IsOutdoor ()) -// { -// if (b1->IsOutdoor ()) -// { -// if (distance > 1000) -// { -// NS_LOG_INFO (this << a1->GetPosition ().z << b1->GetPosition ().z << m_rooftopHeight); -// if ((a1->GetPosition ().z < m_rooftopHeight) -// && (b1->GetPosition ().z < m_rooftopHeight)) -// { -// // ITU limit in distance (i.e., < 2000 for small cells) -// if (distance < m_itu1411DistanceThreshold) -// { -// // short range communication -// loss = ItuR1411 (a1, b1); -// NS_LOG_INFO (this << " 0-0 (>1000): down rooftop -> ITUR1411 : " << loss); -// } -// else -// { -// // out of bound -// loss = std::numeric_limits::infinity (); -// NS_LOG_INFO (this << " 0-0 (>2000): down rooftop -> Infinity (out of bound) : " << loss); -// } -// } -// else -// { -// // Over the rooftop tranmission -> Okumura Hata -// loss = OkumuraHata (a1, b1); -// NS_LOG_INFO (this << " O-O (>1000): Over the rooftop -> OH : " << loss); -// } -// } -// else -// { -// // short range outdoor communication -// loss = ItuR1411 (a1, b1); -// NS_LOG_INFO (this << " 0-0 (<1000) Street canyon -> ITUR1411 : " << loss); -// } -// } -// else -// { -// // b indoor -// if (distance > 1000) -// { -// if ((a1->GetPosition ().z < m_rooftopHeight) -// && (b1->GetPosition ().z < m_rooftopHeight)) -// { -// -// // ITU limit in distance (i.e., < 2000 for small cells) -// if (distance < m_itu1411DistanceThreshold) -// { -// // short range communication -// loss = ItuR1411 (a1, b1) + ExternalWallLoss (b1) + HeightLoss (a1); -// NS_LOG_INFO (this << " 0-I (>1000): down rooftop -> ITUR1411 : " << loss); -// } -// else -// { -// // out of bound -// loss = std::numeric_limits::infinity (); -// NS_LOG_INFO (this << " 0-I (>2000): down rooftop -> ITUR1411 : " << loss); -// } -// } -// else -// { -// // Over the rooftop tranmission -> Okumura Hata -// loss = OkumuraHata (a1, b1) + ExternalWallLoss (b1); -// NS_LOG_INFO (this << " O-I (>1000): Over the rooftop -> OH : " << loss); -// } -// } -// else -// { -// loss = ItuR1411 (a1, b1) + ExternalWallLoss (b1) + HeightLoss (b1); -// NS_LOG_INFO (this << " 0-I (<1000) ITUR1411 + BEL : " << loss); -// } -// } // end b1->isIndoor () -// } -// else -// { -// // a is indoor -// if (b1->IsIndoor ()) -// { -// if (a1->GetBuilding () == b1->GetBuilding ()) -// { -// // nodes are in same building -> indoor communication ITU-R P.1238 -// loss = ItuR1238 (a1, b1) + InternalWallsLoss (a1, b1);; -// NS_LOG_INFO (this << " I-I (same building) ITUR1238 : " << loss); -// -// } -// else -// { -// // nodes are in different buildings -// loss = ItuR1411 (a1, b1) + ExternalWallLoss (a1) + ExternalWallLoss (b1); -// NS_LOG_INFO (this << " I-I (different) ITUR1238 + 2*BEL : " << loss); -// } -// } -// else -// { -// // b is outdoor -// if (distance > 1000) -// { -// if ((a1->GetPosition ().z < m_rooftopHeight) -// && (b1->GetPosition ().z < m_rooftopHeight)) -// { -// -// // ITU limit in distance (i.e., < 2000 for small cells) -// if (distance < m_itu1411DistanceThreshold) -// { -// // short range communication -// loss = ItuR1411 (a1, b1) + ExternalWallLoss (a1) + HeightLoss (a1); -// NS_LOG_INFO (this << " I-O (>1000): down rooftop -> ITUR1411 : " << loss); -// } -// else -// { -// // out of bound -// loss = std::numeric_limits::infinity (); -// NS_LOG_INFO (this << " I-O (>2000): down rooftop -> ITUR1411 : " << loss); -// } -// } -// else -// { -// // above rooftop -> OH -// loss = OkumuraHata (a1, b1) + ExternalWallLoss (a1) + HeightLoss (a1); -// NS_LOG_INFO (this << " =I-O (>1000) over rooftop OH + BEL + HG: " << loss); -// } -// } -// else -// { -// loss = ItuR1411 (a1, b1) + ExternalWallLoss (a1) + HeightLoss (a1); -// NS_LOG_INFO (this << " I-O (<1000) ITUR1411 + BEL + HG: " << loss); -// } -// } // end b1->IsIndoor () -// } // end a1->IsOutdoor () -// -// // Evaluate the shadowing -// std::map, std::map, ShadowingLoss> >::iterator ait = m_shadowingLossMap.find (a); -// if (ait != m_shadowingLossMap.end ()) -// { -// std::map, ShadowingLoss>::iterator bit = ait->second.find (b); -// if (bit != ait->second.end ()) -// { -// return loss + bit->second.GetLoss (); -// } -// else -// { -// double sigma = EvaluateSigma (a1, b1); -// // side effect: will create new entry -// ait->second[b] = ShadowingLoss (0.0, sigma, b); -// return loss + ait->second[b].GetLoss (); -// } -// } -// else -// { -// double sigma = EvaluateSigma (a1, b1); -// // side effect: will create new entries in both maps -// m_shadowingLossMap[a][b] = ShadowingLoss (0.0, sigma, b); -// return loss + m_shadowingLossMap[a][b].GetLoss (); -// } -// -// } - - - double BuildingsPropagationLossModel::GetShadowing (Ptr a, Ptr b) const diff --git a/src/buildings/model/hybrid-buildings-propagation-loss-model.cc b/src/buildings/model/hybrid-buildings-propagation-loss-model.cc index 688ca70cf..27e923279 100644 --- a/src/buildings/model/hybrid-buildings-propagation-loss-model.cc +++ b/src/buildings/model/hybrid-buildings-propagation-loss-model.cc @@ -15,7 +15,8 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * - * Author: Marco Miozzo + * Author: Marco Miozzo + * Nicola Baldo * */ @@ -89,25 +90,14 @@ HybridBuildingsPropagationLossModel::GetLoss (Ptr a, PtrGetPosition ().z < m_rooftopHeight) && (b1->GetPosition ().z < m_rooftopHeight)) { - // ITU limit in distance (i.e., < 2000 for small cells) - if (distance < m_itu1411DistanceThreshold) - { - // short range communication - loss = ItuR1411 (a1, b1); - NS_LOG_INFO (this << " 0-0 (>1000): down rooftop -> ITUR1411 : " << loss); - } - else - { - // out of bound - loss = std::numeric_limits::infinity (); - NS_LOG_INFO (this << " 0-0 (>2000): down rooftop -> Infinity (out of bound) : " << loss); - } + loss = ItuR1411 (a1, b1); + NS_LOG_INFO (this << " 0-0 (>1000): below rooftop -> ITUR1411 : " << loss); } else { // Over the rooftop tranmission -> Okumura Hata loss = OkumuraHata (a1, b1); - NS_LOG_INFO (this << " O-O (>1000): Over the rooftop -> OH : " << loss); + NS_LOG_INFO (this << " O-O (>1000): above rooftop -> OH : " << loss); } } else @@ -124,27 +114,14 @@ HybridBuildingsPropagationLossModel::GetLoss (Ptr a, PtrGetPosition ().z < m_rooftopHeight) && (b1->GetPosition ().z < m_rooftopHeight)) - { - - // ITU limit in distance (i.e., < 2000 for small cells) - if (distance < m_itu1411DistanceThreshold) - { - // short range communication - loss = ItuR1411 (a1, b1) + ExternalWallLoss (b1) + HeightLoss (a1); - NS_LOG_INFO (this << " 0-I (>1000): down rooftop -> ITUR1411 : " << loss); - } - else - { - // out of bound - loss = std::numeric_limits::infinity (); - NS_LOG_INFO (this << " 0-I (>2000): down rooftop -> ITUR1411 : " << loss); - } + { + loss = ItuR1411 (a1, b1) + ExternalWallLoss (b1) + HeightLoss (a1); + NS_LOG_INFO (this << " 0-I (>1000): below rooftop -> ITUR1411 : " << loss); } else { - // Over the rooftop tranmission -> Okumura Hata loss = OkumuraHata (a1, b1) + ExternalWallLoss (b1); - NS_LOG_INFO (this << " O-I (>1000): Over the rooftop -> OH : " << loss); + NS_LOG_INFO (this << " O-I (>1000): above the rooftop -> OH : " << loss); } } else @@ -181,20 +158,8 @@ HybridBuildingsPropagationLossModel::GetLoss (Ptr a, PtrGetPosition ().z < m_rooftopHeight) && (b1->GetPosition ().z < m_rooftopHeight)) { - - // ITU limit in distance (i.e., < 2000 for small cells) - if (distance < m_itu1411DistanceThreshold) - { - // short range communication - loss = ItuR1411 (a1, b1) + ExternalWallLoss (a1) + HeightLoss (a1); - NS_LOG_INFO (this << " I-O (>1000): down rooftop -> ITUR1411 : " << loss); - } - else - { - // out of bound - loss = std::numeric_limits::infinity (); - NS_LOG_INFO (this << " I-O (>2000): down rooftop -> ITUR1411 : " << loss); - } + loss = ItuR1411 (a1, b1) + ExternalWallLoss (a1) + HeightLoss (a1); + NS_LOG_INFO (this << " I-O (>1000): down rooftop -> ITUR1411 : " << loss); } else {