Attachment #1893 for bug #938

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




                   MakeDoubleChecker<double> ())

    .AddAttribute ("BSAntennaHeight",
                   "BS Antenna Height (default is 50m).",
                   DoubleValue (50.0),
                   MakeDoubleAccessor (&Cost231PropagationLossModel::m_BSAntennaHeight),
                   MakeDoubleChecker<double> ())

    .AddAttribute ("SSAntennaHeight",
                   "SS Antenna Height (default is 3m).",
                   DoubleValue (3),
                   MakeDoubleAccessor (&Cost231PropagationLossModel::m_SSAntennaHeight),
                   MakeDoubleChecker<double> ())


Cost231PropagationLossModel::Cost231PropagationLossModel ()
{
  C = 0;
  m_shadowing = 10;
}


  return m_SSAntennaHeight;
}

void
Cost231PropagationLossModel::SetEnvironment (Environment env)
{
  m_environment = env;
}
Cost231PropagationLossModel::Environment
Cost231PropagationLossModel::GetEnvironment (void) const
{
  return m_environment;
}

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

  // Ch. 4, eq. 4.4.3, pg. 135

  double loss_in_db = 46.3 + (33.9 * std::log10(frequency_MHz)) - (13.82 * std::log10 (m_BSAntennaHeight)) - C_H
		  	  	  + ((44.9 - 6.55 * std::log10 (m_BSAntennaHeight)) * std::log10 (distance_km)) + m_shadowing;

  NS_LOG_DEBUG ("dist =" << distance << ", Path Loss = " << loss_in_db);


(-)a/src/propagation/model/cost231-propagation-loss-model.h (-15 / +73 lines)

Lines 51-93	Link Here

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  Cost231PropagationLossModel ();

  Cost231PropagationLossModel ();

  enum Environment

    SubUrban, MediumCity, Metropolitan

};

/**

/**

   * Get the propagation loss

   * \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

   * \returns the propagation loss (in dBm)

   * \returns the propagation loss (in dBm)

*/

*/

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

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

/**

   * Set the BS antenna height

   * \param height BS antenna height [m]

*/

  void SetBSAntennaHeight (double height);

  void SetBSAntennaHeight (double height);

/**

   * Set the SS antenna height

   * \param height SS antenna height [m]

*/

  void SetSSAntennaHeight (double height);

  void SetSSAntennaHeight (double height);

  void SetEnvironment (Environment env);

/**

   * Set the wavelength

   * \param lambda the wavelength

*/

  void SetLambda (double lambda);

  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

*/

  void SetMinDistance (double minDistance);

  void SetMinDistance (double minDistance);

/**

   * Get the BS antenna height

   * \returns BS antenna height [m]

*/

  double GetBSAntennaHeight (void) const;

100

  double GetBSAntennaHeight (void) const;

101

/**

102

   * Get the SS antenna height

103

   * \returns SS antenna height [m]

104

*/

  double GetSSAntennaHeight (void) const;

105

  double GetSSAntennaHeight (void) const;

  Environment GetEnvironment (void) const;

106

/**

107

   * Get the minimum model distance

108

   * \returns the minimum model distance

109

*/

  double GetMinDistance (void) const;

110

  double GetMinDistance (void) const;

111

/**

112

   * Get the wavelength

113

   * \returns the wavelength

114

*/

  double GetLambda (void) const;

115

  double GetLambda (void) const;

  void SetLambda (double frequency, double speed);

116

/**

117

   * Get the shadowing value

118

   * \returns the shadowing value

119

*/

  double GetShadowing (void);

120

  double GetShadowing (void);

121

/**

122

   * Set the shadowing value

123

   * \param shadowing the shadowing value

124

*/

  void SetShadowing (double shadowing);

125

  void SetShadowing (double shadowing);

private:

126

private:

127

/**

128

   * \brief Copy constructor

129

130

   * Defined and unimplemented to avoid misuse

131

*/

132

  Cost231PropagationLossModel (const Cost231PropagationLossModel &);

133

/**

134

   * \brief Copy constructor

135

136

   * Defined and unimplemented to avoid misuse

137

   * \returns

138

*/

139

  Cost231PropagationLossModel & operator = (const Cost231PropagationLossModel &);

140

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

141

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

  virtual int64_t DoAssignStreams (int64_t stream);

142

  virtual int64_t DoAssignStreams (int64_t stream);

  double m_BSAntennaHeight; // in meter

143

  double m_BSAntennaHeight; //!< BS Antenna Height [m]

  double m_SSAntennaHeight; // in meter

144

  double m_SSAntennaHeight; //!< SS Antenna Height [m]

  double C;

145

  double m_lambda; //!< The wavelength

  double m_lambda;

146

  double m_minDistance; //!< minimum distance [m]

  Environment m_environment;

147

  double m_frequency; //!< frequency [Hz]

  double m_minDistance; // in meter

148

  double m_shadowing; //!< Shadowing loss [dB]

  double m_frequency; // frequency in MHz

  double m_shadowing;

149

};

150

};

151

(-)a/src/propagation/model/itu-r-1411-los-propagation-loss-model.h (-3 / +18 lines)

Lines 44-50	Link Here

public:

public:

  // inherited from Object

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  ItuR1411LosPropagationLossModel ();

  ItuR1411LosPropagationLossModel ();

Lines 69-82	Link Here

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

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

private:

private:

/**

   * \brief Copy constructor

   * Defined and unimplemented to avoid misuse

*/

  ItuR1411LosPropagationLossModel (const ItuR1411LosPropagationLossModel &);

/**

   * \brief Copy constructor

   * Defined and unimplemented to avoid misuse

   * \returns

*/

  ItuR1411LosPropagationLossModel & operator = (const ItuR1411LosPropagationLossModel &);

  // 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) const;

  virtual int64_t DoAssignStreams (int64_t stream);

  virtual int64_t DoAssignStreams (int64_t stream);

  double m_lambda; // wavelength

  double m_lambda; //!< wavelength

};

};

} // namespace ns3

} // namespace ns3

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

Lines 44-50	Link Here

public:

public:

  // inherited from Object

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  ItuR1411NlosOverRooftopPropagationLossModel ();

  ItuR1411NlosOverRooftopPropagationLossModel ();

Lines 69-90	Link Here

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

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

private:

private:

/**

   * \brief Copy constructor

   * Defined and unimplemented to avoid misuse

*/

  ItuR1411NlosOverRooftopPropagationLossModel (const ItuR1411NlosOverRooftopPropagationLossModel &);

/**

   * \brief Copy constructor

   * Defined and unimplemented to avoid misuse

   * \returns

*/

  ItuR1411NlosOverRooftopPropagationLossModel & operator = (const ItuR1411NlosOverRooftopPropagationLossModel &);

  // 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) const;

  virtual int64_t DoAssignStreams (int64_t stream);

  virtual int64_t DoAssignStreams (int64_t stream);

  double m_frequency; ///< frequency in MHz

  double m_frequency; //!< frequency in MHz

  double m_lambda; ///< wavelength

  double m_lambda; //!< wavelength

  EnvironmentType m_environment;

  EnvironmentType m_environment; //!< Environment Scenario

  CitySize m_citySize;

  CitySize m_citySize; //!< Dimension of the city

  double m_rooftopHeight; ///< in meters

  double m_rooftopHeight; //!< in meters

  double m_streetsOrientation; ///< in degrees [0,90]

  double m_streetsOrientation; //!< in degrees [0,90]

  double m_streetsWidth; ///< in meters

100

  double m_streetsWidth; //!< in meters

  double m_buildingsExtend; ///< in meters

101

  double m_buildingsExtend; //!< in meters

  double m_buildingSeparation; ///< in meters

102

  double m_buildingSeparation; //!< in meters

103

};

104

};

105

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

Lines 85-91	Link Here

void

void

JakesProcess::SetDopplerFrequencyHz (double dopplerFrequencyHz)

JakesProcess::SetDopplerFrequencyHz (double dopplerFrequencyHz)

  m_omegaDopplerMax = 2 * dopplerFrequencyHz * JakesPropagationLossModel::PI;

  m_omegaDopplerMax = 2 * dopplerFrequencyHz * M_PI;

void

void

Lines 101-107	Link Here

101

      unsigned int n = i + 1;

101

      unsigned int n = i + 1;

102

      /// 1. Rotation speed

102

      /// 1. Rotation speed

103

      /// 1a. Initiate \f[ \alpha_n = \frac{2\pi n - \pi + \theta}{4M},  n=1,2, \ldots,M\f], n is oscillatorNumber, M is m_nOscillators

103

      /// 1a. Initiate \f[ \alpha_n = \frac{2\pi n - \pi + \theta}{4M},  n=1,2, \ldots,M\f], n is oscillatorNumber, M is m_nOscillators

104

      double alpha = (2.0 * JakesPropagationLossModel::PI * n - JakesPropagationLossModel::PI + theta) / (4.0 * m_nOscillators);

104

      double alpha = (2.0 * M_PI * n - M_PI + theta) / (4.0 * m_nOscillators);

105

      /// 1b. Initiate rotation speed:

105

      /// 1b. Initiate rotation speed:

106

      double omega = m_omegaDopplerMax * std::cos (alpha);

106

      double omega = m_omegaDopplerMax * std::cos (alpha);

107

      /// 2. Initiate complex amplitude:

107

      /// 2. Initiate complex amplitude:

(-)a/src/propagation/model/jakes-process.h (-20 / +56 lines)

Lines 55-97	Link Here

class JakesProcess : public Object

class JakesProcess : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  JakesProcess ();

  JakesProcess ();

  virtual ~JakesProcess();

  virtual ~JakesProcess();

  virtual void DoDispose ();

  virtual void DoDispose ();

/**

   * Get the channel complex gain

   * \return the channel complex gain

*/

  std::complex<double> GetComplexGain () const;

  std::complex<double> GetComplexGain () const;

  /// Get Channel gain [dB]

/**

   * Get the channel gain in dB

   * \return the channel gain [dB]

*/

  double GetChannelGainDb () const;

  double GetChannelGainDb () const;

  void SetPropagationLossModel (Ptr<const PropagationLossModel>);

/**

   * Set the propagation model using this class

   * \param model the propagation model using this class

*/

  void SetPropagationLossModel (Ptr<const PropagationLossModel> model);

private:

private:

  /// Represents a single oscillator

/**

   * This class Represents a single oscillator

*/

  struct Oscillator

  struct Oscillator

    /// Initiate oscillator with complex amplitude, initial phase and rotation speed

/**

     * Initiate oscillator with complex amplitude, initial phase and rotation speed

     * \param amplitude initial complex amplitude

     * \param initialPhase initial phase

     * \param omega rotation speed

*/

    Oscillator (std::complex<double> amplitude, double initialPhase, double omega);

    Oscillator (std::complex<double> amplitude, double initialPhase, double omega);

    // Get the complex amplitude at moment \param t

/**

     * Get the complex amplitude at a given moment

     * \param t time instant

     * \returns the complex amplitude

100

*/

    std::complex<double> GetValueAt (Time t) const;

101

    std::complex<double> GetValueAt (Time t) const;

    /// Complex number \f$Re=\cos(\psi_n), Im = i\sin(\psi_n)]\f$

102

    std::complex<double> m_amplitude;

103

    std::complex<double> m_amplitude; //!< Complex number \f$Re=\cos(\psi_n), Im = i\sin(\psi_n)]\f$

    /// Phase \f$\phi_n\f$ of the oscillator

104

    double m_phase; //!< Phase \f$\phi_n\f$ of the oscillator

    double m_phase;

105

    double m_omega; //!< Rotation speed of the oscillator \f$\omega_d \cos(\alpha_n)\f$

    /// Rotation speed of the oscillator \f$\omega_d \cos(\alpha_n)\f$

    double m_omega;

};

106

};

private:

107

private:

108

109

/**

110

   * Set the number of Oscillators to use

111

   * @param nOscillators the number of oscillators

112

*/

  void SetNOscillators (unsigned int nOscillators);

113

  void SetNOscillators (unsigned int nOscillators);

114

115

/**

116

   * Set the Doppler frequency

117

   * @param dopplerFrequencyHz the Doppler frequency [Hz]

118

*/

  void SetDopplerFrequencyHz (double dopplerFrequencyHz);

