This class computes obstacle loss based on the actual straight path that the radio signal travels from the transmitter to the receiver. More...

#include <DielectricObstacleLoss.h>

Inheritance diagram for inet::physicallayer::DielectricObstacleLoss:

Classes
class	TotalObstacleLossComputation

Protected Attributes
Parameters
bool	enableDielectricLoss = false

bool	enableReflectionLoss = false

IRadioMedium *	medium
	The radio medium where the radio signal propagation takes place. More...

ModuleRefByPar< physicalenvironment::IPhysicalEnvironment >	physicalEnvironment
	The physical environment that provides to obstacles. More...

Statistics
unsigned int	intersectionComputationCount
	Total number of obstacle intersection computations. More...

unsigned int	intersectionCount
	Total number of actual obstacle intersections. More...

virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	finish () override

virtual double	computeDielectricLoss (const physicalenvironment::IMaterial *material, Hz frequency, m distance) const

virtual double	computeReflectionLoss (const physicalenvironment::IMaterial incidentMaterial, const physicalenvironment::IMaterial refractiveMaterial, double angle) const

virtual double	computeObjectLoss (const physicalenvironment::IPhysicalObject *object, Hz frequency, const Coord &transmissionPosition, const Coord &receptionPosition) const

	DielectricObstacleLoss ()

virtual std::ostream &	printToStream (std::ostream &stream, int level, int evFlags=0) const override
	Prints this object to the provided output stream. More...

virtual double	computeObstacleLoss (Hz frequency, const Coord &transmissionPosition, const Coord &receptionPosition) const override
	Returns the obstacle loss factor caused by physical objects present in the environment as a function of frequency, transmission position, and reception position. More...

Additional Inherited Members
Public Types inherited from inet::IPrintableObject
enum	PrintLevel { PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO, PRINT_LEVEL_COMPLETE = INT_MIN }

enum	PrintFlag { PRINT_FLAG_FORMATTED = (1 << 0), PRINT_FLAG_MULTILINE = (1 << 1) }

Public Member Functions inherited from inet::IPrintableObject
virtual	~IPrintableObject ()

virtual std::string	printToString () const

virtual std::string	printToString (int level, int evFlags=0) const

virtual std::string	getInfoStringRepresentation (int evFlags=0) const

virtual std::string	getDetailStringRepresentation (int evFlags=0) const

virtual std::string	getDebugStringRepresentation (int evFlags=0) const

virtual std::string	getTraceStringRepresentation (int evFlags=0) const

virtual std::string	getCompleteStringRepresentation (int evFlags=0) const

Static Public Attributes inherited from inet::physicallayer::ITracingObstacleLoss
static simsignal_t	obstaclePenetratedSignal = cComponent::registerSignal("obstaclePenetrated")

Detailed Description

This class computes obstacle loss based on the actual straight path that the radio signal travels from the transmitter to the receiver.

The total loss is the combination of the dielectric losses in the intersected obstacles and the reflection losses of the penetrated faces along this path.

Constructor & Destructor Documentation

◆ DielectricObstacleLoss()

inet::physicallayer::DielectricObstacleLoss::DielectricObstacleLoss ( )

                                                :
     medium(nullptr),
     intersectionComputationCount(0),
     intersectionCount(0)
 {
 }

Member Function Documentation

◆ computeDielectricLoss()

double inet::physicallayer::DielectricObstacleLoss::computeDielectricLoss	(	const physicalenvironment::IMaterial *	material,
		Hz	frequency,
		m	distance
	)		const

protectedvirtual

 {
     // NOTE: based on http://en.wikipedia.org/wiki/Dielectric_loss
     double lossTangent = material->getDielectricLossTangent(frequency);
     mps propagationSpeed = material->getPropagationSpeed();
     double factor = std::exp(-atan(lossTangent) * unit(2 * M_PI * frequency * distance / propagationSpeed).get());
     ASSERT(0 <= factor && factor <= 1);
     return factor;
 }

Referenced by computeObjectLoss().

◆ computeObjectLoss()

double inet::physicallayer::DielectricObstacleLoss::computeObjectLoss	(	const physicalenvironment::IPhysicalObject *	object,
		Hz	frequency,
		const Coord &	transmissionPosition,
		const Coord &	receptionPosition
	)		const

protectedvirtual

 {
     double totalLoss = 1;
     const ShapeBase *shape = object->getShape();
     const Coord& position = object->getPosition();
     const Quaternion& orientation = object->getOrientation();
     RotationMatrix rotation(orientation.toEulerAngles());
     const LineSegment lineSegment(rotation.rotateVectorInverse(transmissionPosition - position), rotation.rotateVectorInverse(receptionPosition - position));
     Coord intersection1, intersection2, normal1, normal2;
     intersectionComputationCount++;
     bool hasIntersections = shape->computeIntersection(lineSegment, intersection1, intersection2, normal1, normal2);
     if (hasIntersections && (intersection1 != intersection2)) {
         intersectionCount++;
         const IMaterial *material = object->getMaterial();
         if (enableDielectricLoss) {
             double intersectionDistance = intersection2.distance(intersection1);
             totalLoss *= computeDielectricLoss(material, frequency, m(intersectionDistance));
         }
         if (enableReflectionLoss && !normal1.isUnspecified()) {
             double angle1 = (intersection1 - intersection2).angle(normal1);
             if (!std::isnan(angle1))
                 totalLoss *= computeReflectionLoss(medium->getMaterial(), material, angle1);
         }
         // TODO this returns NaN because n1 > n2
 //        if (enableReflectionLoss && !normal2.isUnspecified()) {
 //            double angle2 = (intersection2 - intersection1).angle(normal2);
 //            if (!std::isnan(angle2))
 //                totalLoss *= computeReflectionLoss(material, medium->getMaterial(), angle2);
 //        }
         ObstaclePenetratedEvent event(object, intersection1, intersection2, normal1, normal2, totalLoss);
         const_cast<DielectricObstacleLoss *>(this)->emit(obstaclePenetratedSignal, &event);
     }
     return totalLoss;
 }

