Improving rule conformance

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoLorentzVector.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoLorentzVector.h
index f4392ca013d6684d441d289d3e4d53f56e22c746..115e7259663c17076c1906c5b0e9f7a29435b4af 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoLorentzVector.h
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoLorentzVector.h
@@ -110,20 +110,20 @@ public:
 
     const AliFemtoThreeVector<T>& vect() const;    
     
-    void setX(T);
-    void setY(T);
-    void setZ(T);
-    void setPx(T);
-    void setPy(T);
-    void setPz(T);
-    void setE(T);
-    void setT(T);
+    void SetX(T);
+    void SetY(T);
+    void SetZ(T);
+    void SetPx(T);
+    void SetPy(T);
+    void SetPz(T);
+    void SetE(T);
+    void SetT(T);
     
 #ifndef ST_NO_MEMBER_TEMPLATES
-    template <class X> void setVect(const AliFemtoThreeVector<X>&);
+    template <class X> void SetVect(const AliFemtoThreeVector<X>&);
 #else
-    void setVect(const AliFemtoThreeVector<float>&);
-    void setVect(const AliFemtoThreeVector<double>&);
+    void SetVect(const AliFemtoThreeVector<float>&);
+    void SetVect(const AliFemtoThreeVector<double>&);
 #endif   
 
     T perp()               const;
@@ -237,28 +237,28 @@ T AliFemtoLorentzVector<T>::mt() const
 }
 
 template<class T>
-void AliFemtoLorentzVector<T>::setPx(T x) {mThreeVector.setX(x);}
+void AliFemtoLorentzVector<T>::SetPx(T x) {mThreeVector.SetX(x);}
 
 template<class T>
-void AliFemtoLorentzVector<T>::setPy(T y) {mThreeVector.setY(y);}
+void AliFemtoLorentzVector<T>::SetPy(T y) {mThreeVector.SetY(y);}
 
 template<class T>
-void AliFemtoLorentzVector<T>::setPz(T z) {mThreeVector.setZ(z);}
+void AliFemtoLorentzVector<T>::SetPz(T z) {mThreeVector.SetZ(z);}
 
 template<class T>
-void AliFemtoLorentzVector<T>::setX(T x) {mThreeVector.setX(x);}
+void AliFemtoLorentzVector<T>::SetX(T x) {mThreeVector.SetX(x);}
 
 template<class T>
-void AliFemtoLorentzVector<T>::setY(T y) {mThreeVector.setY(y);}
+void AliFemtoLorentzVector<T>::SetY(T y) {mThreeVector.SetY(y);}
 
 template<class T>
-void AliFemtoLorentzVector<T>::setZ(T z) {mThreeVector.setZ(z);}
+void AliFemtoLorentzVector<T>::SetZ(T z) {mThreeVector.SetZ(z);}
 
 template<class T>
-void AliFemtoLorentzVector<T>::setT(T t) {mX4 = t;}
+void AliFemtoLorentzVector<T>::SetT(T t) {mX4 = t;}
 
 template<class T>
-void AliFemtoLorentzVector<T>::setE(T e) {mX4 = e;}
+void AliFemtoLorentzVector<T>::SetE(T e) {mX4 = e;}
 
 template<class T>
 T AliFemtoLorentzVector<T>::x() const {return mThreeVector.x();}
@@ -437,7 +437,7 @@ AliFemtoLorentzVector<T>::boost(const AliFemtoLorentzVector<X>& pframe) const
 
 template<class T>
 template<class X>
-void AliFemtoLorentzVector<T>::setVect(const AliFemtoThreeVector<X>& v)
+void AliFemtoLorentzVector<T>::SetVect(const AliFemtoThreeVector<X>& v)
 {
     mThreeVector = v;
 }
@@ -540,13 +540,13 @@ AliFemtoLorentzVector<T>::boost(const AliFemtoLorentzVector<double>& pframe) con
 }
 
 template<class T>
-void AliFemtoLorentzVector<T>::setVect(const AliFemtoThreeVector<float>& v)
+void AliFemtoLorentzVector<T>::SetVect(const AliFemtoThreeVector<float>& v)
 {
     mThreeVector = v;
 }
 
 template<class T>
-void AliFemtoLorentzVector<T>::setVect(const AliFemtoThreeVector<double>& v)
+void AliFemtoLorentzVector<T>::SetVect(const AliFemtoThreeVector<double>& v)
 {
     mThreeVector = v;
 }