119

  void SetDopplerFrequencyHz (double dopplerFrequencyHz);

120

121

/**

122

123

*/

  void ConstructOscillators ();

124

  void ConstructOscillators ();

private:

125

private:

  /// Vector of oscillators:

126

  std::vector<Oscillator> m_oscillators; //!< Vector of oscillators

  std::vector<Oscillator> m_oscillators;

127

  double m_omegaDopplerMax; //!< max rotation speed Doppler frequency

  ///\name Attributes:

128

  unsigned int m_nOscillators;  //!< number of oscillators

  ///\{

129

  Ptr<UniformRandomVariable> m_uniformVariable; //!< random stream

  double m_omegaDopplerMax;

130

  Ptr<const JakesPropagationLossModel> m_jakes; //!< pointer to the propagation loss model

  unsigned int m_nOscillators;

  Ptr<UniformRandomVariable> m_uniformVariable;

  Ptr<const JakesPropagationLossModel> m_jakes;

  ///\}

};

131

};

} // namespace ns3

132

} // namespace ns3

#endif // DOPPLER_PROCESS_H

133

#endif // DOPPLER_PROCESS_H




NS_OBJECT_ENSURE_REGISTERED (JakesPropagationLossModel);


const double JakesPropagationLossModel::PI = 3.14159265358979323846;

JakesPropagationLossModel::JakesPropagationLossModel()
{
  m_uniformVariable = CreateObject<UniformRandomVariable> ();
  m_uniformVariable->SetAttribute ("Min", DoubleValue (-1.0 * M_PI));
  m_uniformVariable->SetAttribute ("Max", DoubleValue (M_PI));
}

JakesPropagationLossModel::~JakesPropagationLossModel()

    {
      pathData = CreateObject<JakesProcess> ();
      pathData->SetPropagationLossModel (this);
      m_propagationCache.AddPathData (pathData, a, b, 0 /**Spectrum model uid is not used in PropagationLossModel*/);
    }
  return txPowerDbm + pathData->GetChannelGainDb ();
}




/**
 * \ingroup propagation
 *
 * \brief a  Jakes narrowband propagation model.
 * Symmetrical cache for JakesProcess
 */

class JakesPropagationLossModel : public PropagationLossModel
{
public:
  /**
   * \brief Get the type ID.
   * \return the object TypeId
   */
  static TypeId GetTypeId ();
  JakesPropagationLossModel ();
  virtual ~JakesPropagationLossModel ();
  
  static const double PI;

private:
  friend class JakesProcess;

  /**
   * \brief Copy constructor
   *
   * Defined and unimplemented to avoid misuse
   */
  JakesPropagationLossModel (const JakesPropagationLossModel &);
  /**
   * \brief Copy constructor
   *
   * Defined and unimplemented to avoid misuse
   * \returns
   */
  JakesPropagationLossModel & operator = (const JakesPropagationLossModel &);
  double DoCalcRxPower (double txPowerDbm,
                        Ptr<MobilityModel> a,
                        Ptr<MobilityModel> b) const;
  virtual int64_t DoAssignStreams (int64_t stream);

  /**
   * Get the underlying RNG stream
   * \return the RNG stream
   */
  Ptr<UniformRandomVariable> GetUniformRandomVariable () const;

  Ptr<UniformRandomVariable> m_uniformVariable; //!< random stream
  mutable PropagationCache<JakesProcess> m_propagationCache; //!< Propagation cache
  mutable PropagationCache<JakesProcess> m_propagationCache;
};

} // namespace ns3

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

Lines 42-49	Link Here

public:

public:

/**

  // inherited from Object

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  Kun2600MhzPropagationLossModel ();

  Kun2600MhzPropagationLossModel ();

Lines 59-64	Link Here

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

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

private:

private:

/**

   * \brief Copy constructor

   * Defined and unimplemented to avoid misuse

*/

  Kun2600MhzPropagationLossModel (const Kun2600MhzPropagationLossModel &);

/**

   * \brief Copy constructor

   * Defined and unimplemented to avoid misuse

   * \returns

*/

  Kun2600MhzPropagationLossModel & operator = (const Kun2600MhzPropagationLossModel &);

  // inherited from PropagationLossModel

  // inherited from PropagationLossModel

  virtual double DoCalcRxPower (double txPowerDbm,

  virtual double DoCalcRxPower (double txPowerDbm,

(-)a/src/propagation/model/okumura-hata-propagation-loss-model.h (-5 / +20 lines)

Lines 45-51	Link Here

public:

public:

  // inherited from Object

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  OkumuraHataPropagationLossModel ();

  OkumuraHataPropagationLossModel ();

Lines 61-76	Link Here

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

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

private:

private:

/**

   * \brief Copy constructor

   * Defined and unimplemented to avoid misuse

*/

  OkumuraHataPropagationLossModel (const OkumuraHataPropagationLossModel &);

/**

   * \brief Copy constructor

   * Defined and unimplemented to avoid misuse

   * \returns

*/

  OkumuraHataPropagationLossModel & operator = (const OkumuraHataPropagationLossModel &);

  // 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) const;

  virtual int64_t DoAssignStreams (int64_t stream);

  virtual int64_t DoAssignStreams (int64_t stream);

  EnvironmentType m_environment;

  EnvironmentType m_environment;  //!< Environment Scenario

  CitySize m_citySize;

  CitySize m_citySize;  //!< Size of the city

  double m_frequency; // frequency in MHz

  double m_frequency; //!< frequency in Hz

};

};

} // namespace ns3

} // namespace ns3

(-)a/src/propagation/model/propagation-cache.h (-5 / +29 lines)

Lines 27-33	Link Here

/**

/**

 * \ingroup propagation

 * \ingroup propagation

 * \brief Constructs a cache of objects, where each obect is responsible for a single propagation path loss calculations.

 * \brief Constructs a cache of objects, where each object is responsible for a single propagation path loss calculations.

 * Propagation path a-->b and b-->a is the same thing. Propagation path is identified by

 * Propagation path a-->b and b-->a is the same thing. Propagation path is identified by

 * a couple of MobilityModels and a spectrum model UID

 * a couple of MobilityModels and a spectrum model UID

*/

*/

Lines 37-42	Link Here

public:

