3.36/doxygen/test-parabolic-antenna_8cc_source.html

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2011,12 CTTC

 *

 * 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

 *

 * Author: Nicola Baldo <nbaldo@cttc.es>

 */


#include <ns3/log.h>

#include <ns3/test.h>

#include <ns3/double.h>

#include <ns3/parabolic-antenna-model.h>

#include <ns3/simulator.h>

#include <cmath>

#include <string>

#include <iostream>

#include <sstream>


using namespace ns3;


NS_LOG_COMPONENT_DEFINE ("TestParabolicAntennaModel");


enum ParabolicAntennaModelGainTestCondition  {

  EQUAL = 0,

  LESSTHAN = 1

};


class ParabolicAntennaModelTestCase : public TestCase

{

public:

  static std::string BuildNameString (Angles a, double b, double o, double g);

  ParabolicAntennaModelTestCase (Angles a, double b, double o, double g, double expectedGainDb, ParabolicAntennaModelGainTestCondition cond);


private:

  virtual void DoRun (void);


  Angles m_a;

  double m_b;

  double m_o;

  double m_g;

  double m_expectedGain;

  ParabolicAntennaModelGainTestCondition m_cond;

};


std::string ParabolicAntennaModelTestCase::BuildNameString (Angles a, double b, double o, double g)

{

  std::ostringstream oss;

  oss <<  "theta=" << a.GetInclination () << " , phi=" << a.GetAzimuth ()

      << ", beamdwidth=" << b << "deg"

      << ", orientation=" << o

      << ", maxAttenuation=" << g << " dB";

  return oss.str ();

}


ParabolicAntennaModelTestCase::ParabolicAntennaModelTestCase (Angles a, double b, double o, double g, double expectedGainDb, ParabolicAntennaModelGainTestCondition cond)

  : TestCase (BuildNameString (a, b, o, g)),

    m_a (a),

    m_b (b),

    m_o (o),

    m_g (g),

    m_expectedGain (expectedGainDb),

    m_cond (cond)

{

}


void

ParabolicAntennaModelTestCase::DoRun ()

{

  NS_LOG_FUNCTION (this << BuildNameString (m_a, m_b, m_o, m_g));


  Ptr<ParabolicAntennaModel> a = CreateObject<ParabolicAntennaModel> ();

  a->SetAttribute ("Beamwidth", DoubleValue (m_b));

  a->SetAttribute ("Orientation", DoubleValue (m_o));

  a->SetAttribute ("MaxAttenuation", DoubleValue (m_g));

  double actualGain = a->GetGainDb (m_a);

  switch (m_cond)

    {

    case EQUAL:

      NS_TEST_EXPECT_MSG_EQ_TOL (actualGain, m_expectedGain, 0.001, "wrong value of the radiation pattern");

      break;

    case LESSTHAN:

      NS_TEST_EXPECT_MSG_LT (actualGain, m_expectedGain, "gain higher than expected");

      break;

    default:

      break;

    }

}


class ParabolicAntennaModelTestSuite : public TestSuite

{

public:

  ParabolicAntennaModelTestSuite ();

};


ParabolicAntennaModelTestSuite::ParabolicAntennaModelTestSuite ()

  : TestSuite ("parabolic-antenna-model", UNIT)

