Attachment #3157 for bug #2122

View | Details | Raw Unified | Return to bug 2122
Collapse All | Expand All

(-)a/src/buildings/examples/buildings-pathloss-profiler.cc (-1 / +1 lines)

Lines 93-99	Link Here

      Ptr<MobilityBuildingInfo> buildingInfoUe = CreateObject<MobilityBuildingInfo> ();

      Ptr<MobilityBuildingInfo> buildingInfoUe = CreateObject<MobilityBuildingInfo> ();

      mmUe->AggregateObject (buildingInfoUe); // operation usually done by BuildingsHelper::Install

      mmUe->AggregateObject (buildingInfoUe); // operation usually done by BuildingsHelper::Install

      BuildingsHelper::MakeConsistent (mmUe);

      BuildingsHelper::MakeConsistent (mmUe);

      double loss = propagationLossModel->GetLoss (mmEnb, mmUe);

      double loss = propagationLossModel->GetLoss (mmEnb, mmUe, 0.0);

      outFile << i << "\t"

      outFile << i << "\t"

              << loss

              << loss

              << std::endl;

              << std::endl;

(-)a/src/buildings/model/buildings-propagation-loss-model.cc (-2 / +2 lines)

Lines 214-222	Link Here

214

215

216

double

216

double

217

BuildingsPropagationLossModel::DoCalcRxPower (double txPowerDbm, Ptr<MobilityModel> a, Ptr<MobilityModel> b) const

217

BuildingsPropagationLossModel::DoCalcRxPower (double txPowerDbm, Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const

218

219

  return txPowerDbm - GetLoss (a, b) - GetShadowing (a, b);

219

  return txPowerDbm - GetLoss (a, b, frequency) - GetShadowing (a, b);

220

221

222

int64_t

222

int64_t




  /**
   * \param a the mobility model of the source
   * \param b the mobility model of the destination
   * \param frequency the carrier frequency
   * \returns the propagation loss (in dBm)
   */
  virtual double GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const = 0;

  // inherited from PropagationLossModel
  virtual double DoCalcRxPower (double txPowerDbm, Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const;

protected:
  double ExternalWallLoss (Ptr<MobilityBuildingInfo> a) const;






double
HybridBuildingsPropagationLossModel::GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const
{
  NS_ASSERT_MSG ((a->GetPosition ().z >= 0) && (b->GetPosition ().z >= 0), "HybridBuildingsPropagationLossModel does not support underground nodes (placed at z < 0)");


              if ((a->GetPosition ().z < m_rooftopHeight)
                  && (b->GetPosition ().z < m_rooftopHeight))
                {
                  loss = ItuR1411 (a, b, frequency);
                  NS_LOG_INFO (this << " 0-0 (>1000): below rooftop -> ITUR1411 : " << loss);
                }
              else
                {
                  // Over the rooftop tranmission -> Okumura Hata
                  loss = OkumuraHata (a, b, frequency);
                  NS_LOG_INFO (this << " O-O (>1000): above rooftop -> OH : " << loss);
                }
            }
          else
            {
              // short range outdoor communication
              loss = ItuR1411 (a, b, frequency);
              NS_LOG_INFO (this << " 0-0 (<1000) Street canyon -> ITUR1411 : " << loss);
            }
        }

              if ((a->GetPosition ().z < m_rooftopHeight)
                  && (b->GetPosition ().z < m_rooftopHeight))
                {                  
                  loss = ItuR1411 (a, b, frequency) + ExternalWallLoss (b1) + HeightLoss (b1);
                  NS_LOG_INFO (this << " 0-I (>1000): below rooftop -> ITUR1411 : " << loss);
                }
              else
                {
                  loss = OkumuraHata (a, b, frequency) + ExternalWallLoss (b1);
                  NS_LOG_INFO (this << " O-I (>1000): above the rooftop -> OH : " << loss);
                }
            }
          else
            {
              loss = ItuR1411 (a, b, frequency) + ExternalWallLoss (b1) + HeightLoss (b1);
              NS_LOG_INFO (this << " 0-I (<1000) ITUR1411 + BEL : " << loss);
            }
        } // end b1->isIndoor ()

          if (a1->GetBuilding () == b1->GetBuilding ())
            {
              // nodes are in same building -> indoor communication ITU-R P.1238
              loss = ItuR1238 (a, b, frequency) + InternalWallsLoss (a1, b1);;
              NS_LOG_INFO (this << " I-I (same building) ITUR1238 : " << loss);

            }
          else
            {
              // nodes are in different buildings
              loss = ItuR1411 (a, b, frequency) + ExternalWallLoss (a1) + ExternalWallLoss (b1);
              NS_LOG_INFO (this << " I-I (different) ITUR1238 + 2*BEL : " << loss);
            }
        }

              if ((a->GetPosition ().z < m_rooftopHeight)
                  && (b->GetPosition ().z < m_rooftopHeight))
                {
                  loss = ItuR1411 (a, b, frequency) + ExternalWallLoss (a1) + HeightLoss (a1);
                  NS_LOG_INFO (this << " I-O (>1000): down rooftop -> ITUR1411 : " << loss);
                }
              else
                {
                  // above rooftop -> OH
                  loss = OkumuraHata (a, b, frequency) + ExternalWallLoss (a1) + HeightLoss (a1);
                  NS_LOG_INFO (this << " =I-O (>1000) over rooftop OH + BEL + HG: " << loss);
                }
            }
          else
            {
              loss = ItuR1411 (a, b, frequency) + ExternalWallLoss (a1)  + HeightLoss (a1);
              NS_LOG_INFO (this << " I-O (<1000)  ITUR1411 + BEL + HG: " << loss);
            }
        } // end b1->IsIndoor ()