public:

  PropagationCache () {};

  PropagationCache () {};

  ~PropagationCache () {};

  ~PropagationCache () {};

/**

   * Get the model associated with the path

   * \param a 1st node mobility model

   * \param b 2nd node mobility model

   * \param modelUid model UID

   * \return the model

*/

  Ptr<T> GetPathData (Ptr<const MobilityModel> a, Ptr<const MobilityModel> b, uint32_t modelUid)

  Ptr<T> GetPathData (Ptr<const MobilityModel> a, Ptr<const MobilityModel> b, uint32_t modelUid)

    PropagationPathIdentifier key = PropagationPathIdentifier (a, b, modelUid);

    PropagationPathIdentifier key = PropagationPathIdentifier (a, b, modelUid);

Lines 47-52	Link Here

    return it->second;

    return it->second;

};

};

/**

   * Add a model to the path

   * \param data the model to associate to the path

   * \param a 1st node mobility model

   * \param b 2nd node mobility model

   * \param modelUid model UID

*/

  void AddPathData (Ptr<T> data, Ptr<const MobilityModel> a, Ptr<const MobilityModel> b, uint32_t modelUid)

  void AddPathData (Ptr<T> data, Ptr<const MobilityModel> a, Ptr<const MobilityModel> b, uint32_t modelUid)

    PropagationPathIdentifier key = PropagationPathIdentifier (a, b, modelUid);

    PropagationPathIdentifier key = PropagationPathIdentifier (a, b, modelUid);

Lines 57-68	Link Here

  /// Each path is identified by

  /// Each path is identified by

  struct PropagationPathIdentifier

  struct PropagationPathIdentifier

/**

     * Constructor

     * @param a 1st node mobility model

     * @param b 2nd node mobility model

     * @param modelUid model UID

*/

    PropagationPathIdentifier (Ptr<const MobilityModel> a, Ptr<const MobilityModel> b, uint32_t modelUid) :

    PropagationPathIdentifier (Ptr<const MobilityModel> a, Ptr<const MobilityModel> b, uint32_t modelUid) :

      m_srcMobility (a), m_dstMobility (b), m_spectrumModelUid (modelUid)

      m_srcMobility (a), m_dstMobility (b), m_spectrumModelUid (modelUid)

{};

{};

    Ptr<const MobilityModel> m_srcMobility;

    Ptr<const MobilityModel> m_srcMobility; //!< 1st node mobility model

    Ptr<const MobilityModel> m_dstMobility;

    Ptr<const MobilityModel> m_dstMobility; //!< 2nd node mobility model

    uint32_t m_spectrumModelUid;

    uint32_t m_spectrumModelUid; //!< model UID

    bool operator < (const PropagationPathIdentifier & other) const

    bool operator < (const PropagationPathIdentifier & other) const

      if (m_spectrumModelUid != other.m_spectrumModelUid)

      if (m_spectrumModelUid != other.m_spectrumModelUid)

Lines 81-89	Link Here

      return false;

103

      return false;

104

};

105

};

106

107

  /// Typedef: PropagationPathIdentifier, Ptr<T>

  typedef std::map<PropagationPathIdentifier, Ptr<T> > PathCache;

108

  typedef std::map<PropagationPathIdentifier, Ptr<T> > PathCache;

private:

109

private:

  PathCache m_pathCache;

110

  PathCache m_pathCache; //!< Path cache

};

111

};

} // namespace ns3

112

} // namespace ns3

113

(-)a/src/propagation/model/propagation-delay-model.h (-2 / +14 lines)

Lines 37-42	Link Here

class PropagationDelayModel : public Object

class PropagationDelayModel : public Object

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  virtual ~PropagationDelayModel ();

  virtual ~PropagationDelayModel ();

/**

/**

Lines 74-79	Link Here

class RandomPropagationDelayModel : public PropagationDelayModel

class RandomPropagationDelayModel : public PropagationDelayModel

public:

public:

/**

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

/**

/**

Lines 84-90	Link Here

  virtual Time GetDelay (Ptr<MobilityModel> a, Ptr<MobilityModel> b) const;

  virtual Time GetDelay (Ptr<MobilityModel> a, Ptr<MobilityModel> b) const;

private:

private:

  virtual int64_t DoAssignStreams (int64_t stream);

  virtual int64_t DoAssignStreams (int64_t stream);

  Ptr<RandomVariableStream> m_variable;

  Ptr<RandomVariableStream> m_variable; //!< random generator

};

};

/**

/**

Lines 95-100	Link Here

class ConstantSpeedPropagationDelayModel : public PropagationDelayModel

103

class ConstantSpeedPropagationDelayModel : public PropagationDelayModel

104

public:

105

public:

106

/**

107

   * \brief Get the type ID.

108

   * \return the object TypeId

109

*/

  static TypeId GetTypeId (void);

110

  static TypeId GetTypeId (void);

111

100

