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

Public Member Functions
	DielectricObstacleLoss ()

virtual std::ostream &	printToStream (std::ostream &stream, int level) 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...

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

virtual std::string	getInfoStringRepresentation () const

virtual std::string	getDetailStringRepresentation () const

virtual std::string	getDebugStringRepresentation () const

virtual std::string	getTraceStringRepresentation () const

virtual std::string	getCompleteStringRepresentation () const

Protected Member Functions
virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	finish () override

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

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

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

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

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...

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

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

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

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

Member Function Documentation

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

protectedvirtual

Referenced by computeObjectLoss().

 {
     // 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;
 }

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

protectedvirtual

Referenced by inet::physicallayer::DielectricObstacleLoss::TotalObstacleLossComputation::visit().

 {
     double totalLoss = 1;
     const ShapeBase *shape = object->getShape();
     const Coord& position = object->getPosition();
     const EulerAngles& orientation = object->getOrientation();
     Rotation rotation(orientation);
     const LineSegment lineSegment(rotation.rotateVectorCounterClockwise(transmissionPosition - position), rotation.rotateVectorCounterClockwise(receptionPosition - position));
     Coord intersection1, intersection2, normal1, normal2;
     intersectionComputationCount++;
     bool hasIntersections = shape->computeIntersection(lineSegment, intersection1, intersection2, normal1, normal2);
     if (hasIntersections && (intersection1 != intersection2))
     {
         intersectionCount++;
         double intersectionDistance = intersection2.distance(intersection1);
         const IMaterial *material = object->getMaterial();
         totalLoss *= computeDielectricLoss(material, frequency, m(intersectionDistance));
         if (!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 (!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;
 }

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;
 }

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

protectedvirtual

Referenced by computeObjectLoss().

 {
     // 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;
 }

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);
 }

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

overrideprotectedvirtual

 {
     if (stage == INITSTAGE_LOCAL) {
         medium = check_and_cast<IRadioMedium *>(getParentModule());
         physicalEnvironment = getModuleFromPar<IPhysicalEnvironment>(par("physicalEnvironmentModule"), this);
     }
 }

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

inlineoverrideprotectedvirtual

82 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

std::ostream & inet::physicallayer::DielectricObstacleLoss::printToStream	(	std::ostream &	stream,
		int	level
	)		const

overridevirtual

Prints this object to the provided output stream.

Function calls to operator<< with pointers or references either const or not are all forwarded to this function.

Reimplemented from inet::physicallayer::IPrintableObject.

 {
     return stream << "DielectricObstacleLoss";
 }

Member Data Documentation

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

mutableprotected

Total number of obstacle intersection computations.

Referenced by computeObjectLoss(), and finish().

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

mutableprotected

Total number of actual obstacle intersections.

Referenced by computeObjectLoss(), and finish().

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

protected

The radio medium where the radio signal propagation takes place.

Referenced by computeObjectLoss(), and initialize().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation