'Vectors should be passed by const reference, not by value.' (TrigJPsiTools-00-01-07)

	* Tagging TrigJPsiTools-00-01-07.
	* Vectors should be passed by const reference, not by value.
	* Tagging TrigJPsiTools-00-01-06.
	* clang warnings: Unused members.
	* Tagging TrigJPsiTools-00-01-05.
	* Comply with ATLAS naming conventions.

Trigger/TrigTools/TrigJPsiTools/TrigJPsiTools/MakeDiMuonsTool.h

@@ -33,14 +33,18 @@ class MakeDiMuonsTool
   bool initializeTools();
   void initializeMembers();
 
-  void setProbes(std::vector<const CaloCluster*> CombinedCollection, std::vector<int> roi);
-  void setProbes(std::vector< const TrigMuonEFTrack*> trksIn, std::vector<int> roi);
-  void setProbes(std::vector< const Rec::TrackParticle* > trksIn);
-  void setProbes(const TrigInDetTrackCollection* trksIn);
+  void setProbes(const std::vector<const CaloCluster*>& CombinedCollection,
+                 const std::vector<int>& roi);
+  void setProbes(const std::vector< const TrigMuonEFTrack*>& trksIn,
+                 const std::vector<int>& roi);
+  void setProbes(const std::vector< const Rec::TrackParticle* >& trksIn);
+  void setProbes(const TrigInDetTrackCollection* trigCollection);
 
   void setTags(const Analysis::MuonContainer* muonsIn);
-  void setTags(std::vector<const TrigMuonEFCbTrack*> muonsIn, std::vector<int> roi);
-  void setTags(std::vector< const egamma*> trksIn, std::vector<int> roi);
+  void setTags(const std::vector<const TrigMuonEFCbTrack*>& muonsIn,
+               const std::vector<int>& roi);
+  void setTags(const std::vector< const egamma*>& trksIn,
+               const std::vector<int>& roi);
 
   void doTagAndProbe(bool doTagAndProbe);
   void useTrigger(bool useTrigger);
@@ -51,11 +55,12 @@ class MakeDiMuonsTool
   void setTrackMass(double muonmass);
   void setUpperInvMassLimit(double upperlimit);
   void setLowerInvMassLimit(double lowerlimit);
-  void makePairs(std::vector<Wrapper::MuonTrack*> Tracks);
-  void makePairs(std::vector<Wrapper::MuonTrack*> taggedTracks,std::vector<Wrapper::MuonTrack*> probedTracks);
+  void makePairs(const std::vector<Wrapper::MuonTrack*>& Tracks);
+  void makePairs(const std::vector<Wrapper::MuonTrack*>& taggedTracks,std::vector<Wrapper::MuonTrack*> probedTracks);
   std::vector<DiMuonTool*> execute();
-  void TagMuons( std::vector< const TrigMuonEFCbTrack* > m_CombinedCollection, std::vector<int> roi );
-  void TagMuons( const Analysis::MuonContainer* m_MuonCollection );
+  void TagMuons( const std::vector< const TrigMuonEFCbTrack* >& combinedCollection,
+                 const std::vector<int>& roi );
+  void TagMuons( const Analysis::MuonContainer* muonCollection );
 
   bool isTriggeredEF(const Rec::TrackParticle* track, std::string chainName) const;
   bool isTriggeredL2(const Rec::TrackParticle* track, std::string chainName) const;
@@ -70,10 +75,10 @@ class MakeDiMuonsTool
   double m_tagetacut;
   bool   m_TagAndProbe;
 
-  bool   m_runOnline;
+  //bool   m_runOnline;
 
   bool   m_useTrigger;
-  double m_invmass;
+  //double m_invmass;
   double m_trkmass;
   double m_upperlimit;
   double m_lowerlimit;

Trigger/TrigTools/TrigJPsiTools/TrigJPsiTools/MuonTrackAdder.h

@@ -24,19 +24,19 @@ class MuonTrackAdder{
 
   virtual bool muonAdder( Wrapper::MuonTrack* t ) {
     if( t ){
-	mtracks.push_back(t); 
+	m_tracks.push_back(t); 
 	return true; 
     }
     else return false;
   }
 
-  const std::vector< Wrapper::MuonTrack* >& tracks() const { return mtracks; }
+  const std::vector< Wrapper::MuonTrack* >& tracks() const { return m_tracks; }
 
-  virtual void clear() { for(unsigned i=0; i--; ) delete mtracks[i]; mtracks.clear(); } 
+  virtual void clear() { for(unsigned i=0; i--; ) delete m_tracks[i]; m_tracks.clear(); } 
 
 protected:
   
-  std::vector<Wrapper::MuonTrack*> mtracks;
+  std::vector<Wrapper::MuonTrack*> m_tracks;
 
 };
 

Trigger/TrigTools/TrigJPsiTools/TrigJPsiTools/MuonTrackSelector.h

@@ -38,10 +38,10 @@ class MuonTrackSelector : public MuonTrackAdder {
 
   virtual void cleanup() { 
 
-    for (int i=mtracks.size(); i--; ){
-      delete mtracks[i];
+    for (int i=m_tracks.size(); i--; ){
+      delete m_tracks[i];
     }     
-    mtracks.clear(); 
+    m_tracks.clear(); 
 
   }
 

Trigger/TrigTools/TrigJPsiTools/src/MakeDiMuonsTool.cxx

@@ -79,24 +79,26 @@ void MakeDiMuonsTool::initializeMembers()
 
 // input tracks, cuts or turn on tag-and-probe
 
-void MakeDiMuonsTool::setProbes(std::vector<const TrigMuonEFTrack*> trksIn, std::vector<int> roi) {
+void MakeDiMuonsTool::setProbes(const std::vector<const TrigMuonEFTrack*>& trksIn,
+                                const std::vector<int>& roi) {
   for( unsigned i=0; i<trksIn.size(); ++i ) m_selectaProbe.muonSelector( trksIn[i], NULL, roi[i] );
   m_tracks = m_selectaProbe.tracks();
 }
 
-void MakeDiMuonsTool::setProbes(std::vector<const CaloCluster*> CombinedCollection, std::vector<int> roi) {
+void MakeDiMuonsTool::setProbes(const std::vector<const CaloCluster*>& CombinedCollection,
+                                const std::vector<int>& roi) {
   for( unsigned i=0; i<CombinedCollection.size(); ++i ) m_selectaProbe.muonSelector( CombinedCollection[i], roi[i] );
   m_tracks = m_selectaProbe.tracks();
 }
 
-void MakeDiMuonsTool::setProbes(std::vector<const Rec::TrackParticle*> trksIn) {
+void MakeDiMuonsTool::setProbes(const std::vector<const Rec::TrackParticle*>& trksIn) {
   for( unsigned i=0; i<trksIn.size(); ++i ) m_selectaProbe.muonSelector( trksIn[i] );
   m_tracks = m_selectaProbe.tracks();
 }
 
-void MakeDiMuonsTool::setProbes( const TrigInDetTrackCollection* m_TrigCollection ){ 
-  TrigInDetTrackCollection::const_iterator tIt = m_TrigCollection->begin();
-  TrigInDetTrackCollection::const_iterator tLast = m_TrigCollection->end();
+void MakeDiMuonsTool::setProbes( const TrigInDetTrackCollection* trigCollection ){ 
+  TrigInDetTrackCollection::const_iterator tIt = trigCollection->begin();
+  TrigInDetTrackCollection::const_iterator tLast = trigCollection->end();
   while(tIt != tLast){
     m_selectaProbe.muonSelector( *tIt );
     tIt++;
@@ -111,7 +113,8 @@ void MakeDiMuonsTool::setTags( const Analysis::MuonContainer* MuonCollection) {
   TagMuons(m_MuonCollection);
 }
 
-void MakeDiMuonsTool::setTags( std::vector< const TrigMuonEFCbTrack* > CombinedCollection, std::vector<int> roiNums ){
+void MakeDiMuonsTool::setTags( const std::vector< const TrigMuonEFCbTrack* >& CombinedCollection,
+                               const std::vector<int>& roiNums ){
   m_CombinedCollection = CombinedCollection;
   TagMuons(m_CombinedCollection, roiNums);
 }
@@ -126,9 +129,9 @@ void MakeDiMuonsTool::setTrackMass(double muonmass) {m_trkmass=muonmass;}
 void MakeDiMuonsTool::setUpperInvMassLimit(double upperlimit) {m_upperlimit=upperlimit;}
 void MakeDiMuonsTool::setLowerInvMassLimit(double lowerlimit) {m_lowerlimit=lowerlimit;}
 
-void MakeDiMuonsTool::TagMuons( const Analysis::MuonContainer* m_MuonCollection ){ 
+void MakeDiMuonsTool::TagMuons( const Analysis::MuonContainer* muonCollection ){ 
   Analysis::MuonContainer::const_iterator muonItr;
-  for (muonItr=m_MuonCollection->begin(); muonItr != m_MuonCollection->end(); ++muonItr)
+  for (muonItr=muonCollection->begin(); muonItr != muonCollection->end(); ++muonItr)
     {
       if ((*muonItr)->hasInDetTrackParticle()) {
 	if (m_TagAndProbe) {
@@ -146,11 +149,12 @@ void MakeDiMuonsTool::TagMuons( const Analysis::MuonContainer* m_MuonCollection
   
 }
 
-void MakeDiMuonsTool::TagMuons( std::vector<const TrigMuonEFCbTrack*> m_CombinedCollection, std::vector<int> roiNums ){
+void MakeDiMuonsTool::TagMuons( const std::vector<const TrigMuonEFCbTrack*>& combinedCollection,
+                                const std::vector<int>& roiNums ){
   std::vector<const TrigMuonEFCbTrack*>::const_iterator tagItr;
-  if (!m_CombinedCollection.empty()){
+  if (!combinedCollection.empty()){
     int i = 0;
-    for (tagItr=m_CombinedCollection.begin(); tagItr!=m_CombinedCollection.end();++tagItr){
+    for (tagItr=combinedCollection.begin(); tagItr!=combinedCollection.end();++tagItr){
       if ( (*tagItr) ){
 	if (m_TagAndProbe){
 	  m_selectaTag.muonSelector( (*tagItr), NULL, roiNums[i] );
@@ -164,7 +168,8 @@ void MakeDiMuonsTool::TagMuons( std::vector<const TrigMuonEFCbTrack*> m_Combined
 
 }
 
-void MakeDiMuonsTool::setTags(std::vector<const egamma*> trksIn, std::vector<int> roi) {
+void MakeDiMuonsTool::setTags(const std::vector<const egamma*>& trksIn,
+                              const std::vector<int>& roi) {
     for(unsigned int i=0; i < trksIn.size(); ++i) {
       if(trksIn[i] && m_TagAndProbe) {
         m_selectaTag.muonSelector(trksIn[i], roi[i]);
@@ -180,7 +185,7 @@ std::vector<DiMuonTool*> MakeDiMuonsTool::execute()
   else makePairs(m_tracks);
   return m_pairs;
 }
-void MakeDiMuonsTool::makePairs(std::vector<Wrapper::MuonTrack*> Tracks){
+void MakeDiMuonsTool::makePairs(const std::vector<Wrapper::MuonTrack*>& Tracks){
   std::vector<Wrapper::MuonTrack*>::const_iterator track1;
   std::vector<Wrapper::MuonTrack*>::const_iterator track2;
   if(Tracks.size()>=2){
@@ -209,7 +214,7 @@ void MakeDiMuonsTool::makePairs(std::vector<Wrapper::MuonTrack*> Tracks){
   }
 } //Muons(+,-)
 
-void MakeDiMuonsTool::makePairs(std::vector<Wrapper::MuonTrack*> taggedTracks,std::vector<Wrapper::MuonTrack*> probedTracks) {
+void MakeDiMuonsTool::makePairs(const std::vector<Wrapper::MuonTrack*>& taggedTracks,std::vector<Wrapper::MuonTrack*> probedTracks) {
   //std::cout << "JPSI TOOLS -- makePair sizes - tag: " << taggedTracks.size() << " and probe:" << probedTracks.size() << std::endl;
   std::vector<Wrapper::MuonTrack*>::const_iterator tagItr;
   std::vector<Wrapper::MuonTrack*>::const_iterator probeItr;