/**

112

/**

Lines 112-118	Link Here

112

  double GetSpeed (void) const;

124

  double GetSpeed (void) const;

113

private:

125

private:

114

  virtual int64_t DoAssignStreams (int64_t stream);

126

  virtual int64_t DoAssignStreams (int64_t stream);

115

  double m_speed;

127

  double m_speed; //!< speed

116

};

128

};

117

129

118

} // namespace ns3

130

} // namespace ns3





NS_OBJECT_ENSURE_REGISTERED (FriisPropagationLossModel);

const double FriisPropagationLossModel::PI = 3.14159265358979323846;

TypeId 
FriisPropagationLossModel::GetTypeId (void)
{

      return txPowerDbm - m_minLoss;
    }
  double numerator = m_lambda * m_lambda;
  double denominator = 16 * M_PI * M_PI * distance * distance * m_systemLoss;
  double lossDb = -10 * log10 (numerator / denominator);
  NS_LOG_DEBUG ("distance=" << distance<< "m, loss=" << lossDb <<"dB");
  return txPowerDbm - std::max (lossDb, m_minLoss);


NS_OBJECT_ENSURE_REGISTERED (TwoRayGroundPropagationLossModel);

const double TwoRayGroundPropagationLossModel::PI = 3.14159265358979323846;

TypeId 
TwoRayGroundPropagationLossModel::GetTypeId (void)
{

   *
   */

  double dCross = (4 * M_PI * txAntHeight * rxAntHeight) / m_lambda;
  double tmp = 0;
  if (distance <= dCross)
    {
      // We use Friis
      double numerator = m_lambda * m_lambda;
      tmp = M_PI * distance;
      double denominator = 16 * tmp * tmp * m_systemLoss;
      double pr = 10 * std::log10 (numerator / denominator);
      NS_LOG_DEBUG ("Receiver within crossover (" << dCross << "m) for Two_ray path; using Friis");

(-)a/src/propagation/model/propagation-loss-model.h (-57 / +266 lines)

Lines 41-47	Link Here

/**

/**

 * \ingroup propagation

 * \ingroup propagation

 * \brief Modelize the propagation loss through a transmission medium

 * \brief Models the propagation loss through a transmission medium

 * Calculate the receive power (dbm) from a transmit power (dbm)

 * Calculate the receive power (dbm) from a transmit power (dbm)

 * and a mobility model for the source and destination positions.

 * and a mobility model for the source and destination positions.

Lines 49-54	Link Here

class PropagationLossModel : public Object

class PropagationLossModel : public Object

public:

public:

/**

   * Get the type ID.

   * \brief Get the type ID.

   * \return the object TypeId

*/

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  PropagationLossModel ();

  PropagationLossModel ();

Lines 76-81	Link Here

  Ptr<PropagationLossModel> GetNext ();

  Ptr<PropagationLossModel> GetNext ();

/**

/**

   * Returns the Rx Power taking into account all the PropagatinLossModel(s)

   * chained to the current one.

   * \param txPowerDbm current transmission power (in dBm)

   * \param txPowerDbm current transmission power (in dBm)

   * \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

Lines 99-106	Link Here

  int64_t AssignStreams (int64_t stream);

107

  int64_t AssignStreams (int64_t stream);

100

108

101

private:

109

private:

102

  PropagationLossModel (const PropagationLossModel &o);

110

/**

103

  PropagationLossModel &operator = (const PropagationLossModel &o);

111

   * \brief Copy constructor

112

113

   * Defined and unimplemented to avoid misuse

114

*/

115

  PropagationLossModel (const PropagationLossModel &);

116

/**

117

   * \brief Copy constructor

118

119

   * Defined and unimplemented to avoid misuse

120

   * \returns

121

*/

122

  PropagationLossModel &operator = (const PropagationLossModel &);

123

124

/**

125

   * Returns the Rx Power taking into account only the particular

126

   * PropagatinLossModel.

127

128

   * \param txPowerDbm current transmission power (in dBm)

129

   * \param a the mobility model of the source

130

   * \param b the mobility model of the destination

131

   * \returns the reception power after adding/multiplying propagation loss (in dBm)

132

*/

104

  virtual double DoCalcRxPower (double txPowerDbm,

133

  virtual double DoCalcRxPower (double txPowerDbm,

105

                                Ptr<MobilityModel> a,

134

                                Ptr<MobilityModel> a,

106

                                Ptr<MobilityModel> b) const = 0;

135

                                Ptr<MobilityModel> b) const = 0;

Lines 111-117	Link Here

111

*/

140

*/

112

  virtual int64_t DoAssignStreams (int64_t stream) = 0;

141

  virtual int64_t DoAssignStreams (int64_t stream) = 0;

113

142

114

  Ptr<PropagationLossModel> m_next;

143

  Ptr<PropagationLossModel> m_next; //!< Next propagation loss model in the list

115

};

144

};

116

145

117

/**

146

/**

Lines 122-140	Link Here

122

class RandomPropagationLossModel : public PropagationLossModel

151

class RandomPropagationLossModel : public PropagationLossModel

123

152

124

public:

153

public:

154

/**

155

   * \brief Get the type ID.

156

   * \return the object TypeId

157

*/

125

  static TypeId GetTypeId (void);

158

  static TypeId GetTypeId (void);

126

159

127

  RandomPropagationLossModel ();

160

  RandomPropagationLossModel ();

128

  virtual ~RandomPropagationLossModel ();

161

  virtual ~RandomPropagationLossModel ();

129

162

130

private:

163

private:

131

  RandomPropagationLossModel (const RandomPropagationLossModel &o);

164

/**

132

  RandomPropagationLossModel & operator = (const RandomPropagationLossModel &o);

165

   * \brief Copy constructor

166

167

   * Defined and unimplemented to avoid misuse

168

*/

169

  RandomPropagationLossModel (const RandomPropagationLossModel &);

170

/**

171

   * \brief Copy constructor

172

173

   * Defined and unimplemented to avoid misuse

174

   * \returns

175

*/

176

  RandomPropagationLossModel & operator = (const RandomPropagationLossModel &);

133

  virtual double DoCalcRxPower (double txPowerDbm,

177

  virtual double DoCalcRxPower (double txPowerDbm,

134

                                Ptr<MobilityModel> a,

178

                                Ptr<MobilityModel> a,

135

                                Ptr<MobilityModel> b) const;

179

                                Ptr<MobilityModel> b) const;

136

  virtual int64_t DoAssignStreams (int64_t stream);

180

  virtual int64_t DoAssignStreams (int64_t stream);

137

  Ptr<RandomVariableStream> m_variable;

181

  Ptr<RandomVariableStream> m_variable; //!< random generator

138

};

182

};

139

183

140

/**

184

/**

Lines 217-222	Link Here

217

class FriisPropagationLossModel : public PropagationLossModel

261

class FriisPropagationLossModel : public PropagationLossModel

218

262

219

public:

263

public:

264

/**

265

   * \brief Get the type ID.

266

   * \return the object TypeId

267

*/

220

  static TypeId GetTypeId (void);

268

  static TypeId GetTypeId (void);

221

  FriisPropagationLossModel ();

269

  FriisPropagationLossModel ();

222

/**

270

/**

Lines 256-275	Link Here

256

  double GetSystemLoss (void) const;

304

  double GetSystemLoss (void) const;

257

305

258

private:

306

private:

259

  FriisPropagationLossModel (const FriisPropagationLossModel &o);

307

/**

260

  FriisPropagationLossModel & operator = (const FriisPropagationLossModel &o);

308

   * \brief Copy constructor

309

310

   * Defined and unimplemented to avoid misuse

311

*/