{


  // with a 60 deg beamwidth, gain is -20dB at +-77.460 degrees from boresight

  //                                                                         phi,                     theta, beamwidth, orientation,  maxAttn,  expectedGain,   condition

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians    (0),   DegreesToRadians (90)),        60,           0,       20,             0,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (30),   DegreesToRadians (90)),        60,           0,       20,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (-30),   DegreesToRadians (90)),        60,           0,       20,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (-90),   DegreesToRadians (90)),        60,           0,       20,           -20,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (90),   DegreesToRadians (90)),        60,           0,       20,           -20,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (100),   DegreesToRadians (90)),        60,           0,       20,           -20,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (150),   DegreesToRadians (90)),        60,           0,       20,           -20,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (180),   DegreesToRadians (90)),        60,           0,       20,           -20,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-100),   DegreesToRadians (90)),        60,           0,       20,           -20,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-150),   DegreesToRadians (90)),        60,           0,       20,           -20,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-180),   DegreesToRadians (90)),        60,           0,       20,           -20,     EQUAL), TestCase::QUICK);


  // with a 60 deg beamwidth, gain is -10dB at +-54.772 degrees from boresight

  // test positive orientation

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (60),   DegreesToRadians (90)),        60,          60,       10,             0,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (90),   DegreesToRadians (90)),        60,          60,       10,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (30),   DegreesToRadians (90)),        60,          60,       10,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (-30),   DegreesToRadians (90)),        60,          60,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (150),   DegreesToRadians (90)),        60,          60,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (160),   DegreesToRadians (90)),        60,          60,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (210),   DegreesToRadians (90)),        60,          60,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (240),   DegreesToRadians (90)),        60,          60,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (-40),   DegreesToRadians (90)),        60,          60,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (-90),   DegreesToRadians (90)),        60,          60,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-120),   DegreesToRadians (90)),        60,          60,       10,           -10,     EQUAL), TestCase::QUICK);


  // test negative orientation and different beamwidths

  // with a 80 deg beamwidth, gain is -20dB at +- 73.030 degrees from boresight

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-150),   DegreesToRadians (90)),       80,        -150,       10,             0,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-110),   DegreesToRadians (90)),       80,        -150,       10,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-190),   DegreesToRadians (90)),       80,        -150,       10,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (-70),   DegreesToRadians (90)),       80,        -150,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (92),   DegreesToRadians (90)),       80,        -150,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (-30),   DegreesToRadians (90)),       80,        -150,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians    (0),   DegreesToRadians (90)),       80,        -150,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (60),   DegreesToRadians (90)),       80,        -150,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (90),   DegreesToRadians (90)),       80,        -150,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (30),   DegreesToRadians (90)),       80,        -150,       10,           -10,     EQUAL), TestCase::QUICK);


  // test elevation angle

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians    (0),   DegreesToRadians (88)),        60,           0,       20,             0,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (30),   DegreesToRadians (88)),        60,           0,       20,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (-30),   DegreesToRadians (88)),        60,           0,       20,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (-90),   DegreesToRadians (88)),        60,           0,       20,           -20,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-180),   DegreesToRadians (88)),        60,           0,       20,           -20,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (60),   DegreesToRadians (93)),        60,          60,       20,             0,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (90),   DegreesToRadians (93)),        60,          60,       20,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (30),   DegreesToRadians (93)),        60,          60,       20,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-120),   DegreesToRadians (93)),        60,          60,       20,           -20,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-150),   DegreesToRadians (93)),       100,        -150,       10,             0,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-100),   DegreesToRadians (93)),       100,        -150,       10,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-200),   DegreesToRadians (93)),       100,        -150,       10,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (-30),   DegreesToRadians (93)),       100,        -150,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (90), DegreesToRadians (80.5)),       100,        -150,       10,           -10,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians    (0), DegreesToRadians (80.5)),        60,           0,       20,             0,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians   (30), DegreesToRadians (80.5)),        60,           0,       20,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (-30), DegreesToRadians (80.5)),        60,           0,       20,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians  (100), DegreesToRadians (80.5)),        60,           0,       20,           -20,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-150), DegreesToRadians (80.5)),       100,        -150,       30,             0,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-100), DegreesToRadians (80.5)),       100,        -150,       30,            -3,     EQUAL), TestCase::QUICK);

  AddTestCase (new ParabolicAntennaModelTestCase (Angles (DegreesToRadians (-200), DegreesToRadians (80.5)),       100,        -150,       30,            -3,     EQUAL), TestCase::QUICK);


};


