Removing some meaningeless const (coverity)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 13 Dec 2012 05:47:41 +0000 (05:47 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 13 Dec 2012 05:47:41 +0000 (05:47 +0000)
TEvtGen/EvtGenBase/EvtGammaMatrix.hh
TEvtGen/EvtGenBase/EvtTensor3C.cxx
TEvtGen/EvtGenBase/EvtTensor3C.hh
TEvtGen/EvtGenBase/EvtVector3C.hh
TEvtGen/EvtGenModels/EvtBBScalar.cxx
TEvtGen/EvtGenModels/EvtBBScalar.hh
TEvtGen/EvtGenModels/EvtLambdaP_BarGamma.cxx
TEvtGen/EvtGenModels/EvtLambdaP_BarGamma.hh

index 049f1bf..9a21e45 100644 (file)
@@ -96,7 +96,7 @@ inline EvtGammaMatrix operator*(const EvtGammaMatrix& g1,const EvtGammaMatrix& g
   return EvtGammaMatrix(g1)*=g2;
 }
 
-inline EvtGammaMatrix operator/(const EvtGammaMatrix& g, const double d)
+inline EvtGammaMatrix operator/(const EvtGammaMatrix& g, double d)
 {
     return g * EvtComplex(1/d,0);
 }
index 19c41f6..78aed44 100644 (file)
@@ -147,7 +147,7 @@ EvtTensor3C EvtTensor3C::operator*=(const EvtComplex& c) {
 }
 
 
-EvtTensor3C EvtTensor3C::operator*=(const double c){
+EvtTensor3C EvtTensor3C::operator*=(double c){
 
   int i,j;
   
index d4d8e05..51db494 100644 (file)
@@ -41,10 +41,10 @@ class EvtTensor3C {
                                 double phi,double theta,double ksi);
   friend EvtTensor3C operator*(
                  const EvtComplex& c,const EvtTensor3C& t2);
-  friend EvtTensor3C operator*(const double d,const EvtTensor3C& t2);
+  friend EvtTensor3C operator*(double d,const EvtTensor3C& t2);
   friend EvtTensor3C operator*(
                   const EvtTensor3C& t2,const EvtComplex& c);
-  friend EvtTensor3C operator*(const EvtTensor3C& t2,const double d);
+  friend EvtTensor3C operator*(const EvtTensor3C& t2,double d);
   friend EvtTensor3C operator+(
                   const EvtTensor3C& t1,const EvtTensor3C& t2);
   friend EvtTensor3C operator-(
@@ -76,7 +76,7 @@ public:
 
   EvtTensor3C operator+=(const EvtTensor3C& t2);
   EvtTensor3C operator-=(const EvtTensor3C& t2);
-  EvtTensor3C operator*=(const double d);
+  EvtTensor3C operator*=(double d);
   EvtTensor3C operator*=(const EvtComplex& c);
   EvtTensor3C conj() const;
   EvtVector3C cont1(const EvtVector3C& v) const; 
@@ -102,7 +102,7 @@ inline EvtTensor3C operator*(const EvtTensor3C& t2,const EvtComplex& c){
   return EvtTensor3C(t2)*=c;
 }
 
-inline EvtTensor3C operator*(const EvtTensor3C& t2,const double d){
+inline EvtTensor3C operator*(const EvtTensor3C& t2,double d){
   return EvtTensor3C(t2)*=d;
 }
 
index 9e873fe..28eea86 100644 (file)
@@ -45,7 +45,7 @@ public:
   EvtVector3C();
   EvtVector3C(const EvtComplex&,const EvtComplex&,const EvtComplex&);
   virtual ~EvtVector3C();
-  inline void set(const int,const EvtComplex&);
+  inline void set(int,const EvtComplex&);
   inline void set(const EvtComplex&,const EvtComplex&,const EvtComplex&);
   inline void set(double,double,double);
   inline EvtVector3C& operator*=(const EvtComplex& c);
@@ -72,7 +72,7 @@ inline EvtVector3C::EvtVector3C(const EvtVector3R& v1){
 
 } 
 
-inline void EvtVector3C::set(const int i,const EvtComplex& c){
+inline void EvtVector3C::set(int i,const EvtComplex& c){
 
   v[i]=c;
   
index b2b5d02..a89117b 100644 (file)
@@ -110,7 +110,7 @@ void EvtBBScalar::setKnownBaryonTypes(const EvtId& baryon) {
     }
 }
 
-const double EvtBBScalar::baryonF1F2(double t) {
+double EvtBBScalar::baryonF1F2(double t) {
     // check for known form factors for combination of baryons
     if (_baryonCombination.test(Lambda) and _baryonCombination.test(Proton)) {
         return -sqrt(1.5) * G_p(t);
@@ -131,7 +131,7 @@ const double EvtBBScalar::baryonF1F2(double t) {
     }
 }
 
-const double EvtBBScalar::formFactorFit(double t, const vector<double>& params) {
+double EvtBBScalar::formFactorFit(double t, const vector<double>& params) {
     static const double gamma = 2.148;
     static const double Lambda_0 = 0.3;
     double result = 0;
@@ -142,20 +142,20 @@ const double EvtBBScalar::formFactorFit(double t, const vector<double>& params)
 }
 
 
-const double EvtBBScalar::G_p(double t) {
+double EvtBBScalar::G_p(double t) {
     const vector<double> v_x(x, x+5);
     return formFactorFit(t, v_x);
 }
 
 
-const double EvtBBScalar::G_n(double t) {
+double EvtBBScalar::G_n(double t) {
     const vector<double> v_y(y, y+2);
     return -formFactorFit(t, v_y);
 }
 
 
 
-const double EvtBBScalar::baryon_gA(double t) {
+double EvtBBScalar::baryon_gA(double t) {
     // check for known form factors for combination of baryons
     if (_baryonCombination.test(Lambda) and _baryonCombination.test(Proton)) {
         return -1/sqrt(6.) * (D_A(t) + 3*F_A(t));
@@ -177,7 +177,7 @@ const double EvtBBScalar::baryon_gA(double t) {
 }
 
 
-const double EvtBBScalar::baryon_gP(double t) {
+double EvtBBScalar::baryon_gP(double t) {
     // check for known form factors for combination of baryons
     if (_baryonCombination.test(Lambda) and _baryonCombination.test(Proton)) {
         return -1/sqrt(6.) * (D_P(t) + 3*F_P(t));
@@ -198,7 +198,7 @@ const double EvtBBScalar::baryon_gP(double t) {
     }
 }
 
-const double EvtBBScalar::baryon_fS(double t) {
+double EvtBBScalar::baryon_fS(double t) {
     // check for known form factors for combination of baryons
     if (_baryonCombination.test(Lambda) and _baryonCombination.test(Proton)) {
         return -1/sqrt(6.) * (D_S(t) + 3*F_S(t));
@@ -220,45 +220,45 @@ const double EvtBBScalar::baryon_fS(double t) {
 }
 
         
-const double EvtBBScalar::D_A(double t) {
+double EvtBBScalar::D_A(double t) {
     const double d_tilde[] = {x[0]-1.5*y[0], -478};
     const vector<double> v_d_tilde(d_tilde, d_tilde+2);
     return formFactorFit(t, v_d_tilde);
 }
 
 
-const double EvtBBScalar::F_A(double t) {
+double EvtBBScalar::F_A(double t) {
     const double f_tilde[] = {2./3*x[0]+0.5*y[0], -478};
     const vector<double> v_f_tilde(f_tilde, f_tilde+2);
     return formFactorFit(t, v_f_tilde);
 }
 
 
-const double EvtBBScalar::D_P(double t) {
+double EvtBBScalar::D_P(double t) {
     const double d_bar[] = {1.5*y[0]* _massRatio, /*-952*/0};
     const vector<double> v_d_bar(d_bar, d_bar+2);
     return formFactorFit(t, v_d_bar);
 }
 
 
-const double EvtBBScalar::F_P(double t) {
+double EvtBBScalar::F_P(double t) {
     const double f_bar[] = {(x[0]-0.5*y[0]) * _massRatio, /*-952*/0};
     const vector<double> v_f_bar(f_bar, f_bar+2);
     return formFactorFit(t, v_f_bar);
 }
 
 
-const double EvtBBScalar::D_S(double t) {
+double EvtBBScalar::D_S(double t) {
     return -1.5 * _massRatio * G_n(t);
 }
 
 
-const double EvtBBScalar::F_S(double t) {
+double EvtBBScalar::F_S(double t) {
     return (G_p(t) + 0.5*G_n(t)) * _massRatio;
 }
 
 
-const double EvtBBScalar::baryon_hA(double t) {
+double EvtBBScalar::baryon_hA(double t) {
     return (1/_massRatio*baryon_gP(t)-baryon_gA(t))*pow(_baryonMassSum, 2)/t;
 }
 
@@ -342,7 +342,7 @@ void EvtBBScalar::initProbMax()
 }
 
 // Form factor f1 for B-pi transition
-const double EvtBBScalar::B_pi_f1(double t)
+double EvtBBScalar::B_pi_f1(double t)
 {
     FormFactor f = _f1Map[_scalarType];
     double mv2 = f.mV*f.mV;
@@ -350,7 +350,7 @@ const double EvtBBScalar::B_pi_f1(double t)
 }
 
 // Form factor f0 for B-pi transition
-const double EvtBBScalar::B_pi_f0(double t)
+double EvtBBScalar::B_pi_f0(double t)
 {
     FormFactor f = _f0Map[_scalarType];
     double mv2 = f.mV*f.mV;
index 98fff12..49d7803 100644 (file)
@@ -88,28 +88,28 @@ private:
     std::bitset<nBaryons> _baryonCombination;
     void setKnownBaryonTypes(const EvtId& baryon);
     
-    const double B_pi_f1(double t);
-    const double B_pi_f0(double t);
-    const double baryonF1F2(double t);
-    const double G_p(double t);
-    const double G_n(double t);
+    double B_pi_f1(double t);
+    double B_pi_f0(double t);
+    double baryonF1F2(double t);
+    double G_p(double t);
+    double G_n(double t);
     
-    const double baryon_gA(double t);
-    const double baryon_hA(double t);
-    const double baryon_gP(double t);
-    const double baryon_fS(double t);
-
-    const double D_A(double t);
-    const double F_A(double t);
-    const double D_P(double t);
-    const double F_P(double t);
-    const double D_S(double t);
-    const double F_S(double t);
+    double baryon_gA(double t);
+    double baryon_hA(double t);
+    double baryon_gP(double t);
+    double baryon_fS(double t);
+
+    double D_A(double t);
+    double F_A(double t);
+    double D_P(double t);
+    double F_P(double t);
+    double D_S(double t);
+    double F_S(double t);
 
     // (mB1 - mB2)/(mq1 - mq1)
     double _massRatio;
     double _baryonMassSum;
-    const double formFactorFit(double t, const std::vector<double>& params);
+    double formFactorFit(double t, const std::vector<double>& params);
 
     static const EvtComplex const_B;
     static const EvtComplex const_C;
@@ -137,7 +137,7 @@ private:
     amp_C_pseudoscalarPart(const EvtDiracSpinor& b1Pol, const EvtDiracSpinor& b2Pol, double t);
 
     // initialize phasespace and calculate the amplitude for one (i=0,1) state of the photon
-    EvtComplex calcAmpliude(const EvtParticle* p, const unsigned int polState);
+    EvtComplex calcAmplitude(const EvtParticle* p, unsigned int polState);
 };
 
 #endif
index d9db16b..3e3bb67 100644 (file)
@@ -116,21 +116,21 @@ void EvtLambdaP_BarGamma::initProbMax()
 }
 
 // form factors at 0
-const double EvtLambdaP_BarGamma::f0(double fqm, int n){
+double EvtLambdaP_BarGamma::f0(double fqm, int n){
     return fqm * pow(1 - pow(_mLambdab - _mLambda0, 2) / (_mV * _mV), n);
 }
 
-const double EvtLambdaP_BarGamma::g0(double gqm, int n){
+double EvtLambdaP_BarGamma::g0(double gqm, int n){
     return gqm * pow(1 - pow(_mLambdab - _mLambda0, 2) / (_mA * _mA), n);
 }
 
 
-const double EvtLambdaP_BarGamma::constA(){
+double EvtLambdaP_BarGamma::constA(){
     return _GF/sqrt(2.) * _e0 / (8 * EvtConst::pi*EvtConst::pi) * 2 * _c7Eff * _mb * _VtbVtsStar
         * (f0(_f1) - f0(_f2));
 }
 
-const double EvtLambdaP_BarGamma::constB(){
+double EvtLambdaP_BarGamma::constB(){
     return _GF/sqrt(2.) * _e0 / (8 * EvtConst::pi*EvtConst::pi) * 2 * _c7Eff * _mb * _VtbVtsStar
         * (g0(_g1) - (_mLambdab - _mLambda0) / (_mLambdab + _mLambda0) * g0(_g2));
 }
index fbd5b4e..67b99b1 100644 (file)
@@ -61,15 +61,15 @@ private:
 
   // user never needs to call this -> private
   // baryonic form factors f(p), g(p), at p=0
-  const double f0(const double f_qm, int n=1); // calculate f(0) with f(q_max)
-  const double g0(const double f_qm, int n=1); // calculate g(0) with g(q_max)
+  double f0(double f_qm, int n=1); // calculate f(0) with f(q_max)
+  double g0(double f_qm, int n=1); // calculate g(0) with g(q_max)
   
   // shorthand for constants a and b in the formula
-  const double constA();
-  const double constB();
+  double constA();
+  double constB();
 
   // initialize phasespace and calculate the amplitude for one (i=0,1) state of the photon
-  EvtComplex calcAmpliude(const EvtParticle* p, const unsigned int polState);
+  EvtComplex calcAmplitude(const EvtParticle* p, unsigned int polState);
   
 };