This file is indexed.

/usr/include/ThePEG/Cuts/OneCutBase.h is in libthepeg-dev 1.8.0-3build1.

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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
// -*- C++ -*-
//
// OneCutBase.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2011 Leif Lonnblad
//
// ThePEG is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef THEPEG_OneCutBase_H
#define THEPEG_OneCutBase_H
//
// This is the declaration of the OneCutBase class.
//

#include "ThePEG/Interface/Interfaced.h"
#include "OneCutBase.fh"
#include "Cuts.fh"

namespace ThePEG {

/**
 * This class corresponds to a kinematical cut to be made on a single
 * outgoing parton from a hard sub-process.
 *
 * There are four main virtual functions which must be overridden by
 * concrete sub-classes. minKT() should return the minimum allowed
 * transverse momentum of a given type, while minEta() and maxEta()
 * should return the minimum and maximum allowed pseudo-rapidity for a
 * particle of a given type as measured in the lab-system. Note that
 * when applied in the rest frame of a hard sub-process, the
 * transformation from the lab frame is assumed to be a simple boost
 * along the z-axis. In addition the passCut() function should return
 * true if a particle with a given type and given momentum will pass
 * the cuts.
 *
 * @see \ref OneCutBaseInterfaces "The interfaces"
 * defined for OneCutBase.
 */
class OneCutBase: public Interfaced {

public:

  /** @name Standard constructors and destructors. */
  //@{
  /**
   * The default constructor.
   */
  OneCutBase() {}

  /**
   * The destructor.
   */
  virtual ~OneCutBase();
  //@}

public:

  /** @name Virtual functions to be overridden by sub-classes. */
  //@{
  /**
   * Return the minimum allowed value of the transverse momentum of an
   * outgoing parton.
   */
  virtual Energy minKT(tcPDPtr p) const = 0;

  /**
   * Return the minimum allowed pseudo-rapidity of an outgoing parton
   * of the given type. The pseudo-rapidity is measured in the lab
   * system.
   */
  virtual double minEta(tcPDPtr p) const = 0;

  /**
   * Return the maximum allowed pseudo-rapidity of an outgoing parton
   * of the given type. The pseudo-rapidity is measured in the lab
   * system.
   */
  virtual double maxEta(tcPDPtr p) const = 0;

  /**
   * Return the minimum allowed rapidity of an outgoing parton
   * of the given type. The rapidity is measured in the lab
   * system.
   */
  virtual double minRapidityMax(tcPDPtr p) const;

  /**
   * Return the maximum allowed rapidity of an outgoing parton
   * of the given type. The rapidity is measured in the lab
   * system.
   */
  virtual double maxRapidityMin(tcPDPtr p) const;

  /**
   * Return the minimum allowed value of the transverse momentum of
   * the outgoing parton with the lagrest transverse momentum. This
   * version simply returns minKt().
   */
  virtual Energy minMaxKT(tcPDPtr p) const;

  /**
   * Return the minimum allowed pseudo-rapidity of the outgoing parton
   * of the given type with the maximum pseudo-rapidity. The
   * pseudo-rapidity is measured in the lab system. This version
   * simply returns minEta().
   */
  virtual double minMaxEta(tcPDPtr p) const;

  /**
   * Return the maximum allowed pseudo-rapidity of the outgoing parton
   * of the given type with the minimum pseudo-rapidity.. The
   * pseudo-rapidity is measured in the lab system. This version
   * simply returns maxEta().
   */
  virtual double maxMinEta(tcPDPtr p) const;

  /**
   * Return true if a particle with type \a ptype and momentum \a p
   * passes the cuts. The \a parent contains information about the
   * kinematics of the hard sub-process.
   */
  virtual bool passCuts(tcCutsPtr parent,
			tcPDPtr ptype, LorentzMomentum p) const;

  /**
   * Return true if the given particle passes the cuts. The \a parent
   * contains information about the kinematics of the hard
   * sub-process.
   */
  bool passCuts(tcCutsPtr parent, tcPPtr p) const;
  //@}

  /**
   * Describe the currently active cuts in the log file.
   */
  virtual void describe() const;

public:

  /**
   * The standard Init function used to initialize the interfaces.
   * Called exactly once for each class by the class description system
   * before the main function starts or
   * when this class is dynamically loaded.
   */
  static void Init();

private:

  /**
   * The static object used to initialize the description of this class.
   * Indicates that this is a concrete class with persistent data.
   */
  static AbstractNoPIOClassDescription<OneCutBase> initOneCutBase;

  /**
   * The assignment operator is private and must never be called.
   * In fact, it should not even be implemented.
   */
  OneCutBase & operator=(const OneCutBase &);

};

}

#include "ThePEG/Utilities/ClassTraits.h"

namespace ThePEG {

/** @cond TRAITSPECIALIZATIONS */

/** This template specialization informs ThePEG about the
 *  base classes of OneCutBase. */
template <>
struct BaseClassTrait<OneCutBase,1> {
  /** Typedef of the first base class of OneCutBase. */
  typedef Interfaced NthBase;
};

/** This template specialization informs ThePEG about the name of
 *  the OneCutBase class and the shared object where it is defined. */
template <>
struct ClassTraits<OneCutBase>
  : public ClassTraitsBase<OneCutBase> {
  /** Return a platform-independent class name */
  static string className() { return "ThePEG::OneCutBase"; }
};

/** @endcond */

}

#endif /* THEPEG_OneCutBase_H */