312

  FriisPropagationLossModel (const FriisPropagationLossModel &);

313

/**

314

   * \brief Copy constructor

315

316

   * Defined and unimplemented to avoid misuse

317

   * \returns

318

*/

319

  FriisPropagationLossModel & operator = (const FriisPropagationLossModel &);

320

261

  virtual double DoCalcRxPower (double txPowerDbm,

321

  virtual double DoCalcRxPower (double txPowerDbm,

262

                                Ptr<MobilityModel> a,

322

                                Ptr<MobilityModel> a,

263

                                Ptr<MobilityModel> b) const;

323

                                Ptr<MobilityModel> b) const;

264

  virtual int64_t DoAssignStreams (int64_t stream);

324

  virtual int64_t DoAssignStreams (int64_t stream);

325

326

/**

327

   * Transforms a Dbm value to Watt

328

   * \param dbm the Dbm value

329

   * \return the Watts

330

*/

265

  double DbmToW (double dbm) const;

331

  double DbmToW (double dbm) const;

332

333

/**

334

   * Transforms a Watt value to Dbm

335

   * \param w the Watt value

336

   * \return the Dbm

337

*/

266

  double DbmFromW (double w) const;

338

  double DbmFromW (double w) const;

267

339

268

  static const double PI;

340

  double m_lambda;        //!< the carrier wavelength

269

  double m_lambda;

341

  double m_frequency;     //!< the carrier frequency

270

  double m_frequency;

342

  double m_systemLoss;    //!< the system loss

271

  double m_systemLoss;

343

  double m_minLoss;       //!< the minimum loss

272

  double m_minLoss;

273

};

344

};

274

345

275

/**

346

/**

Lines 303-308	Link Here

303

class TwoRayGroundPropagationLossModel : public PropagationLossModel

374

class TwoRayGroundPropagationLossModel : public PropagationLossModel

304

375

305

public:

376

public:

377

/**

378

   * \brief Get the type ID.

379

   * \return the object TypeId

380

*/

306

  static TypeId GetTypeId (void);

381

  static TypeId GetTypeId (void);

307

  TwoRayGroundPropagationLossModel ();

382

  TwoRayGroundPropagationLossModel ();

308

383

Lines 349-369	Link Here

349

  void SetHeightAboveZ (double heightAboveZ);

424

  void SetHeightAboveZ (double heightAboveZ);

350

425

351

private:

426

private:

352

  TwoRayGroundPropagationLossModel (const TwoRayGroundPropagationLossModel &o);

427

/**

353

  TwoRayGroundPropagationLossModel & operator = (const TwoRayGroundPropagationLossModel &o);

428

   * \brief Copy constructor

429

430

   * Defined and unimplemented to avoid misuse

431

*/

432

  TwoRayGroundPropagationLossModel (const TwoRayGroundPropagationLossModel &);

433

/**

434

   * \brief Copy constructor

435

436

   * Defined and unimplemented to avoid misuse

437

   * \returns

438

*/

439

  TwoRayGroundPropagationLossModel & operator = (const TwoRayGroundPropagationLossModel &);

440

354

  virtual double DoCalcRxPower (double txPowerDbm,

441

  virtual double DoCalcRxPower (double txPowerDbm,

355

                                Ptr<MobilityModel> a,

442

                                Ptr<MobilityModel> a,

356

                                Ptr<MobilityModel> b) const;

443

                                Ptr<MobilityModel> b) const;

357

  virtual int64_t DoAssignStreams (int64_t stream);

444

  virtual int64_t DoAssignStreams (int64_t stream);

445

446

/**

447

   * Transforms a Dbm value to Watt

448

   * \param dbm the Dbm value

449

   * \return the Watts

450

*/

358

  double DbmToW (double dbm) const;

451

  double DbmToW (double dbm) const;

452

453

/**

454

   * Transforms a Watt value to Dbm

455

   * \param w the Watt value

456

   * \return the Dbm

457

*/

359

  double DbmFromW (double w) const;

458

  double DbmFromW (double w) const;

360

459

361

  static const double PI;

460

  double m_lambda;        //!< the carrier wavelength

362

  double m_lambda;

461

  double m_frequency;     //!< the carrier frequency

363

  double m_frequency;

462

  double m_systemLoss;    //!< the system loss

364

  double m_systemLoss;

463

  double m_minDistance;   //!< minimum distance for the model

365

  double m_minDistance;

464

  double m_heightAboveZ;  //!< antenna height above the node's Z coordinate

366

  double m_heightAboveZ;

367

};

465

};

368

466

369

/**

467

/**

Lines 389-394	Link Here

389

class LogDistancePropagationLossModel : public PropagationLossModel

487

class LogDistancePropagationLossModel : public PropagationLossModel

390

488

391

public:

489

public:

490

/**

491

   * \brief Get the type ID.

492

   * \return the object TypeId

493

*/

392

  static TypeId GetTypeId (void);

494

  static TypeId GetTypeId (void);

393

  LogDistancePropagationLossModel ();

495

  LogDistancePropagationLossModel ();

394

496

Lines 402-421	Link Here

402

*/

504

*/

403

  double GetPathLossExponent (void) const;

505

  double GetPathLossExponent (void) const;

404

506

507

/**

508

   * Set the reference path loss at a given distance

509

   * \param referenceDistance reference distance

510

   * \param referenceLoss reference path loss

511

*/

405

  void SetReference (double referenceDistance, double referenceLoss);

512

  void SetReference (double referenceDistance, double referenceLoss);

406

513

407

private:

514

private:

408

  LogDistancePropagationLossModel (const LogDistancePropagationLossModel &o);

515

/**

409

  LogDistancePropagationLossModel & operator = (const LogDistancePropagationLossModel &o);

516

   * \brief Copy constructor

517

518

   * Defined and unimplemented to avoid misuse

519

*/

520

  LogDistancePropagationLossModel (const LogDistancePropagationLossModel &);

521

/**

522

   * \brief Copy constructor

523

524

   * Defined and unimplemented to avoid misuse

525

   * \returns

526

*/

527

  LogDistancePropagationLossModel & operator = (const LogDistancePropagationLossModel &);

528