double
HybridBuildingsPropagationLossModel::OkumuraHata (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const
{
  if (m_frequency <= 2.3e9)
    {
      return m_okumuraHata->GetLoss (a, b, frequency);
    }
  else
    {

}

double
HybridBuildingsPropagationLossModel::ItuR1411 (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const
{
  if (a->GetDistanceFrom (b) < m_itu1411NlosThreshold)
    {
      return (m_ituR1411Los->GetLoss (a, b, frequency));
    }
  else
    {
      return (m_ituR1411NlosOverRooftop->GetLoss (a, b, frequency));
    }
}

double
HybridBuildingsPropagationLossModel::ItuR1238 (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const
{
  return m_ituR1238->GetLoss (a, b, frequency);
}






  /**
   * \param a the mobility model of the source
   * \param b the mobility model of the destination
   * \param frequency the carrier frequency
   * \returns the propagation loss (in dBm)
   */
  virtual double GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const;

  
private:

  double OkumuraHata (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const;
  double ItuR1411 (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const;
  double ItuR1238 (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const;

  Ptr<OkumuraHataPropagationLossModel> m_okumuraHata;
  Ptr<ItuR1411LosPropagationLossModel> m_ituR1411Los;




}

double
ItuR1238PropagationLossModel::GetLoss (Ptr<MobilityModel> a1, Ptr<MobilityModel> b1, double frequency) const
{
  NS_LOG_FUNCTION (this << a1 << b1);
  Ptr<MobilityBuildingInfo> a = a1->GetObject<MobilityBuildingInfo> ();

    {
      NS_LOG_ERROR (this << " Unkwnon Wall Type");
    }
  double loss = 20 * std::log10 (frequency / 1e6 /*MHz*/) + N * std::log10 (a1->GetDistanceFrom (b1)) + Lf - 28.0;
  NS_LOG_INFO (this << " Node " << a1->GetPosition () << " <-> " << b1->GetPosition () << " loss = " << loss << " dB");

  return loss;

double 
ItuR1238PropagationLossModel::DoCalcRxPower (double txPowerDbm,
						Ptr<MobilityModel> a,
						Ptr<MobilityModel> b,
            double frequency) const
{
  return (txPowerDbm - GetLoss (a, b, frequency));
}


double 
ItuR1238PropagationLossModel::DoCalcRxPower (double txPowerDbm,
						Ptr<MobilityModel> a,
						Ptr<MobilityModel> b) const
{
  return (txPowerDbm - GetLoss (a, b, m_frequency));
}






   * 
   * \param a the first mobility model
   * \param b the second mobility model
   * \param frequency the carrier frequency
   * 
   * \return the loss in dBm for the propagation between
   * the two given mobility models
   */
  double GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequnecy) const;

private:

  // inherited from PropagationLossModel
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b) const;
  virtual int64_t DoAssignStreams (int64_t stream);
  






double
OhBuildingsPropagationLossModel::GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const
{
  NS_LOG_FUNCTION (this << a << b);


    {
      if (b1->IsOutdoor ())
        {
          loss = m_okumuraHata->GetLoss (a, b, frequency);
          NS_LOG_INFO (this << " O-O : " << loss);
        }
      else
        {
          // b indoor
          loss = m_okumuraHata->GetLoss (a, b, frequency) + ExternalWallLoss (b1);
          NS_LOG_INFO (this << " O-I : " << loss);
        } // end b1->isIndoor ()
    }

          if (a1->GetBuilding () == b1->GetBuilding ())
            {
              // nodes are in same building -> indoor communication ITU-R P.1238
              loss = m_okumuraHata->GetLoss (a, b, frequency) + InternalWallsLoss (a1, b1);;
              NS_LOG_INFO (this << " I-I (same building)" << loss);

            }
          else
            {
              // nodes are in different buildings
              loss = m_okumuraHata->GetLoss (a, b, frequency) + ExternalWallLoss (a1) + ExternalWallLoss (b1);
              NS_LOG_INFO (this << " I-O-I (different buildings): " << loss);
            }
        }
      else
        {
          loss = m_okumuraHata->GetLoss (a, b, frequency) + ExternalWallLoss (a1);
          NS_LOG_INFO (this << " I-O : " << loss);
        } // end b1->IsIndoor ()
    } // end a1->IsOutdoor ()

(-)a/src/buildings/model/oh-buildings-propagation-loss-model.h (-1 / +2 lines)

Lines 47-55	Link Here

/**

/**

   * \param a the mobility model of the source

   * \param a the mobility model of the source

   * \param b the mobility model of the destination

   * \param b the mobility model of the destination

   * \param frequency the carrier frequency

   * \returns the propagation loss (in dBm)

   * \returns the propagation loss (in dBm)

*/

*/

  virtual double GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b) const;

  virtual double GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const;

private:

private:

(-)a/src/buildings/test/buildings-pathloss-test.cc (-1 / +1 lines)

Lines 175-181	Link Here

175

  propagationLossModel->SetAttribute ("ShadowSigmaIndoor", DoubleValue (0.0));

175

  propagationLossModel->SetAttribute ("ShadowSigmaIndoor", DoubleValue (0.0));

176

  propagationLossModel->SetAttribute ("ShadowSigmaExtWalls", DoubleValue (0.0));

176

  propagationLossModel->SetAttribute ("ShadowSigmaExtWalls", DoubleValue (0.0));

177

178

  double loss = propagationLossModel->GetLoss (mma, mmb);

178

  double loss = propagationLossModel->GetLoss (mma, mmb, 0.0);

179

180

  NS_LOG_INFO ("Calculated loss: " << loss);

180

  NS_LOG_INFO ("Calculated loss: " << loss);

181

  NS_LOG_INFO ("Theoretical loss: " << m_lossRef);

181

  NS_LOG_INFO ("Theoretical loss: " << m_lossRef);

(-)a/src/buildings/test/buildings-shadowing-test.cc (-2 / +2 lines)

Lines 108-115	Link Here

108

109

      Ptr<MobilityModel> mma = CreateMobilityModel (m_mobilityModelIndex1);

109

      Ptr<MobilityModel> mma = CreateMobilityModel (m_mobilityModelIndex1);

110

      Ptr<MobilityModel> mmb = CreateMobilityModel (m_mobilityModelIndex2);

110

      Ptr<MobilityModel> mmb = CreateMobilityModel (m_mobilityModelIndex2);

111

      double shadowingLoss = propagationLossModel->DoCalcRxPower (0.0, mma, mmb) + m_lossRef;

111

      double shadowingLoss = propagationLossModel->DoCalcRxPower (0.0, mma, mmb, 0.0) + m_lossRef;

112

      double shadowingLoss2 = propagationLossModel->DoCalcRxPower (0.0, mma, mmb) + m_lossRef;

112

      double shadowingLoss2 = propagationLossModel->DoCalcRxPower (0.0, mma, mmb, 0.0) + m_lossRef;

113

      NS_TEST_ASSERT_MSG_EQ_TOL (shadowingLoss, shadowingLoss2, 0.001,

113

      NS_TEST_ASSERT_MSG_EQ_TOL (shadowingLoss, shadowingLoss2, 0.001,

114

                                 "Shadowing is not constant for the same mobility model pair!");

114

                                 "Shadowing is not constant for the same mobility model pair!");

115

      loss.push_back (shadowingLoss);

115

      loss.push_back (shadowingLoss);




    .AddAttribute ("Lambda",
                   "The wavelength  (default is 2.3 GHz at 300 000 km/s).",
                   DoubleValue (300000000.0 / 2.3e9),
                   MakeDoubleAccessor (static_cast<void (ns3::Cost231PropagationLossModel::*)(double)>(&Cost231PropagationLossModel::SetLambda),
                                       &Cost231PropagationLossModel::GetLambda),
                   MakeDoubleChecker<double> ())
    .AddAttribute ("Frequency",
                   "The Frequency  (default is 2.3 GHz).",

  m_shadowing = 10;
}

void
Cost231PropagationLossModel::SetLambda (double frequency, double speed)
{
  m_lambda = speed / frequency;
  m_frequency = frequency;
}

double
Cost231PropagationLossModel::GetShadowing (void)
{

void
Cost231PropagationLossModel::SetLambda (double lambda)
{
  m_lambda = lambda;
  m_frequency = 300000000 / lambda;
}

double
Cost231PropagationLossModel::GetLambda (void) const
{
  return 300000000 / m_frequency;
}

void

}

double
Cost231PropagationLossModel::GetLoss (Ptr<MobilityModel> a,
                                      Ptr<MobilityModel> b,
                                      double frequency) const
{

  double distance = a->GetDistanceFrom (b);

      return 0.0;
    }

  double frequency_MHz = frequency * 1e-6;

  double distance_km = distance * 1e-3;


}

double
Cost231PropagationLossModel::DoCalcRxPower (double txPowerDbm,
                                            Ptr<MobilityModel> a,
                                            Ptr<MobilityModel> b,
                                            double frequency) const
{
  return txPowerDbm + GetLoss (a, b, frequency);
}

double
Cost231PropagationLossModel::DoCalcRxPower (double txPowerDbm,
                                            Ptr<MobilityModel> a,
                                            Ptr<MobilityModel> b) const
{
  return txPowerDbm + GetLoss (a, b, m_frequency);
}

int64_t




   * Get the propagation loss
   * \param a the mobility model of the source
   * \param b the mobility model of the destination
   * \param frequency the carrier frequency
   * \returns the propagation loss (in dBm)
   */
  double GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const;

  /**
   * Set the BS antenna height

   */
  void SetLambda (double lambda);
  /**
   * Set the wavelength
   * \param frequency the signal frequency [Hz]
   * \param speed the signal speed [m/s]
   */
  void SetLambda (double frequency, double speed);
  /**
   * Set the minimum model distance
   * \param minDistance the minimum model distance
   */

   */
  Cost231PropagationLossModel & operator = (const Cost231PropagationLossModel &);

  virtual double DoCalcRxPower (double txPowerDbm, Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const;
  virtual double DoCalcRxPower (double txPowerDbm, Ptr<MobilityModel> a, Ptr<MobilityModel> b) const;
  virtual int64_t DoAssignStreams (int64_t stream);
  double m_BSAntennaHeight; //!< BS Antenna Height [m]
  double m_SSAntennaHeight; //!< SS Antenna Height [m]
  double m_lambda; //!< The wavelength
  double m_minDistance; //!< minimum distance [m]
  double m_frequency; //!< frequency [Hz]
  double m_shadowing; //!< Shadowing loss [dB]




}

double
ItuR1411LosPropagationLossModel::GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b,
                                          double frequency) const
{
  NS_LOG_FUNCTION (this);
  double lambda = 299792458.0 / frequency;
  double dist = a->GetDistanceFrom (b);
  double lossLow = 0.0;
  double lossUp = 0.0;
  NS_ASSERT_MSG (a->GetPosition ().z > 0 && b->GetPosition ().z > 0, "nodes' height must be greater than 0");
  double Lbp = std::fabs (20 * std::log10 ((lambda * lambda) / (8 * M_PI * a->GetPosition ().z * b->GetPosition ().z)));
  double Rbp = (4 * a->GetPosition ().z * b->GetPosition ().z) / lambda;
  NS_LOG_LOGIC (this << " Lbp " << Lbp << " Rbp " << Rbp << " lambda " << lambda);
  if (dist <= Rbp)
    {
      lossLow = Lbp + 20 * std::log10 (dist / Rbp);

ItuR1411LosPropagationLossModel::SetFrequency (double freq)
{
  NS_ASSERT (freq > 0.0);
  m_frequency = freq;
}


double 
ItuR1411LosPropagationLossModel::DoCalcRxPower (double txPowerDbm,
                                                Ptr<MobilityModel> a,
                                                Ptr<MobilityModel> b,
                                                double frequency) const
{
  return txPowerDbm - GetLoss (a, b, frequency);
}

double 
ItuR1411LosPropagationLossModel::DoCalcRxPower (double txPowerDbm,
                                                Ptr<MobilityModel> a,
                                                Ptr<MobilityModel> b) const
{
  return txPowerDbm - GetLoss (a, b, m_frequency);
}

int64_t




   * 
   * \param a the first mobility model
   * \param b the second mobility model
   * \param frequency the carrier frequency
   * 
   * \return the loss in dBm for the propagation between
   * the two given mobility models
   */
  double GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const;

private:
  /**


  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b) const;
  virtual int64_t DoAssignStreams (int64_t stream);
  
  double m_frequency; //!< frequency in Hz
};

} // namespace ns3

(-)a/src/propagation/model/itu-r-1411-nlos-over-rooftop-propagation-loss-model.cc (-11 / +21 lines)

Lines 99-109	Link Here

100

101

double

101

double

102

ItuR1411NlosOverRooftopPropagationLossModel::GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b) const

102

ItuR1411NlosOverRooftopPropagationLossModel::GetLoss (Ptr<MobilityModel> a,

103

                                                      Ptr<MobilityModel> b,

104

                                                      double frequency) const

103

105

104

  NS_LOG_FUNCTION (this << a << b);

106

  NS_LOG_FUNCTION (this << a << b);

105

  double Lori = 0.0;

107

  double Lori = 0.0;

106

  double fmhz = m_frequency / 1e6;

108

  double fmhz = frequency / 1e6;

109

  double lambda = 299792458.0 / frequency;

107

110

108

  NS_ASSERT_MSG (((m_streetsOrientation >= 0) && (m_streetsOrientation <= 90)),

111

  NS_ASSERT_MSG (((m_streetsOrientation >= 0) && (m_streetsOrientation <= 90)),

109

                 " Street Orientation must be in [0,90]");

112

                 " Street Orientation must be in [0,90]");

Lines 125-133	Link Here

125

  double hm = (a->GetPosition ().z < b->GetPosition ().z ? a->GetPosition ().z : b->GetPosition ().z);

128

  double hm = (a->GetPosition ().z < b->GetPosition ().z ? a->GetPosition ().z : b->GetPosition ().z);

126

  NS_ASSERT_MSG (hm > 0 && hb > 0, "nodes' height must be greater then 0");

129

  NS_ASSERT_MSG (hm > 0 && hb > 0, "nodes' height must be greater then 0");

127

  double Dhb = hb - m_rooftopHeight;

130

  double Dhb = hb - m_rooftopHeight;

128

  double ds = (m_lambda * distance * distance) / (Dhb * Dhb);

131

  double ds = (distance * distance) / (Dhb * Dhb);

129

  double Lmsd = 0.0;

132

  double Lmsd = 0.0;

130

  NS_LOG_LOGIC (this << " build " << m_buildingsExtend << " ds " << ds << " roof " << m_rooftopHeight << " hb " << hb << " lambda " << m_lambda);

133

  NS_LOG_LOGIC (this << " build " << m_buildingsExtend << " ds " << ds << " roof " << m_rooftopHeight << " hb " << hb << " lambda " << lambda);

131

  if (ds < m_buildingsExtend)

134

  if (ds < m_buildingsExtend)

132

135

133

      double Lbsh = 0.0;

136

      double Lbsh = 0.0;

Lines 179-189	Link Here

179

182

180

      else if (hb > m_rooftopHeight)

183

      else if (hb > m_rooftopHeight)

181

184

182

          Qm = 2.35 * pow (Dhb / distance * std::sqrt (m_buildingSeparation / m_lambda), 0.9);

185

          Qm = 2.35 * pow (Dhb / distance * std::sqrt (m_buildingSeparation / lambda), 0.9);

183

186

184

      else

187

      else

185

188

186

          Qm = m_buildingSeparation / (2 * M_PI * distance) * std::sqrt (m_lambda / rho) * (1 / theta - (1 / (2 * M_PI + theta)));

189

          Qm = m_buildingSeparation / (2 * M_PI * distance) * std::sqrt (lambda / rho) * (1 / theta - (1 / (2 * M_PI + theta)));

187

190

188

      Lmsd = -10 * std::log10 (Qm * Qm);

191

      Lmsd = -10 * std::log10 (Qm * Qm);

189

192

Lines 208-223	Link Here

208

ItuR1411NlosOverRooftopPropagationLossModel::SetFrequency (double freq)

211

ItuR1411NlosOverRooftopPropagationLossModel::SetFrequency (double freq)

209

212

210

  m_frequency = freq;

213

  m_frequency = freq;

211

  m_lambda = 299792458.0 / freq;

212

214

213

215

214

215

double

216

double

216

ItuR1411NlosOverRooftopPropagationLossModel::DoCalcRxPower (double txPowerDbm,

217

ItuR1411NlosOverRooftopPropagationLossModel::DoCalcRxPower (double txPowerDbm,

217

						Ptr<MobilityModel> a,

218

                                                            Ptr<MobilityModel> a,

218

						Ptr<MobilityModel> b) const

219

                                                            Ptr<MobilityModel> b,

220

                                                            double frequency) const

219

221

220

  return (txPowerDbm - GetLoss (a, b));

222

  return txPowerDbm - GetLoss (a, b, frequency);

223

224

225

double

226

ItuR1411NlosOverRooftopPropagationLossModel::DoCalcRxPower (double txPowerDbm,

227

                                                            Ptr<MobilityModel> a,

228

                                                            Ptr<MobilityModel> b) const

229

230

  return txPowerDbm - GetLoss (a, b, m_frequency);

221

231

222

232

223

int64_t

233

int64_t




   * 
   * \param a the first mobility model
   * \param b the second mobility model
   * \param frequency the carrier frequency
   * 
   * \return the loss in dBm for the propagation between
   * the two given mobility models
   */
  double GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const;

private:
  /**


  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b) const;
  virtual int64_t DoAssignStreams (int64_t stream);
  
  double m_frequency; //!< frequency in Hz
  double m_lambda; //!< wavelength
  EnvironmentType m_environment; //!< Environment Scenario
  CitySize m_citySize; //!< Dimension of the city
  double m_rooftopHeight; //!< in meters

(-)a/src/propagation/model/jakes-propagation-loss-model.cc (-1 / +2 lines)

Lines 54-60	Link Here

double

double

JakesPropagationLossModel::DoCalcRxPower (double txPowerDbm,

JakesPropagationLossModel::DoCalcRxPower (double txPowerDbm,

                                          Ptr<MobilityModel> a,

                                          Ptr<MobilityModel> a,

                                          Ptr<MobilityModel> b) const

                                          Ptr<MobilityModel> b,

                                          double frequency) const

  Ptr<JakesProcess> pathData = m_propagationCache.GetPathData (a, b, 0 /**Spectrum model uid is not used in PropagationLossModel*/);

  Ptr<JakesProcess> pathData = m_propagationCache.GetPathData (a, b, 0 /**Spectrum model uid is not used in PropagationLossModel*/);

  if (pathData == 0)

  if (pathData == 0)

(-)a/src/propagation/model/jakes-propagation-loss-model.h (-1 / +2 lines)

Lines 62-68	Link Here

  JakesPropagationLossModel & operator = (const JakesPropagationLossModel &);

  JakesPropagationLossModel & operator = (const JakesPropagationLossModel &);

  double DoCalcRxPower (double txPowerDbm,

  double DoCalcRxPower (double txPowerDbm,

                        Ptr<MobilityModel> a,

                        Ptr<MobilityModel> a,

                        Ptr<MobilityModel> b) const;

                        Ptr<MobilityModel> b,

                        double frequency) const;

  virtual int64_t DoAssignStreams (int64_t stream);

  virtual int64_t DoAssignStreams (int64_t stream);

/**

/**

(-)a/src/propagation/model/kun-2600-mhz-propagation-loss-model.cc (-2 / +3 lines)

Lines 65-72	Link Here

double

double

Kun2600MhzPropagationLossModel::DoCalcRxPower (double txPowerDbm,

Kun2600MhzPropagationLossModel::DoCalcRxPower (double txPowerDbm,

					       Ptr<MobilityModel> a,

                                               Ptr<MobilityModel> a,

					       Ptr<MobilityModel> b) const

                                               Ptr<MobilityModel> b,

                                               double frequency) const

  return (txPowerDbm - GetLoss (a, b));

  return (txPowerDbm - GetLoss (a, b));

(-)a/src/propagation/model/kun-2600-mhz-propagation-loss-model.h (-1 / +2 lines)

Lines 78-84	Link Here

  // inherited from PropagationLossModel

  // inherited from PropagationLossModel

  virtual double DoCalcRxPower (double txPowerDbm,

  virtual double DoCalcRxPower (double txPowerDbm,

                                Ptr<MobilityModel> a,

                                Ptr<MobilityModel> a,

                                Ptr<MobilityModel> b) const;

                                Ptr<MobilityModel> b,

                                double frequency) const;

  virtual int64_t DoAssignStreams (int64_t stream);

  virtual int64_t DoAssignStreams (int64_t stream);

};

};

(-)a/src/propagation/model/okumura-hata-propagation-loss-model.cc (-6 / +17 lines)

Lines 73-84	Link Here

double

double

OkumuraHataPropagationLossModel::GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b) const

OkumuraHataPropagationLossModel::GetLoss (Ptr<MobilityModel> a,

                                          Ptr<MobilityModel> b,

                                          double frequency) const

  double loss = 0.0;

  double loss = 0.0;

  double fmhz = m_frequency / 1e6;

  double fmhz = frequency / 1e6;

  double dist = a->GetDistanceFrom (b) / 1000.0;

  double dist = a->GetDistanceFrom (b) / 1000.0;

  if (m_frequency <= 1.500e9)

  if (frequency <= 1.500e9)

      // standard Okumura Hata

      // standard Okumura Hata

      // see eq. (4.4.1) in the COST 231 final report

      // see eq. (4.4.1) in the COST 231 final report

Lines 146-155	Link Here

146

148

147

double

149

double

148

OkumuraHataPropagationLossModel::DoCalcRxPower (double txPowerDbm,

150

OkumuraHataPropagationLossModel::DoCalcRxPower (double txPowerDbm,

149

						Ptr<MobilityModel> a,

151

                                                Ptr<MobilityModel> a,

150

						Ptr<MobilityModel> b) const

152

                                                Ptr<MobilityModel> b,

153

                                                double frequency) const

151

154

152

  return (txPowerDbm - GetLoss (a, b));

155

  return (txPowerDbm - GetLoss (a, b, frequency));

156

157

158

double

159

OkumuraHataPropagationLossModel::DoCalcRxPower (double txPowerDbm,

160

                                                Ptr<MobilityModel> a,

161

                                                Ptr<MobilityModel> b) const

162

163

  return (txPowerDbm - GetLoss (a, b, m_frequency));

153

164

154

165

155

int64_t

166

int64_t




  /** 
   * \param a the first mobility model
   * \param b the second mobility model
   * \param frequency the carrier frequency
   * 
   * \return the loss in dBm for the propagation between
   * the two given mobility models
   */
  double GetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double frequency) const;

private:
  /**


  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b) const;
  virtual int64_t DoAssignStreams (int64_t stream);
  

(-)a/src/propagation/model/propagation-loss-model.cc (-12 / +75 lines)

Lines 72-77	Link Here

double

double

PropagationLossModel::CalcRxPower (double txPowerDbm,

PropagationLossModel::CalcRxPower (double txPowerDbm,

                                   Ptr<MobilityModel> a,

                                   Ptr<MobilityModel> a,

                                   Ptr<MobilityModel> b,

                                   double frequency) const

  double self = DoCalcRxPower (txPowerDbm, a, b, frequency);

  if (m_next != 0)

      self = m_next->CalcRxPower (self, a, b, frequency);

  return self;

double

PropagationLossModel::CalcRxPower (double txPowerDbm,

                                   Ptr<MobilityModel> a,

                                   Ptr<MobilityModel> b) const

                                   Ptr<MobilityModel> b) const

  double self = DoCalcRxPower (txPowerDbm, a, b);

  double self = DoCalcRxPower (txPowerDbm, a, b);

Lines 94-99	Link Here

  return (currentStream - stream);

108

  return (currentStream - stream);

109

110

111

double

112

PropagationLossModel::DoCalcRxPower (double txPowerDbm,

113

                                     Ptr<MobilityModel> a,

114

                                     Ptr<MobilityModel> b) const

115

116

  return DoCalcRxPower (txPowerDbm, a, b, 0.0 /* ignored */);

