This file is indexed.

/usr/include/CLHEP/Vector/ZMxpv.h is in libclhep-dev 2.1.2.3-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
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
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
#ifndef HEP_ZMXPV_H
#define HEP_ZMXPV_H

// ----------------------------------------------------------------------
//
//  ZMxpv.h    	ZMexception's ZMthrown by classes in the PhysicsVectors
//		package.  To avoid name clashes, these start with ZMxpv.
//
//  THIS FILE CONTAINS TWO VERSIONS OF THE NECESSARY CODE:
//
//  With no special defines, this file will produce code for pure CLHEP 
//  building -- no ZOOM Exceptions are involved.
//
//  To force a build using ZOOM Exceptions where the ZMthrow macros appear,
//  compile with ENABLE_ZOOM_EXCEPTIONS defined.
//
// ----------------------------------------------------------------------

//#undef  ENABLE_ZOOM_EXCEPTIONS 	// For CLHEP builds 
//#define ENABLE_ZOOM_EXCEPTIONS    	// For ZOOM  builds

// There should be some external way to control this.  We haven't found it yet.
// Right now, this must be changed by hand when going between CLHEP and ZOOM.
#undef  ENABLE_ZOOM_EXCEPTIONS 	

  // Member functions of the Vector classes are capable of ZMthrow-ing the
  // following ZMexception's:
  //
  //	ZMxPhysicsVectors	Severe	Parent exception of all ZMexceptions
  //					particular to classes in the package.
  //
  //    ZMxpvInfiniteVector     Error
  //                                    Mathematical operation will lead
  //                                    to infinity or NAN in a component
  //                                    of a result vector.
  //    ZMxpvZeroVector         Error
  //                                    A zero vector was used to specify
  //                                    a direction based on vector.unit().
  //    ZMxpvTachyonic          Error
  //                                    A relativistic kinematic function was
  //                                    taken, involving a vector representing
  //                                    a speed at or beyond that of light (=1).
  //	ZMxpvSpacelike		Error
  //					A spacelike 4-vector was used in a
  //					context where its restMass or gamma
  //					needs to be computed:  The result is
  //					formally imaginary (a zero result is
  //					supplied).
  //    ZMxpvInfinity 		Error
  //                                    Mathematical operation will lead
  //                                    to infinity as a Scalar result.
  //    ZMxpvNegativeMass	Error
  //                                    Kinematic operation, e.g. invariant
  //					mass, rendered meaningless by an input
  //					with negative time component.
  //	ZMxpvVectorInputFails	Error
  //					Input to a SpaceVector or Lorentz
  //					Vector failed due to bad format or EOF.
  //	ZMxpvParallelCols	Error
  //					Purportedly orthogonal col's supplied
  //					to form a Rotation are exactly
  //					parallel instead.
  //	ZMxpvImproperRotation	Error
  //					Orthogonal col's supplied form a
  //					refection (determinant -1) more
  //					nearly than rather than a rotation.
  //	ZMxpvImproperTransformation Error
  //                                    Orthogonalized rows supplied form a
  //                                    tachyonic boost, a reflection, or
  //                                    a combination of those flaws,
  //                                    more nearly than a proper Lorentz
  //                                    transformation.
  //	ZMxpvFixedAxis		Error
  //					Attempt to change a RotationX,
  //					RotationY, or RotationZ in such a way
  //					that the axis might no longer be X,
  //					Y, or Z respectively.
  //	ZMxpvIndexRange		Error
  //					When using the syntax of v(i) to get
  //					a vector component, i is out of range.
  //	ZMxpvNotOrthogonal	Warning
  //					Purportedly orthogonal col's supplied
  //					to form a Rotation or LT are not
  //					orthogonal within the tolerance.
  //	ZMxpvNotSymplectic	Warning
  //					A row supplied to form a Lorentz
  //					transformation has a value of restmass
  //					incorrect by more than the tolerance:
  //					It should be -1 for rows 1-3,
  //					+1 for row 4.
  //    ZMxpvAmbiguousAngle     Warning
  //                                    Method involves taking an angle against
  //                                    a reference vector of zero length, or
  //                                    phi in polar coordinates of a vector
  //                                    along the Z axis.
  //    ZMxpvNegativeR          Warning
  //                                    R of a supplied vector is negative.
  //                                    The mathematical operation done is
  //                                    still formally valid.
  //    ZMxpvUnusualTheta       Warning
  //                                    Theta supplied to construct or set
  //                                    a vector is outside the range [0,PI].
  //                                    The mathematical operation done is
  //                                    still formally valid.  But note that
  //                                    when sin(theta) < 0, phi becomes an
  //                                    angle against the -X axis.
  //______________________________________________________________________

#ifndef ENABLE_ZOOM_EXCEPTIONS 

