A Discrete-Event Network Simulator
API
wifi-phy-operating-channel.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2021
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation;
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16  *
17  * Authors: Stefano Avallone <stavallo@unina.it>
18  * Sébastien Deronne <sebastien.deronne@gmail.com>
19  */
20 
21 #include "wifi-phy-operating-channel.h"
22 
23 #include "wifi-phy-common.h"
24 
25 #include "ns3/assert.h"
26 #include "ns3/log.h"
27 
28 #include <algorithm>
29 
30 namespace ns3
31 {
32 
33 NS_LOG_COMPONENT_DEFINE("WifiPhyOperatingChannel");
34 
35 const std::set<FrequencyChannelInfo> WifiPhyOperatingChannel::m_frequencyChannels = {
36  // 2.4 GHz channels
37  // 802.11b uses width of 22, while OFDM modes use width of 20
38  {std::make_tuple(1, 2412, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
39  {std::make_tuple(1, 2412, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
40  {std::make_tuple(2, 2417, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
41  {std::make_tuple(2, 2417, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
42  {std::make_tuple(3, 2422, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
43  {std::make_tuple(3, 2422, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
44  {std::make_tuple(4, 2427, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
45  {std::make_tuple(4, 2427, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
46  {std::make_tuple(5, 2432, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
47  {std::make_tuple(5, 2432, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
48  {std::make_tuple(6, 2437, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
49  {std::make_tuple(6, 2437, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
50  {std::make_tuple(7, 2442, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
51  {std::make_tuple(7, 2442, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
52  {std::make_tuple(8, 2447, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
53  {std::make_tuple(8, 2447, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
54  {std::make_tuple(9, 2452, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
55  {std::make_tuple(9, 2452, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
56  {std::make_tuple(10, 2457, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
57  {std::make_tuple(10, 2457, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
58  {std::make_tuple(11, 2462, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
59  {std::make_tuple(11, 2462, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
60  {std::make_tuple(12, 2467, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
61  {std::make_tuple(12, 2467, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
62  {std::make_tuple(13, 2472, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
63  {std::make_tuple(13, 2472, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
64  // Only defined for 802.11b
65  {std::make_tuple(14, 2484, 22, WIFI_PHY_DSSS_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
66  // 40 MHz channels
67  {std::make_tuple(3, 2422, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
68  {std::make_tuple(4, 2427, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
69  {std::make_tuple(5, 2432, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
70  {std::make_tuple(6, 2437, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
71  {std::make_tuple(7, 2442, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
72  {std::make_tuple(8, 2447, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
73  {std::make_tuple(9, 2452, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
74  {std::make_tuple(10, 2457, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
75  {std::make_tuple(11, 2462, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_2_4GHZ)},
76 
77  // Now the 5 GHz channels used for 802.11a/n/ac/ax/be
78  // 20 MHz channels
79  {std::make_tuple(36, 5180, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
80  {std::make_tuple(40, 5200, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
81  {std::make_tuple(44, 5220, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
82  {std::make_tuple(48, 5240, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
83  {std::make_tuple(52, 5260, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
84  {std::make_tuple(56, 5280, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
85  {std::make_tuple(60, 5300, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
86  {std::make_tuple(64, 5320, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
87  {std::make_tuple(100, 5500, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
88  {std::make_tuple(104, 5520, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
89  {std::make_tuple(108, 5540, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
90  {std::make_tuple(112, 5560, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
91  {std::make_tuple(116, 5580, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
92  {std::make_tuple(120, 5600, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
93  {std::make_tuple(124, 5620, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
94  {std::make_tuple(128, 5640, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
95  {std::make_tuple(132, 5660, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
96  {std::make_tuple(136, 5680, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
97  {std::make_tuple(140, 5700, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
98  {std::make_tuple(144, 5720, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
99  {std::make_tuple(149, 5745, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
100  {std::make_tuple(153, 5765, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
101  {std::make_tuple(157, 5785, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
102  {std::make_tuple(161, 5805, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
103  {std::make_tuple(165, 5825, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
104  {std::make_tuple(169, 5845, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
105  {std::make_tuple(173, 5865, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
106  {std::make_tuple(177, 5885, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
107  {std::make_tuple(181, 5905, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
108  // 40 MHz channels
109  {std::make_tuple(38, 5190, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
110  {std::make_tuple(46, 5230, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
111  {std::make_tuple(54, 5270, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
112  {std::make_tuple(62, 5310, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
113  {std::make_tuple(102, 5510, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
114  {std::make_tuple(110, 5550, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
115  {std::make_tuple(118, 5590, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
116  {std::make_tuple(126, 5630, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
117  {std::make_tuple(134, 5670, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
118  {std::make_tuple(142, 5710, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
119  {std::make_tuple(151, 5755, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
120  {std::make_tuple(159, 5795, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
121  {std::make_tuple(167, 5835, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
122  {std::make_tuple(175, 5875, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
123  // 80 MHz channels
124  {std::make_tuple(42, 5210, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
125  {std::make_tuple(58, 5290, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
126  {std::make_tuple(106, 5530, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
127  {std::make_tuple(122, 5610, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
128  {std::make_tuple(138, 5690, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
129  {std::make_tuple(155, 5775, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
130  {std::make_tuple(171, 5855, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
131  // 160 MHz channels
132  {std::make_tuple(50, 5250, 160, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
133  {std::make_tuple(114, 5570, 160, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
134  {std::make_tuple(163, 5815, 160, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_5GHZ)},
135 
136  // 802.11p 10 MHz channels at the 5.855-5.925 band
137  {std::make_tuple(172, 5860, 10, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
138  {std::make_tuple(174, 5870, 10, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
139  {std::make_tuple(176, 5880, 10, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
140  {std::make_tuple(178, 5890, 10, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
141  {std::make_tuple(180, 5900, 10, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
142  {std::make_tuple(182, 5910, 10, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
143  {std::make_tuple(184, 5920, 10, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
144 
145  // 802.11p 5 MHz channels at the 5.855-5.925 band (for simplification, we consider the same
146  // center frequencies as the 10 MHz channels)
147  {std::make_tuple(171, 5860, 5, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
148  {std::make_tuple(173, 5870, 5, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
149  {std::make_tuple(175, 5880, 5, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
150  {std::make_tuple(177, 5890, 5, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
151  {std::make_tuple(179, 5900, 5, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
152  {std::make_tuple(181, 5910, 5, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
153  {std::make_tuple(183, 5920, 5, WIFI_PHY_80211p_CHANNEL, WIFI_PHY_BAND_5GHZ)},
154 
155  // Now the 6 GHz channels for 802.11ax/be
156  // 20 MHz channels
157  {std::make_tuple(1, 5955, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
158  {std::make_tuple(5, 5975, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
159  {std::make_tuple(9, 5995, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
160  {std::make_tuple(13, 6015, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
161  {std::make_tuple(17, 6035, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
162  {std::make_tuple(21, 6055, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
163  {std::make_tuple(25, 6075, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
164  {std::make_tuple(29, 6095, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
165  {std::make_tuple(33, 6115, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
166  {std::make_tuple(37, 6135, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
167  {std::make_tuple(41, 6155, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
168  {std::make_tuple(45, 6175, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
169  {std::make_tuple(49, 6195, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
170  {std::make_tuple(53, 6215, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
171  {std::make_tuple(57, 6235, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
172  {std::make_tuple(61, 6255, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
173  {std::make_tuple(65, 6275, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
174  {std::make_tuple(69, 6295, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
175  {std::make_tuple(73, 6315, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
176  {std::make_tuple(77, 6335, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
177  {std::make_tuple(81, 6355, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
178  {std::make_tuple(85, 6375, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
179  {std::make_tuple(89, 6395, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
180  {std::make_tuple(93, 6415, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
181  {std::make_tuple(97, 6435, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
182  {std::make_tuple(101, 6455, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
183  {std::make_tuple(105, 6475, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
184  {std::make_tuple(109, 6495, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
185  {std::make_tuple(113, 6515, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
186  {std::make_tuple(117, 6535, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
187  {std::make_tuple(121, 6555, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
188  {std::make_tuple(125, 6575, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
189  {std::make_tuple(129, 6595, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
190  {std::make_tuple(133, 6615, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
191  {std::make_tuple(137, 6635, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
192  {std::make_tuple(141, 6655, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
193  {std::make_tuple(145, 6675, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
194  {std::make_tuple(149, 6695, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
195  {std::make_tuple(153, 6715, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
196  {std::make_tuple(157, 6735, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
197  {std::make_tuple(161, 6755, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
198  {std::make_tuple(165, 6775, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
199  {std::make_tuple(169, 6795, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
200  {std::make_tuple(173, 6815, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
201  {std::make_tuple(177, 6835, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
202  {std::make_tuple(181, 6855, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
203  {std::make_tuple(185, 6875, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
204  {std::make_tuple(189, 6895, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
205  {std::make_tuple(193, 6915, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
206  {std::make_tuple(197, 6935, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
207  {std::make_tuple(201, 6955, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
208  {std::make_tuple(205, 6975, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
209  {std::make_tuple(209, 6995, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
210  {std::make_tuple(213, 7015, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
211  {std::make_tuple(217, 7035, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
212  {std::make_tuple(221, 7055, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
213  {std::make_tuple(225, 7075, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
214  {std::make_tuple(229, 7095, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
215  {std::make_tuple(233, 7115, 20, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
216  // 40 MHz channels
217  {std::make_tuple(3, 5965, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
218  {std::make_tuple(11, 6005, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
219  {std::make_tuple(19, 6045, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
220  {std::make_tuple(27, 6085, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
221  {std::make_tuple(35, 6125, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
222  {std::make_tuple(43, 6165, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
223  {std::make_tuple(51, 6205, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
224  {std::make_tuple(59, 6245, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
225  {std::make_tuple(67, 6285, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
226  {std::make_tuple(75, 6325, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
227  {std::make_tuple(83, 6365, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
228  {std::make_tuple(91, 6405, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
229  {std::make_tuple(99, 6445, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
230  {std::make_tuple(107, 6485, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
231  {std::make_tuple(115, 6525, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
232  {std::make_tuple(123, 6565, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
233  {std::make_tuple(131, 6605, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
234  {std::make_tuple(139, 6645, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
235  {std::make_tuple(147, 6685, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
236  {std::make_tuple(155, 6725, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
237  {std::make_tuple(163, 6765, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
238  {std::make_tuple(171, 6805, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
239  {std::make_tuple(179, 6845, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
240  {std::make_tuple(187, 6885, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
241  {std::make_tuple(195, 6925, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
242  {std::make_tuple(203, 6965, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
243  {std::make_tuple(211, 7005, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
244  {std::make_tuple(219, 7045, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
245  {std::make_tuple(227, 7085, 40, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
246  // 80 MHz channels
247  {std::make_tuple(7, 5985, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
248  {std::make_tuple(23, 6065, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
249  {std::make_tuple(39, 6145, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
250  {std::make_tuple(55, 6225, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
251  {std::make_tuple(71, 6305, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
252  {std::make_tuple(87, 6385, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
253  {std::make_tuple(103, 6465, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
254  {std::make_tuple(119, 6585, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
255  {std::make_tuple(135, 6625, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
256  {std::make_tuple(151, 6705, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
257  {std::make_tuple(167, 6785, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
258  {std::make_tuple(183, 6865, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
259  {std::make_tuple(199, 6945, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
260  {std::make_tuple(215, 7025, 80, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
261  // 160 MHz channels
262  {std::make_tuple(15, 6025, 160, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
263  {std::make_tuple(47, 6185, 160, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
264  {std::make_tuple(79, 6345, 160, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
265  {std::make_tuple(111, 6505, 160, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
266  {std::make_tuple(143, 6665, 160, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
267  {std::make_tuple(175, 6825, 160, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
268  {std::make_tuple(207, 6985, 160, WIFI_PHY_OFDM_CHANNEL, WIFI_PHY_BAND_6GHZ)},
269 };
270 
271 WifiPhyOperatingChannel::WifiPhyOperatingChannel()
272  : WifiPhyOperatingChannel(m_frequencyChannels.end())
273 {
274 }
275 
276 WifiPhyOperatingChannel::WifiPhyOperatingChannel(ConstIterator it)
277  : m_channelIt(it),
278  m_primary20Index(0)
279 {
280  NS_LOG_FUNCTION(this);
281 }
282 
283 WifiPhyOperatingChannel::~WifiPhyOperatingChannel()
284 {
285  NS_LOG_FUNCTION_NOARGS();
286 }
287 
288 bool
289 WifiPhyOperatingChannel::IsSet() const
290 {
291  return m_channelIt != m_frequencyChannels.end();
292 }
293 
294 void
295 WifiPhyOperatingChannel::Set(uint8_t number,
296  uint16_t frequency,
297  uint16_t width,
298  WifiStandard standard,
299  WifiPhyBand band)
300 {
301  NS_LOG_FUNCTION(this << +number << frequency << width << standard << band);
302 
303  auto channelIt = FindFirst(number, frequency, width, standard, band);
304 
305  if (channelIt != m_frequencyChannels.end() &&
306  FindFirst(number, frequency, width, standard, band, std::next(channelIt)) ==
307  m_frequencyChannels.end())
308  {
309  // a unique channel matches the specified criteria
310  m_channelIt = channelIt;
311  m_primary20Index = 0;
312  return;
313  }
314 
315  // if a unique channel was not found, throw an exception (mainly for unit testing this code)
316  throw std::runtime_error(
317  "WifiPhyOperatingChannel: No unique channel found given the specified criteria");
318 }
319 
320 void
321 WifiPhyOperatingChannel::SetDefault(uint16_t width, WifiStandard standard, WifiPhyBand band)
322 {
323  NS_LOG_FUNCTION(this << width << standard << band);
324 
325  Set(GetDefaultChannelNumber(width, standard, band), 0, width, standard, band);
326 }
327 
328 uint8_t
329 WifiPhyOperatingChannel::GetDefaultChannelNumber(uint16_t width,
330  WifiStandard standard,
331  WifiPhyBand band)
332 {
333  auto channelIt = FindFirst(0, 0, width, standard, band);
334 
335  if (channelIt != m_frequencyChannels.end())
336  {
337  // a channel matches the specified criteria
338  return std::get<0>(*channelIt);
339  }
340 
341  // if a default channel was not found, throw an exception (mainly for unit testing this code)
342  throw std::runtime_error("WifiPhyOperatingChannel: No default channel found of the given width "
343  "and for the given PHY standard and band");
344 }
345 
346 WifiPhyOperatingChannel::ConstIterator
347 WifiPhyOperatingChannel::FindFirst(uint8_t number,
348  uint16_t frequency,
349  uint16_t width,
350  WifiStandard standard,
351  WifiPhyBand band,
352  ConstIterator start)
353 {
354  // lambda used to match channels against the specified criteria
355  auto predicate = [&](const FrequencyChannelInfo& channel) {
356  if (number != 0 && std::get<0>(channel) != number)
357  {
358  return false;
359  }
360  if (frequency != 0 && std::get<1>(channel) != frequency)
361  {
362  return false;
363  }
364  if (width != 0 && std::get<2>(channel) != width)
365  {
366  return false;
367  }
368  if (standard != WIFI_STANDARD_UNSPECIFIED &&
369  std::get<3>(channel) != GetFrequencyChannelType(standard))
370  {
371  return false;
372  }
373  if (std::get<4>(channel) != band)
374  {
375  return false;
376  }
377  return true;
378  };
379 
380  // Do not search for a channel matching the specified criteria if the given PHY band
381  // is not allowed for the given standard (if any) or the given channel width is not
382  // allowed for the given standard (if any)
383  if (const auto standardIt = wifiStandards.find(standard);
384  standardIt != wifiStandards.cend() &&
385  (std::find(standardIt->second.cbegin(), standardIt->second.cend(), band) ==
386  standardIt->second.cend() ||
387  width > GetMaximumChannelWidth(GetModulationClassForStandard(standard))))
388  {
389  return m_frequencyChannels.cend();
390  }
391 
392  return std::find_if(start, m_frequencyChannels.cend(), predicate);
393 }
394 
395 uint8_t
396 WifiPhyOperatingChannel::GetNumber() const
397 {
398  NS_ASSERT(IsSet());
399  return std::get<0>(*m_channelIt);
400 }
401 
402 uint16_t
403 WifiPhyOperatingChannel::GetFrequency() const
404 {
405  NS_ASSERT(IsSet());
406  return std::get<1>(*m_channelIt);
407 }
408 
409 uint16_t
410 WifiPhyOperatingChannel::GetWidth() const
411 {
412  NS_ASSERT(IsSet());
413  return std::get<2>(*m_channelIt);
414 }
415 
416 WifiPhyBand
417 WifiPhyOperatingChannel::GetPhyBand() const
418 {
419  NS_ASSERT(IsSet());
420  return std::get<4>(*m_channelIt);
421 }
422 
423 bool
424 WifiPhyOperatingChannel::IsOfdm() const
425 {
426  NS_ASSERT(IsSet());
427  return std::get<FrequencyChannelType>(*m_channelIt) == WIFI_PHY_OFDM_CHANNEL;
428 }
429 
430 bool
431 WifiPhyOperatingChannel::IsDsss() const
432 {
433  NS_ASSERT(IsSet());
434  return std::get<FrequencyChannelType>(*m_channelIt) == WIFI_PHY_DSSS_CHANNEL;
435 }
436 
437 bool
438 WifiPhyOperatingChannel::Is80211p() const
439 {
440  NS_ASSERT(IsSet());
441  return std::get<FrequencyChannelType>(*m_channelIt) == WIFI_PHY_80211p_CHANNEL;
442 }
443 
444 uint8_t
445 WifiPhyOperatingChannel::GetPrimaryChannelIndex(uint16_t primaryChannelWidth) const
446 {
447  NS_LOG_FUNCTION(this << primaryChannelWidth);
448 
449  if (primaryChannelWidth % 20 != 0)
450  {
451  NS_LOG_DEBUG("The operating channel width is not a multiple of 20 MHz; return 0");
452  return 0;
453  }
454 
455  NS_ASSERT(primaryChannelWidth <= GetWidth());
456 
457  // the index of primary40 is half the index of primary20; the index of
458  // primary80 is half the index of primary40, ...
459  uint16_t width = 20;
460  uint8_t index = m_primary20Index;
461 
462  while (width < primaryChannelWidth)
463  {
464  index /= 2;
465  width *= 2;
466  }
467  NS_LOG_LOGIC("Return primary index " << +index);
468  return index;
469 }
470 
471 uint8_t
472 WifiPhyOperatingChannel::GetSecondaryChannelIndex(uint16_t secondaryChannelWidth) const
473 {
474  NS_LOG_FUNCTION(this << secondaryChannelWidth);
475  const uint8_t primaryIndex = GetPrimaryChannelIndex(secondaryChannelWidth);
476  const uint8_t secondaryIndex =
477  (primaryIndex % 2 == 0) ? (primaryIndex + 1) : (primaryIndex - 1);
478  NS_LOG_LOGIC("Return secondary index " << +secondaryIndex);
479  return secondaryIndex;
480 }
481 
482 void
483 WifiPhyOperatingChannel::SetPrimary20Index(uint8_t index)
484 {
485  NS_LOG_FUNCTION(this << +index);
486 
487  NS_ABORT_MSG_IF(index > 0 && index >= GetWidth() / 20, "Primary20 index out of range");
488  m_primary20Index = index;
489 }
490 
491 uint16_t
492 WifiPhyOperatingChannel::GetPrimaryChannelCenterFrequency(uint16_t primaryChannelWidth) const
493 {
494  uint16_t freq = GetFrequency() - GetWidth() / 2. +
495  (GetPrimaryChannelIndex(primaryChannelWidth) + 0.5) * primaryChannelWidth;
496 
497  NS_LOG_FUNCTION(this << primaryChannelWidth << freq);
498  return freq;
499 }
500 
501 uint16_t
502 WifiPhyOperatingChannel::GetSecondaryChannelCenterFrequency(uint16_t secondaryChannelWidth) const
503 {
504  const uint8_t primaryIndex = GetPrimaryChannelIndex(secondaryChannelWidth);
505  const uint16_t primaryCenterFrequency = GetPrimaryChannelCenterFrequency(secondaryChannelWidth);
506  return (primaryIndex % 2 == 0) ? (primaryCenterFrequency + secondaryChannelWidth)
507  : (primaryCenterFrequency - secondaryChannelWidth);
508 }
509 
510 uint8_t
511 WifiPhyOperatingChannel::GetPrimaryChannelNumber(uint16_t primaryChannelWidth,
512  WifiStandard standard) const
513 {
514  auto frequency = GetPrimaryChannelCenterFrequency(primaryChannelWidth);
515  NS_ASSERT_MSG(IsSet(), "No channel set");
516  auto& [chanNumber, centerFreq, channelWidth, channelType, band] = *m_channelIt;
517  auto primaryChanIt = FindFirst(0, frequency, primaryChannelWidth, standard, band);
518  NS_ASSERT_MSG(primaryChanIt != m_frequencyChannels.end(), "Primary channel number not found");
519  return std::get<0>(*primaryChanIt);
520 }
521 
522 std::set<uint8_t>
523 WifiPhyOperatingChannel::GetAll20MHzChannelIndicesInPrimary(uint16_t width) const
524 {
525  if (width > GetWidth())
526  {
527  // a primary channel of the given width does not exist
528  return {};
529  }
530 
531  uint16_t currWidth = 20; // MHz
532  std::set<uint8_t> indices;
533  indices.insert(m_primary20Index);
534 
535  while (currWidth < width)
536  {
537  indices.merge(GetAll20MHzChannelIndicesInSecondary(indices));
538  currWidth <<= 1;
539  }
540 
541  return indices;
542 }
543 
544 std::set<uint8_t>
545 WifiPhyOperatingChannel::GetAll20MHzChannelIndicesInSecondary(uint16_t width) const
546 {
547  return GetAll20MHzChannelIndicesInSecondary(GetAll20MHzChannelIndicesInPrimary(width));
548 }
549 
550 std::set<uint8_t>
551 WifiPhyOperatingChannel::GetAll20MHzChannelIndicesInSecondary(
552  const std::set<uint8_t>& primaryIndices) const
553 {
554  if (primaryIndices.empty() || GetWidth() == 20)
555  {
556  return {};
557  }
558 
559  uint8_t size = 1;
560  uint16_t primaryWidth = 20; // MHz
561 
562  // find the width of the primary channel corresponding to the size of the given set
563  while (size != primaryIndices.size())
564  {
565  size <<= 1;
566  primaryWidth <<= 1;
567 
568  if (primaryWidth >= GetWidth())
569  {
570  // the width of the primary channel resulting from the given indices
571  // exceeds the width of the operating channel
572  return {};
573  }
574  }
575 
576  std::set<uint8_t> secondaryIndices;
577  for (const auto& index : primaryIndices)
578  {
579  secondaryIndices.insert(index ^ size);
580  }
581 
582  return secondaryIndices;
583 }
584 
585 std::set<uint8_t>
586 WifiPhyOperatingChannel::Get20MHzIndicesCoveringRu(HeRu::RuSpec ru, uint16_t width) const
587 {
588  auto ruType = ru.GetRuType();
589 
590  NS_ASSERT_MSG(HeRu::GetBandwidth(ruType) <= width,
591  "No RU of type " << ruType << " is contained in a " << width << " MHz channel");
592  NS_ASSERT_MSG(width <= GetWidth(),
593  "The given width (" << width << " MHz) exceeds the operational width ("
594  << GetWidth() << " MHz)");
595 
596  // trivial case: 2x996-tone RU
597  if (ruType == HeRu::RU_2x996_TONE)
598  {
599  return {0, 1, 2, 3, 4, 5, 6, 7};
600  }
601 
602  // handle first the special case of center 26-tone RUs
603  if (ruType == HeRu::RU_26_TONE && ru.GetIndex() == 19)
604  {
605  NS_ASSERT_MSG(width >= 80,
606  "26-tone RU with index 19 is only present in channels of at least 80 MHz");
607  // the center 26-tone RU in an 80 MHz channel is not fully covered by
608  // any 20 MHz channel, but by the two central 20 MHz channels in the 80 MHz channel
609  auto indices = ru.GetPrimary80MHz() ? GetAll20MHzChannelIndicesInPrimary(80)
610  : GetAll20MHzChannelIndicesInSecondary(80);
611  indices.erase(indices.begin());
612  indices.erase(std::prev(indices.end()));
613  return indices;
614  }
615 
616  auto ruIndex = ru.GetIndex();
617 
618  if (ruType == HeRu::RU_26_TONE && ruIndex > 19)
619  {
620  // "ignore" the center 26-tone RU in an 80 MHz channel
621  ruIndex--;
622  }
623 
624  // if the RU refers to a 160 MHz channel, we have to update the RU index (which
625  // refers to an 80 MHz channel) if the RU is not in the lower 80 MHz channel
626  if (width == 160)
627  {
628  bool primary80IsLower80 = (m_primary20Index < 4);
629  if (primary80IsLower80 != ru.GetPrimary80MHz())
630  {
631  auto nRusIn80MHz = HeRu::GetNRus(80, ruType);
632  // "ignore" the center 26-tone RU in an 80 MHz channel
633  if (ruType == HeRu::RU_26_TONE)
634  {
635  nRusIn80MHz--;
636  }
637  ruIndex += nRusIn80MHz;
638  }
639  }
640 
641  uint8_t n20MHzChannels; // number of 20 MHz channels in the channel covering the RU
642 
643  switch (ruType)
644  {
645  case HeRu::RU_26_TONE:
646  case HeRu::RU_52_TONE:
647  case HeRu::RU_106_TONE:
648  case HeRu::RU_242_TONE:
649  n20MHzChannels = 1;
650  break;
651  case HeRu::RU_484_TONE:
652  n20MHzChannels = 2;
653  break;
654  case HeRu::RU_996_TONE:
655  n20MHzChannels = 4;
656  break;
657  default:
658  NS_ABORT_MSG("Unhandled RU type: " << ruType);
659  }
660 
661  auto nRusInCoveringChannel = HeRu::GetNRus(n20MHzChannels * 20, ruType);
662  // compute the index (starting at 0) of the covering channel within the given width
663  std::size_t indexOfCoveringChannelInGivenWidth = (ruIndex - 1) / nRusInCoveringChannel;
664 
665  // expand the index of the covering channel in the indices of its constituent
666  // 20 MHz channels (within the given width)
667  NS_ASSERT(indexOfCoveringChannelInGivenWidth < 8); // max number of 20 MHz channels
668  std::set<uint8_t> indices({static_cast<uint8_t>(indexOfCoveringChannelInGivenWidth)});
669 
670  while (n20MHzChannels > 1)
671  {
672  std::set<uint8_t> updatedIndices;
673  for (const auto& idx : indices)
674  {
675  updatedIndices.insert(idx * 2);
676  updatedIndices.insert(idx * 2 + 1);
677  }
678  indices.swap(updatedIndices);
679  n20MHzChannels /= 2;
680  }
681 
682  // finally, add the appropriate offset if width is less than the operational channel width
683  auto offset = GetPrimaryChannelIndex(width) * width / 20;
684 
685  if (offset > 0)
686  {
687  std::set<uint8_t> updatedIndices;
688  for (const auto& idx : indices)
689  {
690  updatedIndices.insert(idx + offset);
691  }
692  indices.swap(updatedIndices);
693  }
694 
695  return indices;
696 }
697 
698 bool
699 WifiPhyOperatingChannel::operator==(const WifiPhyOperatingChannel& other) const
700 {
701  return m_channelIt == other.m_channelIt;
702 }
703 
704 bool
705 WifiPhyOperatingChannel::operator!=(const WifiPhyOperatingChannel& other) const
706 {
707  return !(*this == other);
708 }
709 
710 std::ostream&
711 operator<<(std::ostream& os, const WifiPhyOperatingChannel& channel)
712 {
713  if (channel.IsSet())
714  {
715  os << "channel " << +channel.GetNumber() << " in band " << channel.GetPhyBand()
716  << " frequency " << channel.GetFrequency() << " width " << channel.GetWidth();
717  }
718  else
719  {
720  os << "channel not set";
721  }
722  return os;
723 }
724 
725 } // namespace ns3
ns3::HeRu::RuSpec
RU Specification.
Definition: he-ru.h:66
ns3::HeRu::RuSpec::GetIndex
std::size_t GetIndex() const
Get the RU index.
Definition: he-ru.cc:461
ns3::HeRu::RuSpec::GetRuType
RuType GetRuType() const
Get the RU type.
Definition: he-ru.cc:454
ns3::HeRu::RuSpec::GetPrimary80MHz
bool GetPrimary80MHz() const
Get the primary 80 MHz flag.
Definition: he-ru.cc:468
ns3::HeRu::GetBandwidth
static uint16_t GetBandwidth(RuType ruType)
Get the approximate bandwidth occupied by a RU.
Definition: he-ru.cc:763
ns3::HeRu::GetNRus
static std::size_t GetNRus(uint16_t bw, RuType ruType)
Get the number of distinct RUs of the given type (number of tones) available in a HE PPDU of the give...
Definition: he-ru.cc:491
ns3::HeRu::RU_26_TONE
@ RU_26_TONE
Definition: he-ru.h:42
ns3::HeRu::RU_484_TONE
@ RU_484_TONE
Definition: he-ru.h:46
ns3::HeRu::RU_996_TONE
@ RU_996_TONE
Definition: he-ru.h:47
ns3::HeRu::RU_106_TONE
@ RU_106_TONE
Definition: he-ru.h:44
ns3::HeRu::RU_52_TONE
@ RU_52_TONE
Definition: he-ru.h:43
ns3::HeRu::RU_242_TONE
@ RU_242_TONE
Definition: he-ru.h:45
ns3::HeRu::RU_2x996_TONE
@ RU_2x996_TONE
Definition: he-ru.h:48
ns3::WifiPhyOperatingChannel
Class that keeps track of all information about the current PHY operating channel.
Definition: wifi-phy-operating-channel.h:47
ns3::WifiPhyOperatingChannel::IsSet
bool IsSet() const
Return true if a valid channel has been set, false otherwise.
Definition: wifi-phy-operating-channel.cc:289
ns3::WifiPhyOperatingChannel::operator==
bool operator==(const WifiPhyOperatingChannel &other) const
Check if the given WifiPhyOperatingChannel is equivalent.
Definition: wifi-phy-operating-channel.cc:699
ns3::WifiPhyOperatingChannel::WifiPhyOperatingChannel
WifiPhyOperatingChannel()
Create an uninitialized PHY operating channel.
Definition: wifi-phy-operating-channel.cc:271
ns3::WifiPhyOperatingChannel::m_frequencyChannels
static const std::set< FrequencyChannelInfo > m_frequencyChannels
Available frequency channels.
Definition: wifi-phy-operating-channel.h:89
ns3::WifiPhyOperatingChannel::GetSecondaryChannelCenterFrequency
uint16_t GetSecondaryChannelCenterFrequency(uint16_t secondaryChannelWidth) const
Get the center frequency of the secondary channel of the given width.
Definition: wifi-phy-operating-channel.cc:502
ns3::WifiPhyOperatingChannel::operator!=
bool operator!=(const WifiPhyOperatingChannel &other) const
Check if the given WifiPhyOperatingChannel is different.
Definition: wifi-phy-operating-channel.cc:705
ns3::WifiPhyOperatingChannel::IsDsss
bool IsDsss() const
Return whether the operating channel is a DSSS channel.
Definition: wifi-phy-operating-channel.cc:431
ns3::WifiPhyOperatingChannel::GetPrimaryChannelIndex
uint8_t GetPrimaryChannelIndex(uint16_t primaryChannelWidth) const
If the operating channel width is a multiple of 20 MHz, return the index of the primary channel of th...
Definition: wifi-phy-operating-channel.cc:445
ns3::WifiPhyOperatingChannel::SetPrimary20Index
void SetPrimary20Index(uint8_t index)
Set the index of the primary 20 MHz channel (0 indicates the 20 MHz subchannel with the lowest center...
Definition: wifi-phy-operating-channel.cc:483
ns3::WifiPhyOperatingChannel::m_channelIt
ConstIterator m_channelIt
const iterator pointing to the configured frequency channel
Definition: wifi-phy-operating-channel.h:300
ns3::WifiPhyOperatingChannel::FindFirst
static ConstIterator FindFirst(uint8_t number, uint16_t frequency, uint16_t width, WifiStandard standard, WifiPhyBand band, ConstIterator start=m_frequencyChannels.begin())
Find the first channel matching the specified parameters.
Definition: wifi-phy-operating-channel.cc:347
ns3::WifiPhyOperatingChannel::Set
void Set(uint8_t number, uint16_t frequency, uint16_t width, WifiStandard standard, WifiPhyBand band)
Set the channel according to the specified parameters if a unique frequency channel matches the speci...
Definition: wifi-phy-operating-channel.cc:295
ns3::WifiPhyOperatingChannel::Is80211p
bool Is80211p() const
Return whether the operating channel is an 802.11p channel.
Definition: wifi-phy-operating-channel.cc:438
ns3::WifiPhyOperatingChannel::GetPrimaryChannelNumber
uint8_t GetPrimaryChannelNumber(uint16_t primaryChannelWidth, WifiStandard standard) const
Get channel number of the primary channel.
Definition: wifi-phy-operating-channel.cc:511
ns3::WifiPhyOperatingChannel::SetDefault
void SetDefault(uint16_t width, WifiStandard standard, WifiPhyBand band)
Set the default channel of the given width and for the given standard and band.
Definition: wifi-phy-operating-channel.cc:321
ns3::WifiPhyOperatingChannel::IsOfdm
bool IsOfdm() const
Return whether the operating channel is an OFDM channel.
Definition: wifi-phy-operating-channel.cc:424
ns3::WifiPhyOperatingChannel::GetWidth
uint16_t GetWidth() const
Return the width of the whole operating channel (in MHz).
Definition: wifi-phy-operating-channel.cc:410
ns3::WifiPhyOperatingChannel::GetDefaultChannelNumber
static uint8_t GetDefaultChannelNumber(uint16_t width, WifiStandard standard, WifiPhyBand band)
Get the default channel number of the given width and for the given standard and band.
Definition: wifi-phy-operating-channel.cc:329
ns3::WifiPhyOperatingChannel::GetAll20MHzChannelIndicesInSecondary
std::set< uint8_t > GetAll20MHzChannelIndicesInSecondary(uint16_t width) const
Get the channel indices of all the 20 MHz channels included in the secondary channel of the given wid...
Definition: wifi-phy-operating-channel.cc:545
ns3::WifiPhyOperatingChannel::Get20MHzIndicesCoveringRu
std::set< uint8_t > Get20MHzIndicesCoveringRu(HeRu::RuSpec ru, uint16_t width) const
Get the channel indices of the minimum subset of 20 MHz channels containing the given RU.
Definition: wifi-phy-operating-channel.cc:586
ns3::WifiPhyOperatingChannel::GetSecondaryChannelIndex
uint8_t GetSecondaryChannelIndex(uint16_t secondaryChannelWidth) const
If the operating channel width is made of a multiple of 20 MHz, return the index of the secondary cha...
Definition: wifi-phy-operating-channel.cc:472
ns3::WifiPhyOperatingChannel::m_primary20Index
uint8_t m_primary20Index
index of the primary20 channel (0 indicates the 20 MHz subchannel with the lowest center frequency)
Definition: wifi-phy-operating-channel.h:301
ns3::WifiPhyOperatingChannel::GetAll20MHzChannelIndicesInPrimary
std::set< uint8_t > GetAll20MHzChannelIndicesInPrimary(uint16_t width) const
Get the channel indices of all the 20 MHz channels included in the primary channel of the given width...
Definition: wifi-phy-operating-channel.cc:523
ns3::WifiPhyOperatingChannel::GetPhyBand
WifiPhyBand GetPhyBand() const
Return the PHY band of the operating channel.
Definition: wifi-phy-operating-channel.cc:417
ns3::WifiPhyOperatingChannel::GetNumber
uint8_t GetNumber() const
Return the channel number identifying the whole operating channel.
Definition: wifi-phy-operating-channel.cc:396
ns3::WifiPhyOperatingChannel::GetPrimaryChannelCenterFrequency
uint16_t GetPrimaryChannelCenterFrequency(uint16_t primaryChannelWidth) const
Get the center frequency of the primary channel of the given width.
Definition: wifi-phy-operating-channel.cc:492
ns3::WifiPhyOperatingChannel::ConstIterator
std::set< FrequencyChannelInfo >::const_iterator ConstIterator
Typedef for a const iterator pointing to a channel in the set of available channels.
Definition: wifi-phy-operating-channel.h:50
ns3::WifiPhyOperatingChannel::GetFrequency
uint16_t GetFrequency() const
Return the center frequency of the operating channel (in MHz).
Definition: wifi-phy-operating-channel.cc:403
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:66
NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:86
NS_ABORT_MSG
#define NS_ABORT_MSG(msg)
Unconditional abnormal program termination with a message.
Definition: abort.h:49
NS_ABORT_MSG_IF
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268
NS_LOG_LOGIC
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:282
NS_LOG_FUNCTION_NOARGS
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
Definition: log-macros-enabled.h:206
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition: log-macros-enabled.h:240
ns3::WifiStandard
WifiStandard
Identifies the IEEE 802.11 specifications that a Wifi device can be configured to use.
Definition: wifi-standards.h:38
ns3::WifiPhyBand
WifiPhyBand
Identifies the PHY band.
Definition: wifi-phy-band.h:33
ns3::WIFI_STANDARD_UNSPECIFIED
@ WIFI_STANDARD_UNSPECIFIED
Definition: wifi-standards.h:39
ns3::WIFI_PHY_80211p_CHANNEL
@ WIFI_PHY_80211p_CHANNEL
Definition: wifi-standards.h:109
ns3::WIFI_PHY_OFDM_CHANNEL
@ WIFI_PHY_OFDM_CHANNEL
Definition: wifi-standards.h:108
ns3::WIFI_PHY_DSSS_CHANNEL
@ WIFI_PHY_DSSS_CHANNEL
Definition: wifi-standards.h:107
ns3::WIFI_PHY_BAND_6GHZ
@ WIFI_PHY_BAND_6GHZ
The 6 GHz band.
Definition: wifi-phy-band.h:39
ns3::WIFI_PHY_BAND_2_4GHZ
@ WIFI_PHY_BAND_2_4GHZ
The 2.4 GHz band.
Definition: wifi-phy-band.h:35
ns3::WIFI_PHY_BAND_5GHZ
@ WIFI_PHY_BAND_5GHZ
The 5 GHz band.
Definition: wifi-phy-band.h:37
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::FrequencyChannelInfo
std::tuple< uint8_t, uint16_t, uint16_t, FrequencyChannelType, WifiPhyBand > FrequencyChannelInfo
A tuple (number, frequency, width, type, band) identifying a frequency channel.
Definition: wifi-phy-operating-channel.h:39
ns3::wifiStandards
const std::map< WifiStandard, std::list< WifiPhyBand > > wifiStandards
map a given standard configured by the user to the allowed PHY bands
Definition: wifi-standards.h:89
ns3::GetMaximumChannelWidth
uint16_t GetMaximumChannelWidth(WifiModulationClass modulation)
Get the maximum channel width in MHz allowed for the given modulation class.
Definition: wifi-phy-common.cc:248
ns3::GetModulationClassForStandard
WifiModulationClass GetModulationClassForStandard(WifiStandard standard)
Return the modulation class corresponding to a given standard.
Definition: wifi-phy-common.cc:210
ns3::operator<<
std::ostream & operator<<(std::ostream &os, const Angles &a)
Definition: angles.cc:159
ns3::GetFrequencyChannelType
FrequencyChannelType GetFrequencyChannelType(WifiStandard standard)
Get the type of the frequency channel for the given standard.
Definition: wifi-standards.h:119
third.channel
channel
Definition: third.py:88
prev
uint32_t prev
Definition: tcp-bbr-example.cc:72
wifi-phy-common.h
Declaration of the following enums: