CLHEP VERSION Reference Documentation
   
CLHEP Home Page     CLHEP Documentation     CLHEP Bug Reports

CLHEP/GenericFunctions/Bessel.hh
Go to the documentation of this file.
1 // -*- C++ -*-
2 // $Id: Bessel.hh,v 1.2 2003/09/06 14:04:13 boudreau Exp $
3 //---------------------Bessel-------------------------------------------------//
4 // //
5 // Class Bessel, providing Bessel Functions The Namespace "FractionalORder" //
6 // and "Integral order" are nested here, so that you fully specify the class //
7 // like this: //
8 // //
9 // Genfun::FractionalOrder::Bessel //
10 // //
11 // or //
12 // //
13 // Genfun::IntegralOrder::Bessel //
14 // //
15 // //
16 // Joe Boudreau, April 2001 //
17 // //
18 //-------------------------------------------------------------------------- //
19 #ifndef Bessel_h
20 #define Bessel_h 1
23 namespace Genfun {
24 
25 namespace FractionalOrder {
30  class Bessel : public AbsFunction {
31 
33 
34  public:
35 
36  // Enumerated type:
37  enum Type {J, Y};
38 
39  // Constructor: Use this one and you will get a Bessel function of
40  // integer order
41  Bessel (Type type);
42 
43  // Copy constructor
44  Bessel(const Bessel &right);
45 
46  // Destructor
47  virtual ~Bessel();
48 
49  // Retreive function value
50  virtual double operator ()(double argument) const;
51  virtual double operator ()(const Argument & a) const {return operator() (a[0]);}
52 
53  // Get the order of the Bessel Function. Default value, 0.0. If modified the
54  // Bessel function
55  Parameter & order();
56  const Parameter & order() const;
57 
58  private:
59 
60  // It is illegal to assign an adjustable constant
61  const Bessel & operator=(const Bessel &right);
62 
63  // The type and order of the Bessel function
64  Type _type;
65  Parameter _order; // the fractional order:
66 
67  };
68 } // namespace FractionalOrder
69 
70 namespace IntegralOrder {
75  class Bessel : public AbsFunction {
76 
78 
79  public:
80 
81  // Enumerated type:
82  enum Type {J, Y};
83 
84  // Constructor: Use this one and you will get a Bessel function of
85  // integer order
86  Bessel (Type type, unsigned int order);
87 
88  // Copy constructor
89  Bessel(const Bessel &right);
90 
91  // Destructor
92  virtual ~Bessel();
93 
94  // Retreive function value
95  virtual double operator ()(double argument) const;
96  virtual double operator ()(const Argument & a) const {return operator() (a[0]);}
97 
98  private:
99 
100  // It is illegal to assign an adjustable constant
101  const Bessel & operator=(const Bessel &right);
102 
103  // The type and order of the Bessel function
104  Type _type;
105  unsigned int _order;
106 
107  double _bessel_IJ_taylor(double nu,
108  double x,
109  int sign,
110  int kmax,
111  double threshhold) const;
112 
113  };
114 } // namespace IntegralOrder
115 
116 } // namespace Genfun
117 
118 
119 #include "CLHEP/GenericFunctions/Bessel.icc"
120 #endif
Genfun::FractionalOrder::Bessel::Bessel
Bessel(Type type)
a
@ a
Definition: testCategories.cc:125
Parameter.hh
Genfun::AbsFunction
Definition: CLHEP/GenericFunctions/AbsFunction.hh:48
Genfun::IntegralOrder::Bessel::operator()
virtual double operator()(double argument) const
Genfun::IntegralOrder::Bessel::J
@ J
Definition: CLHEP/GenericFunctions/Bessel.hh:82
AbsFunction.hh
Genfun::IntegralOrder::Bessel
Definition: CLHEP/GenericFunctions/Bessel.hh:75
Genfun::IntegralOrder::Bessel::~Bessel
virtual ~Bessel()
type
Signatures of Hep3Vector::rotate For equivalent ZOOM axis There is no harm in leaving this axis CLHEP has implemented a first forming an identity then rotating that by axis and I leave the CLHEP code alone people are of course free to use the ZOOM originated method with signature which I believe will be faster Return types for rotateZ CLHEP and PhysicsVectors each have these three and they are identical except that the ZOOM version returns a reference to while in CLHEP they return void Having methods that alter an object return a reference to that object is convenient for certain chained and costs nothing I don t wish to potentially break ZOOM user code for no good so I have made these CLHEP method conform to this convention There are a couple of other CLHEP rotate and which use the void return type
Definition: minorMergeIssues.doc:113
Genfun::FractionalOrder::Bessel::J
@ J
Definition: CLHEP/GenericFunctions/Bessel.hh:37
Genfun::Argument
Definition: CLHEP/GenericFunctions/Argument.hh:17
Y
Definition: testSharedPtrBasic.cc:34
Genfun::FractionalOrder::Bessel::Type
Type
Definition: CLHEP/GenericFunctions/Bessel.hh:37
Genfun::IntegralOrder::Bessel::Type
Type
Definition: CLHEP/GenericFunctions/Bessel.hh:82
Genfun::FractionalOrder::Bessel::operator()
virtual double operator()(double argument) const
Genfun::Parameter
Definition: CLHEP/GenericFunctions/Parameter.hh:35
Genfun::FractionalOrder::Bessel::order
Parameter & order()
x
any side effects of that construction would occur twice The semantics of throw x
Definition: whyZMthrowRethrows.txt:37
Genfun::IntegralOrder::Bessel::Bessel
Bessel(Type type, unsigned int order)
Genfun::FractionalOrder::Bessel
Definition: CLHEP/GenericFunctions/Bessel.hh:30
FUNCTION_OBJECT_DEF
#define FUNCTION_OBJECT_DEF(classname)
Definition: CLHEP/GenericFunctions/AbsFunction.hh:144
Genfun::FractionalOrder::Bessel::~Bessel
virtual ~Bessel()
Genfun
Definition: CLHEP/GenericFunctions/Abs.hh:14