continue
factory = self._factories[factory_id]
for guid in guids[factory_id]:
+ factory.create_function(self, guid)
parameters = self._get_parameters(guid)
- factory_parameters = dict() if guid not in \
- self._factory_set else self._factory_set[guid]
- factory.create_function(self, guid, parameters,
- factory_parameters)
for name, value in parameters.iteritems():
self.set(TIME_NOW, guid, name, value)
factory = self._factories[factory_id]
start_function = factory.start_function
if start_function:
- traces = self._traces(guid)
- parameters = self._parameters(guid)
- start_function(self, guid, parameters, traces)
+ start_function(self, guid)
self._started = True
def action(self, time, guid, action):
factory = self._factories[factory_id]
stop_function = factory.stop_function
if stop_function:
- traces = self._traces(guid)
- parameters = self._parameters(guid)
- stop_function(self, guid, parameters, traces)
+ stop_function(self, guid)
def status(self, guid):
if not guid in self._create:
factory = self._factories[factory_id]
status_function = factory.status_function
if status_function:
- return status_function(self, guid, parameters, traces)
+ return status_function(self, guid)
return STATUS_UNDETERMINED
def trace(self, guid, trace_id):
return dict() if guid not in self._create_set else \
self._create_set[guid]
+ def _get_factory_parameters(self, guid):
+ return dict() if guid not in self._factory_set else \
+ self._factory_set[guid]
+
### Creation functions ###
-def create_node(testbed_instance, guid, parameters, factory_parameters):
+def create_node(testbed_instance, guid):
+ parameters = testbed_instance._get_parameters(guid)
forward_X11 = False
if "forward_X11" in parameters:
forward_X11 = parameters["forward_X11"]
element = testbed_instance.netns.Node(forward_X11 = forward_X11)
testbed_instance.elements[guid] = element
-def create_p2piface(testbed_instance, guid, parameters, factory_parameters):
+def create_p2piface(testbed_instance, guid):
if guid in testbed_instance.elements:
# The interface pair was already instantiated
return
testbed_instance.elements[guid] = element1
testbed_instance.elements[guid2] = element2
-def create_tapiface(testbed_instance, guid, parameters, factory_parameters):
+def create_tapiface(testbed_instance, guid):
node_guid = testbed_instance.get_connected(guid, "node", "devs")
if len(node_guid) == 0:
raise RuntimeError("Can't instantiate interface %d outside netns \
element = node.add_tap()
testbed_instance.elements[guid] = element
-def create_nodeiface(testbed_instance, guid, parameters, factory_parameters):
+def create_nodeiface(testbed_instance, guid):
node_guid = testbed_instance.get_connected(guid, "node", "devs")
if len(node_guid) == 0:
raise RuntimeError("Can't instantiate interface %d outside netns \
element = node.add_if()
testbed_instance.elements[guid] = element
-def create_switch(testbed_instance, guid, parameters, factory_parameters):
+def create_switch(testbed_instance, guid):
element = testbed_instance.netns.Switch()
testbed_instance.elements[guid] = element
-def create_application(testbed_instance, guid, parameters, factory_parameters):
+def create_application(testbed_instance, guid):
testbed_instance.elements[guid] = None # Delayed construction
### Start/Stop functions ###
-def start_application(testbed_instance, guid, parameters, traces):
+def start_application(testbed_instance, guid):
+ parameters = testbed_instance._get_parameters(guid)
+ traces = testbed_instance._get_traces(guid)
user = parameters["user"]
command = parameters["command"]
stdout = stderr = None
### Status functions ###
-def status_application(testbed_instance, guid, parameters, traces):
+def status_application(testbed_instance, guid):
if guid not in testbed_instance.elements.keys():
return STATUS_NOT_STARTED
app = testbed_instance.elements[guid]
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from nepi.util import validation
+
+attributes = dict({
+ "SleepCurrentA": dict({
+ "name": "SleepCurrentA",
+ "validation_function": validation.is_double,
+ "value": 2.0000000000000002e-05,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The default radio Sleep current in Ampere."
+ }),
+ "Protocol": dict({
+ "name": "Protocol",
+ "validation_function": validation.is_string,
+ "value": "ns3::UdpSocketFactory",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The type of protocol to use."
+ }),
+ "TxCurrentA": dict({
+ "name": "TxCurrentA",
+ "validation_function": validation.is_double,
+ "value": 0.017399999999999999,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The radio Tx current in Ampere."
+ }),
+ "BasicEnergySourceInitialEnergyJ": dict({
+ "name": "BasicEnergySourceInitialEnergyJ",
+ "validation_function": validation.is_double,
+ "value": 10.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Initial energy stored in basic energy source."
+ }),
+ "FrameSize": dict({
+ "name": "FrameSize",
+ "validation_function": validation.is_integer,
+ "value": 1000,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Size of data frames in bytes"
+ }),
+ "RateStep": dict({
+ "name": "RateStep",
+ "validation_function": validation.is_integer,
+ "value": 4,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Increments available for rate assignment in bps"
+ }),
+ "Stop": dict({
+ "name": "Stop",
+ "validation_function": validation.is_time,
+ "value": "0ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The simulation time at which to tear down the device thread."
+ }),
+ "ChannelSwitchDelay": dict({
+ "name": "ChannelSwitchDelay",
+ "validation_function": validation.is_time,
+ "value": "250000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Delay between two short frames transmitted on different frequencies. NOTE: Unused now."
+ }),
+ "Time": dict({
+ "name": "Time",
+ "validation_function": validation.is_time,
+ "value": "1000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Change current direction and speed after moving for this delay."
+ }),
+ "ewndFor12mbps": dict({
+ "name": "ewndFor12mbps",
+ "validation_function": validation.is_integer,
+ "value": 20,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "ewnd parameter for 12 Mbs data mode"
+ }),
+ "BerThreshold": dict({
+ "name": "BerThreshold",
+ "validation_function": validation.is_double,
+ "value": 1.0000000000000001e-05,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The maximum Bit Error Rate acceptable at any transmission mode"
+ }),
+ "Dot11MeshHWMPactivePathTimeout": dict({
+ "name": "Dot11MeshHWMPactivePathTimeout",
+ "validation_function": validation.is_time,
+ "value": "5120000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Lifetime of reactive routing information"
+ }),
+ "pmtlFor48mbps": dict({
+ "name": "pmtlFor48mbps",
+ "validation_function": validation.is_double,
+ "value": 0.23000000000000001,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pmtl parameter for 48 Mbs data mode"
+ }),
+ "SystemLoss": dict({
+ "name": "SystemLoss",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The system loss"
+ }),
+ "ReferenceLoss": dict({
+ "name": "ReferenceLoss",
+ "validation_function": validation.is_double,
+ "value": 46.677700000000002,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The reference loss at distance d0 (dB). (Default is Friis at 1m with 5.15 GHz)"
+ }),
+ "MaxQueueTime": dict({
+ "name": "MaxQueueTime",
+ "validation_function": validation.is_time,
+ "value": "30000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Maximum time packets can be queued (in seconds)"
+ }),
+ "Dot11MeshHWMPactiveRootTimeout": dict({
+ "name": "Dot11MeshHWMPactiveRootTimeout",
+ "validation_function": validation.is_time,
+ "value": "5120000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Lifetime of poractive routing information"
+ }),
+ "DutyCycle": dict({
+ "name": "DutyCycle",
+ "validation_function": validation.is_double,
+ "value": 0.5,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "the duty cycle of the generator, i.e., the fraction of the period that is occupied by a signal"
+ }),
+ "DeviceName": dict({
+ "name": "DeviceName",
+ "validation_function": validation.is_string,
+ "value": "eth1",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The name of the underlying real device (e.g. eth1)."
+ }),
+ "Direction": dict({
+ "name": "Direction",
+ "validation_function": validation.is_string,
+ "value": "Uniform:0:6.28318",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A random variable used to pick the direction (gradients)."
+ }),
+ "OffTime": dict({
+ "name": "OffTime",
+ "validation_function": validation.is_string,
+ "value": "Constant:1",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A RandomVariable used to pick the duration of the 'Off' state."
+ }),
+ "UpdatePeriod": dict({
+ "name": "UpdatePeriod",
+ "validation_function": validation.is_time,
+ "value": "1000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The interval between decisions about rate control changes"
+ }),
+ "DelayBinWidth": dict({
+ "name": "DelayBinWidth",
+ "validation_function": validation.is_double,
+ "value": 0.001,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The width used in the delay histogram."
+ }),
+ "EnergyDetectionThreshold": dict({
+ "name": "EnergyDetectionThreshold",
+ "validation_function": validation.is_double,
+ "value": -96.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The energy of a received signal should be higher than this threshold (dbm) to allow the PHY layer to detect the signal."
+ }),
+ "PacketSizeBinWidth": dict({
+ "name": "PacketSizeBinWidth",
+ "validation_function": validation.is_double,
+ "value": 20.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The width used in the packetSize histogram."
+ }),
+ "Resolution": dict({
+ "name": "Resolution",
+ "validation_function": validation.is_time,
+ "value": "1000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "the lengh of the time interval over which the power spectral density of incoming signals is averaged"
+ }),
+ "MaxX": dict({
+ "name": "MaxX",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Maximum X value of traveling region, [m]"
+ }),
+ "IdleCurrentA": dict({
+ "name": "IdleCurrentA",
+ "validation_function": validation.is_double,
+ "value": 0.000426,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The default radio Idle current in Ampere."
+ }),
+ "Netmask": dict({
+ "name": "Netmask",
+ "validation_function": validation.is_string,
+ "value": "255.255.255.255",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The network mask to assign to the tap device, when in ConfigureLocal mode. This address will override the discovered MAC address of the simulated device."
+ }),
+ "PathDiscoveryTime": dict({
+ "name": "PathDiscoveryTime",
+ "validation_function": validation.is_time,
+ "value": "5599999999ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Estimate of maximum time needed to find route in network = 2 * NetTraversalTime"
+ }),
+ "poriFor24mbps": dict({
+ "name": "poriFor24mbps",
+ "validation_function": validation.is_double,
+ "value": 0.1681,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pori parameter for 24 Mbs data mode"
+ }),
+ "Exponent0": dict({
+ "name": "Exponent0",
+ "validation_function": validation.is_double,
+ "value": 1.8999999999999999,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The exponent for the first field."
+ }),
+ "TimeStep": dict({
+ "name": "TimeStep",
+ "validation_function": validation.is_time,
+ "value": "1000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Change current direction and speed after moving for this time."
+ }),
+ "MaxMissedBeacons": dict({
+ "name": "MaxMissedBeacons",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Number of beacons which much be consecutively missed before we attempt to restart association."
+ }),
+ "RxGain": dict({
+ "name": "RxGain",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Reception gain (dB)."
+ }),
+ "MaxRetries": dict({
+ "name": "MaxRetries",
+ "validation_function": validation.is_integer,
+ "value": 4,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of retries"
+ }),
+ "pmtlFor24mbps": dict({
+ "name": "pmtlFor24mbps",
+ "validation_function": validation.is_double,
+ "value": 0.26500000000000001,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pmtl parameter for 24 Mbs data mode"
+ }),
+ "TurnOnRtsAfterRateIncrease": dict({
+ "name": "TurnOnRtsAfterRateIncrease",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "If true the RTS mechanism will be turned on when the rate will be increased"
+ }),
+ "Gain": dict({
+ "name": "Gain",
+ "validation_function": validation.is_double,
+ "value": 0.10000000000000001,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "XXX"
+ }),
+ "SuccessK": dict({
+ "name": "SuccessK",
+ "validation_function": validation.is_double,
+ "value": 2.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Multiplication factor for the success threshold in the AARF algorithm."
+ }),
+ "MinTimerThreshold": dict({
+ "name": "MinTimerThreshold",
+ "validation_function": validation.is_integer,
+ "value": 15,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The minimum value for the "timer" threshold in the AARF algorithm."
+ }),
+ "TimerThreshold": dict({
+ "name": "TimerThreshold",
+ "validation_function": validation.is_integer,
+ "value": 15,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The "timer" threshold in the ARF algorithm."
+ }),
+ "poriFor36mbps": dict({
+ "name": "poriFor36mbps",
+ "validation_function": validation.is_double,
+ "value": 0.115,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pori parameter for 36 Mbs data mode"
+ }),
+ "SlotTime": dict({
+ "name": "SlotTime",
+ "validation_function": validation.is_time,
+ "value": "20000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Time slot duration for MAC backoff"
+ }),
+ "DeltaX": dict({
+ "name": "DeltaX",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The x space between objects."
+ }),
+ "DeltaY": dict({
+ "name": "DeltaY",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The y space between objects."
+ }),
+ "Shipping": dict({
+ "name": "Shipping",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Shipping contribution to noise between 0 and 1"
+ }),
+ "HardLimit": dict({
+ "name": "HardLimit",
+ "validation_function": validation.is_time,
+ "value": "100000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Maximum acceptable real-time jitter (used in conjunction with SynchronizationMode=HardLimit)"
+ }),
+ "SupportedModesPhy2": dict({
+ "name": "SupportedModesPhy2",
+ "validation_function": validation.is_string,
+ "value": "2|0|1|",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "List of modes supported by Phy2"
+ }),
+ "SupportedModesPhy1": dict({
+ "name": "SupportedModesPhy1",
+ "validation_function": validation.is_string,
+ "value": "2|0|1|",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "List of modes supported by Phy1"
+ }),
+ "TxGain": dict({
+ "name": "TxGain",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Transmission gain (dB)."
+ }),
+ "MaxPropDelay": dict({
+ "name": "MaxPropDelay",
+ "validation_function": validation.is_time,
+ "value": "2000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Maximum possible propagation delay to gateway"
+ }),
+ "Alpha": dict({
+ "name": "Alpha",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "A constant representing the tunable parameter in the Gauss-Markov model."
+ }),
+ "X": dict({
+ "name": "X",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The x coordinate of the center of the disc."
+ }),
+ "ExpirationTime": dict({
+ "name": "ExpirationTime",
+ "validation_function": validation.is_time,
+ "value": "30000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Time it takes for learned MAC state entry to expire."
+ }),
+ "GratuitousReply": dict({
+ "name": "GratuitousReply",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Indicates whether a gratuitous RREP should be unicast to the node originated route discovery."
+ }),
+ "CcaThreshold": dict({
+ "name": "CcaThreshold",
+ "validation_function": validation.is_double,
+ "value": 10.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Aggregate energy of incoming signals to move to CCA Busy state dB"
+ }),
+ "AllowedHelloLoss": dict({
+ "name": "AllowedHelloLoss",
+ "validation_function": validation.is_integer,
+ "value": 2,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Number of hello messages which may be loss for valid link."
+ }),
+ "Wind": dict({
+ "name": "Wind",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Wind speed in m/s"
+ }),
+ "Exponent1": dict({
+ "name": "Exponent1",
+ "validation_function": validation.is_double,
+ "value": 3.7999999999999998,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The exponent for the second field."
+ }),
+ "DefaultTtl": dict({
+ "name": "DefaultTtl",
+ "validation_function": validation.is_integer,
+ "value": 64,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The TTL value set by default on all outgoing packets generated on this node."
+ }),
+ "TxPowerEnd": dict({
+ "name": "TxPowerEnd",
+ "validation_function": validation.is_double,
+ "value": 16.020600000000002,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Maximum available transmission level (dbm)."
+ }),
+ "DataRate": dict({
+ "name": "DataRate",
+ "validation_function": validation.is_string,
+ "value": "32768bps",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The default data rate for point to point links"
+ }),
+ "MaxSuccessThreshold": dict({
+ "name": "MaxSuccessThreshold",
+ "validation_function": validation.is_integer,
+ "value": 60,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum value of the success threshold in the AARF algorithm."
+ }),
+ "MaxRangCorrectionRetries": dict({
+ "name": "MaxRangCorrectionRetries",
+ "validation_function": validation.is_integer,
+ "value": 16,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Number of retries on contention Ranging Requests"
+ }),
+ "Dot11MeshHWMPpreqMinInterval": dict({
+ "name": "Dot11MeshHWMPpreqMinInterval",
+ "validation_function": validation.is_time,
+ "value": "102400000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Minimal interval between to successive PREQs"
+ }),
+ "BlackListTimeout": dict({
+ "name": "BlackListTimeout",
+ "validation_function": validation.is_time,
+ "value": "5599999999ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Time for which the node is put into the blacklist = RreqRetries * NetTraversalTime"
+ }),
+ "MaxBytes": dict({
+ "name": "MaxBytes",
+ "validation_function": validation.is_integer,
+ "value": 6553500,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The maximum number of bytes accepted by this DropTailQueue."
+ }),
+ "MaxAmsduSize": dict({
+ "name": "MaxAmsduSize",
+ "validation_function": validation.is_integer,
+ "value": 7935,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Max length in byte of an A-MSDU"
+ }),
+ "Distance2": dict({
+ "name": "Distance2",
+ "validation_function": validation.is_double,
+ "value": 200.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Beginning of the third distance field. Default is 200m."
+ }),
+ "MaxFrames": dict({
+ "name": "MaxFrames",
+ "validation_function": validation.is_integer,
+ "value": 1,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of frames to include in a single RTS"
+ }),
+ "RxGainPhy2": dict({
+ "name": "RxGainPhy2",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Gain added to incoming signal at receiver of Phy2"
+ }),
+ "LayoutType": dict({
+ "name": "LayoutType",
+ "validation_function": validation.is_enum,
+ "value": "RowFirst",
+ "range": None,
+ "flags": None,
+ "allowed": ["RowFirst",
+ "ColumnFirst"],
+ "type": Attribute.ENUM,
+ "help": "The type of layout."
+ }),
+ "ewndFor54mbps": dict({
+ "name": "ewndFor54mbps",
+ "validation_function": validation.is_integer,
+ "value": 40,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "ewnd parameter for 54 Mbs data mode"
+ }),
+ "FailureThreshold": dict({
+ "name": "FailureThreshold",
+ "validation_function": validation.is_integer,
+ "value": 2,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The number of consecutive transmissions failure to decrease the rate."
+ }),
+ "ewndFor24mbps": dict({
+ "name": "ewndFor24mbps",
+ "validation_function": validation.is_integer,
+ "value": 40,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "ewnd parameter for 24 Mbs data mode"
+ }),
+ "ewndFor48mbps": dict({
+ "name": "ewndFor48mbps",
+ "validation_function": validation.is_integer,
+ "value": 40,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "ewnd parameter for 48 Mbs data mode"
+ }),
+ "SendEnable": dict({
+ "name": "SendEnable",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Enable or disable the transmitter section of the device."
+ }),
+ "DataMode": dict({
+ "name": "DataMode",
+ "validation_function": validation.is_string,
+ "value": "OfdmRate6Mbps",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The transmission mode to use for every data packet transmission"
+ }),
+ "ErrorUnit": dict({
+ "name": "ErrorUnit",
+ "validation_function": validation.is_enum,
+ "value": "EU_BYTE",
+ "range": None,
+ "flags": None,
+ "allowed": ["EU_BYTE",
+ "EU_PKT",
+ "EU_BIT"],
+ "type": Attribute.ENUM,
+ "help": "The error unit"
+ }),
+ "IpAddress": dict({
+ "name": "IpAddress",
+ "validation_function": validation.is_ip4address,
+ "value": None,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The IP address to assign to the tap device, when in ConfigureLocal mode. This address will override the discovered IP address of the simulated device."
+ }),
+ "MinSuccessThreshold": dict({
+ "name": "MinSuccessThreshold",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The minimum value for the success threshold in the AARF algorithm."
+ }),
+ "NodeTraversalTime": dict({
+ "name": "NodeTraversalTime",
+ "validation_function": validation.is_time,
+ "value": "40000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Conservative estimate of the average one hop traversal time for packets and should include queuing delays, interrupt processing times and transfer times."
+ }),
+ "TxPowerPhy2": dict({
+ "name": "TxPowerPhy2",
+ "validation_function": validation.is_double,
+ "value": 190.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Transmission output power in dB of Phy2"
+ }),
+ "TxPowerPhy1": dict({
+ "name": "TxPowerPhy1",
+ "validation_function": validation.is_double,
+ "value": 190.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Transmission output power in dB of Phy1"
+ }),
+ "ReceiveEnable": dict({
+ "name": "ReceiveEnable",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Enable or disable the receiver section of the device."
+ }),
+ "Lambda": dict({
+ "name": "Lambda",
+ "validation_function": validation.is_double,
+ "value": 0.058252400000000003,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The wavelength (default is 5.15 GHz at 300 000 km/s)."
+ }),
+ "ewndFor6mbps": dict({
+ "name": "ewndFor6mbps",
+ "validation_function": validation.is_integer,
+ "value": 6,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "ewnd parameter for 6 Mbs data mode"
+ }),
+ "NumberOfRaysPerPath": dict({
+ "name": "NumberOfRaysPerPath",
+ "validation_function": validation.is_integer,
+ "value": 1,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The number of rays to use by default for compute the fading coeficent for a given path (default is 1)"
+ }),
+ "HnaInterval": dict({
+ "name": "HnaInterval",
+ "validation_function": validation.is_time,
+ "value": "5000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "HNA messages emission interval. Normally it is equal to TcInterval."
+ }),
+ "RanVar": dict({
+ "name": "RanVar",
+ "validation_function": validation.is_string,
+ "value": "Uniform:0:1",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The decision variable attached to this error model."
+ }),
+ "Theta": dict({
+ "name": "Theta",
+ "validation_function": validation.is_string,
+ "value": "Uniform:0:6.283",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A random variable which represents the angle (gradients) of a position in a random disc."
+ }),
+ "UpdateStatistics": dict({
+ "name": "UpdateStatistics",
+ "validation_function": validation.is_time,
+ "value": "100000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The interval between updating statistics table "
+ }),
+ "Distance1": dict({
+ "name": "Distance1",
+ "validation_function": validation.is_double,
+ "value": 80.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Beginning of the second distance field. Default is 80m."
+ }),
+ "MyRouteTimeout": dict({
+ "name": "MyRouteTimeout",
+ "validation_function": validation.is_time,
+ "value": "11199999999ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Value of lifetime field in RREP generating by this node = 2 * max(ActiveRouteTimeout, PathDiscoveryTime)"
+ }),
+ "RcvBufSize": dict({
+ "name": "RcvBufSize",
+ "validation_function": validation.is_integer,
+ "value": 131072,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "PacketSocket maximum receive buffer size (bytes)"
+ }),
+ "RreqRetries": dict({
+ "name": "RreqRetries",
+ "validation_function": validation.is_integer,
+ "value": 2,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of retransmissions of RREQ to discover a route"
+ }),
+ "MaxNumberOfPeerLinks": dict({
+ "name": "MaxNumberOfPeerLinks",
+ "validation_function": validation.is_integer,
+ "value": 32,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of peer links"
+ }),
+ "QueueLimit": dict({
+ "name": "QueueLimit",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum packets to queue at MAC"
+ }),
+ "MinSpeed": dict({
+ "name": "MinSpeed",
+ "validation_function": validation.is_double,
+ "value": 0.29999999999999999,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Minimum speed value, [m/s]"
+ }),
+ "MaxSpeed": dict({
+ "name": "MaxSpeed",
+ "validation_function": validation.is_double,
+ "value": 0.69999999999999996,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Maximum speed value, [m/s]"
+ }),
+ "NumberOfRetryRates": dict({
+ "name": "NumberOfRetryRates",
+ "validation_function": validation.is_integer,
+ "value": 100,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Number of retry rates"
+ }),
+ "MaxPacketSize": dict({
+ "name": "MaxPacketSize",
+ "validation_function": validation.is_integer,
+ "value": 1024,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The maximum size of a packet."
+ }),
+ "TxPowerLevels": dict({
+ "name": "TxPowerLevels",
+ "validation_function": validation.is_integer,
+ "value": 1,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Number of transmission power levels available between TxPowerBase and TxPowerEnd included."
+ }),
+ "RandomStart": dict({
+ "name": "RandomStart",
+ "validation_function": validation.is_time,
+ "value": "500000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Window when beacon generating starts (uniform random) in seconds"
+ }),
+ "SampleColumn": dict({
+ "name": "SampleColumn",
+ "validation_function": validation.is_double,
+ "value": 10.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The number of columns used for sampling"
+ }),
+ "NormalDirection": dict({
+ "name": "NormalDirection",
+ "validation_function": validation.is_string,
+ "value": "Normal:0:1:10",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A gaussian random variable used to calculate the next direction value."
+ }),
+ "MinPause": dict({
+ "name": "MinPause",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Minimum pause value, [s]"
+ }),
+ "TcInterval": dict({
+ "name": "TcInterval",
+ "validation_function": validation.is_time,
+ "value": "5000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "TC messages emission interval."
+ }),
+ "RfFlag": dict({
+ "name": "RfFlag",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Reply and forward flag"
+ }),
+ "CcaThresholdPhy2": dict({
+ "name": "CcaThresholdPhy2",
+ "validation_function": validation.is_double,
+ "value": 10.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Aggregate energy of incoming signals to move to CCA Busy state dB of Phy2"
+ }),
+ "CcaThresholdPhy1": dict({
+ "name": "CcaThresholdPhy1",
+ "validation_function": validation.is_double,
+ "value": 10.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Aggregate energy of incoming signals to move to CCA Busy state dB of Phy1"
+ }),
+ "MaxQueueLen": dict({
+ "name": "MaxQueueLen",
+ "validation_function": validation.is_integer,
+ "value": 64,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of packets that we allow a routing protocol to buffer."
+ }),
+ "HeightAboveZ": dict({
+ "name": "HeightAboveZ",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The height of the antenna (m) above the node's Z coordinate"
+ }),
+ "poriFor9mbps": dict({
+ "name": "poriFor9mbps",
+ "validation_function": validation.is_double,
+ "value": 0.1434,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pori parameter for 9 Mbs data mode"
+ }),
+ "BasicEnergySupplyVoltageV": dict({
+ "name": "BasicEnergySupplyVoltageV",
+ "validation_function": validation.is_double,
+ "value": 3.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Initial supply voltage for basic energy source."
+ }),
+ "LostUlMapInterval": dict({
+ "name": "LostUlMapInterval",
+ "validation_function": validation.is_time,
+ "value": "500000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Time since last received UL-MAP before uplink synchronization is considered lost, maximum is 600."
+ }),
+ "UnicastPreqThreshold": dict({
+ "name": "UnicastPreqThreshold",
+ "validation_function": validation.is_integer,
+ "value": 1,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of PREQ receivers, when we send a PREQ as a chain of unicasts"
+ }),
+ "poriFor48mbps": dict({
+ "name": "poriFor48mbps",
+ "validation_function": validation.is_double,
+ "value": 0.047,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pori parameter for 48 Mbs data mode"
+ }),
+ "pmtlFor54mbps": dict({
+ "name": "pmtlFor54mbps",
+ "validation_function": validation.is_double,
+ "value": 0.094,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pmtl parameter for 54 Mbs data mode"
+ }),
+ "BeaconInterval": dict({
+ "name": "BeaconInterval",
+ "validation_function": validation.is_time,
+ "value": "102400000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Delay between two beacons"
+ }),
+ "IntervalT20": dict({
+ "name": "IntervalT20",
+ "validation_function": validation.is_time,
+ "value": "500000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Time the SS searches for preambles on a given channel. Minimum is 2 MAC frames"
+ }),
+ "IntervalT21": dict({
+ "name": "IntervalT21",
+ "validation_function": validation.is_time,
+ "value": "10000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "time the SS searches for (decodable) DL-MAP on a given channel"
+ }),
+ "MeanPitch": dict({
+ "name": "MeanPitch",
+ "validation_function": validation.is_string,
+ "value": "Constant:0",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A random variable used to assign the average pitch."
+ }),
+ "Dot11MeshHWMPrannInterval": dict({
+ "name": "Dot11MeshHWMPrannInterval",
+ "validation_function": validation.is_time,
+ "value": "5120000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Lifetime of poractive routing information"
+ }),
+ "Distribution": dict({
+ "name": "Distribution",
+ "validation_function": validation.is_string,
+ "value": "Constant:1",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The distribution to choose the initial phases."
+ }),
+ "RxThreshold": dict({
+ "name": "RxThreshold",
+ "validation_function": validation.is_double,
+ "value": 10.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Required SNR for signal acquisition in dB"
+ }),
+ "WaypointsLeft": dict({
+ "name": "WaypointsLeft",
+ "validation_function": validation.is_integer,
+ "value": 0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The number of waypoints remaining."
+ }),
+ "ConfirmTimeout": dict({
+ "name": "ConfirmTimeout",
+ "validation_function": validation.is_time,
+ "value": "40960000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Confirm timeout"
+ }),
+ "ActiveRouteTimeout": dict({
+ "name": "ActiveRouteTimeout",
+ "validation_function": validation.is_time,
+ "value": "3000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Period of time during which the route is considered to be valid"
+ }),
+ "InitialRangInterval": dict({
+ "name": "InitialRangInterval",
+ "validation_function": validation.is_time,
+ "value": "50000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Time between Initial Ranging regions assigned by the BS. Maximum is 2s"
+ }),
+ "ewndFor18mbps": dict({
+ "name": "ewndFor18mbps",
+ "validation_function": validation.is_integer,
+ "value": 20,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "ewnd parameter for 18 Mbs data mode"
+ }),
+ "FlowInterruptionsBinWidth": dict({
+ "name": "FlowInterruptionsBinWidth",
+ "validation_function": validation.is_double,
+ "value": 0.25,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The width used in the flowInterruptions histogram."
+ }),
+ "MinY": dict({
+ "name": "MinY",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The y coordinate where the grid starts."
+ }),
+ "poriFor12mbps": dict({
+ "name": "poriFor12mbps",
+ "validation_function": validation.is_double,
+ "value": 0.18609999999999999,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pori parameter for 12 Mbs data mode"
+ }),
+ "UnicastDataThreshold": dict({
+ "name": "UnicastDataThreshold",
+ "validation_function": validation.is_integer,
+ "value": 1,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number ofbroadcast receivers, when we send a broadcast as a chain of unicasts"
+ }),
+ "SuccessRatio": dict({
+ "name": "SuccessRatio",
+ "validation_function": validation.is_double,
+ "value": 0.10000000000000001,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Ratio of maximum erroneous transmissions needed to switch to a higher rate"
+ }),
+ "SupportedModes": dict({
+ "name": "SupportedModes",
+ "validation_function": validation.is_string,
+ "value": "2|0|1|",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "List of modes supported by this PHY"
+ }),
+ "CaptureSize": dict({
+ "name": "CaptureSize",
+ "validation_function": validation.is_integer,
+ "value": 65535,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum length of captured packets (cf. pcap snaplen)"
+ }),
+ "NetTraversalTime": dict({
+ "name": "NetTraversalTime",
+ "validation_function": validation.is_time,
+ "value": "2799999999ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Estimate of the average net traversal time = 2 * NodeTraversalTime * NetDiameter"
+ }),
+ "Lifetime": dict({
+ "name": "Lifetime",
+ "validation_function": validation.is_time,
+ "value": "120000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The lifetime of the routing enrty"
+ }),
+ "DeletePeriod": dict({
+ "name": "DeletePeriod",
+ "validation_function": validation.is_time,
+ "value": "15000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "DeletePeriod is intended to provide an upper bound on the time for which an upstream node A can have a neighbor B as an active next hop for destination D, while B has invalidated the route to D. = 5 * max (HelloInterval, ActiveRouteTimeout)"
+ }),
+ "MaxPerHopDelay": dict({
+ "name": "MaxPerHopDelay",
+ "validation_function": validation.is_time,
+ "value": "10000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The maximum per-hop delay that should be considered. Packets still not received after this delay are to be considered lost."
+ }),
+ "NumberOfOscillatorsPerRay": dict({
+ "name": "NumberOfOscillatorsPerRay",
+ "validation_function": validation.is_integer,
+ "value": 4,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The number of oscillators to use by default for compute the coeficent for a given ray of a given path (default is 4)"
+ }),
+ "MinRetryRate": dict({
+ "name": "MinRetryRate",
+ "validation_function": validation.is_double,
+ "value": 0.01,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Smallest allowed RTS retry rate"
+ }),
+ "Pause": dict({
+ "name": "Pause",
+ "validation_function": validation.is_string,
+ "value": "Constant:2",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A random variable used to pick the pause of a random waypoint model."
+ }),
+ "Exponent": dict({
+ "name": "Exponent",
+ "validation_function": validation.is_double,
+ "value": 3.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The exponent of the Path Loss propagation model"
+ }),
+ "MidInterval": dict({
+ "name": "MidInterval",
+ "validation_function": validation.is_time,
+ "value": "5000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "MID messages emission interval. Normally it is equal to TcInterval."
+ }),
+ "pmtlFor9mbps": dict({
+ "name": "pmtlFor9mbps",
+ "validation_function": validation.is_double,
+ "value": 0.39319999999999999,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pmtl parameter for 9 Mbs data mode"
+ }),
+ "Dot11MeshHWMPnetDiameterTraversalTime": dict({
+ "name": "Dot11MeshHWMPnetDiameterTraversalTime",
+ "validation_function": validation.is_time,
+ "value": "102400000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Time we suppose the packet to go from one edge of the network to another"
+ }),
+ "TxPowerStart": dict({
+ "name": "TxPowerStart",
+ "validation_function": validation.is_double,
+ "value": 16.020600000000002,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Minimum available transmission level (dbm)."
+ }),
+ "ewndFor9mbps": dict({
+ "name": "ewndFor9mbps",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "ewnd parameter for 9 Mbs data mode"
+ }),
+ "IntervalT12": dict({
+ "name": "IntervalT12",
+ "validation_function": validation.is_time,
+ "value": "10000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Wait for UCD descriptor.Maximum is 5*MaxUcdInterval"
+ }),
+ "NormalPitch": dict({
+ "name": "NormalPitch",
+ "validation_function": validation.is_string,
+ "value": "Normal:0:1:10",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A gaussian random variable used to calculate the next pitch value."
+ }),
+ "PacketWindowSize": dict({
+ "name": "PacketWindowSize",
+ "validation_function": validation.is_integer,
+ "value": 32,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The size of the window used to compute the packet loss. This value should be a multiple of 8."
+ }),
+ "Start": dict({
+ "name": "Start",
+ "validation_function": validation.is_time,
+ "value": "0ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The simulation time at which to spin up the device thread."
+ }),
+ "MaxDcdInterval": dict({
+ "name": "MaxDcdInterval",
+ "validation_function": validation.is_time,
+ "value": "10000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Maximum time between transmission of DCD messages. Maximum is 10s"
+ }),
+ "ChannelNumber": dict({
+ "name": "ChannelNumber",
+ "validation_function": validation.is_integer,
+ "value": 1,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Channel center frequency = Channel starting frequency + 5 MHz * (nch - 1)"
+ }),
+ "MaxPacketFailure": dict({
+ "name": "MaxPacketFailure",
+ "validation_function": validation.is_integer,
+ "value": 2,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of failed packets before link will be closed"
+ }),
+ "AddCreditThreshold": dict({
+ "name": "AddCreditThreshold",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Add credit threshold"
+ }),
+ "Basic": dict({
+ "name": "Basic",
+ "validation_function": validation.is_bool,
+ "value": False,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "If true the RRAA-BASIC algorithm will be used, otherwise the RRAA wil be used"
+ }),
+ "UcdInterval": dict({
+ "name": "UcdInterval",
+ "validation_function": validation.is_time,
+ "value": "3000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Time between transmission of UCD messages. Maximum value is 10s."
+ }),
+ "DestinationOnly": dict({
+ "name": "DestinationOnly",
+ "validation_function": validation.is_bool,
+ "value": False,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Indicates only the destination may respond to this RREQ."
+ }),
+ "Local": dict({
+ "name": "Local",
+ "validation_function": validation.is_address,
+ "value": None,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The Address on which to Bind the rx socket."
+ }),
+ "NumberOfNodes": dict({
+ "name": "NumberOfNodes",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Number of non-gateway nodes in this gateway's neighborhood"
+ }),
+ "MaxPause": dict({
+ "name": "MaxPause",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Maximum pause value, [s]"
+ }),
+ "MaxBeaconLoss": dict({
+ "name": "MaxBeaconLoss",
+ "validation_function": validation.is_integer,
+ "value": 2,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of lost beacons before link will be closed"
+ }),
+ "MaxY": dict({
+ "name": "MaxY",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Maximum Y value of traveling region, [m]"
+ }),
+ "MaxReservations": dict({
+ "name": "MaxReservations",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of reservations to accept per cycle"
+ }),
+ "OnTime": dict({
+ "name": "OnTime",
+ "validation_function": validation.is_string,
+ "value": "Constant:1",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A RandomVariable used to pick the duration of the 'On' state."
+ }),
+ "RxGainPhy1": dict({
+ "name": "RxGainPhy1",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Gain added to incoming signal at receiver of Phy1"
+ }),
+ "Gateway": dict({
+ "name": "Gateway",
+ "validation_function": validation.is_ip4address,
+ "value": None,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The IP address of the default gateway to assign to the host machine, when in ConfigureLocal mode."
+ }),
+ "GridWidth": dict({
+ "name": "GridWidth",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The number of objects layed out on a line."
+ }),
+ "NormalVelocity": dict({
+ "name": "NormalVelocity",
+ "validation_function": validation.is_string,
+ "value": "Normal:0:1:10",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A gaussian random variable used to calculate the next velocity value."
+ }),
+ "ReferenceDistance": dict({
+ "name": "ReferenceDistance",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The distance at which the reference loss is calculated (m)"
+ }),
+ "m1": dict({
+ "name": "m1",
+ "validation_function": validation.is_double,
+ "value": 0.75,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "m1 for distances smaller than Distance2. Default is 0.75."
+ }),
+ "m0": dict({
+ "name": "m0",
+ "validation_function": validation.is_double,
+ "value": 1.5,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "m0 for distances smaller than Distance1. Default is 1.5."
+ }),
+ "BroadcastInterval": dict({
+ "name": "BroadcastInterval",
+ "validation_function": validation.is_time,
+ "value": "5000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "How often we must send broadcast packets"
+ }),
+ "Variable": dict({
+ "name": "Variable",
+ "validation_function": validation.is_string,
+ "value": "Uniform:0:1",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The random variable which generates random delays (s)."
+ }),
+ "MacAddress": dict({
+ "name": "MacAddress",
+ "validation_function": validation.is_string,
+ "value": "ff:ff:ff:ff:ff:ff",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The MAC address to assign to the tap device, when in ConfigureLocal mode. This address will override the discovered MAC address of the simulated device."
+ }),
+ "MaxBeaconShiftValue": dict({
+ "name": "MaxBeaconShiftValue",
+ "validation_function": validation.is_integer,
+ "value": 15,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of TUs for beacon shifting"
+ }),
+ "MeanDirection": dict({
+ "name": "MeanDirection",
+ "validation_function": validation.is_string,
+ "value": "Uniform:0:6.28319",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A random variable used to assign the average direction."
+ }),
+ "NextHopWait": dict({
+ "name": "NextHopWait",
+ "validation_function": validation.is_time,
+ "value": "50000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Period of our waiting for the neighbour's RREP_ACK = 10 ms + NodeTraversalTime"
+ }),
+ "EnableBeaconCollisionAvoidance": dict({
+ "name": "EnableBeaconCollisionAvoidance",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Enable/Disable Beacon collision avoidance."
+ }),
+ "TimeoutBuffer": dict({
+ "name": "TimeoutBuffer",
+ "validation_function": validation.is_integer,
+ "value": 2,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Its purpose is to provide a buffer for the timeout so that if the RREP is delayed due to congestion, a timeout is less likely to occur while the RREP is still en route back to the source."
+ }),
+ "PeriodicEnergyUpdateInterval": dict({
+ "name": "PeriodicEnergyUpdateInterval",
+ "validation_function": validation.is_time,
+ "value": "1000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Time between two consecutive periodic energy updates."
+ }),
+ "RxCurrentA": dict({
+ "name": "RxCurrentA",
+ "validation_function": validation.is_double,
+ "value": 0.019699999999999999,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The radio Rx current in Ampere."
+ }),
+ "LocalIpv6": dict({
+ "name": "LocalIpv6",
+ "validation_function": validation.is_string,
+ "value": "0000:0000:0000:0000:0000:0000:0000:0000",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Local Ipv6Address of the sender"
+ }),
+ "Remote": dict({
+ "name": "Remote",
+ "validation_function": validation.is_address,
+ "value": None,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The address of the destination"
+ }),
+ "SSAntennaHeight": dict({
+ "name": "SSAntennaHeight",
+ "validation_function": validation.is_double,
+ "value": 3.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": " SS Antenna Height (default is 3m)."
+ }),
+ "MeanVelocity": dict({
+ "name": "MeanVelocity",
+ "validation_function": validation.is_string,
+ "value": "Uniform:0:1",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A random variable used to assign the average velocity."
+ }),
+ "NumberOfRates": dict({
+ "name": "NumberOfRates",
+ "validation_function": validation.is_integer,
+ "value": 0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Number of rate divisions supported by each PHY"
+ }),
+ "BSAntennaHeight": dict({
+ "name": "BSAntennaHeight",
+ "validation_function": validation.is_double,
+ "value": 50.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": " BS Antenna Height (default is 50m)."
+ }),
+ "Interval": dict({
+ "name": "Interval",
+ "validation_function": validation.is_time,
+ "value": "1000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The time to wait between packets"
+ }),
+ "CcaMode1Threshold": dict({
+ "name": "CcaMode1Threshold",
+ "validation_function": validation.is_double,
+ "value": -99.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The energy of a received signal should be higher than this threshold (dbm) to allow the PHY layer to declare CCA BUSY state"
+ }),
+ "Mtu": dict({
+ "name": "Mtu",
+ "validation_function": validation.is_integer,
+ "value": 1500,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The MAC-level Maximum Transmission Unit"
+ }),
+ "pmtlFor12mbps": dict({
+ "name": "pmtlFor12mbps",
+ "validation_function": validation.is_double,
+ "value": 0.2868,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pmtl parameter for 12 Mbs data mode"
+ }),
+ "MaxRtsWnd": dict({
+ "name": "MaxRtsWnd",
+ "validation_function": validation.is_integer,
+ "value": 40,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum value for Rts window of Aarf-CD"
+ }),
+ "HoldingTimeout": dict({
+ "name": "HoldingTimeout",
+ "validation_function": validation.is_time,
+ "value": "40960000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Holding timeout"
+ }),
+ "AssocRequestTimeout": dict({
+ "name": "AssocRequestTimeout",
+ "validation_function": validation.is_time,
+ "value": "500000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The interval between two consecutive assoc request attempts."
+ }),
+ "Timeout": dict({
+ "name": "Timeout",
+ "validation_function": validation.is_time,
+ "value": "50000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Timeout for the RRAA BASIC loss estimaton block (s)"
+ }),
+ "Dot11MeshHWMPmaxPREQretries": dict({
+ "name": "Dot11MeshHWMPmaxPREQretries",
+ "validation_function": validation.is_integer,
+ "value": 3,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of retries before we suppose the destination to be unreachable"
+ }),
+ "Z": dict({
+ "name": "Z",
+ "validation_function": validation.is_string,
+ "value": "Uniform:0:1",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A random variable which represents the z coordinate of a position in a random box."
+ }),
+ "CW": dict({
+ "name": "CW",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The MAC parameter CW"
+ }),
+ "MaxPacketNumber": dict({
+ "name": "MaxPacketNumber",
+ "validation_function": validation.is_integer,
+ "value": 400,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "If a packet arrives when there are already this number of packets, it is dropped."
+ }),
+ "RemoteIpv6": dict({
+ "name": "RemoteIpv6",
+ "validation_function": validation.is_string,
+ "value": "0000:0000:0000:0000:0000:0000:0000:0000",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The Ipv6Address of the outbound packets"
+ }),
+ "RttEstimatorFactory": dict({
+ "name": "RttEstimatorFactory",
+ "validation_function": validation.is_string,
+ "value": "ns3::RttMeanDeviation[]",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "How RttEstimator objects are created."
+ }),
+ "TxPower": dict({
+ "name": "TxPower",
+ "validation_function": validation.is_double,
+ "value": 190.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Transmission output power in dB"
+ }),
+ "pmtlFor36mbps": dict({
+ "name": "pmtlFor36mbps",
+ "validation_function": validation.is_double,
+ "value": 0.33629999999999999,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pmtl parameter for 36 Mbs data mode"
+ }),
+ "MinRtsWnd": dict({
+ "name": "MinRtsWnd",
+ "validation_function": validation.is_integer,
+ "value": 1,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Minimum value for Rts window of Aarf-CD"
+ }),
+ "Frequency": dict({
+ "name": "Frequency",
+ "validation_function": validation.is_double,
+ "value": 2300000000.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The Frequency (default is 2.3 GHz)."
+ }),
+ "Willingness": dict({
+ "name": "Willingness",
+ "validation_function": validation.is_enum,
+ "value": "default",
+ "range": None,
+ "flags": None,
+ "allowed": ["never",
+ "low",
+ "default",
+ "high",
+ "always"],
+ "type": Attribute.ENUM,
+ "help": "Willingness of a node to carry and forward traffic for other nodes."
+ }),
+ "DoFlag": dict({
+ "name": "DoFlag",
+ "validation_function": validation.is_bool,
+ "value": False,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Destination only HWMP flag"
+ }),
+ "BlockAckThreshold": dict({
+ "name": "BlockAckThreshold",
+ "validation_function": validation.is_integer,
+ "value": 0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "If number of packets in this queue reaches this value, block ack mechanism is used. If this value is 0,
+ block ack is never used."
+ }),
+ "TimerK": dict({
+ "name": "TimerK",
+ "validation_function": validation.is_double,
+ "value": 2.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Multiplication factor for the timer threshold in the AARF algorithm."
+ }),
+ "Period": dict({
+ "name": "Period",
+ "validation_function": validation.is_time,
+ "value": "1000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "the period (=1/frequency)"
+ }),
+ "Library": dict({
+ "name": "Library",
+ "validation_function": validation.is_string,
+ "value": "liblinux2.6.26.so",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Set the linux library to be used to create the stack"
+ }),
+ "DcdInterval": dict({
+ "name": "DcdInterval",
+ "validation_function": validation.is_time,
+ "value": "3000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Time between transmission of DCD messages. Maximum value is 10s."
+ }),
+ "SpreadCoef": dict({
+ "name": "SpreadCoef",
+ "validation_function": validation.is_double,
+ "value": 1.5,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Spreading coefficient used in calculation of Thorp's approximation"
+ }),
+ "ewndFor36mbps": dict({
+ "name": "ewndFor36mbps",
+ "validation_function": validation.is_integer,
+ "value": 40,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "ewnd parameter for 36 Mbs data mode"
+ }),
+ "MaxTtl": dict({
+ "name": "MaxTtl",
+ "validation_function": validation.is_integer,
+ "value": 32,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Initial value of Time To Live field"
+ }),
+ "MinDistance": dict({
+ "name": "MinDistance",
+ "validation_function": validation.is_double,
+ "value": 0.5,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The distance under which the propagation model refuses to give results (m)"
+ }),
+ "RxNoiseFigure": dict({
+ "name": "RxNoiseFigure",
+ "validation_function": validation.is_double,
+ "value": 7.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Loss (dB) in the Signal-to-Noise-Ratio due to non-idealities in the receiver. According to Wikipedia (http://en.wikipedia.org/wiki/Noise_figure), this is 'the difference in decibels (dB) between the noise output of the actual receiver to the noise output of an ideal receiver with the same overall gain and bandwidth when the receivers are connected to sources at the standard noise temperature T0 (usually 290 K)'."
+ }),
+ "DopplerFreq": dict({
+ "name": "DopplerFreq",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The doppler frequency in Hz (f_d = v / lambda = v * f / c), the default is 0)"
+ }),
+ "RetryTimeout": dict({
+ "name": "RetryTimeout",
+ "validation_function": validation.is_time,
+ "value": "40960000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Retry timeout"
+ }),
+ "ControlMode": dict({
+ "name": "ControlMode",
+ "validation_function": validation.is_string,
+ "value": "OfdmRate6Mbps",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The transmission mode to use for every control packet transmission."
+ }),
+ "Size": dict({
+ "name": "Size",
+ "validation_function": validation.is_integer,
+ "value": 56,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The number of data bytes to be sent, real packet will be 8 (ICMP) + 20 (IP) bytes longer."
+ }),
+ "ErrorRate": dict({
+ "name": "ErrorRate",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The error rate."
+ }),
+ "PacketLength": dict({
+ "name": "PacketLength",
+ "validation_function": validation.is_double,
+ "value": 1200.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The packet length used for calculating mode TxTime"
+ }),
+ "MaxCost": dict({
+ "name": "MaxCost",
+ "validation_function": validation.is_integer,
+ "value": 32,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Cost threshold after which packet will be dropped"
+ }),
+ "SegmentSize": dict({
+ "name": "SegmentSize",
+ "validation_function": validation.is_double,
+ "value": 6000.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The largest allowable segment size packet"
+ }),
+ "poriFor18mbps": dict({
+ "name": "poriFor18mbps",
+ "validation_function": validation.is_double,
+ "value": 0.13250000000000001,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pori parameter for 18 Mbs data mode"
+ }),
+ "UnicastPerrThreshold": dict({
+ "name": "UnicastPerrThreshold",
+ "validation_function": validation.is_integer,
+ "value": 32,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of PERR receivers, when we send a PERR as a chain of unicasts"
+ }),
+ "EnableHello": dict({
+ "name": "EnableHello",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Indicates whether a hello messages enable."
+ }),
+ "BeaconGeneration": dict({
+ "name": "BeaconGeneration",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Whether or not beacons are generated."
+ }),
+ "MaxUcdInterval": dict({
+ "name": "MaxUcdInterval",
+ "validation_function": validation.is_time,
+ "value": "10000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Maximum time between transmission of UCD messages. Maximum is 10s"
+ }),
+ "Dot11MeshHWMPperrMinInterval": dict({
+ "name": "Dot11MeshHWMPperrMinInterval",
+ "validation_function": validation.is_time,
+ "value": "102400000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Minimal interval between to successive PREQs"
+ }),
+ "Delay": dict({
+ "name": "Delay",
+ "validation_function": validation.is_time,
+ "value": "0ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Transmission delay through the channel"
+ }),
+ "SIFS": dict({
+ "name": "SIFS",
+ "validation_function": validation.is_time,
+ "value": "200000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Spacing to give between frames (this should match gateway)"
+ }),
+ "MaxRange": dict({
+ "name": "MaxRange",
+ "validation_function": validation.is_double,
+ "value": 250.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Maximum Transmission Range (meters)"
+ }),
+ "LostDlMapInterval": dict({
+ "name": "LostDlMapInterval",
+ "validation_function": validation.is_time,
+ "value": "500000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Time since last received DL-MAP message before downlink synchronization is considered lost. Maximum is 600ms"
+ }),
+ "IntervalT2": dict({
+ "name": "IntervalT2",
+ "validation_function": validation.is_time,
+ "value": "10000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Wait for broadcast ranging timeout, i.e., wait for initial ranging opportunity. Maximum is 5*Ranging interval"
+ }),
+ "TurnOffRtsAfterRateDecrease": dict({
+ "name": "TurnOffRtsAfterRateDecrease",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "If true the RTS mechanism will be turned off when the rate will be decreased"
+ }),
+ "MaxContentionRangingRetries": dict({
+ "name": "MaxContentionRangingRetries",
+ "validation_function": validation.is_integer,
+ "value": 16,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Number of retries on contention Ranging Requests"
+ }),
+ "DAD": dict({
+ "name": "DAD",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Always do DAD check."
+ }),
+ "RemotePort": dict({
+ "name": "RemotePort",
+ "validation_function": validation.is_integer,
+ "value": 0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The destination port of the outbound packets"
+ }),
+ "Distance0": dict({
+ "name": "Distance0",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Beginning of the first (near) distance field"
+ }),
+ "FlowInterruptionsMinTime": dict({
+ "name": "FlowInterruptionsMinTime",
+ "validation_function": validation.is_time,
+ "value": "500000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The minimum inter-arrival time that is considered a flow interruption."
+ }),
+ "PacketSize": dict({
+ "name": "PacketSize",
+ "validation_function": validation.is_integer,
+ "value": 512,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The size of packets sent in on state"
+ }),
+ "LookAroundRate": dict({
+ "name": "LookAroundRate",
+ "validation_function": validation.is_double,
+ "value": 10.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "the percentage to try other rates"
+ }),
+ "NumberOfHops": dict({
+ "name": "NumberOfHops",
+ "validation_function": validation.is_integer,
+ "value": 13,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Number of frequencies in hopping pattern"
+ }),
+ "Dot11MeshHWMPpathToRootInterval": dict({
+ "name": "Dot11MeshHWMPpathToRootInterval",
+ "validation_function": validation.is_time,
+ "value": "2048000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Interval between two successive proactive PREQs"
+ }),
+ "ProbeRequestTimeout": dict({
+ "name": "ProbeRequestTimeout",
+ "validation_function": validation.is_time,
+ "value": "50000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The interval between two consecutive probe request attempts."
+ }),
+ "RreqRateLimit": dict({
+ "name": "RreqRateLimit",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of RREQ per second."
+ }),
+ "RangReqOppSize": dict({
+ "name": "RangReqOppSize",
+ "validation_function": validation.is_integer,
+ "value": 8,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The ranging opportunity size in symbols"
+ }),
+ "BwReqOppSize": dict({
+ "name": "BwReqOppSize",
+ "validation_function": validation.is_integer,
+ "value": 2,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The bandwidth request opportunity size in symbols"
+ }),
+ "Rho": dict({
+ "name": "Rho",
+ "validation_function": validation.is_string,
+ "value": "Uniform:0:200",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "A random variable which represents the radius of a position in a random disc."
+ }),
+ "Address": dict({
+ "name": "Address",
+ "validation_function": validation.is_string,
+ "value": "ff:ff:ff:ff:ff:ff",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The MAC address of this device."
+ }),
+ "RetryStep": dict({
+ "name": "RetryStep",
+ "validation_function": validation.is_double,
+ "value": 0.01,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Retry rate increment"
+ }),
+ "m2": dict({
+ "name": "m2",
+ "validation_function": validation.is_double,
+ "value": 0.75,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "m2 for distances greater than Distance2. Default is 0.75."
+ }),
+ "Distance": dict({
+ "name": "Distance",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Change current direction and speed after moving for this distance."
+ }),
+ "InterframeGap": dict({
+ "name": "InterframeGap",
+ "validation_function": validation.is_time,
+ "value": "0ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The time to wait between packet (frame) transmissions"
+ }),
+ "EnableBroadcast": dict({
+ "name": "EnableBroadcast",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Indicates whether a broadcast data packets forwarding enable."
+ }),
+ "HelloInterval": dict({
+ "name": "HelloInterval",
+ "validation_function": validation.is_time,
+ "value": "2000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "HELLO messages emission interval."
+ }),
+ "RemoteAddress": dict({
+ "name": "RemoteAddress",
+ "validation_function": validation.is_ip4address,
+ "value": None,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The destination Ipv4Address of the outbound packets"
+ }),
+ "Rss": dict({
+ "name": "Rss",
+ "validation_function": validation.is_double,
+ "value": -150.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The fixed receiver Rss."
+ }),
+ "EWMA": dict({
+ "name": "EWMA",
+ "validation_function": validation.is_double,
+ "value": 75.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "EWMA level"
+ }),
+ "FailureRatio": dict({
+ "name": "FailureRatio",
+ "validation_function": validation.is_double,
+ "value": 0.33333299999999999,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Ratio of minimum erroneous transmissions needed to switch to a lower rate"
+ }),
+ "Bounds": dict({
+ "name": "Bounds",
+ "validation_function": validation.is_string,
+ "value": "-100|100|-100|100|0|100",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Bounds of the area to cruise."
+ }),
+ "pmtlFor18mbps": dict({
+ "name": "pmtlFor18mbps",
+ "validation_function": validation.is_double,
+ "value": 0.37219999999999998,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pmtl parameter for 18 Mbs data mode"
+ }),
+ "MinX": dict({
+ "name": "MinX",
+ "validation_function": validation.is_double,
+ "value": 1.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The x coordinate where the grid starts."
+ }),
+ "TotalRate": dict({
+ "name": "TotalRate",
+ "validation_function": validation.is_integer,
+ "value": 4096,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Total available channel rate in bps (for a single channel, without splitting reservation channel)"
+ }),
+ "Exponent2": dict({
+ "name": "Exponent2",
+ "validation_function": validation.is_double,
+ "value": 3.7999999999999998,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The exponent for the third field."
+ }),
+ "MaxDelay": dict({
+ "name": "MaxDelay",
+ "validation_function": validation.is_time,
+ "value": "10000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "If a packet stays longer than this delay in the queue, it is dropped."
+ }),
+ "MaxQueueSize": dict({
+ "name": "MaxQueueSize",
+ "validation_function": validation.is_integer,
+ "value": 255,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum number of packets we can store when resolving route"
+ }),
+ "Mode": dict({
+ "name": "Mode",
+ "validation_function": validation.is_enum,
+ "value": "Distance",
+ "range": None,
+ "flags": None,
+ "allowed": ["Distance",
+ "Time"],
+ "type": Attribute.ENUM,
+ "help": "The mode indicates the condition used to change the current speed and direction"
+ }),
+ "rho": dict({
+ "name": "rho",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The radius of the disc"
+ }),
+ "ProbeThreshold": dict({
+ "name": "ProbeThreshold",
+ "validation_function": validation.is_integer,
+ "value": 1,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The number of consecutive transmissions failure to activate the RTS probe."
+ }),
+ "Y": dict({
+ "name": "Y",
+ "validation_function": validation.is_double,
+ "value": 0.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The y coordinate of the center of the disc."
+ }),
+ "poriFor6mbps": dict({
+ "name": "poriFor6mbps",
+ "validation_function": validation.is_double,
+ "value": 0.5,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Pori parameter for 6 Mbs data mode"
+ }),
+ "Root": dict({
+ "name": "Root",
+ "validation_function": validation.is_string,
+ "value": "ff:ff:ff:ff:ff:ff",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The MAC address of root mesh point."
+ }),
+ "RxQueueSize": dict({
+ "name": "RxQueueSize",
+ "validation_function": validation.is_integer,
+ "value": 1000,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Maximum size of the read queue. This value limits number of packets that have been read from the network into a memory buffer but have not yet been processed by the simulator."
+ }),
+ "IntervalT8": dict({
+ "name": "IntervalT8",
+ "validation_function": validation.is_time,
+ "value": "50000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Wait for DSA/DSC Acknowledge timeout. Maximum 300ms."
+ }),
+ "NetDiameter": dict({
+ "name": "NetDiameter",
+ "validation_function": validation.is_integer,
+ "value": 35,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Net diameter measures the maximum possible number of hops between two nodes in the network"
+ }),
+ "Dot11sMeshHeaderLength": dict({
+ "name": "Dot11sMeshHeaderLength",
+ "validation_function": validation.is_integer,
+ "value": 6,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Length of the mesh header"
+ }),
+ "JitterBinWidth": dict({
+ "name": "JitterBinWidth",
+ "validation_function": validation.is_double,
+ "value": 0.001,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The width used in the jitter histogram."
+ }),
+ "IntervalT7": dict({
+ "name": "IntervalT7",
+ "validation_function": validation.is_time,
+ "value": "100000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "wait for DSA/DSC/DSD Response timeout. Maximum is 1s"
+ }),
+ "Verbose": dict({
+ "name": "Verbose",
+ "validation_function": validation.is_bool,
+ "value": False,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Produce usual output."
+ }),
+ "IntervalT1": dict({
+ "name": "IntervalT1",
+ "validation_function": validation.is_time,
+ "value": "50000000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "Wait for DCD timeout. Maximum is 5*maxDcdInterval"
+ }),
+ "DefaultLoss": dict({
+ "name": "DefaultLoss",
+ "validation_function": validation.is_double,
+ "value": 1.7976900000000001e+308,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The default value for propagation loss, dB."
+ }),
+ "IntervalT3": dict({
+ "name": "IntervalT3",
+ "validation_function": validation.is_time,
+ "value": "200000000ns",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "ranging Response reception timeout following the transmission of a ranging request. Maximum is 200ms"
+ }),
+ "MaxPackets": dict({
+ "name": "MaxPackets",
+ "validation_function": validation.is_integer,
+ "value": 100,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The maximum number of packets accepted by this DropTailQueue."
+ }),
+ "EnableLearning": dict({
+ "name": "EnableLearning",
+ "validation_function": validation.is_bool,
+ "value": True,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.BOOL,
+ "help": "Enable the learning mode of the Learning Bridge"
+ }),
+ "Rate": dict({
+ "name": "Rate",
+ "validation_function": validation.is_string,
+ "value": "1000000bps",
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.STRING,
+ "help": "The PHY rate used by this device"
+ }),
+ "RetryRate": dict({
+ "name": "RetryRate",
+ "validation_function": validation.is_double,
+ "value": 0.20000000000000001,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "Number of retry attempts per second (of RTS/GWPING)"
+ }),
+ "Threshold": dict({
+ "name": "Threshold",
+ "validation_function": validation.is_double,
+ "value": 8.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "SINR cutoff for good packet reception"
+ }),
+ "SuccessThreshold": dict({
+ "name": "SuccessThreshold",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "The minimum number of sucessfull transmissions to try a new rate."
+ }),
+ "Speed": dict({
+ "name": "Speed",
+ "validation_function": validation.is_double,
+ "value": 300000000.0,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "The speed (m/s)"
+ }),
+ "Port": dict({
+ "name": "Port",
+ "validation_function": validation.is_integer,
+ "value": 9,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Port on which we listen for incoming packets."
+ }),
+ "NoisePowerSpectralDensity": dict({
+ "name": "NoisePowerSpectralDensity",
+ "validation_function": validation.is_double,
+ "value": 4.1400000000000002e-21,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.DOUBLE,
+ "help": "the power spectral density of the measuring instrument noise, in Watt/Hz. Mostly useful to make spectrograms look more similar to those obtained by real devices. Defaults to the value for thermal noise at 300K."
+ }),
+ "RaiseThreshold": dict({
+ "name": "RaiseThreshold",
+ "validation_function": validation.is_integer,
+ "value": 10,
+ "range": None,
+ "flags": None,
+ "allowed": None,
+ "type": Attribute.INTEGER,
+ "help": "Attempt to raise the rate if we hit that threshold"
+ })
+ })
return content
def shutdown(self):
- for trace in self._traces.values():
- trace.close()
for element in self._elements.values():
element.destroy()
def trace_filename(self, guid, trace_id):
# TODO: Need to be defined inside a home!!!! with and experiment id_code
- return os.path.join(self.home_directory, "%d_%s" % (guid, trace_id))
+ filename = self._trace_filenames[guid][trace_id]
+ return os.path.join(self.home_directory, filename)
- def follow_trace(self, trace_id, trace):
- self._traces[trace_id] = trace
+ def follow_trace(self, guid, trace_id, filename):
+ if guid not in self._traces:
+ self._traces[guid] = dict()
+ self._traces[guid][trace_id] = filename
def _set(self, element, factory_id, name, value):
TypeId = self.ns3.TypeId()
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from metadata_v3_9_RC3 import create_device, create_element, create_ipv4stack, \
+ create_node, create_wifi_standard_model
+
+factories_info = dict{(
+ "ns3::Ping6": dict{(
+ "category": "Application",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": stop_application,
+ "start_function": start_application,
+ "status_function": status_application,
+ "box_attributes": ["MaxPackets",
+ "Interval",
+ "RemoteIpv6",
+ "LocalIpv6",
+ "PacketSize",
+ "StartTime",
+ "StopTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UdpL4Protocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ProtocolNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RandomDiscPositionAllocator": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Theta",
+ "Rho",
+ "X",
+ "Y"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Node": dict{(
+ "category": "Topology",
+ "create_function": create_node,
+ "help": "",
+ "connector_types": ["devs", "apps", "protos", "mobility"],
+ "allow_routes": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::GridPositionAllocator": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["GridWidth",
+ "MinX",
+ "MinY",
+ "DeltaX",
+ "DeltaY",
+ "LayoutType"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::TapBridge": dict{(
+ "category": "Device"
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Mtu",
+ "DeviceName",
+ "Gateway",
+ "IpAddress",
+ "MacAddress",
+ "Netmask",
+ "Start",
+ "Stop"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::FlowMonitor": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["MaxPerHopDelay",
+ "DelayBinWidth",
+ "JitterBinWidth",
+ "PacketSizeBinWidth",
+ "FlowInterruptionsBinWidth",
+ "FlowInterruptionsMinTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::ConstantVelocityMobilityModel": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Position",
+ "Velocity"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::V4Ping": dict{(
+ "category": "Application",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": stop_application,
+ "start_function": start_application,
+ "status_function": status_application,
+ "box_attributes": ["Remote",
+ "Verbose",
+ "Interval",
+ "Size",
+ "StartTime",
+ "StopTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::dot11s::PeerLink": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["RetryTimeout",
+ "HoldingTimeout",
+ "ConfirmTimeout",
+ "MaxRetries",
+ "MaxBeaconLoss",
+ "MaxPacketFailure"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::PointToPointNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node", "err", "queue", "chan"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Mtu",
+ "Address",
+ "DataRate",
+ "InterframeGap"],
+ "factory_attributes": [],
+ "traces": ["p2ppcap"]
+ )},
+ "ns3::NakagamiPropagationLossModel": dict{(
+ "category": "Loss",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Distance1",
+ "Distance2",
+ "m0",
+ "m1",
+ "m2"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::AarfWifiManager": dict{(
+ "category": "Manager",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["SuccessK",
+ "TimerK",
+ "MaxSuccessThreshold",
+ "MinTimerThreshold",
+ "MinSuccessThreshold",
+ "IsLowLatency",
+ "MaxSsrc",
+ "MaxSlrc",
+ "RtsCtsThreshold",
+ "FragmentationThreshold",
+ "NonUnicastMode"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6OptionJumbogram": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["OptionNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::TwoRayGroundPropagationLossModel": dict{(
+ "category": "Loss",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Lambda",
+ "SystemLoss",
+ "MinDistance",
+ "HeightAboveZ"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::OnOffApplication": dict{(
+ "category": "Application",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": stop_application,
+ "start_function": start_application,
+ "status_function": status_application,
+ "box_attributes": ["DataRate",
+ "PacketSize",
+ "Remote",
+ "OnTime",
+ "OffTime",
+ "MaxBytes",
+ "Protocol",
+ "StartTime",
+ "StopTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::AdhocWifiMac": dict{(
+ "category": "Mac",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["CtsTimeout",
+ "AckTimeout",
+ "BasicBlockAckTimeout",
+ "CompressedBlockAckTimeout",
+ "Sifs",
+ "EifsNoDifs",
+ "Slot",
+ "Pifs",
+ "MaxPropagationDelay",
+ "Ssid"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::ConstantAccelerationMobilityModel": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Position",
+ "Velocity"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::GaussMarkovMobilityModel": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Bounds",
+ "TimeStep",
+ "Alpha",
+ "MeanVelocity",
+ "MeanDirection",
+ "MeanPitch",
+ "NormalVelocity",
+ "NormalDirection",
+ "NormalPitch",
+ "Position",
+ "Velocity"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::dot11s::HwmpProtocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"]
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["RandomStart",
+ "MaxQueueSize",
+ "Dot11MeshHWMPmaxPREQretries",
+ "Dot11MeshHWMPnetDiameterTraversalTime",
+ "Dot11MeshHWMPpreqMinInterval",
+ "Dot11MeshHWMPperrMinInterval",
+ "Dot11MeshHWMPactiveRootTimeout",
+ "Dot11MeshHWMPactivePathTimeout",
+ "Dot11MeshHWMPpathToRootInterval",
+ "Dot11MeshHWMPrannInterval",
+ "MaxTtl",
+ "UnicastPerrThreshold",
+ "UnicastPreqThreshold",
+ "UnicastDataThreshold",
+ "DoFlag",
+ "RfFlag"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::NscTcpL4Protocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Library",
+ "ProtocolNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::dot11s::AirtimeLinkMetricCalculator": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Dot11sMeshHeaderLength"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanMacCw": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["CW",
+ "SlotTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::AthstatsWifiTraceSink": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Interval"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::FlameStack": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanMacRc": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["RetryRate",
+ "MaxFrames",
+ "QueueLimit",
+ "SIFS",
+ "NumberOfRates",
+ "MinRetryRate",
+ "RetryStep",
+ "NumberOfRetryRates",
+ "MaxPropDelay"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::WaypointMobilityModel": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["WaypointsLeft",
+ "Position",
+ "Velocity"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::FileDescriptorNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "Network interface associated to a file descriptor",
+ "connector_types": ["node", "fd", "err"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Address"],
+ "factory_attributes": [],
+ "traces": ["fdpcap"]
+ )},
+ "ns3::CsmaNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "CSMA (carrier sense, multiple access) interface",
+ "connector_types": ["node", "chan", "err", "queue"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Address",
+ "Mtu",
+ "SendEnable",
+ "ReceiveEnable"],
+ "factory_attributes": [],
+ "traces": ["csmapcap", "csmapcap_promisc"]
+ )},
+ "ns3::UanPropModelThorp": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["SpreadCoef"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::NqstaWifiMac": dict{(
+ "category": "Mac",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ProbeRequestTimeout",
+ "AssocRequestTimeout",
+ "MaxMissedBeacons",
+ "CtsTimeout",
+ "AckTimeout",
+ "BasicBlockAckTimeout",
+ "CompressedBlockAckTimeout",
+ "Sifs",
+ "EifsNoDifs",
+ "Slot",
+ "Pifs",
+ "MaxPropagationDelay",
+ "Ssid"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Icmpv6L4Protocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["DAD",
+ "ProtocolNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::SimpleNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node", "chan"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::FriisPropagationLossModel": dict{(
+ "category": "Loss",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Lambda",
+ "SystemLoss",
+ "MinDistance"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6OptionRouterAlert": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["OptionNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UniformDiscPositionAllocator": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["rho",
+ "X",
+ "Y"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RandomBoxPositionAllocator": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["X",
+ "Y",
+ "Z"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6ExtensionDestination": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ExtensionNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::LoopbackNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::ConstantSpeedPropagationDelayModel": dict{(
+ "category": "Delay",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["chan"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Speed"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6ExtensionHopByHop": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ExtensionNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::BridgeChannel": dict{(
+ "category": "Channel",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["devs"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Radvd": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["StartTime",
+ "StopTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::PacketSocket": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["RcvBufSize"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::flame::FlameProtocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["BroadcastInterval",
+ "MaxCost"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Cost231PropagationLossModel": dict{(
+ "category": "Loss",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Lambda",
+ "Frequency",
+ "BSAntennaHeight",
+ "SSAntennaHeight",
+ "MinDistance"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6ExtensionESP": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ExtensionNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::CaraWifiManager": dict{(
+ "category": "Manager",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ProbeThreshold",
+ "FailureThreshold",
+ "SuccessThreshold",
+ "Timeout",
+ "IsLowLatency",
+ "MaxSsrc",
+ "MaxSlrc",
+ "RtsCtsThreshold",
+ "FragmentationThreshold",
+ "NonUnicastMode"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RttMeanDeviation": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Gain",
+ "MaxMultiplier",
+ "InitialEstimation",
+ "MinRTO"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Icmpv4L4Protocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ProtocolNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::WaveformGenerator": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Period",
+ "DutyCycle"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::YansWifiChannel": dict{(
+ "category": "Channel",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["phys", "delay", "loss"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::SimpleChannel": dict{(
+ "category": "Channel",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["devs"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6ExtensionFragment": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ExtensionNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Dot11sStack": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Root"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::FriisSpectrumPropagationLossModel": dict{(
+ "category": "Loss",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RandomRectanglePositionAllocator": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["X",
+ "Y"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::NqapWifiMac": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["BeaconInterval",
+ "BeaconGeneration",
+ "CtsTimeout",
+ "AckTimeout",
+ "BasicBlockAckTimeout",
+ "CompressedBlockAckTimeout",
+ "Sifs",
+ "EifsNoDifs",
+ "Slot",
+ "Pifs",
+ "MaxPropagationDelay",
+ "Ssid"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::HierarchicalMobilityModel": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Position",
+ "Velocity"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::ThreeLogDistancePropagationLossModel": dict{(
+ "category": "Loss",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["prev", "next"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Distance0",
+ "Distance1",
+ "Distance2",
+ "Exponent0",
+ "Exponent1",
+ "Exponent2",
+ "ReferenceLoss"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanNoiseModelDefault": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Wind",
+ "Shipping"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::dot11s::HwmpRtable": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::PacketBurst": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RandomPropagationDelayModel": dict{(
+ "category": "Delay",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["chan"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Variable"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::ArpL3Protocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::SteadyStateRandomWaypointMobilityModel": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["MinSpeed",
+ "MaxSpeed",
+ "MinPause",
+ "MaxPause",
+ "MinX",
+ "MaxX",
+ "MinY",
+ "MaxY",
+ "Position",
+ "Velocity"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::BaseStationNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["InitialRangInterval",
+ "DcdInterval",
+ "UcdInterval",
+ "IntervalT8",
+ "RangReqOppSize",
+ "BwReqOppSize",
+ "MaxRangCorrectionRetries",
+ "Mtu",
+ "RTG",
+ "TTG"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UdpServer": dict{(
+ "category": "Application",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": stop_application,
+ "start_function": start_application,
+ "status_function": status_application,
+ "box_attributes": ["Port",
+ "PacketWindowSize",
+ "StartTime",
+ "StopTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::AarfcdWifiManager": dict{(
+ "category": "Manager",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["SuccessK",
+ "TimerK",
+ "MaxSuccessThreshold",
+ "MinTimerThreshold",
+ "MinSuccessThreshold",
+ "MinRtsWnd",
+ "MaxRtsWnd",
+ "TurnOffRtsAfterRateDecrease",
+ "TurnOnRtsAfterRateIncrease",
+ "IsLowLatency",
+ "MaxSsrc",
+ "MaxSlrc",
+ "RtsCtsThreshold",
+ "FragmentationThreshold",
+ "NonUnicastMode"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanTransducerHd": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::LogDistancePropagationLossModel": dict{(
+ "category": "Loss",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["prev", "next"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Exponent",
+ "ReferenceDistance",
+ "ReferenceLoss"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::EmuNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node", "queue"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Mtu",
+ "Address",
+ "DeviceName",
+ "Start",
+ "Stop",
+ "RxQueueSize"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6ExtensionLooseRouting": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ExtensionNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RandomWaypointMobilityModel": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Speed",
+ "Pause",
+ "Position",
+ "Velocity"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RangePropagationLossModel": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["MaxRange"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::AlohaNoackNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Address",
+ "Mtu"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::MatrixPropagationLossModel": dict{(
+ "category": "Loss",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["DefaultLoss"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::WifiNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node", "mac", "phy", "manager"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Mtu"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::CsmaChannel": dict{(
+ "category": "Channel",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["devs"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["DataRate",
+ "Delay"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::BridgeNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Mtu",
+ "EnableLearning",
+ "ExpirationTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6ExtensionRouting": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ExtensionNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::QstaWifiMac": dict{(
+ "category": "Mac",
+ "create_function": create_wifi_standard_model,
+ "help": "Station Wifi MAC Model",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ProbeRequestTimeout",
+ "AssocRequestTimeout",
+ "MaxMissedBeacons",
+ "CtsTimeout",
+ "AckTimeout",
+ "BasicBlockAckTimeout",
+ "CompressedBlockAckTimeout",
+ "Sifs",
+ "EifsNoDifs",
+ "Slot",
+ "Pifs",
+ "MaxPropagationDelay",
+ "Ssid"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UdpEchoClient": dict{(
+ "category": "Application",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": stop_application,
+ "start_function": start_application,
+ "status_function": status_application,
+ "box_attributes": ["MaxPackets",
+ "Interval",
+ "RemoteAddress",
+ "RemotePort",
+ "PacketSize",
+ "StartTime",
+ "StopTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UdpClient": dict{(
+ "category": "Application",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": stop_application,
+ "start_function": start_application,
+ "status_function": status_application,
+ "box_attributes": ["MaxPackets",
+ "Interval",
+ "RemoteAddress",
+ "RemotePort",
+ "PacketSize",
+ "StartTime",
+ "StopTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::PointToPointChannel": dict{(
+ "category": "Channel",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev2"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Delay"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6StaticRouting": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::DropTailQueue": dict{(
+ "category": "Device",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["MaxPackets",
+ "MaxBytes"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::ConstantPositionMobilityModel": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Position",
+ "Velocity"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::FixedRssLossModel": dict{(
+ "category": "Loss",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Rss"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::EnergySourceContainer": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RandomWalk2dMobilityModel": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Bounds",
+ "Time",
+ "Distance",
+ "Mode",
+ "Direction",
+ "Speed",
+ "Position",
+ "Velocity"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::ListPositionAllocator": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::dot11s::PeerManagementProtocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["MaxNumberOfPeerLinks",
+ "MaxBeaconShiftValue",
+ "EnableBeaconCollisionAvoidance"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::MeshPointDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Mtu"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::BasicEnergySource": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["BasicEnergySourceInitialEnergyJ",
+ "BasicEnergySupplyVoltageV",
+ "PeriodicEnergyUpdateInterval"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6OptionPadn": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["OptionNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::QapWifiMac": dict{(
+ "category": "Mac",
+ "create_function": create_wifi_standard_model,
+ "help": "Access point Wifi MAC Model",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["BeaconInterval",
+ "BeaconGeneration",
+ "CtsTimeout",
+ "AckTimeout",
+ "BasicBlockAckTimeout",
+ "CompressedBlockAckTimeout",
+ "Sifs",
+ "EifsNoDifs",
+ "Slot",
+ "Pifs",
+ "MaxPropagationDelay",
+ "Ssid"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::YansErrorRateModel": dict{(
+ "category": "Error",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::WifiMacQueue": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["MaxPacketNumber",
+ "MaxDelay"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::NonCommunicatingNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RateErrorModel": dict{(
+ "category": "Error",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ErrorUnit",
+ "ErrorRate",
+ "RanVar",
+ "IsEnabled"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::MeshWifiInterfaceMac": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["BeaconInterval",
+ "RandomStart",
+ "BeaconGeneration",
+ "CtsTimeout",
+ "AckTimeout",
+ "BasicBlockAckTimeout",
+ "CompressedBlockAckTimeout",
+ "Sifs",
+ "EifsNoDifs",
+ "Slot",
+ "Pifs",
+ "MaxPropagationDelay",
+ "Ssid"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanPhyCalcSinrDual": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6ExtensionAH": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["ExtensionNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::SingleModelSpectrumChannel": dict{(
+ "category": "Channel",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::YansWifiPhy": dict{(
+ "category": "Phy",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev", "err", "chan"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["EnergyDetectionThreshold",
+ "CcaMode1Threshold",
+ "TxGain",
+ "RxGain",
+ "TxPowerLevels",
+ "TxPowerEnd",
+ "TxPowerStart",
+ "RxNoiseFigure",
+ "ChannelSwitchDelay",
+ "ChannelNumber"],
+ "factory_attributes": [],
+ "traces": ["yanswifipcap"]
+ )},
+ "ns3::WifiRadioEnergyModel": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["TxCurrentA",
+ "RxCurrentA",
+ "IdleCurrentA",
+ "SleepCurrentA"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::EdcaTxopN": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["BlockAckThreshold",
+ "MinCw",
+ "MaxCw",
+ "Aifsn"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanPhyPerGenDefault": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Threshold"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::IdealWifiManager": dict{(
+ "category": "Manager",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["BerThreshold",
+ "IsLowLatency",
+ "MaxSsrc",
+ "MaxSlrc",
+ "RtsCtsThreshold",
+ "FragmentationThreshold",
+ "NonUnicastMode"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::MultiModelSpectrumChannel": dict{(
+ "category": "Channel",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::HalfDuplexIdealPhy": dict{(
+ "category": "Phy",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Rate"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanPhyCalcSinrDefault": dict{(
+ "category": "Phy",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::ReceiveListErrorModel": dict{(
+ "category": "Error",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["IsEnabled"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::SpectrumAnalyzer": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Resolution",
+ "NoisePowerSpectralDensity"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::ConstantRateWifiManager": dict{(
+ "category": "Manager",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["DataMode",
+ "ControlMode",
+ "IsLowLatency",
+ "MaxSsrc",
+ "MaxSlrc",
+ "RtsCtsThreshold",
+ "FragmentationThreshold",
+ "NonUnicastMode"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6OptionPad1": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["OptionNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UdpTraceClient": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["RemoteAddress",
+ "RemotePort",
+ "MaxPacketSize",
+ "StartTime",
+ "StopTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RraaWifiManager": dict{(
+ "category": "Manager",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Basic",
+ "Timeout",
+ "ewndFor54mbps",
+ "ewndFor48mbps",
+ "ewndFor36mbps",
+ "ewndFor24mbps",
+ "ewndFor18mbps",
+ "ewndFor12mbps",
+ "ewndFor9mbps",
+ "ewndFor6mbps",
+ "poriFor48mbps",
+ "poriFor36mbps",
+ "poriFor24mbps",
+ "poriFor18mbps",
+ "poriFor12mbps",
+ "poriFor9mbps",
+ "poriFor6mbps",
+ "pmtlFor54mbps",
+ "pmtlFor48mbps",
+ "pmtlFor36mbps",
+ "pmtlFor24mbps",
+ "pmtlFor18mbps",
+ "pmtlFor12mbps",
+ "pmtlFor9mbps",
+ "IsLowLatency",
+ "MaxSsrc",
+ "MaxSlrc",
+ "RtsCtsThreshold",
+ "FragmentationThreshold",
+ "NonUnicastMode"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RandomPropagationLossModel": dict{(
+ "category": "Loss",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Variable"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanChannel": dict{(
+ "category": "Channel",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::MinstrelWifiManager": dict{(
+ "category": "Manager",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["UpdateStatistics",
+ "LookAroundRate",
+ "EWMA",
+ "SegmentSize",
+ "SampleColumn",
+ "PacketLength",
+ "IsLowLatency",
+ "MaxSsrc",
+ "MaxSlrc",
+ "RtsCtsThreshold",
+ "FragmentationThreshold",
+ "NonUnicastMode"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanPhyDual": dict{(
+ "category": "Phy",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["CcaThresholdPhy1",
+ "CcaThresholdPhy2",
+ "TxPowerPhy1",
+ "TxPowerPhy2",
+ "RxGainPhy1",
+ "RxGainPhy2",
+ "SupportedModesPhy1",
+ "SupportedModesPhy2"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::ListErrorModel": dict{(
+ "category": "Error",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["IsEnabled"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::VirtualNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Mtu"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanPhyGen": dict{(
+ "category": "Phy",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["CcaThreshold",
+ "RxThreshold",
+ "TxPower",
+ "RxGain",
+ "SupportedModes"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv6L3Protocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["DefaultTtl",
+ "IpForward"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::PointToPointRemoteChannel": dict{(
+ "category": "Channel",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Delay"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanPhyPerUmodem": dict{(
+ "category": "Phy",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::OnoeWifiManager": dict{(
+ "category": "Manager",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["UpdatePeriod",
+ "RaiseThreshold",
+ "AddCreditThreshold",
+ "IsLowLatency",
+ "MaxSsrc",
+ "MaxSlrc",
+ "RtsCtsThreshold",
+ "FragmentationThreshold",
+ "NonUnicastMode"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::QadhocWifiMac": dict{(
+ "category": "Mac",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["CtsTimeout",
+ "AckTimeout",
+ "BasicBlockAckTimeout",
+ "CompressedBlockAckTimeout",
+ "Sifs",
+ "EifsNoDifs",
+ "Slot",
+ "Pifs",
+ "MaxPropagationDelay",
+ "Ssid"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::JakesPropagationLossModel": dict{(
+ "category": "Loss",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["NumberOfRaysPerPath",
+ "NumberOfOscillatorsPerRay",
+ "DopplerFreq",
+ "Distribution"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::PacketSink": dict{(
+ "category": "Application",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": stop_application,
+ "start_function": start_application,
+ "status_function": status_application,
+ "box_attributes": ["Local",
+ "Protocol",
+ "StartTime",
+ "StopTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::RandomDirection2dMobilityModel": dict{(
+ "category": "Mobility",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Bounds",
+ "Speed",
+ "Pause",
+ "Position",
+ "Velocity"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanMacAloha": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::MsduStandardAggregator": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["MaxAmsduSize"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::DcaTxop": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["MinCw",
+ "MaxCw",
+ "Aifsn"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanPhyCalcSinrFhFsk": dict{(
+ "category": "Phy",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["NumberOfHops"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanPropModelIdeal": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UanMacRcGw": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["MaxReservations",
+ "NumberOfRates",
+ "RetryRate",
+ "MaxPropDelay",
+ "SIFS",
+ "NumberOfNodes",
+ "MinRetryRate",
+ "RetryStep",
+ "NumberOfRetryRates",
+ "TotalRate",
+ "RateStep",
+ "FrameSize"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::NistErrorRateModel": dict{(
+ "category": "Error",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["phy"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": [],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::Ipv4L3Protocol": dict{(
+ "category": "Protocol",
+ "create_function": create_ipv4stack,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["DefaultTtl",
+ "IpForward",
+ "WeakEsModel"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::aodv::RoutingProtocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["HelloInterval",
+ "RreqRetries",
+ "RreqRateLimit",
+ "NodeTraversalTime",
+ "NextHopWait",
+ "ActiveRouteTimeout",
+ "MyRouteTimeout",
+ "BlackListTimeout",
+ "DeletePeriod",
+ "TimeoutBuffer",
+ "NetDiameter",
+ "NetTraversalTime",
+ "PathDiscoveryTime",
+ "MaxQueueLen",
+ "MaxQueueTime",
+ "AllowedHelloLoss",
+ "GratuitousReply",
+ "DestinationOnly",
+ "EnableHello",
+ "EnableBroadcast"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::TcpL4Protocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["RttEstimatorFactory",
+ "ProtocolNumber"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::olsr::RoutingProtocol": dict{(
+ "category": "Protocol",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["HelloInterval",
+ "TcInterval",
+ "MidInterval",
+ "HnaInterval",
+ "Willingness"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::UdpEchoServer": dict{(
+ "category": "Application",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": stop_application,
+ "start_function": start_application,
+ "status_function": status_application,
+ "box_attributes": ["Port",
+ "StartTime",
+ "StopTime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::AmrrWifiManager": dict{(
+ "category": "Manager",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["UpdatePeriod",
+ "FailureRatio",
+ "SuccessRatio",
+ "MaxSuccessThreshold",
+ "MinSuccessThreshold",
+ "IsLowLatency",
+ "MaxSsrc",
+ "MaxSlrc",
+ "RtsCtsThreshold",
+ "FragmentationThreshold",
+ "NonUnicastMode"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::ArfWifiManager": dict{(
+ "category": "Manager",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": ["dev"],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["TimerThreshold",
+ "SuccessThreshold",
+ "IsLowLatency",
+ "MaxSsrc",
+ "MaxSlrc",
+ "RtsCtsThreshold",
+ "FragmentationThreshold",
+ "NonUnicastMode"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::SubscriberStationNetDevice": dict{(
+ "category": "Device",
+ "create_function": create_device,
+ "help": "",
+ "connector_types": ["node"],
+ "allow_routes": False,
+ "allow_addresses": True,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["LostDlMapInterval",
+ "LostUlMapInterval",
+ "MaxDcdInterval",
+ "MaxUcdInterval",
+ "IntervalT1",
+ "IntervalT2",
+ "IntervalT3",
+ "IntervalT7",
+ "IntervalT12",
+ "IntervalT20",
+ "IntervalT21",
+ "MaxContentionRangingRetries",
+ "Mtu",
+ "RTG",
+ "TTG"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+ "ns3::flame::FlameRtable": dict{(
+ "category": "",
+ "create_function": create_element,
+ "help": "",
+ "connector_types": [],
+ "allow_routes": False,
+ "allow_addresses": False,
+ "stop_function": None,
+ "start_function": None,
+ "status_function": None,
+ "box_attributes": ["Lifetime"],
+ "factory_attributes": [],
+ "traces": []
+ )},
+)}
from constants import TESTBED_ID
from nepi.core import metadata
from nepi.core.attributes import Attribute
-from nepi.util import validation
from nepi.util.constants import AF_INET, STATUS_NOT_STARTED, STATUS_RUNNING, \
STATUS_FINISHED
def connect_node_other(tesbed_instance, node, other):
node.AggregateObject(other)
+ ### create traces functions ###
+
+def get_node_guid(testbed_instance, guid):
+ node_guid = testbed_instance.get_connected(guid, "node", "devs")[0]
+ return node_guid
+
+def get_dev_number(testbed_instance, guid):
+ dev_guids = testbed_instance.get_connected(node_guid, "devs", "node")
+ interface_number = 0
+ for guid_ in dev_guids:
+ if guid_ == guid:
+ break
+ inteface_number += 1
+ return interface_number
+
+def p2pcap_trace(testbed_instance, guid):
+ trace_id = "p2ppcap"
+ node_guid = get_node_guid(testbed_instance, guid)
+ interface_number = get_dev_number(testbed_instance, guid)
+ element = testbed_instance._elements[guid]
+ filename = "trace-p2p-node-%d-dev-%d.pcap" % (node_name, interface_number)
+ testbed_instance.follow_trace(guid, trace_id, filename)
+ filepath = testbed_instance.trace_filename(self, guid, trace_id):
+ helper = testbed_instance.ns3.PointToPointHelper()
+ helper.EnablePcap(filepath, element, explicitFilename = True)
+
+def _csmapcap_trace(testbed_instance, guid, trace_id, promisc):
+ node_guid = get_node_guid(testbed_instance, guid)
+ interface_number = get_dev_number(testbed_instance, guid)
+ element = testbed_instance._elements[guid]
+ filename = "trace-csma-node-%d-dev-%d.pcap" % (node_name, interface_number)
+ testbed_instance.follow_trace(guid, trace_id, filename)
+ filepath = testbed_instance.trace_filename(self, guid, trace_id):
+ helper = testbed_instance.ns3.CsmaHelper()
+ helper.EnablePcap(filepath, element, promiscuous = promisc,
+ explicitFilename = True)
+
+def csmapcap_trace(testbed_instance, guid):
+ trace_id = "csmapcap"
+ promisc = False
+ _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
+
+def csmapcap_promisc_trace(testbed_instance, guid):
+ trace_id = "csmapcap_promisc"
+ promisc = True
+ _csmapcap_trace(testbed_instance, guid, trace_id, promisc)
+
+def fdpcap_trace(testbed_instance, guid):
+ trace_id = "fdpcap"
+ node_guid = get_node_guid(testbed_instance, guid)
+ interface_number = get_dev_number(testbed_instance, guid)
+ element = testbed_instance._elements[guid]
+ filename = "trace-fd-node-%d-dev-%d.pcap" % (node_name, interface_number)
+ testbed_instance.follow_trace(guid, trace_id, filename)
+ filepath = testbed_instance.trace_filename(self, guid, trace_id):
+ helper = testbed_instance.ns3.FileDescriptorHelper()
+ helper.EnablePcap(filepath, element, explicitFilename = True)
+
+def yanswifipcap_trace(testbed_instance, guid):
+ trace_id = "yanswifipcap"
+ dev_guid = testbed_instance.get_connected(guid, "dev", "phy")[0]
+ node_guid = get_node_guid(testbed_instance, dev_guid)
+ interface_number = get_dev_number(testbed_instance, dev_guid)
+ element = testbed_instance._elements[dev_guid]
+ filename = "trace-yanswifi-node-%d-dev-%d.pcap" % (node_name, interface_number)
+ testbed_instance.follow_trace(guid, trace_id, filename)
+ filepath = testbed_instance.trace_filename(self, guid, trace_id):
+ helper = testbed_instance.ns3.YansWifiPhyHelper()
+ helper.EnablePcap(filepath, element, explicitFilename = True)
+
+trace_functions = dict({
+ "p2ppcap": p2ppcap_trace,
+ "csmapcap": csmapcap_trace,
+ "csmapcap_promisc": csmapcap_promisc_trace,
+ "fdpcap": fdpcap_trace,
+ "yanswifipcap": yanswifipcap_trace
+ })
+
### Creation functions ###
-def create_element(testbed_instance, guid, parameters, factory_parameters):
+def create_element(testbed_instance, guid):
element_factory = testbed_instance.ns3.ObjectFactory()
factory_id = testbed_instance._create[guid]
element_factory.SetTypeId(factory_id)
+ factory_parameters = testbed_instance._get_factory_parameters(guid)
for name, value in factory_parameters.iteritems():
testbed_instance._set(element_factory, factory_id, name, value)
element = element_factory.Create()
testbed_instance._elements[guid] = element
+ traces = testbed_instance._get_traces(guid)
+ for trace_id in traces:
+ trace_func = trace_functions[trace_id]
+ trace_func(testbed_instance, guid)
-def create_node(testbed_instance, guid, parameters, factory_parameters):
- create_element(testbed_instance, guid, parameters, factory_parameters)
+def create_node(testbed_instance, guid):
+ create_element(testbed_instance, guid)
element = testbed_instance._elements[guid]
element.AggregateObject(testbed_instance.PacketSocketFactory())
-def create_dev(testbed_instance, guid, parameters, factory_parameters):
- create_element(testbed_instance, guid, parameters, factory_parameters)
+def create_device(testbed_instance, guid):
+ create_element(testbed_instance, guid)
element = testbed_instance._elements[guid]
+ parameters = testbed_instance._get_parameters(guid)
if "macAddress" in parameters:
address = parameters["macAddress"]
macaddr = testbed_instance.ns3.Mac48Address(address)
macaddr = testbed_instance.ns3.Mac48Address.Allocate()
element.SetAddress(macaddr)
-def create_wifi_standard_model(testbed_instance, guid, parameters,
- factory_parameters):
- create_element(testbed_instance, guid, parameters, factory_parameters)
+def create_wifi_standard_model(testbed_instance, guid):
+ create_element(testbed_instance, guid)
element = testbed_instance._elements[guid]
+ parameters = testbed_instance._get_parameters(guid)
if "standard" in parameters:
standard = parameters["standard"]
if standard:
elements.ConfigureStandard(wifi_standards[standard])
-def create_ipv4stack(testbed_instance, guid, parameters, factory_parameters):
- create_element(testbed_instance, guid, parameters, factory_parameters)
+def create_ipv4stack(testbed_instance, guid):
+ create_element(testbed_instance, guid)
element = testbed_instance._elements[guid]
list_routing = testbed_instance.ns3.Ipv4ListRouting()
element.SetRoutingProtocol(list_routing)
### Start/Stop functions ###
-def start_application(testbed_instance, guid, parameters, traces):
+def start_application(testbed_instance, guid):
element = testbed_instance.elements[guid]
element.Start()
-def stop_application(testbed_instance, guid, parameters, traces):
+def stop_application(testbed_instance, guid):
element = testbed_instance.elements[guid]
element.Stop()
### Status functions ###
-def status_application(testbed_instance, guid, parameters, traces):
+def status_application(testbed_instance, guid):
if guid not in testbed_instance.elements.keys():
return STATUS_NOT_STARTED
app = testbed_instance.elements[guid]
+ parameters = testbed_instance._get_parameters(guid)
if "stopTime" in parameters:
stop = parameters["stopTime"]
if stop:
})
]
-# TODO!
-attributes = dict({
- "forward_X11": dict({
- "name": "forward_X11",
- "help": "Forward x11 from main namespace to the node",
- "type": Attribute.BOOL,
- "value": False,
- "range": None,
- "allowed": None,
- "flags": Attribute.DesignOnly,
- "validation_function": validation.is_bool
- }),
- })
-
-# TODO!
traces = dict({
- "stdout": dict({
- "name": "stdout",
- "help": "Standard output stream"
+ "p2ppcap": dict({
+ "name": "P2PPcapTrace",
+ "help": "Trace to sniff packets from a P2P network device"
}),
- })
+ "csmapcap_promisc": dict({
+ "name": "CsmaPromiscPcapTrace",
+ "help": "Trace to sniff packets from a Csma network device in promiscuous mode"
+ }),
+ "csmapcap": dict({
+ "name": "CsmaPcapTrace",
+ "help": "Trace to sniff packets from a Csma network device"
+ }),
+ "fdpcap": dict({
+ "name": "FileDescriptorPcapTrace",
+ "help": "Trace to sniff packets from a FileDescriptor network device"
+ }),
+ "yanswifipcap": dict({
+ "name": "YansWifiPhyPcapTrace",
+ "help": "Trace to sniff packets from a Wifi network device"
+ }),
+})
-# TODO!
-factories_order = [ NODE, P2PIFACE, NODEIFACE, TAPIFACE, SWITCH,
- APPLICATION ]
-
-# TODO!
-factories_info = dict({
- NODE: dict({
- "allow_routes": True,
- "help": "Emulated Node with virtualized network stack",
- "category": "topology",
- "create_function": create_node,
- "start_function": None,
- "stop_function": None,
- "status_function": None,
- "box_attributes": ["forward_X11"],
- "connector_types": ["devs", "apps"]
- }),
- })
+factories_order = ["ns3::BasicEnergySource",
+ "ns3::WifiRadioEnergyModel",
+ "ns3::BSSchedulerRtps",
+ "ns3::BSSchedulerSimple",
+ "ns3::SubscriberStationNetDevice",
+ "ns3::BaseStationNetDevice",
+ "ns3::UdpTraceClient",
+ "ns3::UdpServer",
+ "ns3::UdpClient",
+ "ns3::FlowMonitor",
+ "ns3::Radvd",
+ "ns3::Ping6",
+ "ns3::flame::FlameProtocol",
+ "ns3::flame::FlameRtable",
+ "ns3::dot11s::AirtimeLinkMetricCalculator",
+ "ns3::dot11s::HwmpProtocol",
+ "ns3::dot11s::HwmpRtable",
+ "ns3::dot11s::PeerManagementProtocol",
+ "ns3::dot11s::PeerLink",
+ "ns3::MeshWifiInterfaceMac",
+ "ns3::MeshPointDevice",
+ "ns3::UanMacRcGw",
+ "ns3::UanMacRc",
+ "ns3::UanPhyCalcSinrDual",
+ "ns3::UanPhyPerGenDefault",
+ "ns3::UanPhyDual",
+ "ns3::UanPropModelThorp",
+ "ns3::UanMacCw",
+ "ns3::UanNoiseModelDefault",
+ "ns3::UanMacAloha",
+ "ns3::UanPropModelIdeal",
+ "ns3::UanTransducerHd",
+ "ns3::UanPhyCalcSinrDefault",
+ "ns3::UanPhyGen",
+ "ns3::UanPhyCalcSinrFhFsk",
+ "ns3::UanPhyPerUmodem",
+ "ns3::UanChannel",
+ "ns3::V4Ping",
+ "ns3::AthstatsWifiTraceSink",
+ "ns3::FlameStack",
+ "ns3::Dot11sStack",
+ "ns3::NonCommunicatingNetDevice",
+ "ns3::HalfDuplexIdealPhy",
+ "ns3::AlohaNoackNetDevice",
+ "ns3::SpectrumAnalyzer",
+ "ns3::WaveformGenerator",
+ "ns3::MultiModelSpectrumChannel",
+ "ns3::SingleModelSpectrumChannel",
+ "ns3::MsduStandardAggregator",
+ "ns3::EdcaTxopN",
+ "ns3::QstaWifiMac",
+ "ns3::QapWifiMac",
+ "ns3::QadhocWifiMac",
+ "ns3::MinstrelWifiManager",
+ "ns3::CaraWifiManager",
+ "ns3::AarfcdWifiManager",
+ "ns3::OnoeWifiManager",
+ "ns3::AmrrWifiManager",
+ "ns3::ConstantRateWifiManager",
+ "ns3::IdealWifiManager",
+ "ns3::AarfWifiManager",
+ "ns3::ArfWifiManager",
+ "ns3::WifiNetDevice",
+ "ns3::NqstaWifiMac",
+ "ns3::NqapWifiMac",
+ "ns3::AdhocWifiMac",
+ "ns3::DcaTxop",
+ "ns3::WifiMacQueue",
+ "ns3::YansWifiChannel",
+ "ns3::YansWifiPhy",
+ "ns3::NistErrorRateModel",
+ "ns3::YansErrorRateModel",
+ "ns3::WaypointMobilityModel",
+ "ns3::ConstantAccelerationMobilityModel",
+ "ns3::RandomDirection2dMobilityModel",
+ "ns3::RandomWalk2dMobilityModel",
+ "ns3::SteadyStateRandomWaypointMobilityModel",
+ "ns3::RandomWaypointMobilityModel",
+ "ns3::GaussMarkovMobilityModel",
+ "ns3::ConstantVelocityMobilityModel",
+ "ns3::ConstantPositionMobilityModel",
+ "ns3::ListPositionAllocator",
+ "ns3::GridPositionAllocator",
+ "ns3::RandomRectanglePositionAllocator",
+ "ns3::RandomBoxPositionAllocator",
+ "ns3::RandomDiscPositionAllocator",
+ "ns3::UniformDiscPositionAllocator",
+ "ns3::HierarchicalMobilityModel",
+ "ns3::aodv::RoutingProtocol",
+ "ns3::UdpEchoServer",
+ "ns3::UdpEchoClient",
+ "ns3::PacketSink",
+ "ns3::OnOffApplication",
+ "ns3::VirtualNetDevice",
+ "ns3::FileDescriptorNetDevice",
+ "ns3::TapBridge",
+ "ns3::BridgeChannel",
+ "ns3::BridgeNetDevice",
+ "ns3::EmuNetDevice",
+ "ns3::CsmaChannel",
+ "ns3::CsmaNetDevice",
+ "ns3::PointToPointRemoteChannel",
+ "ns3::PointToPointChannel",
+ "ns3::PointToPointNetDevice",
+ "ns3::NscTcpL4Protocol",
+ "ns3::Icmpv6L4Protocol",
+ "ns3::Ipv6OptionPad1",
+ "ns3::Ipv6OptionPadn",
+ "ns3::Ipv6OptionJumbogram",
+ "ns3::Ipv6OptionRouterAlert",
+ "ns3::Ipv6ExtensionHopByHop",
+ "ns3::Ipv6ExtensionDestination",
+ "ns3::Ipv6ExtensionFragment",
+ "ns3::Ipv6ExtensionRouting",
+ "ns3::Ipv6ExtensionLooseRouting",
+ "ns3::Ipv6ExtensionESP",
+ "ns3::Ipv6ExtensionAH",
+ "ns3::Ipv6L3Protocol",
+ "ns3::LoopbackNetDevice",
+ "ns3::Icmpv4L4Protocol",
+ "ns3::RttMeanDeviation",
+ "ns3::ArpL3Protocol",
+ "ns3::TcpL4Protocol",
+ "ns3::UdpL4Protocol",
+ "ns3::Ipv4L3Protocol",
+ "ns3::SimpleNetDevice",
+ "ns3::SimpleChannel",
+ "ns3::PacketSocket",
+ "ns3::DropTailQueue",
+ "ns3::Node",
+ "ns3::FriisSpectrumPropagationLossModel",
+ "ns3::Cost231PropagationLossModel",
+ "ns3::JakesPropagationLossModel",
+ "ns3::RandomPropagationLossModel",
+ "ns3::FriisPropagationLossModel",
+ "ns3::TwoRayGroundPropagationLossModel",
+ "ns3::LogDistancePropagationLossModel",
+ "ns3::ThreeLogDistancePropagationLossModel",
+ "ns3::NakagamiPropagationLossModel",
+ "ns3::FixedRssLossModel",
+ "ns3::MatrixPropagationLossModel",
+ "ns3::RangePropagationLossModel",
+ "ns3::RandomPropagationDelayModel",
+ "ns3::ConstantSpeedPropagationDelayModel",
+ "ns3::RateErrorModel",
+ "ns3::ListErrorModel",
+ "ns3::ReceiveListErrorModel",
+ "ns3::PacketBurst",
+ "ns3::EnergySourceContainer"
+ ]
testbed_attributes = dict({
"ns3_bindings": dict({
@property
def attributes(self):
+ from attributes_metadata_v3_9_RC3 import attributes
return attributes
@property
@property
def factories_info(self):
+ from factories_metadata_v3_9_RC3 import factories_info
return factories_info
@property
git://git.onelab.eu / nepi.git / commitdiff