three-gpp-channel-model.h

Go to the documentation of this file.

/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2015, NYU WIRELESS, Tandon School of Engineering,
 * New York University
 * Copyright (c) 2019 SIGNET Lab, Department of Information Engineering,
 * University of Padova
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef THREE_GPP_CHANNEL_H
#define THREE_GPP_CHANNEL_H

#include  <complex.h>
#include "ns3/angles.h"
#include <ns3/object.h>
#include <ns3/nstime.h>
#include <ns3/random-variable-stream.h>
#include <ns3/boolean.h>
#include <unordered_map>
#include <ns3/channel-condition-model.h>
#include <ns3/matrix-based-channel-model.h>

namespace ns3 {

class MobilityModel;

class ThreeGppChannelModel : public MatrixBasedChannelModel
{
public:
  ThreeGppChannelModel ();

  ~ThreeGppChannelModel ();
  
  void DoDispose () override;

  static TypeId GetTypeId ();


  void SetChannelConditionModel (Ptr<ChannelConditionModel> model);

  Ptr<ChannelConditionModel> GetChannelConditionModel () const;

  void SetFrequency (double f);

  double GetFrequency (void) const;

  void SetScenario (const std::string &scenario);

  std::string GetScenario (void) const;

  Ptr<const ChannelMatrix> GetChannel (Ptr<const MobilityModel> aMob,
                                       Ptr<const MobilityModel> bMob,
                                       Ptr<const ThreeGppAntennaArrayModel> aAntenna,
                                       Ptr<const ThreeGppAntennaArrayModel> bAntenna) override;
  int64_t AssignStreams (int64_t stream);
  
private:
  void Shuffle (double * first, double * last) const;
  struct ThreeGppChannelMatrix : public MatrixBasedChannelModel::ChannelMatrix
  {
    Ptr<const ChannelCondition> m_channelCondition; 
    
    // TODO these are not currently used, they have to be correctly set when including the spatial consistent update procedure
    /*The following parameters are stored for spatial consistent updating. The notation is 
    that of 3GPP technical reports, but it can apply also to other channel realizations*/
    MatrixBasedChannelModel::Double2DVector m_nonSelfBlocking; 
    Vector m_preLocUT; 
    Vector m_locUT; 
    MatrixBasedChannelModel::Double2DVector m_norRvAngles; 
    double m_DS; 
    double m_K; 
    uint8_t m_numCluster; 
    MatrixBasedChannelModel::Double3DVector m_clusterPhase; 
    Vector m_speed; 
    double m_dis2D; 
    double m_dis3D; 
  };

  struct ParamsTable : public SimpleRefCount<ParamsTable>
  {
    uint8_t m_numOfCluster = 0;
    uint8_t m_raysPerCluster = 0;
    double m_uLgDS = 0;
    double m_sigLgDS = 0;
    double m_uLgASD = 0;
    double m_sigLgASD = 0;
    double m_uLgASA = 0;
    double m_sigLgASA = 0;
    double m_uLgZSA = 0;
    double m_sigLgZSA = 0;
    double m_uLgZSD = 0;
    double m_sigLgZSD = 0;
    double m_offsetZOD = 0;
    double m_cDS = 0;
    double m_cASD = 0;
    double m_cASA = 0;
    double m_cZSA = 0;
    double m_uK = 0;
    double m_sigK = 0;
    double m_rTau = 0;
    double m_uXpr = 0;
    double m_sigXpr = 0;
    double m_perClusterShadowingStd = 0;

    double m_sqrtC[7][7];
  };

  virtual Ptr<const ParamsTable> GetThreeGppTable (Ptr<const ChannelCondition> channelCondition, double hBS, double hUT, double distance2D) const;

  Ptr<ThreeGppChannelMatrix> GetNewChannel (Vector locUT, Ptr<const ChannelCondition> channelCondition,
                                            Ptr<const ThreeGppAntennaArrayModel> sAntenna,
                                            Ptr<const ThreeGppAntennaArrayModel> uAntenna,
                                            Angles &uAngle, Angles &sAngle,
                                            double dis2D, double hBS, double hUT) const;

  DoubleVector CalcAttenuationOfBlockage (Ptr<ThreeGppChannelMatrix> params,
                                          const DoubleVector &clusterAOA,
                                          const DoubleVector &clusterZOA) const;

  bool ChannelMatrixNeedsUpdate (Ptr<const ThreeGppChannelMatrix> channelMatrix, Ptr<const ChannelCondition> channelCondition) const;

  std::unordered_map<uint32_t, Ptr<ThreeGppChannelMatrix> > m_channelMap; 
  Time m_updatePeriod; 
  double m_frequency; 
  std::string m_scenario; 
  Ptr<ChannelConditionModel> m_channelConditionModel; 
  Ptr<UniformRandomVariable> m_uniformRv; 
  Ptr<NormalRandomVariable> m_normalRv; 
  Ptr<UniformRandomVariable> m_uniformRvShuffle; 

  // parameters for the blockage model
  bool m_blockage; 
  uint16_t m_numNonSelfBlocking; 
  bool m_portraitMode; 
  double m_blockerSpeed; 

  static const uint8_t PHI_INDEX = 0; 
  static const uint8_t X_INDEX = 1; 
  static const uint8_t THETA_INDEX = 2; 
  static const uint8_t Y_INDEX = 3; 
  static const uint8_t R_INDEX = 4; 
};
} // namespace ns3

#endif /* THREE_GPP_CHANNEL_H */