410

  virtual double DoCalcRxPower (double txPowerDbm,

529

  virtual double DoCalcRxPower (double txPowerDbm,

411

                                Ptr<MobilityModel> a,

530

                                Ptr<MobilityModel> a,

412

                                Ptr<MobilityModel> b) const;

531

                                Ptr<MobilityModel> b) const;

413

  virtual int64_t DoAssignStreams (int64_t stream);

532

  virtual int64_t DoAssignStreams (int64_t stream);

533

534

/**

535

   *  Creates a default reference loss model

536

   * \return a default reference loss model

537

*/

414

  static Ptr<PropagationLossModel> CreateDefaultReference (void);

538

  static Ptr<PropagationLossModel> CreateDefaultReference (void);

415

539

416

  double m_exponent;

540

  double m_exponent; //!< model exponent

417

  double m_referenceDistance;

541

  double m_referenceDistance; //!< reference distance

418

  double m_referenceLoss;

542

  double m_referenceLoss; //!< reference loss

419

};

543

};

420

544

421

/**

545

/**

Lines 461-489	Link Here

461

class ThreeLogDistancePropagationLossModel : public PropagationLossModel

585

class ThreeLogDistancePropagationLossModel : public PropagationLossModel

462

586

463

public:

587

public:

588

/**

589

   * \brief Get the type ID.

590

   * \return the object TypeId

591

*/

464

  static TypeId GetTypeId (void);

592

  static TypeId GetTypeId (void);

465

  ThreeLogDistancePropagationLossModel ();

593

  ThreeLogDistancePropagationLossModel ();

466

594

467

  // Parameters are all accessible via attributes.

595

  // Parameters are all accessible via attributes.

468

596

469

private:

597

private:

470

  ThreeLogDistancePropagationLossModel (const ThreeLogDistancePropagationLossModel& o);

598

/**

471

  ThreeLogDistancePropagationLossModel& operator= (const ThreeLogDistancePropagationLossModel& o);

599

   * \brief Copy constructor

600

601

   * Defined and unimplemented to avoid misuse

602

*/

603

  ThreeLogDistancePropagationLossModel (const ThreeLogDistancePropagationLossModel&);

604

/**

605

   * \brief Copy constructor

606

607

   * Defined and unimplemented to avoid misuse

608

   * \returns

609

*/

610

  ThreeLogDistancePropagationLossModel& operator= (const ThreeLogDistancePropagationLossModel&);

472

611

473

  virtual double DoCalcRxPower (double txPowerDbm,

612

  virtual double DoCalcRxPower (double txPowerDbm,

474

                                Ptr<MobilityModel> a,

613

                                Ptr<MobilityModel> a,

475

                                Ptr<MobilityModel> b) const;

614

                                Ptr<MobilityModel> b) const;

476

  virtual int64_t DoAssignStreams (int64_t stream);

615

  virtual int64_t DoAssignStreams (int64_t stream);

477

616

478

  double m_distance0;

617

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

479

  double m_distance1;

618

  double m_distance1; //!< Beginning of the second (middle) distance field.

480

  double m_distance2;

619

  double m_distance2; //!< Beginning of the third (far) distance field.

481

620

482

  double m_exponent0;

621

  double m_exponent0; //!< The exponent for the first field.

483

  double m_exponent1;

622

  double m_exponent1; //!< The exponent for the second field.

484

  double m_exponent2;

623

  double m_exponent2; //!< The exponent for the third field.

485

624

486

  double m_referenceLoss;

625

  double m_referenceLoss; //!< The reference loss at distance d0 (dB).

487

};

626

};

488

627

489

/**

628

/**

Lines 509-514	Link Here

509

class NakagamiPropagationLossModel : public PropagationLossModel

648

class NakagamiPropagationLossModel : public PropagationLossModel

510

649

511

public:

650

public:

651

/**

652

   * \brief Get the type ID.

653

   * \return the object TypeId

654

*/

512

  static TypeId GetTypeId (void);

655

  static TypeId GetTypeId (void);

513

656

514

  NakagamiPropagationLossModel ();

657

  NakagamiPropagationLossModel ();

Lines 516-538	Link Here

516

  // Parameters are all accessible via attributes.

659

  // Parameters are all accessible via attributes.

517

660

518

private:

661

private:

519

  NakagamiPropagationLossModel (const NakagamiPropagationLossModel& o);

662

/**

520

  NakagamiPropagationLossModel& operator= (const NakagamiPropagationLossModel& o);

663

   * \brief Copy constructor

664

665

   * Defined and unimplemented to avoid misuse

666

*/

667

  NakagamiPropagationLossModel (const NakagamiPropagationLossModel&);

668

/**

669

   * \brief Copy constructor

670

671

   * Defined and unimplemented to avoid misuse

672

   * \returns

673

*/

674

  NakagamiPropagationLossModel& operator= (const NakagamiPropagationLossModel&);

521

675

522

  virtual double DoCalcRxPower (double txPowerDbm,

676

  virtual double DoCalcRxPower (double txPowerDbm,

523

                                Ptr<MobilityModel> a,

677

                                Ptr<MobilityModel> a,

524

                                Ptr<MobilityModel> b) const;

678

                                Ptr<MobilityModel> b) const;

525

  virtual int64_t DoAssignStreams (int64_t stream);

679

  virtual int64_t DoAssignStreams (int64_t stream);

526

680

527

  double m_distance1;

681

  double m_distance1; //!< Distance1

528

  double m_distance2;

682

  double m_distance2; //!< Distance2

529

683

530

  double m_m0;

684

  double m_m0;        //!< m for distances smaller than Distance1

531

  double m_m1;

685

  double m_m1;        //!< m for distances smaller than Distance2

532

  double m_m2;

686

  double m_m2;        //!< m for distances greater than Distance2

533

687

534

  Ptr<ErlangRandomVariable>  m_erlangRandomVariable;

688

  Ptr<ErlangRandomVariable>  m_erlangRandomVariable; //!< Erlang random variable

535

  Ptr<GammaRandomVariable> m_gammaRandomVariable;

689

  Ptr<GammaRandomVariable> m_gammaRandomVariable;    //!< Gamma random variable

536

};

690

};

537

691

538