117

118

// ------------------------------------------------------------------------- //

119

// ------------------------------------------------------------------------- //

120

NS_OBJECT_ENSURE_REGISTERED (RandomPropagationLossModel);

121

NS_OBJECT_ENSURE_REGISTERED (RandomPropagationLossModel);

Lines 124-129	Link Here

124

double

146

double

125

RandomPropagationLossModel::DoCalcRxPower (double txPowerDbm,

147

RandomPropagationLossModel::DoCalcRxPower (double txPowerDbm,

126

                                           Ptr<MobilityModel> a,

148

                                           Ptr<MobilityModel> a,

149

                                           Ptr<MobilityModel> b,

150

                                           double frequency) const

151

152

  double rxc = -m_variable->GetValue ();

153

  NS_LOG_DEBUG ("attenuation coefficient="<<rxc<<"Db");

154

  return txPowerDbm + rxc;

155

156

157

double

158

RandomPropagationLossModel::DoCalcRxPower (double txPowerDbm,

159

                                           Ptr<MobilityModel> a,

127

                                           Ptr<MobilityModel> b) const

160

                                           Ptr<MobilityModel> b) const

128

161

129

  double rxc = -m_variable->GetValue ();

162

  double rxc = -m_variable->GetValue ();

Lines 224-231	Link Here

