This file is indexed.

/usr/include/HepMC/GenCrossSection.h is in libhepmc-dev 2.06.09-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
#ifndef HEPMC_GEN_CROSS_SECTION_H
#define HEPMC_GEN_CROSS_SECTION_H

//--------------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////
// garren@fnal.gov, May 2009
// 
//////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------------

#include <iostream>

namespace HepMC {

//! The GenCrossSection class stores the generated cross section

///
/// \class  GenCrossSection
/// HepMC::GenCrossSection is used to store the generated cross section.
/// This class is meant to be used to pass, on an event by event basis,
/// the current best guess of the total cross section. 
/// It is expected that the final cross section will be stored elsewhere.
///
///   - double cross_section;  		// cross section in pb
///   - double cross_section_error;  	// error associated with this cross section   
/// 
/// The units of cross_section and cross_section_error are expected to be pb.
/// 
/// GenCrossSection information will be written if GenEvent contains a pointer 
/// to a valid GenCrossSection object.
///
class GenCrossSection {

public:
  GenCrossSection()
    : m_cross_section(0),
      m_cross_section_error(0),
      m_is_set(false)
    {}
  ~GenCrossSection() {}

  GenCrossSection( GenCrossSection const & orig ); //!< copy

  void swap( GenCrossSection & other); //!< swap
  GenCrossSection &  operator = ( GenCrossSection const & rhs ); //!< shallow
  /// check for equality
  bool         operator==( const GenCrossSection& ) const;
  /// check for inequality
  bool         operator!=( const GenCrossSection& ) const;


  // ---  accessors:

  /// cross section in pb
  double cross_section()          const { return m_cross_section; }
  /// error associated with this cross section in pb
  double cross_section_error()    const { return m_cross_section_error; }

  /// True if the cross section has been set.  False by default.
  bool   is_set()                 const { return m_is_set; }

  // ---  mutators:
  /// Set cross section and error in pb
  void   set_cross_section( double xs, double xs_err );
  /// set cross section in pb
  void   set_cross_section( double );
  /// set error associated with this cross section in pb
  void   set_cross_section_error( double );
  /// Clear all GenCrossSection info 
  /// (disables output of GenCrossSection until the cross section is set again)
  void   clear();
 
  // ---  I/O:
  /// write to an output stream
  std::ostream &  write( std::ostream & ) const;
  /// read from an input stream
  std::istream &  read( std::istream & );

private: // data members
    double m_cross_section;
    double m_cross_section_error;
    bool   m_is_set;

};

//
// streaming I/O

inline std::ostream & operator << ( std::ostream & os, GenCrossSection & xs )
{ return xs.write(os); }

inline std::istream & operator >> ( std::istream & is, GenCrossSection & xs )
{ return xs.read(is); }

//
// inline methods

inline void GenCrossSection::set_cross_section( double xs, double xserr ) { 
  set_cross_section(xs);
  set_cross_section_error(xserr); 
}

inline void GenCrossSection::set_cross_section( double xs )        
{
  m_cross_section = xs;
  m_is_set = true;
}

inline void GenCrossSection::set_cross_section_error( double xserr )  
{
  m_cross_section_error = xserr;
}

} // HepMC

#endif  // HEPMC_GEN_CROSS_SECTION_H