◆ computeObstacleLoss()

double inet::physicallayer::DielectricObstacleLoss::computeObstacleLoss	(	Hz	frequency,
		const Coord &	transmissionPosition,
		const Coord &	receptionPosition
	)		const

overridevirtual

Returns the obstacle loss factor caused by physical objects present in the environment as a function of frequency, transmission position, and reception position.

The value is in the range [0, 1] where 1 means no loss at all and 0 means all power is lost.

Implements inet::physicallayer::IObstacleLoss.

 {
     double totalLoss = 1;
     TotalObstacleLossComputation obstacleLossVisitor(this, frequency, transmissionPosition, receptionPosition);
     physicalEnvironment->visitObjects(&obstacleLossVisitor, LineSegment(transmissionPosition, receptionPosition));
     totalLoss = obstacleLossVisitor.getTotalLoss();
     return totalLoss;
 }

◆ computeReflectionLoss()

double inet::physicallayer::DielectricObstacleLoss::computeReflectionLoss	(	const physicalenvironment::IMaterial *	incidentMaterial,
		const physicalenvironment::IMaterial *	refractiveMaterial,
		double	angle
	)		const

protectedvirtual

 {
     // NOTE: based on http://en.wikipedia.org/wiki/Fresnel_equations
     double n1 = incidentMaterial->getRefractiveIndex();
     double n2 = refractiveMaterial->getRefractiveIndex();
     double st = sin(angle);
     double ct = cos(angle);
     double n1ct = n1 * ct;
     double n2ct = n2 * ct;
     double k = sqrt(1 - pow(n1 / n2 * st, 2));
     double n1k = n1 * k;
     double n2k = n2 * k;
     double rs = pow((n1ct - n2k) / (n1ct + n2k), 2);
     double rp = pow((n1k - n2ct) / (n1k + n2ct), 2);
     double r = (rs + rp) / 2;
     double transmittance = 1 - r;
     ASSERT(0 <= transmittance && transmittance <= 1);
     return transmittance;
 }

Referenced by computeObjectLoss().

◆ finish()

void inet::physicallayer::DielectricObstacleLoss::finish ( )

overrideprotectedvirtual

 {
     EV_INFO << "Obstacle loss intersection computation count: " << intersectionComputationCount << endl;
     EV_INFO << "Obstacle loss intersection count: " << intersectionCount << endl;
     recordScalar("Obstacle loss intersection computation count", intersectionComputationCount);
     recordScalar("Obstacle loss intersection count", intersectionCount);
 }

◆ initialize()

void inet::physicallayer::DielectricObstacleLoss::initialize ( int stage )

overrideprotectedvirtual

 {
     if (stage == INITSTAGE_LOCAL) {
         enableDielectricLoss = par("enableDielectricLoss");
         enableReflectionLoss = par("enableReflectionLoss");
         medium = check_and_cast<IRadioMedium *>(getParentModule());
         physicalEnvironment.reference(this, "physicalEnvironmentModule", true);
     }
 }

◆ numInitStages()

virtual int inet::physicallayer::DielectricObstacleLoss::numInitStages ( ) const

inlineoverrideprotectedvirtual

74 { return NUM_INIT_STAGES; }

◆ printToStream()

std::ostream & inet::physicallayer::DielectricObstacleLoss::printToStream	(	std::ostream &	stream,
		int	level,
		int	evFlags = `0`
	)		const

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

 {
     return stream << "DielectricObstacleLoss";
 }

Member Data Documentation

◆ enableDielectricLoss

bool inet::physicallayer::DielectricObstacleLoss::enableDielectricLoss = false

protected

Referenced by computeObjectLoss(), and initialize().

◆ enableReflectionLoss

bool inet::physicallayer::DielectricObstacleLoss::enableReflectionLoss = false

protected

Referenced by computeObjectLoss(), and initialize().

◆ intersectionComputationCount

unsigned int inet::physicallayer::DielectricObstacleLoss::intersectionComputationCount

mutableprotected

Total number of obstacle intersection computations.

Referenced by computeObjectLoss(), and finish().

◆ intersectionCount

unsigned int inet::physicallayer::DielectricObstacleLoss::intersectionCount

mutableprotected

Total number of actual obstacle intersections.

Referenced by computeObjectLoss(), and finish().

◆ medium

IRadioMedium* inet::physicallayer::DielectricObstacleLoss::medium

protected

The radio medium where the radio signal propagation takes place.

Referenced by computeObjectLoss(), and initialize().

◆ physicalEnvironment

ModuleRefByPar<physicalenvironment::IPhysicalEnvironment> inet::physicallayer::DielectricObstacleLoss::physicalEnvironment

protected

The physical environment that provides to obstacles.

Referenced by computeObstacleLoss(), and initialize().

The documentation for this class was generated from the following files:

Classes

Protected Attributes

Statistics

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DielectricObstacleLoss()

Member Function Documentation

◆ computeDielectricLoss()

◆ computeObjectLoss()

◆ computeObstacleLoss()

◆ computeReflectionLoss()

◆ finish()

◆ initialize()

◆ numInitStages()

◆ printToStream()

Member Data Documentation

◆ enableDielectricLoss

◆ enableReflectionLoss

◆ intersectionComputationCount

◆ intersectionCount

◆ medium

◆ physicalEnvironment