/**

692

/**

Lines 551-556	Link Here

551

class FixedRssLossModel : public PropagationLossModel

705

class FixedRssLossModel : public PropagationLossModel

552

706

553

public:

707

public:

708

/**

709

   * \brief Get the type ID.

710

   * \return the object TypeId

711

*/

554

  static TypeId GetTypeId (void);

712

  static TypeId GetTypeId (void);

555

713

556

  FixedRssLossModel ();

714

  FixedRssLossModel ();

Lines 563-575	Link Here

563

  void SetRss (double rss);

721

  void SetRss (double rss);

564

722

565

private:

723

private:

566

  FixedRssLossModel (const FixedRssLossModel &o);

724

/**

567

  FixedRssLossModel & operator = (const FixedRssLossModel &o);

725

   * \brief Copy constructor

726

727

   * Defined and unimplemented to avoid misuse

728

*/

729

  FixedRssLossModel (const FixedRssLossModel &);

730

/**

731

   * \brief Copy constructor

732

733

   * Defined and unimplemented to avoid misuse

734

   * \returns

735

*/

736

  FixedRssLossModel & operator = (const FixedRssLossModel &);

737

568

  virtual double DoCalcRxPower (double txPowerDbm,

738

  virtual double DoCalcRxPower (double txPowerDbm,

569

                                Ptr<MobilityModel> a,

739

                                Ptr<MobilityModel> a,

570

                                Ptr<MobilityModel> b) const;

740

                                Ptr<MobilityModel> b) const;

741

571

  virtual int64_t DoAssignStreams (int64_t stream);

742

  virtual int64_t DoAssignStreams (int64_t stream);

572

  double m_rss;

743

  double m_rss; //!< the received signal strength

573

};

744

};

574

745

575

/**

746

/**

Lines 582-587	Link Here

582

class MatrixPropagationLossModel : public PropagationLossModel

753

class MatrixPropagationLossModel : public PropagationLossModel

583

754

584

public:

755

public:

756

/**

757

   * \brief Get the type ID.

758

   * \return the object TypeId

759

*/

585

  static TypeId GetTypeId (void);

760

  static TypeId GetTypeId (void);

586

761

587

  MatrixPropagationLossModel ();

762

  MatrixPropagationLossModel ();

Lines 597-617	Link Here

597

   * \param symmetric   If true (default), both a->b and b->a paths will be affected

772

   * \param symmetric   If true (default), both a->b and b->a paths will be affected

598

*/

773

*/

599

  void SetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double loss, bool symmetric = true);

774

  void SetLoss (Ptr<MobilityModel> a, Ptr<MobilityModel> b, double loss, bool symmetric = true);

600

  /// Set default loss (in dB, positive) to be used, infinity if not set

775

601

  void SetDefaultLoss (double);

776

/**

777

   * Set the default propagation loss (in dB, positive) to be used, infinity if not set

778

   * \param defaultLoss the default proagation loss

779

*/

780

  void SetDefaultLoss (double defaultLoss);

602

781

603

private:

782

private:

783

/**

784

   * \brief Copy constructor

785

786

   * Defined and unimplemented to avoid misuse

787

*/

788

  MatrixPropagationLossModel (const MatrixPropagationLossModel &);

789

/**

790

   * \brief Copy constructor

791

792

   * Defined and unimplemented to avoid misuse

793

   * \returns

794

*/

795

  MatrixPropagationLossModel &operator = (const MatrixPropagationLossModel &);

796

604

  virtual double DoCalcRxPower (double txPowerDbm,

797

  virtual double DoCalcRxPower (double txPowerDbm,

605

                                Ptr<MobilityModel> a,

798

                                Ptr<MobilityModel> a,

606

                                Ptr<MobilityModel> b) const;

799

                                Ptr<MobilityModel> b) const;

800

607

  virtual int64_t DoAssignStreams (int64_t stream);

801

  virtual int64_t DoAssignStreams (int64_t stream);

608

private:

802

private:

609

  /// default loss

803

  double m_default; //!< default loss

610

  double m_default;

611

804

805

  /// Typedef: Mobility models pair

612

  typedef std::pair< Ptr<MobilityModel>, Ptr<MobilityModel> > MobilityPair;

806

  typedef std::pair< Ptr<MobilityModel>, Ptr<MobilityModel> > MobilityPair;

613

  /// Fixed loss between pair of nodes

807

614

  std::map<MobilityPair, double> m_loss;

808

  std::map<MobilityPair, double> m_loss; //!< Propagation loss between pair of nodes

615

};

809

};

616

810

617

/**

811

/**

Lines 627-643	Link Here

627

class RangePropagationLossModel : public PropagationLossModel

821

class RangePropagationLossModel : public PropagationLossModel

628

822

629

public:

823

public:

824

/**

825

   * \brief Get the type ID.

826

   * \return the object TypeId

827

*/

630

  static TypeId GetTypeId (void);

828

  static TypeId GetTypeId (void);

631

  RangePropagationLossModel ();

829

  RangePropagationLossModel ();

632

private:

830

private:

633

  RangePropagationLossModel (const RangePropagationLossModel& o);

831

/**

634

  RangePropagationLossModel& operator= (const RangePropagationLossModel& o);

832

   * \brief Copy constructor

833

834

   * Defined and unimplemented to avoid misuse

835

*/

836

  RangePropagationLossModel (const RangePropagationLossModel&);

837

/**

838

   * \brief Copy constructor

839

840

   * Defined and unimplemented to avoid misuse

841

   * \returns

842

*/

843

  RangePropagationLossModel& operator= (const RangePropagationLossModel&);

635

  virtual double DoCalcRxPower (double txPowerDbm,

844

  virtual double DoCalcRxPower (double txPowerDbm,

636

                                Ptr<MobilityModel> a,

845

                                Ptr<MobilityModel> a,

637

                                Ptr<MobilityModel> b) const;

846

                                Ptr<MobilityModel> b) const;

638

  virtual int64_t DoAssignStreams (int64_t stream);

847

  virtual int64_t DoAssignStreams (int64_t stream);

639

private:

848

private:

640

  double m_range;

849

  double m_range; //!< Maximum Transmission Range (meters)

641

};

850

};

642

851

643

} // namespace ns3

852

} // namespace ns3

Return to bug 938