@@ -721,10 +721,10 @@ istream&  operator>>(istream& is, AliFemtoLorentzVector<T>& v)
 {
     T  x, y, z, t;
     is >> x >> y >> z >> t;
-    v.setX(x);
-    v.setY(y);
-    v.setZ(z);
-    v.setT(t);
+    v.SetX(x);
+    v.SetY(y);
+    v.SetZ(z);
+    v.SetT(t);
     return is;
 }
 

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelGlobalHiddenInfo.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelGlobalHiddenInfo.cxx
index ab9a684b6ec9352a5fb73a8eda9dfa07ee3e9674..315820a723699d527f5529f6efdbb5b578e5389e 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelGlobalHiddenInfo.cxx
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelGlobalHiddenInfo.cxx
@@ -62,9 +62,9 @@ void                   AliFemtoModelGlobalHiddenInfo::SetGlobalEmissionPoint(con
 {
   // set position from vector
   if (fGlobalEmissionPoint) {
-    fGlobalEmissionPoint->setX(aPos.x());
-    fGlobalEmissionPoint->setY(aPos.y());
-    fGlobalEmissionPoint->setZ(aPos.z());
+    fGlobalEmissionPoint->SetX(aPos.x());
+    fGlobalEmissionPoint->SetY(aPos.y());
+    fGlobalEmissionPoint->SetZ(aPos.z());
   }
   else {
     fGlobalEmissionPoint = new AliFemtoThreeVector();
@@ -74,11 +74,11 @@ void                   AliFemtoModelGlobalHiddenInfo::SetGlobalEmissionPoint(con
 //_____________________________________________
 void                   AliFemtoModelGlobalHiddenInfo::SetGlobalEmissionPoint(Double_t aRx, Double_t aRy, Double_t aRz)
 {
-  // set position from components
+  // Set position from components
   if (fGlobalEmissionPoint) {
-    fGlobalEmissionPoint->setX(aRx);
-    fGlobalEmissionPoint->setY(aRy);
-    fGlobalEmissionPoint->setZ(aRz);
+    fGlobalEmissionPoint->SetX(aRx);
+    fGlobalEmissionPoint->SetY(aRy);
+    fGlobalEmissionPoint->SetZ(aRz);
   }
   else {
     fGlobalEmissionPoint = new AliFemtoThreeVector(aRx, aRy, aRz); 

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelHiddenInfo.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelHiddenInfo.cxx
index 21e9a0098ac9d3c9973929391c805c56de78f0fc..f280840353f3f1f87ee29cefec0b4035088f8a8d 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelHiddenInfo.cxx
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoModelHiddenInfo.cxx
@@ -80,11 +80,11 @@ Double_t                  AliFemtoModelHiddenInfo::GetMass() const
 //_____________________________________________
 void                   AliFemtoModelHiddenInfo::SetTrueMomentum(AliFemtoThreeVector *aMom)
 {
-  // set momentum from vector
+  // Set momentum from vector
   if (fTrueMomentum) {
-    fTrueMomentum->setX(aMom->x());
-    fTrueMomentum->setY(aMom->y());
-    fTrueMomentum->setZ(aMom->z());
+    fTrueMomentum->SetX(aMom->x());
+    fTrueMomentum->SetY(aMom->y());
+    fTrueMomentum->SetZ(aMom->z());
   }
   else {
     fTrueMomentum = new AliFemtoThreeVector(*aMom);
@@ -93,11 +93,11 @@ void                   AliFemtoModelHiddenInfo::SetTrueMomentum(AliFemtoThreeVec
 //_____________________________________________
 void                   AliFemtoModelHiddenInfo::SetTrueMomentum(const AliFemtoThreeVector& aMom)
 {
-  // set momentum from vector
+  // Set momentum from vector
   if (fTrueMomentum) {
-    fTrueMomentum->setX(aMom.x());
-    fTrueMomentum->setY(aMom.y());
-    fTrueMomentum->setZ(aMom.z());
+    fTrueMomentum->SetX(aMom.x());
+    fTrueMomentum->SetY(aMom.y());
+    fTrueMomentum->SetZ(aMom.z());
   }
   else {
     fTrueMomentum = new AliFemtoThreeVector();
@@ -107,21 +107,21 @@ void                   AliFemtoModelHiddenInfo::SetTrueMomentum(const AliFemtoTh
 //_____________________________________________
 void                   AliFemtoModelHiddenInfo::SetTrueMomentum(Double_t aPx, Double_t aPy, Double_t aPz)
 {
-  // set momentum from components
+  // Set momentum from components
   if (!fTrueMomentum) fTrueMomentum = new AliFemtoThreeVector();
-    fTrueMomentum->setX(aPx);
-    fTrueMomentum->setY(aPy);
-    fTrueMomentum->setZ(aPz);
+    fTrueMomentum->SetX(aPx);
+    fTrueMomentum->SetY(aPy);
+    fTrueMomentum->SetZ(aPz);
 }
 //_____________________________________________
 void                   AliFemtoModelHiddenInfo::SetEmissionPoint(AliFemtoLorentzVector *aPos)
 {
-  // set position from vector
+  // Set position from vector
   if (fEmissionPoint) {
-    fEmissionPoint->setX(aPos->px());
-    fEmissionPoint->setY(aPos->py());
-    fEmissionPoint->setZ(aPos->pz());
-    fEmissionPoint->setT(aPos->e());
+    fEmissionPoint->SetX(aPos->px());
+    fEmissionPoint->SetY(aPos->py());
+    fEmissionPoint->SetZ(aPos->pz());
+    fEmissionPoint->SetT(aPos->e());
   }
   else {
     fEmissionPoint = new AliFemtoLorentzVector(*aPos);
@@ -130,12 +130,12 @@ void                   AliFemtoModelHiddenInfo::SetEmissionPoint(AliFemtoLorentz
 //_____________________________________________
 void                   AliFemtoModelHiddenInfo::SetEmissionPoint(const AliFemtoLorentzVector& aPos)
 {
-  // set position from vector
+  // Set position from vector
   if (fEmissionPoint) {
-    fEmissionPoint->setX(aPos.px());
-    fEmissionPoint->setY(aPos.py());
-    fEmissionPoint->setZ(aPos.pz());
-    fEmissionPoint->setT(aPos.e());
+    fEmissionPoint->SetX(aPos.px());
+    fEmissionPoint->SetY(aPos.py());
+    fEmissionPoint->SetZ(aPos.pz());
+    fEmissionPoint->SetT(aPos.e());
   }
   else {
     fEmissionPoint = new AliFemtoLorentzVector();
@@ -155,12 +155,12 @@ void                   AliFemtoModelHiddenInfo::SetMass(Double_t aMass)
 //_____________________________________________
 void                   AliFemtoModelHiddenInfo::SetEmissionPoint(Double_t aRx, Double_t aRy, Double_t aRz, Double_t aT)
 {
-  // set position from components
+  // Set position from components
   if (fEmissionPoint) {
-    fEmissionPoint->setX(aRx);
-    fEmissionPoint->setY(aRy);
-    fEmissionPoint->setZ(aRz);
-    fEmissionPoint->setT(aT);
+    fEmissionPoint->SetX(aRx);
+    fEmissionPoint->SetY(aRy);
+    fEmissionPoint->SetZ(aRz);
+    fEmissionPoint->SetT(aT);
   }
   else {
     fEmissionPoint = new AliFemtoLorentzVector(aRx, aRy, aRz, aT); 

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.cxx
index e7d2d7173b91b8bc17c5b449f972ce647b8e2dab..8e8e4fda9647542178acf37fbf5e34c82efccb8b 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.cxx
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoPair.cxx
@@ -334,7 +334,7 @@ void AliFemtoPair::QYKPLCMS(double& qP, double& qT, double& q0) const
   // create dummy particle
   AliFemtoLorentzVector  l(0.0, 0.0, dummyPz) ; 
   double dummyMass = 1.0 ;
-  l.setE(l.vect().massHypothesis(dummyMass) );
+  l.SetE(l.vect().MassHypothesis(dummyMass) );
   // boost particles along the beam into a frame with velocity beta 
   AliFemtoLorentzVector l1boosted = l1.boost(l) ;
   AliFemtoLorentzVector l2boosted = l2.boost(l) ;
@@ -360,7 +360,7 @@ void AliFemtoPair::QYKPPF(double& qP, double& qT, double& q0) const
   // the center of gravity of the pair travels with l
   AliFemtoLorentzVector  l = l1 + l2 ; 
   l = -l ;
-  l.setE(-l.e()) ;
+  l.SetE(-l.e()) ;
   // boost particles  
   AliFemtoLorentzVector l1boosted = l1.boost(l) ;
   AliFemtoLorentzVector l2boosted = l2.boost(l) ;
@@ -647,7 +647,7 @@ double AliFemtoPair::KStarFlipped() const {
 
   AliFmThreeVectorD qwe = tP1.vect();
   qwe *= -1.; // flip it
-  tP1.setVect(qwe);
+  tP1.SetVect(qwe);
   
   AliFemtoLorentzVector tSum = (tP1+fTrack2->FourMomentum());
   double tMass = abs(tSum);
@@ -679,7 +679,7 @@ double AliFemtoPair::CVKFlipped() const{
   AliFemtoLorentzVector tP1 = fTrack1->FourMomentum();
   AliFmThreeVectorD qwe = tP1.vect();
   qwe *= -1.; // flip it
-  tP1.setVect(qwe);
+  tP1.SetVect(qwe);
   
   AliFemtoLorentzVector tSum = (tP1+fTrack2->FourMomentum());
   double tMass = abs(tSum);
@@ -707,8 +707,8 @@ double AliFemtoPair::PInv() const{
 double AliFemtoPair::QInvFlippedXY() const{
   // qinv with X and Y flipped
   AliFemtoLorentzVector tP1 = fTrack1->FourMomentum();
-  tP1.setX(-1.*tP1.x());
-  tP1.setY(-1.*tP1.y());
+  tP1.SetX(-1.*tP1.x());
+  tP1.SetY(-1.*tP1.y());
   AliFemtoLorentzVector tDiff = (tP1-fTrack2->FourMomentum());
   return ( -1.* tDiff.m());
 }

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.cxx
index 39732f7376c9c3df415c186cdccb4a2dcb12bf1b..c77cb37345de075f2e46beb10f69ccdb782c8231 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.cxx
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoParticle.cxx
@@ -181,9 +181,9 @@ AliFemtoParticle::AliFemtoParticle(const AliFemtoTrack* const hbtTrack,const dou
   // I know there is a better way to do this...
   fTrack = new AliFemtoTrack(*hbtTrack);
   AliFemtoThreeVector temp = hbtTrack->P();
-  fFourMomentum.setVect(temp);
+  fFourMomentum.SetVect(temp);
   double ener = ::sqrt(temp.mag2()+mass*mass);
-  fFourMomentum.setE(ener);
+  fFourMomentum.SetE(ener);
 //  fMap[0] = hbtTrack->TopologyMap(0);
  // fMap[1] = hbtTrack->TopologyMap(1);
  // fNhits = hbtTrack->NHits();
@@ -191,12 +191,12 @@ AliFemtoParticle::AliFemtoParticle(const AliFemtoTrack* const hbtTrack,const dou
   //CalculateNominalTpcExitAndEntrancePoints();
 
  
-  fPrimaryVertex.setX(0.);
-  fPrimaryVertex.setY(0.);
-  fPrimaryVertex.setZ(0.);
-  fSecondaryVertex.setX(0.);
-  fSecondaryVertex.setY(0.);
-  fSecondaryVertex.setZ(0.);
+  fPrimaryVertex.SetX(0.);
+  fPrimaryVertex.SetY(0.);
+  fPrimaryVertex.SetZ(0.);
+  fSecondaryVertex.SetX(0.);
+  fSecondaryVertex.SetY(0.);
+  fSecondaryVertex.SetZ(0.);
   /* TO JA ODZNACZYLEM NIE WIEM DLACZEGO
   CalculateTpcExitAndEntrancePoints(&fHelix,&fPrimaryVertex,
                                    &fSecondaryVertex,
@@ -244,9 +244,9 @@ AliFemtoParticle::AliFemtoParticle(const AliFemtoV0* const hbtV0,const double& m
   //fMap[1]= 0;
   // I know there is a better way to do this...
   AliFemtoThreeVector temp = hbtV0->MomV0();
-  fFourMomentum.setVect(temp);
+  fFourMomentum.SetVect(temp);
   double ener = ::sqrt(temp.mag2()+mass*mass);
-  fFourMomentum.setE(ener);
+  fFourMomentum.SetE(ener);
   // Calculating TpcEntrancePoint for Positive V0 daugther
   fPrimaryVertex = hbtV0->PrimaryVertex();
   fSecondaryVertex = hbtV0->DecayVertexV0();
@@ -308,9 +308,9 @@ AliFemtoParticle::AliFemtoParticle(const AliFemtoKink* const hbtKink,const doubl
   //fMap[1]= 0;
   // I know there is a better way to do this...
   AliFemtoThreeVector temp = hbtKink->Parent().P();
-  fFourMomentum.setVect(temp);
+  fFourMomentum.SetVect(temp);
   double ener = ::sqrt(temp.mag2()+mass*mass);
-  fFourMomentum.setE(ener);
+  fFourMomentum.SetE(ener);
 }
 
 //_____________________
@@ -339,9 +339,9 @@ AliFemtoParticle::AliFemtoParticle(const AliFemtoXi* const hbtXi, const double&
  // fMap[0]= 0;
   //fMap[1]= 0;
   AliFemtoThreeVector temp;// = hbtXi->mMofXi;
-  fFourMomentum.setVect(temp);
+  fFourMomentum.SetVect(temp);
   double ener = ::sqrt(temp.mag2()+mass*mass);
-  fFourMomentum.setE(ener);
+  fFourMomentum.SetE(ener);
   fHiddenInfo = 0;
 }
 //_____________________
@@ -492,12 +492,12 @@ double AliFemtoParticle::GetProtonPurity()
 //   // inner field cage
 //   //  static AliFemtoThreeVector ZeroVec(0.,0.,0.);
 //   AliFemtoThreeVector tZeroVec(0.,0.,0.);
-// //   tZeroVec.setX(tHelix->origin().x()-PrimVert->x());
-// //   tZeroVec.setY(tHelix->origin().y()-PrimVert->y());
-// //   tZeroVec.setZ(tHelix->origin().z()-PrimVert->z());
-//   tZeroVec.setX(SecVert->x()-PrimVert->x());
-//   tZeroVec.setY(SecVert->y()-PrimVert->y());
-//   tZeroVec.setZ(SecVert->z()-PrimVert->z());
+// //   tZeroVec.SetX(tHelix->origin().x()-PrimVert->x());
+// //   tZeroVec.SetY(tHelix->origin().y()-PrimVert->y());
+// //   tZeroVec.SetZ(tHelix->origin().z()-PrimVert->z());
+//   tZeroVec.SetX(SecVert->x()-PrimVert->x());
+//   tZeroVec.SetY(SecVert->y()-PrimVert->y());
+//   tZeroVec.SetZ(SecVert->z()-PrimVert->z());
 //   double dip, curv, phase;
 //   int h;
 //   curv = tHelix->Curvature();
@@ -540,21 +540,21 @@ double AliFemtoParticle::GetProtonPurity()
 //       IsNaN(tmpTpcEntrancePoint->z()) ){ 
 //     cout << "tmpTpcEntrancePoint NAN"<< endl; 
 //     cout << "tmpNominalTpcEntrancePoint = " <<tmpTpcEntrancePoint<< endl;
-//     tmpTpcEntrancePoint->setX(-9999.);
-//     tmpTpcEntrancePoint->setY(-9999.);
-//     tmpTpcEntrancePoint->setZ(-9999.);
+//     tmpTpcEntrancePoint->SetX(-9999.);
+//     tmpTpcEntrancePoint->SetY(-9999.);
+//     tmpTpcEntrancePoint->SetZ(-9999.);
 //   } 
     
 //   if (IsNaN(tmpTpcExitPoint->x()) || 
 //       IsNaN(tmpTpcExitPoint->y()) || 
 //       IsNaN(tmpTpcExitPoint->z()) ) {
-// //     cout << "tmpTpcExitPoint NAN set at (-9999,-9999,-9999)"<< endl; 
+// //     cout << "tmpTpcExitPoint NAN Set at (-9999,-9999,-9999)"<< endl; 
 // //     cout << "tmpTpcExitPoint X= " <<tmpTpcExitPoint->x()<< endl;
 // //     cout << "tmpTpcExitPoint Y= " <<tmpTpcExitPoint->y()<< endl;
 // //     cout << "tmpTpcExitPoint Z= " <<tmpTpcExitPoint->z()<< endl;
-//     tmpTpcExitPoint->setX(-9999.);
-//     tmpTpcExitPoint->setY(-9999.);
-//     tmpTpcExitPoint->setZ(-9999.);
+//     tmpTpcExitPoint->SetX(-9999.);
+//     tmpTpcExitPoint->SetY(-9999.);
+//     tmpTpcExitPoint->SetZ(-9999.);
 //   }
 
 
@@ -645,10 +645,10 @@ double AliFemtoParticle::GetProtonPurity()
 //       cout <<"***ERROR tPhi"<< endl;
 //     }  
 //     // calculate crossing plane
-//     tn.setX(cos(tPhi));
-//     tn.setY(sin(tPhi));       
-//     tr.setX(tRowRadius[ti]*cos(tPhi));
-//     tr.setY(tRowRadius[ti]*sin(tPhi));
+//     tn.SetX(cos(tPhi));
+//     tn.SetY(sin(tPhi));       
+//     tr.SetX(tRowRadius[ti]*cos(tPhi));
+//     tr.SetY(tRowRadius[ti]*sin(tPhi));
 //     // find crossing point
 //     tLength = hel.PathLength(tr,tn); 
 //     if (IsNaN(tLength)){
@@ -678,10 +678,10 @@ double AliFemtoParticle::GetProtonPurity()
 //     else{
 //       if(tmpSect[ti] != tSect){
 //     // Try again on the other sector
-//     tn.setX(cos(tPhi));
-//     tn.setY(sin(tPhi));       
-//     tr.setX(tRowRadius[ti]*cos(tPhi));
-//     tr.setY(tRowRadius[ti]*sin(tPhi));
+//     tn.SetX(cos(tPhi));
+//     tn.SetY(sin(tPhi));       
+//     tr.SetX(tRowRadius[ti]*cos(tPhi));
+//     tr.SetY(tRowRadius[ti]*sin(tPhi));
 //     // find crossing point
 //     tLength = hel.PathLength(tr,tn);
 //     tPoint = hel.At(tLength);
@@ -726,7 +726,7 @@ double AliFemtoParticle::GetProtonPurity()
 //       cout << "*******************ERROR***************************" << endl;
 //     }
 //     // If padrow ti not reached all other beyond are not reached
-//     // in this case set sector to -1
+//     // in this case Set sector to -1
 //     if (tmpSect[ti]==-1){
 //       for (int tj=ti; tj<45;tj++){
 //     tmpSect[tj] = -1;

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoThreeVector.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoThreeVector.h
index f4443556408bb9b46573e9cd34386986cfa9f7de..1d6f2c721c9c12da10d2c548f545bd4af0b1b07e 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoThreeVector.h
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoThreeVector.h
@@ -129,14 +129,14 @@ public:
     AliFmThreeVector<T>& operator=(const AliFmThreeVector<double>&);
 #endif
     
-    void setX(T);
-    void setY(T);
-    void setZ(T);
-
-    void setPhi(T);
-    void setTheta(T);
-    void setMag(T);
-    void setMagnitude(T);
+    void SetX(T);
+    void SetY(T);
+    void SetZ(T);
+
+    void SetPhi(T);
+    void SetTheta(T);
+    void SetMag(T);
+    void SetMagnitude(T);
     
     T   x()                        const;
     T   y()                        const;
@@ -156,14 +156,14 @@ public:
     T&  operator() (size_t);
     T&  operator[] (size_t);
     
-    T   massHypothesis(T mass)     const;
+    T   MassHypothesis(T mass)     const;
     
-    AliFmThreeVector<T>  unit()       const;
-    AliFmThreeVector<T>  orthogonal() const;
+    AliFmThreeVector<T>  Unit()       const;
+    AliFmThreeVector<T>  Orthogonal() const;
 
-    void  rotateX(T);
-    void  rotateY(T);
-    void  rotateZ(T);
+    void  RotateX(T);
+    void  RotateY(T);
+    void  RotateZ(T);
     
     AliFmThreeVector<T>  operator- ();
     AliFmThreeVector<T>  operator+ ();
@@ -223,16 +223,16 @@ template<class T>
 inline AliFmThreeVector<T>::~AliFmThreeVector() {/* nop */}
 
 template<class T>
-inline void AliFmThreeVector<T>::setX(T x) {mX1 = x;}
+inline void AliFmThreeVector<T>::SetX(T x) {mX1 = x;}
 
 template<class T>
-inline void AliFmThreeVector<T>::setY(T y) {mX2 = y;}
+inline void AliFmThreeVector<T>::SetY(T y) {mX2 = y;}
 
 template<class T>
-inline void AliFmThreeVector<T>::setZ(T z) {mX3 = z;}
+inline void AliFmThreeVector<T>::SetZ(T z) {mX3 = z;}
 
 template<class T>
-void AliFmThreeVector<T>::setPhi(T angle)
+void AliFmThreeVector<T>::SetPhi(T angle)
 {
     double  r = magnitude();
     double th = theta();
@@ -242,7 +242,7 @@ void AliFmThreeVector<T>::setPhi(T angle)
 }
 
 template <class T>
-void AliFmThreeVector<T>::setTheta(T angle)
+void AliFmThreeVector<T>::SetTheta(T angle)
 {
     double r  = magnitude();
     double ph = phi();
@@ -253,7 +253,7 @@ void AliFmThreeVector<T>::setTheta(T angle)
 }
 
 template <class T>
-void AliFmThreeVector<T>::setMagnitude(T r)
+void AliFmThreeVector<T>::SetMagnitude(T r)
 {
     double th = theta();
     double ph = phi();
@@ -264,9 +264,9 @@ void AliFmThreeVector<T>::setMagnitude(T r)
 }
 
 template <class T>
-void AliFmThreeVector<T>::setMag(T mag)
+void AliFmThreeVector<T>::SetMag(T mag)
 {
-    setMagnitude(mag);
+    SetMagnitude(mag);
 }
 
 template<class T>
@@ -308,20 +308,20 @@ inline T AliFmThreeVector<T>::pseudoRapidity() const
 }
 
 template<class T>
-inline AliFmThreeVector<T> AliFmThreeVector<T>::unit() const
+inline AliFmThreeVector<T> AliFmThreeVector<T>::Unit() const
 {
     double tmp = mag(); if (tmp<=0.) tmp = 1e-20;
     return *this/tmp;
 }
 
 template <class T>
-T AliFmThreeVector<T>::massHypothesis(T mass) const
+T AliFmThreeVector<T>::MassHypothesis(T mass) const
 {
     return ::sqrt((*this)*(*this) + mass*mass);
 }
 
 template <class T>
-AliFmThreeVector<T> AliFmThreeVector<T>::orthogonal() const
+AliFmThreeVector<T> AliFmThreeVector<T>::Orthogonal() const
 {
     // Direct copy from CLHEP--it is probably better to
     // use your own dot/cross product code...
@@ -336,7 +336,7 @@ AliFmThreeVector<T> AliFmThreeVector<T>::orthogonal() const
 }
 
 template <class T>
-void AliFmThreeVector<T>::rotateX(T angle)
+void AliFmThreeVector<T>::RotateX(T angle)
 {
     // may in the future make use of the AliFmRotation class!
     double yPrime = cos(angle)*mX2 - sin(angle)*mX3;
@@ -347,7 +347,7 @@ void AliFmThreeVector<T>::rotateX(T angle)
 }
 
 template <class T>
-void AliFmThreeVector<T>::rotateY(T angle)
+void AliFmThreeVector<T>::RotateY(T angle)
 {
     // may in the future make use of the AliFmRotation class!
     double zPrime = cos(angle)*mX3 - sin(angle)*mX1;
@@ -358,7 +358,7 @@ void AliFmThreeVector<T>::rotateY(T angle)
 }
 
 template <class T>
-void AliFmThreeVector<T>::rotateZ(T angle)
+void AliFmThreeVector<T>::RotateZ(T angle)
 {
     // may in the future make use of the AliFmRotation class!
     double xPrime = cos(angle)*mX1 - sin(angle)*mX2;
@@ -849,9 +849,9 @@ istream&  operator>>(istream& is, AliFmThreeVector<T>& v)
 {
     T  x, y, z;
     is >> x >> y >> z;
-    v.setX(x);
-    v.setY(y);
-    v.setZ(z);
+    v.SetX(x);
+    v.SetY(y);
+    v.SetZ(z);
     return is;
 }
 #endif /* ! __CINT__ */

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.cxx
index 66250bb537fa2a3f9a81ad2bff0fb417ea7660f8..52043010a72caaeb816ba2f94b6f2dd73264b341 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.cxx
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoTrack.cxx
@@ -315,9 +315,9 @@ void AliFemtoTrack::SetNominalTPCEntrancePoint(const AliFemtoThreeVector& aXTPC)
 void AliFemtoTrack::SetNominalTPCEntrancePoint(double *aXTPC)
 {
   // Store the nominal TPC entrance point
-  fNominalTpcEntrancePoint.setX(aXTPC[0]);
-  fNominalTpcEntrancePoint.setY(aXTPC[1]);
-  fNominalTpcEntrancePoint.setZ(aXTPC[2]);
+  fNominalTpcEntrancePoint.SetX(aXTPC[0]);
+  fNominalTpcEntrancePoint.SetY(aXTPC[1]);
+  fNominalTpcEntrancePoint.SetZ(aXTPC[2]);
 }
 
 void AliFemtoTrack::SetNominalTPCExitPoint(const AliFemtoThreeVector& aXTPC)
@@ -327,7 +327,7 @@ void AliFemtoTrack::SetNominalTPCExitPoint(const AliFemtoThreeVector& aXTPC)
 void AliFemtoTrack::SetNominalTPCExitPoint(double *aXTPC)
 {
   // Store the nominal TPC exit point
-  fNominalTpcExitPoint.setX(aXTPC[0]);
-  fNominalTpcExitPoint.setY(aXTPC[1]);
-  fNominalTpcExitPoint.setZ(aXTPC[2]);
+  fNominalTpcExitPoint.SetX(aXTPC[0]);
+  fNominalTpcExitPoint.SetY(aXTPC[1]);
+  fNominalTpcExitPoint.SetZ(aXTPC[2]);
 }

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoV0.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoV0.h
index 3ac9b19a483d9fab3a362fa257c8a3efbd661d90..fdd9510e31c247d73bc06d8fbe64a0c98c7159d2 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoV0.h
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoV0.h
@@ -319,28 +319,28 @@ inline unsigned short   AliFemtoV0::IdPos() const { return fKeyPos; }
 inline unsigned short   AliFemtoV0::KeyPos() const { return fKeyPos; }
 
 inline void AliFemtoV0::SetdecayLengthV0(const float x){ fDecayLengthV0= x;}   
-inline void AliFemtoV0::SetdecayVertexV0X(const float x){ fDecayVertexV0.setX(x);}
-inline void AliFemtoV0::SetdecayVertexV0Y(const float x){ fDecayVertexV0.setY(x);}
-inline void AliFemtoV0::SetdecayVertexV0Z(const float x){ fDecayVertexV0.setZ(x);}
+inline void AliFemtoV0::SetdecayVertexV0X(const float x){ fDecayVertexV0.SetX(x);}
+inline void AliFemtoV0::SetdecayVertexV0Y(const float x){ fDecayVertexV0.SetY(x);}
+inline void AliFemtoV0::SetdecayVertexV0Z(const float x){ fDecayVertexV0.SetZ(x);}
 inline void AliFemtoV0::SetdecayVertexV0(const AliFemtoThreeVector v){ fDecayVertexV0 = v; }
 inline void AliFemtoV0::SetdcaV0Daughters(const float x){fDcaV0Daughters= x;} 
 inline void AliFemtoV0::SetdcaV0ToPrimVertex(const float x){fDcaV0ToPrimVertex= x;}   
 inline void AliFemtoV0::SetdcaPosToPrimVertex(const float x){fDcaPosToPrimVertex = x;} 
 inline void AliFemtoV0::SetdcaNegToPrimVertex(const float x){fDcaNegToPrimVertex = x;} 
 inline void AliFemtoV0::SetmomPos(const AliFemtoThreeVector v){fMomPos = v; }
-inline void AliFemtoV0::SetmomPosX(const float x){fMomPos.setX(x);}
-inline void AliFemtoV0::SetmomPosY(const float x){fMomPos.setY(x);}
-inline void AliFemtoV0::SetmomPosZ(const float x){fMomPos.setZ(x);}
+inline void AliFemtoV0::SetmomPosX(const float x){fMomPos.SetX(x);}
+inline void AliFemtoV0::SetmomPosY(const float x){fMomPos.SetY(x);}
+inline void AliFemtoV0::SetmomPosZ(const float x){fMomPos.SetZ(x);}
 inline void AliFemtoV0::SetmomNeg(const AliFemtoThreeVector v){fMomNeg = v; }
-inline void AliFemtoV0::SetmomNegX(const float x){fMomNeg.setX(x);}
-inline void AliFemtoV0::SetmomNegY(const float x){fMomNeg.setY(x);}
-inline void AliFemtoV0::SetmomNegZ(const float x){fMomNeg.setZ(x);}
+inline void AliFemtoV0::SetmomNegX(const float x){fMomNeg.SetX(x);}
+inline void AliFemtoV0::SetmomNegY(const float x){fMomNeg.SetY(x);}
+inline void AliFemtoV0::SetmomNegZ(const float x){fMomNeg.SetZ(x);}
 inline void AliFemtoV0::SetTrackTopologyMapPos(unsigned int word, const unsigned long& m){fTrackTopologyMapPos[word]=m;} 
 inline void AliFemtoV0::SetTrackTopologyMapNeg(unsigned int word, const unsigned long& m){fTrackTopologyMapNeg[word]=m;} 
 inline void AliFemtoV0::SetmomV0(AliFemtoThreeVector v){fMomV0= v; }
-inline void AliFemtoV0::SetmomV0X(const float x){fMomV0.setX(x);}
-inline void AliFemtoV0::SetmomV0Y(const float x){fMomV0.setY(x);}
-inline void AliFemtoV0::SetmomV0Z(const float x){fMomV0.setZ(x);}
+inline void AliFemtoV0::SetmomV0X(const float x){fMomV0.SetX(x);}
+inline void AliFemtoV0::SetmomV0Y(const float x){fMomV0.SetY(x);}
+inline void AliFemtoV0::SetmomV0Z(const float x){fMomV0.SetZ(x);}
 
 inline void AliFemtoV0::SetalphaV0( float x){fAlphaV0= x;}
 inline void AliFemtoV0::SetptArmV0( float x){fPtArmV0 = x;}

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoXi.h b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoXi.h
index fff3f1c98532051da98d9c1b0bab98e0f12f84b2..ac006167306eff8a1fea8a682bdb5c85aca32670 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFemtoXi.h
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFemtoXi.h
@@ -195,22 +195,22 @@ inline unsigned short   AliFemtoXi::IdBac() const { return fKeyBac; }
 inline unsigned short   AliFemtoXi::KeyBac() const { return fKeyBac; }
 
 inline void AliFemtoXi::SetdecayLengthXi(const float x){ fDecayLengthXi= x;}   
-inline void AliFemtoXi::SetdecayVertexXiX(const float x){ fDecayVertexXi.setX(x);}
-inline void AliFemtoXi::SetdecayVertexXiY(const float x){ fDecayVertexXi.setY(x);}
-inline void AliFemtoXi::SetdecayVertexXiZ(const float x){ fDecayVertexXi.setZ(x);}
+inline void AliFemtoXi::SetdecayVertexXiX(const float x){ fDecayVertexXi.SetX(x);}
+inline void AliFemtoXi::SetdecayVertexXiY(const float x){ fDecayVertexXi.SetY(x);}
+inline void AliFemtoXi::SetdecayVertexXiZ(const float x){ fDecayVertexXi.SetZ(x);}
 inline void AliFemtoXi::SetdecayVertexXi(const AliFemtoThreeVector v){ fDecayVertexXi = v; }
 inline void AliFemtoXi::SetdcaXiDaughters(const float x){fDcaXiDaughters= x;} 
 inline void AliFemtoXi::SetdcaXiToPrimVertex(const float x){fDcaXiToPrimVertex= x;}   
 inline void AliFemtoXi::SetdcaBacToPrimVertex(const float x){ fDcaBachelorToPrimVertex = x;} 
 inline void AliFemtoXi::SetmomBac(const AliFemtoThreeVector v){fMomBachelor = v; }
-inline void AliFemtoXi::SetmomBacX(const float x){fMomBachelor.setX(x);}
-inline void AliFemtoXi::SetmomBacY(const float x){fMomBachelor.setY(x);}
-inline void AliFemtoXi::SetmomBacZ(const float x){fMomBachelor.setZ(x);}
+inline void AliFemtoXi::SetmomBacX(const float x){fMomBachelor.SetX(x);}
+inline void AliFemtoXi::SetmomBacY(const float x){fMomBachelor.SetY(x);}
+inline void AliFemtoXi::SetmomBacZ(const float x){fMomBachelor.SetZ(x);}
 inline void AliFemtoXi::SetTrackTopologyMapBac(unsigned int word, const unsigned long& m){fTopologyMapBachelor[word]=m;} 
 inline void AliFemtoXi::SetmomXi(AliFemtoThreeVector v){fMomXi= v; }
-inline void AliFemtoXi::SetmomXiX(const float x){fMomXi.setX(x);}
-inline void AliFemtoXi::SetmomXiY(const float x){fMomXi.setY(x);}
-inline void AliFemtoXi::SetmomXiZ(const float x){fMomXi.setZ(x);}
+inline void AliFemtoXi::SetmomXiX(const float x){fMomXi.SetX(x);}
+inline void AliFemtoXi::SetmomXiY(const float x){fMomXi.SetY(x);}
+inline void AliFemtoXi::SetmomXiZ(const float x){fMomXi.SetZ(x);}
 
 inline void AliFemtoXi::SetalphaXi( float x){fAlphaXi= x;}
 inline void AliFemtoXi::SetptArmXi( float x){fPtArmXi = x;}

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFmHelix.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFmHelix.cxx
index b897445bb2137d557743a85c811fffaabd18773b..5d2cf575ad83dc2542247d71086b8919c0511304 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFmHelix.cxx
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFmHelix.cxx
@@ -369,11 +369,11 @@ pair<double, double> AliFmHelix::PathLength(double r, double x, double y, bool /
   // path length
        double x0 = fOrigin.x();
        double y0 = fOrigin.y();
-       fOrigin.setX(x0-x);
-       fOrigin.setY(y0-y);
+       fOrigin.SetX(x0-x);
+       fOrigin.SetY(y0-y);
        pair<double, double> result = this->PathLength(r);
-       fOrigin.setX(x0);
-       fOrigin.setY(y0);
+       fOrigin.SetX(x0);
+       fOrigin.SetY(y0);
        return result;  
 }
 

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFmHelix.h b/PWG2/FEMTOSCOPY/AliFemto/AliFmHelix.h
index 8caaaa70f37a393ab462cb001c8beeff8b5dc00a..10c6b9544bf6cbf3df7b625586392ebc457672c3 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFmHelix.h
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFmHelix.h
@@ -171,7 +171,7 @@ inline int AliFmHelix::Bad(double WorldSize) const
     if (!::finite(fDipAngle    ))      return   11;
     if (!::finite(fCurvature   ))      return   12;
 
-    ierr = fOrigin.bad(WorldSize);
+    ierr = fOrigin.Bad(WorldSize);
     if (ierr)                           return    3+ierr*100;
 
     if (::fabs(fDipAngle)  >1.58)      return   21;

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFmLorentzVector.h b/PWG2/FEMTOSCOPY/AliFemto/AliFmLorentzVector.h
index 4bf7c006b21999317249ca9e2f7c1f5265c5e534..75314334a94c25b0093121bc952a97b3a3a748e6 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFmLorentzVector.h
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFmLorentzVector.h
@@ -110,20 +110,20 @@ public:
 
     const AliFmThreeVector<T>& vect() const;    
     
-    void setX(T);
-    void setY(T);
-    void setZ(T);
-    void setPx(T);
-    void setPy(T);
-    void setPz(T);
-    void setE(T);
-    void setT(T);
+    void SetX(T);
+    void SetY(T);
+    void SetZ(T);
+    void SetPx(T);
+    void SetPy(T);
+    void SetPz(T);
+    void SetE(T);
+    void SetT(T);
     
 #ifndef ST_NO_MEMBER_TEMPLATES
-    template <class X> void setVect(const AliFmThreeVector<X>&);
+    template <class X> void SetVect(const AliFmThreeVector<X>&);
 #else
-    void setVect(const AliFmThreeVector<float>&);
-    void setVect(const AliFmThreeVector<double>&);
+    void SetVect(const AliFmThreeVector<float>&);
+    void SetVect(const AliFmThreeVector<double>&);
 #endif   
 
     T perp()               const;
@@ -237,28 +237,28 @@ T AliFmLorentzVector<T>::mt() const
 }
 
 template<class T>
-void AliFmLorentzVector<T>::setPx(T ax) {mThreeVector.setX(ax);}
+void AliFmLorentzVector<T>::SetPx(T ax) {mThreeVector.SetX(ax);}
 
 template<class T>
-void AliFmLorentzVector<T>::setPy(T ay) {mThreeVector.setY(ay);}
+void AliFmLorentzVector<T>::SetPy(T ay) {mThreeVector.SetY(ay);}
 
 template<class T>
-void AliFmLorentzVector<T>::setPz(T az) {mThreeVector.setZ(az);}
+void AliFmLorentzVector<T>::SetPz(T az) {mThreeVector.SetZ(az);}
 
 template<class T>
-void AliFmLorentzVector<T>::setX(T ax) {mThreeVector.setX(ax);}
+void AliFmLorentzVector<T>::SetX(T ax) {mThreeVector.SetX(ax);}
 
 template<class T>
-void AliFmLorentzVector<T>::setY(T ay) {mThreeVector.setY(ay);}
+void AliFmLorentzVector<T>::SetY(T ay) {mThreeVector.SetY(ay);}
 
 template<class T>
-void AliFmLorentzVector<T>::setZ(T az) {mThreeVector.setZ(az);}
+void AliFmLorentzVector<T>::SetZ(T az) {mThreeVector.SetZ(az);}
 
 template<class T>
-void AliFmLorentzVector<T>::setT(T at) {mX4 = at;}
+void AliFmLorentzVector<T>::SetT(T at) {mX4 = at;}
 
 template<class T>
-void AliFmLorentzVector<T>::setE(T ae) {mX4 = ae;}
+void AliFmLorentzVector<T>::SetE(T ae) {mX4 = ae;}
 
 template<class T>
 T AliFmLorentzVector<T>::x() const {return mThreeVector.x();}
@@ -437,7 +437,7 @@ AliFmLorentzVector<T>::boost(const AliFmLorentzVector<X>& pframe) const
 
 template<class T>
 template<class X>
-void AliFmLorentzVector<T>::setVect(const AliFmThreeVector<X>& v)
+void AliFmLorentzVector<T>::SetVect(const AliFmThreeVector<X>& v)
 {
     mThreeVector = v;
 }
@@ -540,13 +540,13 @@ AliFmLorentzVector<T>::boost(const AliFmLorentzVector<double>& pframe) const
 }
 
 template<class T>
-void AliFmLorentzVector<T>::setVect(const AliFmThreeVector<float>& v)
+void AliFmLorentzVector<T>::SetVect(const AliFmThreeVector<float>& v)
 {
     mThreeVector = v;
 }
 
 template<class T>
-void AliFmLorentzVector<T>::setVect(const AliFmThreeVector<double>& v)
+void AliFmLorentzVector<T>::SetVect(const AliFmThreeVector<double>& v)
 {
     mThreeVector = v;
 }
@@ -721,10 +721,10 @@ istream&  operator>>(istream& is, AliFmLorentzVector<T>& v)
 {
     T  x, y, z, t;
     is >> x >> y >> z >> t;
-    v.setX(x);
-    v.setY(y);
-    v.setZ(z);
-    v.setT(t);
+    v.SetX(x);
+    v.SetY(y);
+    v.SetZ(z);
+    v.SetT(t);
     return is;
 }
 

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFmPhysicalHelix.cxx b/PWG2/FEMTOSCOPY/AliFemto/AliFmPhysicalHelix.cxx
index f6fb0acf2bf930d44a5c03fbfb6da7d802d9701f..5c0b65529b2011b345681a7a58b7fd4d9207b198 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFmPhysicalHelix.cxx
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFmPhysicalHelix.cxx
@@ -88,18 +88,18 @@ double AliFmPhysicalHelix::GeometricSignedDistance(double x, double y)
     // Geometric signed distance
     double thePath = this->PathLength(x,y);
     AliFmThreeVector<double> tDCA2dPosition = this->At(thePath);
-    tDCA2dPosition.setZ(0);
+    tDCA2dPosition.SetZ(0);
     AliFmThreeVector<double> position(x,y,0);
     AliFmThreeVector<double> tDCAVec = (tDCA2dPosition-position);
     AliFmThreeVector<double> momVec;
     // Deal with straight tracks
     if (this->fSingularity) {
        momVec = this->At(1)- this->At(0);
-       momVec.setZ(0);
+       momVec.SetZ(0);
     }
     else {
        momVec = this->MomentumAt(thePath,1./tesla); // Don't care about Bmag.  Helicity is what matters.
-       momVec.setZ(0);
+       momVec.SetZ(0);
     }
     
     double cross = tDCAVec.x()*momVec.y() - tDCAVec.y()*momVec.x();

diff --git a/PWG2/FEMTOSCOPY/AliFemto/AliFmThreeVector.h b/PWG2/FEMTOSCOPY/AliFemto/AliFmThreeVector.h
index 0e6a6543fd382bc055431a25d544e2afafc48981..a6b5b0110cc19eeca85ed6ca1e5b006d259f79df 100644 (file)
--- a/PWG2/FEMTOSCOPY/AliFemto/AliFmThreeVector.h
+++ b/PWG2/FEMTOSCOPY/AliFemto/AliFmThreeVector.h
@@ -129,14 +129,14 @@ public:
     AliFmThreeVector<T>& operator=(const AliFmThreeVector<double>&);
 #endif
     
-    void setX(T);
-    void setY(T);
-    void setZ(T);
-
-    void setPhi(T);
-    void setTheta(T);
-    void setMag(T);
-    void setMagnitude(T);
+    void SetX(T);
+    void SetY(T);
+    void SetZ(T);
+
+    void SetPhi(T);
+    void SetTheta(T);
+    void SetMag(T);
+    void SetMagnitude(T);
     
     T   x()                        const;
     T   y()                        const;
@@ -156,7 +156,7 @@ public:
     T&  operator() (size_t);
     T&  operator[] (size_t);
     
-    T   massHypothesis(T mass)     const;
+    T   MassHypothesis(T mass)     const;
     
     AliFmThreeVector<T>  unit()       const;
     AliFmThreeVector<T>  orthogonal() const;
@@ -203,8 +203,8 @@ public:
     AliFmThreeVector<T>& operator+= (const AliFmThreeVector<double>&);
     AliFmThreeVector<T>& operator-= (const AliFmThreeVector<double>&);
 #endif
-  int             valid(double world = 1.e+5) const;
-    int               bad(double world = 1.e+5) const;
+    int             Valid(double world = 1.e+5) const;
+    int               Bad(double world = 1.e+5) const;
 protected:
     T    mX1, mX2, mX3;
 #ifdef __ROOT__
@@ -223,16 +223,16 @@ template<class T>
 inline AliFmThreeVector<T>::~AliFmThreeVector() {/* nop */}
 
 template<class T>
-inline void AliFmThreeVector<T>::setX(T ax) {mX1 = ax;}
+inline void AliFmThreeVector<T>::SetX(T ax) {mX1 = ax;}
 
 template<class T>
-inline void AliFmThreeVector<T>::setY(T ay) {mX2 = ay;}
+inline void AliFmThreeVector<T>::SetY(T ay) {mX2 = ay;}
 
 template<class T>
-inline void AliFmThreeVector<T>::setZ(T az) {mX3 = az;}
+inline void AliFmThreeVector<T>::SetZ(T az) {mX3 = az;}
 
 template<class T>
-void AliFmThreeVector<T>::setPhi(T aangle)
+void AliFmThreeVector<T>::SetPhi(T aangle)
 {
     double  r = magnitude();
     double th = theta();
@@ -242,7 +242,7 @@ void AliFmThreeVector<T>::setPhi(T aangle)
 }
 
 template <class T>
-void AliFmThreeVector<T>::setTheta(T aangle)
+void AliFmThreeVector<T>::SetTheta(T aangle)
 {
     double r  = magnitude();
     double ph = phi();
@@ -253,7 +253,7 @@ void AliFmThreeVector<T>::setTheta(T aangle)
 }
 
 template <class T>
-void AliFmThreeVector<T>::setMagnitude(T r)
+void AliFmThreeVector<T>::SetMagnitude(T r)
 {
     double th = theta();
     double ph = phi();
@@ -264,9 +264,9 @@ void AliFmThreeVector<T>::setMagnitude(T r)
 }
 
 template <class T>
-void AliFmThreeVector<T>::setMag(T amag)
+void AliFmThreeVector<T>::SetMag(T amag)
 {
-    setMagnitude(amag);
+    SetMagnitude(amag);
 }
 
 template<class T>
@@ -315,7 +315,7 @@ inline AliFmThreeVector<T> AliFmThreeVector<T>::unit() const
 }
 
 template <class T>
-T AliFmThreeVector<T>::massHypothesis(T mass) const
+T AliFmThreeVector<T>::MassHypothesis(T mass) const
 {
     return ::sqrt((*this)*(*this) + mass*mass);
 }
@@ -734,11 +734,11 @@ AliFmThreeVector<T>::pseudoProduct(const AliFmThreeVector<double>& v) const
 #endif  // ST_NO_MEMBER_TEMPLATES
 template<class T>
 inline int
-AliFmThreeVector<T>::valid(double world) const  {return !bad(world);}
+AliFmThreeVector<T>::Valid(double world) const  {return !Bad(world);}
 
 template<class T>
 inline int
-AliFmThreeVector<T>::bad(double world) const
+AliFmThreeVector<T>::Bad(double world) const
 {
   for (int i=0;i<3;i++) {
          if (!finite((&mX1)[i])      ) return 10+i;            
@@ -849,9 +849,9 @@ istream&  operator>>(istream& is, AliFmThreeVector<T>& v)
 {
     T  x, y, z;
     is >> x >> y >> z;
-    v.setX(x);
-    v.setY(y);
-    v.setZ(z);
+    v.SetX(x);
+    v.SetY(y);
+    v.SetZ(z);
     return is;
 }
 #endif /* ! __CINT__ */