//  This is the CLHEP version.  When compiled for CLHEP, the basic CLHEP 
//  Vector classes will not (at least for now) depend on ZOOM Exceptions.  
//  Though this header lists the various sorts of Exceptions that could be 
//  thrown, ZMthrow.h in the pure CLHEP context will make ZMthrowC  
//  do what CLHEP has always done:  whine to cerr about the problem 
//  and continue.
//  ZMthrowA will whine to cerr and throw an exception; by catching the
//  exception as a std::exception, the outside code can call e.what() to 
//  find the message string.
//
//	If CLHEP ever embraces the ZOOM Exceptions mechanism, we will simply
//	modify this file.

#include <string>
#include <exception>

#define ZMthrowA(A) do { std::cerr << A.name() << " thrown:\n" 	   \
             <<   A.what() << "\n" 					   \
	     << "at line " << __LINE__ << " in file " << __FILE__ << "\n"; \
  throw A;} while (0)

#define ZMthrowC(A) do { std::cerr << A.name() << ":\n" 		   \
             <<   A.what() << "\n" 					   \
	     << "at line " << __LINE__ << " in file " << __FILE__ << "\n"; \
  } while (0)

class CLHEP_vector_exception : public std::exception {
public:
    CLHEP_vector_exception ( const std::string & s1 ) throw();
    virtual const char* what() const throw();
    virtual const char* name() const throw() = 0; 
    virtual ~CLHEP_vector_exception() throw() {} 
  private:								
    std::string message;  
};

#define CLHEP_vector_exception_header(NAME) 				\
  class NAME : public CLHEP_vector_exception {				\
  public:								\
    NAME ( const std::string & s ) throw();				\
    virtual const char* name() const throw();  				\
    virtual ~NAME() throw() {}						\
  };


// The following exceptions might be encountered via ZMtrhowA

CLHEP_vector_exception_header( ZMxPhysicsVectors )
CLHEP_vector_exception_header( ZMxpvSpacelike )
CLHEP_vector_exception_header( ZMxpvNegativeMass )
CLHEP_vector_exception_header( ZMxpvVectorInputFails )
CLHEP_vector_exception_header( ZMxpvIndexRange )
CLHEP_vector_exception_header( ZMxpvFixedAxis )

// The following are sometimes ZMthrowA and sometimes ZMthrowC

CLHEP_vector_exception_header( ZMxpvTachyonic )
CLHEP_vector_exception_header( ZMxpvZeroVector )
CLHEP_vector_exception_header( ZMxpvImproperTransformation )
CLHEP_vector_exception_header( ZMxpvInfiniteVector )
CLHEP_vector_exception_header( ZMxpvInfinity )
CLHEP_vector_exception_header( ZMxpvImproperRotation )
CLHEP_vector_exception_header( ZMxpvAmbiguousAngle )

// THe following won't throw; they are encountered via ZMthrowC

CLHEP_vector_exception_header( ZMxpvNegativeR )
CLHEP_vector_exception_header( ZMxpvUnusualTheta )
CLHEP_vector_exception_header( ZMxpvParallelCols )
CLHEP_vector_exception_header( ZMxpvNotOrthogonal )
CLHEP_vector_exception_header( ZMxpvNotSymplectic )

#endif // endif for ifndef ENABLE_ZOOM_EXCEPTIONS 

// =============================================================
// =============================================================
// =============================================================

#ifdef ENABLE_ZOOM_EXCEPTIONS 

//  This is the ZOOM version.  When compiled for ZOOM, even the basic CLHEP 
//  Vector classes will depend on ZOOM Exceptions.  
//  Though in the CLHEP context methods use ZMthrowA and ZMthrowC, these
//  in the ZOOM context become ZMthrow.
//
//  Either this file or ZMxpvCLHEP.h is copied to become ZMxpv.h, depending 
//  on whether this is a ZOOM or a CLHEP build.  
//

#ifndef ZMEXCEPTIONS_H
  #include "Exceptions/ZMexception.h"
  #include "Exceptions/ZMthrow.h"
#endif
using namespace zmex;

namespace zmpv  {

ZMexStandardDefinition (ZMexception, ZMxPhysicsVectors);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvInfiniteVector);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvZeroVector);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvTachyonic);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvSpacelike);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvInfinity);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvNegativeMass);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvAmbiguousAngle);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvNegativeR);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvUnusualTheta);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvVectorInputFails);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvParallelCols);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvImproperRotation);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvImproperTransformation);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvIndexRange);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvNotOrthogonal);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvNotSymplectic);
ZMexStandardDefinition (ZMxPhysicsVectors, ZMxpvFixedAxis);

#define ZMthrowA(A) ZMthrow(A)
#define ZMthrowC(A) ZMthrow(A)

}  // namespace zmpv

#endif // ENABLE_ZOOM_EXCEPTIONS

#endif // HEP_ZMXPV_H