#include <DimensionalTransmitterBase.h>

Inheritance diagram for inet::physicallayer::DimensionalTransmitterBase:

Classes
class	FrequencyGainEntry

class	TimeGainEntry

Public Member Functions
	DimensionalTransmitterBase ()

virtual std::ostream &	printToStream (std::ostream &stream, int level) const override
	Prints this object to the provided output stream. 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 void	initialize (int stage)

virtual ConstMapping *	createPowerMapping (const simtime_t startTime, const simtime_t endTime, Hz carrierFrequency, Hz bandwidth, W power) const

Protected Attributes
DimensionSet	dimensions

Mapping::InterpolationMethod	interpolationMode

std::vector< TimeGainEntry >	timeGains

std::vector< FrequencyGainEntry >	frequencyGains

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 }

Constructor & Destructor Documentation

inet::physicallayer::DimensionalTransmitterBase::DimensionalTransmitterBase ( )

                                                        :
     interpolationMode((Mapping::InterpolationMethod)-1)
 {
 }

Member Function Documentation

ConstMapping * inet::physicallayer::DimensionalTransmitterBase::createPowerMapping	(	const simtime_t	startTime,
		const simtime_t	endTime,
		Hz	carrierFrequency,
		Hz	bandwidth,
		W	power
	)		const

protectedvirtual

Referenced by inet::physicallayer::APSKDimensionalTransmitter::createTransmission(), and inet::physicallayer::Ieee80211DimensionalTransmitter::createTransmission().

 {
     Mapping *powerMapping = MappingUtils::createMapping(Argument::MappedZero, dimensions, interpolationMode);
     Argument position(dimensions);
     bool hasTimeDimension = dimensions.hasDimension(Dimension::time);
     bool hasFrequencyDimension = dimensions.hasDimension(Dimension::frequency);
     if (hasTimeDimension && hasFrequencyDimension) {
         double startFrequency = (carrierFrequency - bandwidth / 2).get();
         double endFrequency = (carrierFrequency + bandwidth / 2).get();
         // must be 0 before the start
         position.setTime(0);
         position.setArgValue(Dimension::frequency, 0);
         powerMapping->setValue(position, 0);
         position.setTime(startTime);
         powerMapping->setValue(position, 0);
         position.setTime(endTime);
         powerMapping->setValue(position, 0);
         position.setTime(0);
         position.setArgValue(Dimension::frequency, startFrequency);
         powerMapping->setValue(position, 0);
         position.setArgValue(Dimension::frequency, endFrequency);
         powerMapping->setValue(position, 0);
         // iterate over timeGains and frequencyGains
         for (const auto & timeGainEntry : timeGains) {
 
             switch (timeGainEntry.timeUnit) {
                 case 's':
                     position.setTime(timeGainEntry.time >= 0 ? startTime + timeGainEntry.time : endTime - timeGainEntry.time);
                     break;
                 case '%':
                     position.setTime((1 - timeGainEntry.time) * startTime + timeGainEntry.time * endTime);
                     break;
                 default:
                     throw cRuntimeError("Unknown time unit");
             }
             for (const auto & frequencyGainEntry : frequencyGains) {
 
                 switch (frequencyGainEntry.frequencyUnit) {
                     case 's':
                         position.setArgValue(Dimension::frequency, frequencyGainEntry.frequency >= 0 ? startFrequency + frequencyGainEntry.frequency : endFrequency - frequencyGainEntry.frequency);
                         break;
                     case '%':
                         position.setArgValue(Dimension::frequency, (1 - frequencyGainEntry.frequency) * startFrequency + frequencyGainEntry.frequency * endFrequency);
                         break;
                     default:
                         throw cRuntimeError("Unknown frequency unit");
                 }
                 powerMapping->setValue(position, timeGainEntry.gain * frequencyGainEntry.gain * power.get());
             }
         }
         // must be 0 after the end
         position.setTime(startTime);
         position.setArgValue(Dimension::frequency, endFrequency);
         powerMapping->setValue(position, 0);
         position.setTime(endTime);
         position.setArgValue(Dimension::frequency, startFrequency);
         powerMapping->setValue(position, 0);
         position.setTime(endTime);
         position.setArgValue(Dimension::frequency, endFrequency);
         powerMapping->setValue(position, 0);
     }
     else if (hasTimeDimension) {
         // must be 0 before the start
         position.setTime(0);
         powerMapping->setValue(position, 0);
         // iterate over timeGains
         for (const auto & timeGainEntry : timeGains) {
 
             switch (timeGainEntry.timeUnit) {
                 case 's':
                     position.setTime(timeGainEntry.time >= 0 ? startTime + timeGainEntry.time : endTime - timeGainEntry.time);
                     break;
                 case '%':
                     position.setTime((1 - timeGainEntry.time) * startTime + timeGainEntry.time * endTime);
                     break;
                 default:
                     throw cRuntimeError("Unknown time unit");
             }
             powerMapping->setValue(position, timeGainEntry.gain * power.get());
         }
         // must be 0 after the end
         position.setTime(endTime);
         powerMapping->setValue(position, 0);
     }
     else if (hasFrequencyDimension) {
         double startFrequency = (carrierFrequency - bandwidth / 2).get();
         double endFrequency = (carrierFrequency + bandwidth / 2).get();
         // must be 0 before the start
         position.setArgValue(Dimension::frequency, 0);
         powerMapping->setValue(position, 0);
         // iterate over frequencyGains
         for (const auto & frequencyGainEntry : frequencyGains) {
 
             switch (frequencyGainEntry.frequencyUnit) {
                 case 's':
                     position.setArgValue(Dimension::frequency, frequencyGainEntry.frequency >= 0 ? startFrequency + frequencyGainEntry.frequency : endFrequency - frequencyGainEntry.frequency);
                     break;
                 case '%':
                     position.setArgValue(Dimension::frequency, (1 - frequencyGainEntry.frequency) * startFrequency + frequencyGainEntry.frequency * endFrequency);
                     break;
                 default:
                     throw cRuntimeError("Unknown frequency unit");
             }
             powerMapping->setValue(position, frequencyGainEntry.gain * power.get());
         }
         // must be 0 after the end
         position.setArgValue(Dimension::frequency, endFrequency);
         powerMapping->setValue(position, 0);
     }
     else
         throw cRuntimeError("Unknown dimensions");
     return powerMapping;
 }

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

