This file is indexed.

/usr/include/ns3.26/ns3/spectrum-interference.h is in libns3-dev 3.26+dfsg-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2009 CTTC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Nicola Baldo <nbaldo@cttc.es>
 */


#ifndef SPECTRUM_INTERFERENCE_H
#define SPECTRUM_INTERFERENCE_H

#include <ns3/object.h>
#include <ns3/packet.h>
#include <ns3/nstime.h>
#include <ns3/spectrum-value.h>

namespace ns3 {




class SpectrumErrorModel;



/**
 * \ingroup spectrum
 *
 * This class implements a gaussian interference model, i.e., all
 * incoming signals are added to the total interference.
 *
 */
class SpectrumInterference : public Object
{
public:
  SpectrumInterference ();
  virtual ~SpectrumInterference ();

  /**
   * Register this type.
   * \return The TypeId.
   */
  static TypeId GetTypeId (void);
  
  /**
   * Set the SpectrumErrorModel to be used.
   *
   * @param e the error model
   */
  void SetErrorModel (Ptr<SpectrumErrorModel> e);

  /**
   * Notify that the PHY is starting a RX attempt
   *
   * @param p the packet corresponding to the signal being RX
   * @param rxPsd the power spectral density of the signal being RX
   */
  void StartRx (Ptr<const Packet> p, Ptr<const SpectrumValue> rxPsd);

  /**
   * Notify that the PHY has aborted RX
   */
  void AbortRx ();

  /**
   * Notify that the RX attempt has ended. The receiving PHY must call
   * this method upon RX end in order to:
   * 1) know if RX was successful or not
   * 2) free up resources that might eventually be used for the
   * calculation of interference. Note that for this reason this
   * method must also be called when RX is aborted.
   *
   *
   * @return true if RX was successful, false otherwise
   */
  bool EndRx ();


  /**
   * Notify that a new signal is being perceived in the medium. This
   * method is to be called for all incoming signal, regardless of
   * whether they're useful signals or interferers.
   *
   * @param spd the power spectral density of the new signal
   * @param duration the duration of the new signal
   */
  void AddSignal (Ptr<const SpectrumValue> spd, const Time duration);

  /**
   * Set the Noise Power Spectral Density
   *
   * @param noisePsd the Noise Power Spectral Density in power units
   * (Watt, Pascal...) per Hz.
   */
  void SetNoisePowerSpectralDensity (Ptr<const SpectrumValue> noisePsd);


protected:
  void DoDispose ();

private:

  /**
   * Evaluate a Chunk, depending on the Rx status and the last update time
   */
  void ConditionallyEvaluateChunk ();
  /**
   * Adds a signal perceived in the medium.
   * @param spd the power spectral density of the new signal
   */
  void DoAddSignal  (Ptr<const SpectrumValue> spd);
  /**
    * Removes a signal perceived in the medium.
    * @param spd the power spectral density of the new signal
    */
  void DoSubtractSignal  (Ptr<const SpectrumValue> spd);

  bool m_receiving; //!< True if in Rx status

  /**
   * Stores the power spectral density of the signal whose RX is being attempted
   */
  Ptr<const SpectrumValue> m_rxSignal;

  /**
   * Stores the spectral power density of the sum of incoming signals;
   * does not include noise, includes the SPD of the signal being RX
   */
  Ptr<SpectrumValue> m_allSignals;

  Ptr<const SpectrumValue> m_noise; //!< Noise spectral power density

  Time m_lastChangeTime;     //!< the time of the last change in m_TotalPower

  Ptr<SpectrumErrorModel> m_errorModel; //!< Error model



};



} // namespace ns3





#endif /* SPECTRUM_INTERFERENCE_H */