224

double

257

double

225

FriisPropagationLossModel::DoCalcRxPower (double txPowerDbm,

258

FriisPropagationLossModel::DoCalcRxPower (double txPowerDbm,

226

                                          Ptr<MobilityModel> a,

259

                                          Ptr<MobilityModel> a,

227

                                          Ptr<MobilityModel> b) const

260

                                          Ptr<MobilityModel> b,

261

                                          double frequency) const

228

262

263

  static const double C = 299792458.0; // speed of light in vacuum

264

  double lambda = C / frequency;

265

229

/*

266

/*

230

   * Friis free space equation:

267

   * Friis free space equation:

231

   * where Pt, Gr, Gr and P are in Watt units

268

   * where Pt, Gr, Gr and P are in Watt units

Lines 256-262	Link Here

256

   * lambda: wavelength (m)

293

   * lambda: wavelength (m)

257

*/

294

*/

258

  double distance = a->GetDistanceFrom (b);

295

  double distance = a->GetDistanceFrom (b);

259

  if (distance < 3*m_lambda)

296

  if (distance < 3*lambda)

260

297

261

      NS_LOG_WARN ("distance not within the far field region => inaccurate propagation loss value");

298

      NS_LOG_WARN ("distance not within the far field region => inaccurate propagation loss value");

262

299

Lines 264-276	Link Here

264

301

265

      return txPowerDbm - m_minLoss;

302

      return txPowerDbm - m_minLoss;

266

303

267

  double numerator = m_lambda * m_lambda;

304

  double numerator = lambda * lambda;

268

  double denominator = 16 * M_PI * M_PI * distance * distance * m_systemLoss;

305

  double denominator = 16 * M_PI * M_PI * distance * distance * m_systemLoss;

269

  double lossDb = -10 * log10 (numerator / denominator);

306

  double lossDb = -10 * log10 (numerator / denominator);

270

  NS_LOG_DEBUG ("distance=" << distance<< "m, loss=" << lossDb <<"dB");

307

  NS_LOG_DEBUG ("distance=" << distance<< "m, loss=" << lossDb <<"dB");

271

  return txPowerDbm - std::max (lossDb, m_minLoss);

308

  return txPowerDbm - std::max (lossDb, m_minLoss);

272

309

273

310

311

double

312

FriisPropagationLossModel::DoCalcRxPower (double txPowerDbm,

313

                                          Ptr<MobilityModel> a,

314

                                          Ptr<MobilityModel> b) const

315

316

  return DoCalcRxPower (txPowerDbm, a, b, m_frequency);

317

318

274

int64_t

319

int64_t

275

FriisPropagationLossModel::DoAssignStreams (int64_t stream)

320

FriisPropagationLossModel::DoAssignStreams (int64_t stream)

276

321

Lines 374-381	Link Here

374

double

419

double

375

TwoRayGroundPropagationLossModel::DoCalcRxPower (double txPowerDbm,

420

TwoRayGroundPropagationLossModel::DoCalcRxPower (double txPowerDbm,

376

                                                 Ptr<MobilityModel> a,

421

                                                 Ptr<MobilityModel> a,

377

                                                 Ptr<MobilityModel> b) const

422

                                                 Ptr<MobilityModel> b,

423

                                                 double frequency) const

378

424

425

  static const double C = 299792458.0; // speed of light in vacuum

426

  double lambda = C / frequency;

427

379

/*

428

/*

380

   * Two-Ray Ground equation:

429

   * Two-Ray Ground equation:

381

430

Lines 419-430	Link Here

419

468

420

*/

469

*/

421

470

422

  double dCross = (4 * M_PI * txAntHeight * rxAntHeight) / m_lambda;

471

  double dCross = (4 * M_PI * txAntHeight * rxAntHeight) / lambda;

423

  double tmp = 0;

472

  double tmp = 0;

424

  if (distance <= dCross)

473

  if (distance <= dCross)

425

474

426

      // We use Friis

475

      // We use Friis

427

      double numerator = m_lambda * m_lambda;

476

      double numerator = lambda * lambda;

428

      tmp = M_PI * distance;

477

      tmp = M_PI * distance;

429

      double denominator = 16 * tmp * tmp * m_systemLoss;

478

      double denominator = 16 * tmp * tmp * m_systemLoss;

430

      double pr = 10 * std::log10 (numerator / denominator);

479

      double pr = 10 * std::log10 (numerator / denominator);

Lines 445-450	Link Here

445

494

446

495

447

496

497

double

498

TwoRayGroundPropagationLossModel::DoCalcRxPower (double txPowerDbm,

499

                                                 Ptr<MobilityModel> a,

500

                                                 Ptr<MobilityModel> b) const

501

502

  return DoCalcRxPower (txPowerDbm, a, b, m_frequency);

503

504

448

int64_t

505

int64_t

449

TwoRayGroundPropagationLossModel::DoAssignStreams (int64_t stream)

506

TwoRayGroundPropagationLossModel::DoAssignStreams (int64_t stream)

450

507

Lines 506-512	Link Here

506

double

563

double

507

LogDistancePropagationLossModel::DoCalcRxPower (double txPowerDbm,

564

LogDistancePropagationLossModel::DoCalcRxPower (double txPowerDbm,

508

                                                Ptr<MobilityModel> a,

565

                                                Ptr<MobilityModel> a,

509

                                                Ptr<MobilityModel> b) const

566

                                                Ptr<MobilityModel> b,

567

                                                double frequency) const

510

568

511

  double distance = a->GetDistanceFrom (b);

569

  double distance = a->GetDistanceFrom (b);

512

  if (distance <= m_referenceDistance)

570

  if (distance <= m_referenceDistance)

Lines 598-604	Link Here

598

double

656

double

599

ThreeLogDistancePropagationLossModel::DoCalcRxPower (double txPowerDbm,

657

ThreeLogDistancePropagationLossModel::DoCalcRxPower (double txPowerDbm,

600

                                                     Ptr<MobilityModel> a,

658

                                                     Ptr<MobilityModel> a,

601

                                                     Ptr<MobilityModel> b) const

659

                                                     Ptr<MobilityModel> b,

660

                                                     double frequency) const

602

661

603

  double distance = a->GetDistanceFrom (b);

662

  double distance = a->GetDistanceFrom (b);

604

  NS_ASSERT (distance >= 0);

663

  NS_ASSERT (distance >= 0);

Lines 700-706	Link Here

700

double

759

double

701

NakagamiPropagationLossModel::DoCalcRxPower (double txPowerDbm,

760

NakagamiPropagationLossModel::DoCalcRxPower (double txPowerDbm,

702

                                             Ptr<MobilityModel> a,

761

                                             Ptr<MobilityModel> a,

703

                                             Ptr<MobilityModel> b) const

762

                                             Ptr<MobilityModel> b,

763

                                             double frequency) const

704

764

705

  // select m parameter

765

  // select m parameter

706

766

Lines 793-799	Link Here

793

double

853

double

794

FixedRssLossModel::DoCalcRxPower (double txPowerDbm,

854

FixedRssLossModel::DoCalcRxPower (double txPowerDbm,

795

                                  Ptr<MobilityModel> a,

855

                                  Ptr<MobilityModel> a,

796

                                  Ptr<MobilityModel> b) const

856

                                  Ptr<MobilityModel> b,

857

                                  double frequency) const

797

858

798

  return m_rss;

859

  return m_rss;

799

860

Lines 864-870	Link Here

864

double

925

double

865

MatrixPropagationLossModel::DoCalcRxPower (double txPowerDbm,

926

MatrixPropagationLossModel::DoCalcRxPower (double txPowerDbm,

866

                                           Ptr<MobilityModel> a,

927

                                           Ptr<MobilityModel> a,

867

                                           Ptr<MobilityModel> b) const

928

                                           Ptr<MobilityModel> b,

929

                                           double frequency) const

868

930

869

  std::map<MobilityPair, double>::const_iterator i = m_loss.find (std::make_pair (a, b));

931

  std::map<MobilityPair, double>::const_iterator i = m_loss.find (std::make_pair (a, b));

870

932

Lines 911-917	Link Here

911

double

973

double

912

RangePropagationLossModel::DoCalcRxPower (double txPowerDbm,

974

RangePropagationLossModel::DoCalcRxPower (double txPowerDbm,

913

                                          Ptr<MobilityModel> a,

975

                                          Ptr<MobilityModel> a,

914

                                          Ptr<MobilityModel> b) const

976

                                          Ptr<MobilityModel> b,

977

                                          double frequency) const

915

978

916

  double distance = a->GetDistanceFrom (b);

979

  double distance = a->GetDistanceFrom (b);

917

  if (distance <= m_range)