protectedvirtual

Reimplemented in inet::physicallayer::Ieee80211DimensionalTransmitter, and inet::physicallayer::APSKDimensionalTransmitter.

Referenced by inet::physicallayer::APSKDimensionalTransmitter::initialize(), and inet::physicallayer::Ieee80211DimensionalTransmitter::initialize().

 {
     if (stage == INITSTAGE_LOCAL)
     {
         cModule *module = check_and_cast<cModule *>(this);
         // TODO: factor parsing?
         // dimensions
         const char *dimensionsString = module->par("dimensions");
         cStringTokenizer tokenizer(dimensionsString);
         while (tokenizer.hasMoreTokens()) {
             const char *dimensionString = tokenizer.nextToken();
             if (!strcmp("time", dimensionString))
                 dimensions.addDimension(Dimension::time);
             else if (!strcmp("frequency", dimensionString))
                 dimensions.addDimension(Dimension::frequency);
             else
                 throw cRuntimeError("Unknown dimension");
         }
         // interpolation mode
         const char *interpolationModeString = module->par("interpolationMode");
         if (!strcmp("linear", interpolationModeString))
             interpolationMode = Mapping::LINEAR;
         else if (!strcmp("sample-hold", interpolationModeString))
             interpolationMode = Mapping::STEPS;
         else
             throw cRuntimeError("Unknown interpolation mode: '%s'", interpolationModeString);
         // time gains
         cStringTokenizer timeGainsTokenizer(module->par("timeGains"));
         while (timeGainsTokenizer.hasMoreTokens()) {
             char *end;
             const char *timeString = timeGainsTokenizer.nextToken();
             double time = strtod(timeString, &end);
             char timeUnit;
             if (!end)
                 timeUnit = 's';
             else if (*end == '%') {
                 timeUnit = '%';
                 time /= 100;
                 if (time < 0 || time > 1)
                     throw cRuntimeError("Invalid percentage in timeGains parameter");
             }
             else {
                 timeUnit = 's';
                 time = cNEDValue::parseQuantity(timeString, "s");
             }
             const char *gainString = timeGainsTokenizer.nextToken();
             double gain = strtod(gainString, &end);
             if (end && !strcmp(end, "dB"))
                 gain = math::dB2fraction(gain);
             if (gain < 0 || gain > 1)
                 throw cRuntimeError("Invalid gain in timeGains parameter");
             timeGains.push_back(TimeGainEntry(timeUnit, time, gain));
         }
         // frequency gains
         cStringTokenizer frequencyGainsTokenizer(module->par("frequencyGains"));
         while (frequencyGainsTokenizer.hasMoreTokens()) {
             char *end;
             const char *frequencyString = frequencyGainsTokenizer.nextToken();
             double frequency = strtod(frequencyString, &end);
             char frequencyUnit;
             if (!end)
                 frequencyUnit = 'H';
             else if (*end == '%') {
                 frequencyUnit = '%';
                 frequency /= 100;
                 if (frequency < 0 || frequency > 1)
                     throw cRuntimeError("Invalid percentage in frequencyGains parameter");
             }
             else {
                 frequencyUnit = 'H';
                 frequency = cNEDValue::parseQuantity(frequencyString, "Hz");
             }
             const char *gainString = frequencyGainsTokenizer.nextToken();
             double gain = strtod(gainString, &end);
             if (end && !strcmp(end, "dB"))
                 gain = math::dB2fraction(gain);
             if (gain < 0 || gain > 1)
                 throw cRuntimeError("Invalid gain in frequencyGains parameter");
             frequencyGains.push_back(FrequencyGainEntry(frequencyUnit, frequency, gain));
         }
     }
 }

std::ostream & inet::physicallayer::DimensionalTransmitterBase::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.

Reimplemented in inet::physicallayer::Ieee80211DimensionalTransmitter, and inet::physicallayer::APSKDimensionalTransmitter.

Referenced by inet::physicallayer::APSKDimensionalTransmitter::printToStream(), and inet::physicallayer::Ieee80211DimensionalTransmitter::printToStream().

 {
     if (level <= PRINT_LEVEL_TRACE)
         stream << ", interpolationMode = " << interpolationMode
                << ", dimensions = " << dimensions ;
                // TODO: << "timeGains = " << timeGains
                // TODO: << "frequencyGains = " << frequencyGains ;
     return stream;
 }