static ParabolicAntennaModelTestSuite g_staticParabolicAntennaModelTestSuiteInstance;

ParabolicAntennaModelTestCase
ParabolicAntennaModel Test.
Definition: test-parabolic-antenna.cc:52

ParabolicAntennaModelTestCase::m_g
double m_g
MaxGain.
Definition: test-parabolic-antenna.cc:81

ParabolicAntennaModelTestCase::BuildNameString
static std::string BuildNameString(Angles a, double b, double o, double g)
Build the test name.
Definition: test-parabolic-antenna.cc:86

ParabolicAntennaModelTestCase::m_b
double m_b
Beamwidth.
Definition: test-parabolic-antenna.cc:79

ParabolicAntennaModelTestCase::m_o
double m_o
Orientation.
Definition: test-parabolic-antenna.cc:80

ParabolicAntennaModelTestCase::m_a
Angles m_a
Antenna angle.
Definition: test-parabolic-antenna.cc:78

ParabolicAntennaModelTestCase::m_cond
ParabolicAntennaModelGainTestCondition m_cond
Test condition.
Definition: test-parabolic-antenna.cc:83

ParabolicAntennaModelTestCase::m_expectedGain
double m_expectedGain
Expected gain.
Definition: test-parabolic-antenna.cc:82

ParabolicAntennaModelTestCase::ParabolicAntennaModelTestCase
ParabolicAntennaModelTestCase(Angles a, double b, double o, double g, double expectedGainDb, ParabolicAntennaModelGainTestCondition cond)
Constructor.
Definition: test-parabolic-antenna.cc:97

ParabolicAntennaModelTestCase::DoRun
virtual void DoRun(void)
Implementation to actually run this TestCase.
Definition: test-parabolic-antenna.cc:109

ParabolicAntennaModelTestSuite
ParabolicAntennaModel TestSuite.
Definition: test-parabolic-antenna.cc:138

ParabolicAntennaModelTestSuite::ParabolicAntennaModelTestSuite
ParabolicAntennaModelTestSuite()
Definition: test-parabolic-antenna.cc:143

ns3::Angles
Class holding the azimuth and inclination angles of spherical coordinates.
Definition: angles.h:119

ns3::Angles::GetInclination
double GetInclination(void) const
Getter for inclination angle.
Definition: angles.cc:231

ns3::Angles::GetAzimuth
double GetAzimuth(void) const
Getter for azimuth angle.
Definition: angles.cc:224

ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41

ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:74

ns3::TestCase
encapsulates test code
Definition: test.h:994

ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299

ns3::TestSuite
A suite of tests to run.
Definition: test.h:1188

ParabolicAntennaModelGainTestCondition
ParabolicAntennaModelGainTestCondition
Test condition (equal to or less than)
Definition: test-parabolic-antenna.cc:41

EQUAL
@ EQUAL
Definition: test-parabolic-antenna.cc:42

LESSTHAN
@ LESSTHAN
Definition: test-parabolic-antenna.cc:43

NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205

NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition: log-macros-enabled.h:244

NS_TEST_EXPECT_MSG_LT
#define NS_TEST_EXPECT_MSG_LT(actual, limit, msg)
Test that an actual value is less than a limit and report if not.
Definition: test.h:748

NS_TEST_EXPECT_MSG_EQ_TOL
#define NS_TEST_EXPECT_MSG_EQ_TOL(actual, limit, tol, msg)
Test that actual and expected (limit) values are equal to plus or minus some tolerance and report if ...
Definition: test.h:491

ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.

ns3::DegreesToRadians
double DegreesToRadians(double degrees)
converts degrees to radians
Definition: angles.cc:40

g_staticParabolicAntennaModelTestSuiteInstance
static ParabolicAntennaModelTestSuite g_staticParabolicAntennaModelTestSuiteInstance
Static variable for test initialization.
Definition: test-parabolic-antenna.cc:213