980

  if (distance <= m_range)




   * \param txPowerDbm current transmission power (in dBm)
   * \param a the mobility model of the source
   * \param b the mobility model of the destination
   * \param frequency the carrier frequency
   * \returns the reception power after adding/multiplying propagation loss (in dBm)
   */
  double CalcRxPower (double txPowerDbm,
                      Ptr<MobilityModel> a,
                      Ptr<MobilityModel> b,
                      double frequency) const;

  /**
   * Returns the Rx Power taking into account all the PropagationLossModel(s)
   * chained to the current one.
   *
   * \param txPowerDbm current transmission power (in dBm)
   * \param a the mobility model of the source
   * \param b the mobility model of the destination
   * \returns the reception power after adding/multiplying propagation loss (in dBm)
   * \deprecated This method will go away in future versions of ns-3.
   * See https://www.nsnam.org/bugzilla/show_bug.cgi?id=2122
   */
  NS_DEPRECATED
  double CalcRxPower (double txPowerDbm,
                      Ptr<MobilityModel> a,
                      Ptr<MobilityModel> b) const;

  /**

   * \param txPowerDbm current transmission power (in dBm)
   * \param a the mobility model of the source
   * \param b the mobility model of the destination
   * \param frequency the carrier frequency
   * \returns the reception power after adding/multiplying propagation loss (in dBm)
   */
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const = 0;

  /**
   * Returns the Rx Power taking into account only the particular
   * PropagationLossModel.
   *
   * \param txPowerDbm current transmission power (in dBm)
   * \param a the mobility model of the source
   * \param b the mobility model of the destination
   * \returns the reception power after adding/multiplying propagation loss (in dBm)
   * \deprecated This method will go away in future versions of ns-3.
   * See https://www.nsnam.org/bugzilla/show_bug.cgi?id=2122
   */
  NS_DEPRECATED
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b) const;

  /**
   * Subclasses must implement this; those not using random variables

  RandomPropagationLossModel & operator = (const RandomPropagationLossModel &);
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b) const;
  virtual int64_t DoAssignStreams (int64_t stream);
  Ptr<RandomVariableStream> m_variable; //!< random generator


  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b) const;
  virtual int64_t DoAssignStreams (int64_t stream);



  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b) const;
  virtual int64_t DoAssignStreams (int64_t stream);



  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;
  virtual int64_t DoAssignStreams (int64_t stream);

  /**


  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;
  virtual int64_t DoAssignStreams (int64_t stream);

  double m_distance0; //!< Beginning of the first (near) distance field


  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;
  virtual int64_t DoAssignStreams (int64_t stream);

  double m_distance1; //!< Distance1


  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;

  virtual int64_t DoAssignStreams (int64_t stream);
  double m_rss; //!< the received signal strength


  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;

  virtual int64_t DoAssignStreams (int64_t stream);
private:

  RangePropagationLossModel& operator= (const RangePropagationLossModel&);
  virtual double DoCalcRxPower (double txPowerDbm,
                                Ptr<MobilityModel> a,
                                Ptr<MobilityModel> b,
                                double frequency) const;
  virtual int64_t DoAssignStreams (int64_t stream);
private:
  double m_range; //!< Maximum Transmission Range (meters)

(-)a/src/propagation/test/itu-r-1411-los-test-suite.cc (-1 / +1 lines)

Lines 82-88	Link Here

  Ptr<ItuR1411LosPropagationLossModel> propagationLossModel = CreateObject<ItuR1411LosPropagationLossModel> ();

  Ptr<ItuR1411LosPropagationLossModel> propagationLossModel = CreateObject<ItuR1411LosPropagationLossModel> ();

  propagationLossModel->SetAttribute ("Frequency", DoubleValue (m_freq));

  propagationLossModel->SetAttribute ("Frequency", DoubleValue (m_freq));

  double loss = propagationLossModel->GetLoss (mma, mmb);

  double loss = propagationLossModel->GetLoss (mma, mmb, m_freq);

  NS_LOG_INFO ("Calculated loss: " << loss);

  NS_LOG_INFO ("Calculated loss: " << loss);

  NS_LOG_INFO ("Theoretical loss: " << m_lossRef);

  NS_LOG_INFO ("Theoretical loss: " << m_lossRef);

(-)a/src/propagation/test/itu-r-1411-nlos-over-rooftop-test-suite.cc (-1 / +1 lines)

Lines 88-94	Link Here

  propagationLossModel->SetAttribute ("Environment", EnumValue (m_env));

  propagationLossModel->SetAttribute ("Environment", EnumValue (m_env));

  propagationLossModel->SetAttribute ("CitySize", EnumValue (m_city));

  propagationLossModel->SetAttribute ("CitySize", EnumValue (m_city));

  double loss = propagationLossModel->GetLoss (mma, mmb);

  double loss = propagationLossModel->GetLoss (mma, mmb, m_freq);

  NS_LOG_INFO ("Calculated loss: " << loss);

  NS_LOG_INFO ("Calculated loss: " << loss);

  NS_LOG_INFO ("Theoretical loss: " << m_lossRef);

  NS_LOG_INFO ("Theoretical loss: " << m_lossRef);

(-)a/src/propagation/test/okumura-hata-test-suite.cc (-1 / +1 lines)

Lines 88-94	Link Here

  propagationLossModel->SetAttribute ("Environment", EnumValue (m_env));

  propagationLossModel->SetAttribute ("Environment", EnumValue (m_env));

  propagationLossModel->SetAttribute ("CitySize", EnumValue (m_city));

  propagationLossModel->SetAttribute ("CitySize", EnumValue (m_city));

  double loss = propagationLossModel->GetLoss (mma, mmb);

  double loss = propagationLossModel->GetLoss (mma, mmb, m_freq);

  NS_LOG_INFO ("Calculated loss: " << loss);

  NS_LOG_INFO ("Calculated loss: " << loss);

  NS_LOG_INFO ("Theoretical loss: " << m_lossRef);

  NS_LOG_INFO ("Theoretical loss: " << m_lossRef);





  // the test vectors have been determined for a wavelength of 0.125 m 
  // which corresponds to a frequency of 2398339664.0 Hz in the vacuum
  double frequency{2398339664.0};
  Config::SetDefault ("ns3::FriisPropagationLossModel::Frequency", DoubleValue (frequency));
  Config::SetDefault ("ns3::FriisPropagationLossModel::SystemLoss", DoubleValue (1.0));

  // Select a reference transmit power

    {
      testVector = m_testVectors.Get (i);
      b->SetPosition (testVector.m_position);
      double resultdBm = lossModel->CalcRxPower (testVector.m_pt, a, b, frequency);
      double resultW = std::pow (10.0, resultdBm/10.0)/1000;
      NS_TEST_EXPECT_MSG_EQ_TOL (resultW, testVector.m_pr, testVector.m_tolerance, "Got unexpected rcv power");
    }

{
  // the test vectors have been determined for a wavelength of 0.125 m 
  // which corresponds to a frequency of 2398339664.0 Hz in the vacuum
  double frequency{2398339664.0};
  Config::SetDefault ("ns3::TwoRayGroundPropagationLossModel::Frequency", DoubleValue (frequency));
  Config::SetDefault ("ns3::TwoRayGroundPropagationLossModel::SystemLoss", DoubleValue (1.0));

  // set antenna height to 1.5m above z coordinate

    {
      testVector = m_testVectors.Get (i);
      b->SetPosition (testVector.m_position);
      double resultdBm = lossModel->CalcRxPower (testVector.m_pt, a, b, frequency);
      double resultW = std::pow (10.0, resultdBm / 10.0) / 1000;
      NS_TEST_EXPECT_MSG_EQ_TOL (resultW, testVector.m_pr, testVector.m_tolerance, "Got unexpected rcv power");
    }

LogDistancePropagationLossModelTestCase::DoRun (void)
{
  // reference loss at 2.4 GHz is 40.045997
  double frequency{40.045997};
  Config::SetDefault ("ns3::LogDistancePropagationLossModel::ReferenceLoss", DoubleValue (frequency));
  Config::SetDefault ("ns3::LogDistancePropagationLossModel::Exponent", DoubleValue (3));

  // Select a reference transmit power

    {
      testVector = m_testVectors.Get (i);
      b->SetPosition (testVector.m_position);
      double resultdBm = lossModel->CalcRxPower (testVector.m_pt, a, b, frequency);
      double resultW = std::pow (10.0, resultdBm/10.0)/1000;
      NS_TEST_EXPECT_MSG_EQ_TOL (resultW, testVector.m_pr, testVector.m_tolerance, "Got unexpected rcv power");
    }

void
MatrixPropagationLossModelTestCase::DoRun (void)
{
  double frequency{0.0}; // Does not matter for MatrixPropagationLossModel
  Ptr<MobilityModel> m[3];
  for (int i = 0; i < 3; ++i)
    {

  loss.SetLoss (m[2], m[0], 100, /*symmetric = */ false);
  // default from 1 to 2

  NS_TEST_ASSERT_MSG_EQ (loss.CalcRxPower (0, m[0], m[1], frequency), -10, "Loss 0 -> 1 incorrect");
  NS_TEST_ASSERT_MSG_EQ (loss.CalcRxPower (0, m[1], m[0], frequency), -10, "Loss 1 -> 0 incorrect");
  NS_TEST_ASSERT_MSG_EQ (loss.CalcRxPower (0, m[0], m[2], frequency), -30, "Loss 0 -> 2 incorrect");
  NS_TEST_ASSERT_MSG_EQ (loss.CalcRxPower (0, m[2], m[0], frequency), -100, "Loss 2 -> 0 incorrect");
  NS_TEST_ASSERT_MSG_EQ (loss.CalcRxPower (0, m[1], m[2], frequency), 0, "Loss 1 -> 2 incorrect");
  NS_TEST_ASSERT_MSG_EQ (loss.CalcRxPower (0, m[2], m[1], frequency), 0, "Loss 2 -> 1 incorrect");

  Simulator::Destroy ();
}

void
RangePropagationLossModelTestCase::DoRun (void)
{
  double frequency{0.0}; // Does not matter for RangePropagationLossModel
  Config::SetDefault ("ns3::RangePropagationLossModel::MaxRange", DoubleValue (127.2));
  Ptr<MobilityModel> a = CreateObject<ConstantPositionMobilityModel> (); 
  a->SetPosition (Vector (0,0,0));


  double txPwrdBm = -80.0;
  double tolerance = 1e-6;
  double resultdBm = lossModel->CalcRxPower (txPwrdBm, a, b, frequency);
  NS_TEST_EXPECT_MSG_EQ_TOL (resultdBm, txPwrdBm, tolerance, "Got unexpected rcv power");
  b->SetPosition (Vector (127.25,0,0));  // beyond range
  resultdBm = lossModel->CalcRxPower (txPwrdBm, a, b, frequency);
  NS_TEST_EXPECT_MSG_EQ_TOL (resultdBm, -1000.0, tolerance, "Got unexpected rcv power");
  Simulator::Destroy ();
}

Return to bug 2122