Merge pull request cms-sw#21166 from davidlange6/clangTidyCleanT4_Cle…

…anup1

another pass through the clang check cleanup

Alignment/CommonAlignment/interface/AlignableBeamSpot.h

@@ -24,64 +24,64 @@ class AlignableBeamSpot : public Alignable
   AlignableBeamSpot();
 
   /// Destructor
-  virtual ~AlignableBeamSpot();
+  ~AlignableBeamSpot() override;
 
   /// Add a component and set its mother to this alignable.
   /// (Note: The component will be adopted, e.g. later deleted.)
   /// Also find average position of this composite from its modules' positions.
-  virtual void addComponent( Alignable* component ) {}
+  void addComponent( Alignable* component ) override {}
 
   /// Return vector of direct components
-  virtual Alignables components() const { return std::vector<Alignable*>(); }
+  Alignables components() const override { return std::vector<Alignable*>(); }
 
   /// Provide all components, subcomponents etc. (cf. description in base class)
-  virtual void recursiveComponents(Alignables &result) const { }
+  void recursiveComponents(Alignables &result) const override { }
 
   /// Move with respect to the global reference frame
-  virtual void move( const GlobalVector& displacement );
+  void move( const GlobalVector& displacement ) override;
 
   /// Rotation interpreted in global reference frame
-  virtual void rotateInGlobalFrame( const RotationType& rotation );
+  void rotateInGlobalFrame( const RotationType& rotation ) override;
 
   /// Set the AlignmentPositionError and, if (propagateDown), to all components
-  virtual void setAlignmentPositionError(const AlignmentPositionError &ape, bool propagateDown);
+  void setAlignmentPositionError(const AlignmentPositionError &ape, bool propagateDown) override;
 
   /// Add (or set if it does not exist yet) the AlignmentPositionError,
   /// if (propagateDown), add also to all components
-  virtual void addAlignmentPositionError(const AlignmentPositionError &ape, bool propagateDown);
+  void addAlignmentPositionError(const AlignmentPositionError &ape, bool propagateDown) override;
 
   /// Add (or set if it does not exist yet) the AlignmentPositionError
   /// resulting from a rotation in the global reference frame,
   /// if (propagateDown), add also to all components
-  virtual void addAlignmentPositionErrorFromRotation(const RotationType &rot, bool propagateDown);
+  void addAlignmentPositionErrorFromRotation(const RotationType &rot, bool propagateDown) override;
 
   /// Add the AlignmentPositionError resulting from local rotation (if this Alignable is a Det) and,
   /// if (propagateDown), add to all the components of the composite
-  virtual void addAlignmentPositionErrorFromLocalRotation( const RotationType& rotation,
-							   bool propagateDown );
+  void addAlignmentPositionErrorFromLocalRotation( const RotationType& rotation,
+							   bool propagateDown ) override;
 
   /// Return the alignable type identifier
-  virtual StructureType alignableObjectId() const { return align::BeamSpot; }
+  StructureType alignableObjectId() const override { return align::BeamSpot; }
 
   /// Recursive printout of alignable structure
-  virtual void dump() const;
+  void dump() const override;
 
   /// Return vector of alignment data
-  virtual Alignments* alignments() const;
+  Alignments* alignments() const override;
 
   /// Return vector of alignment errors
-  virtual AlignmentErrorsExtended* alignmentErrors() const;
+  AlignmentErrorsExtended* alignmentErrors() const override;
 
   /// alignment position error - for checking only, otherwise use alignmentErrors() above!  
   const AlignmentPositionError* alignmentPositionError() const { return theAlignmentPositionError;}
 
   /// Return surface deformations
-  virtual int surfaceDeformationIdPairs(std::vector<std::pair<int,SurfaceDeformation*> > &) const { return 0; }
+  int surfaceDeformationIdPairs(std::vector<std::pair<int,SurfaceDeformation*> > &) const override { return 0; }
 
   /// do no use, for compatibility only
-  virtual void setSurfaceDeformation(const SurfaceDeformation*, bool);
+  void setSurfaceDeformation(const SurfaceDeformation*, bool) override;
   /// do no use, for compatibility only
-  virtual void addSurfaceDeformation(const SurfaceDeformation*, bool);
+  void addSurfaceDeformation(const SurfaceDeformation*, bool) override;
 
   /// initialize the alignable with the passed beam spot parameters 
   void initialize(double x, double y, double z,

Alignment/CommonAlignment/interface/AlignableDetOrUnitPtr.h

@@ -33,24 +33,24 @@ class AlignableDetOrUnitPtr
 
   /// Constructor from AlignableBeamSpot* (non-explicit: for automatic conversions)
   inline AlignableDetOrUnitPtr(AlignableBeamSpot *aliBeamSpot)
-    : theAliBeamSpot(aliBeamSpot), theAliDet(0), theAliDetUnit(0) {}
+    : theAliBeamSpot(aliBeamSpot), theAliDet(nullptr), theAliDetUnit(nullptr) {}
 
   /// Constructor from AlignableDet* (non-explicit: for automatic conversions)
   inline AlignableDetOrUnitPtr(AlignableDet *aliDet)
-    : theAliBeamSpot(0), theAliDet(aliDet), theAliDetUnit(0) {}
+    : theAliBeamSpot(nullptr), theAliDet(aliDet), theAliDetUnit(nullptr) {}
 
   /// Constructor from AlignableDetUnit* (non-explicit: for automatic conversions)
   inline AlignableDetOrUnitPtr(AlignableDetUnit *aliDetUnit) 
-    : theAliBeamSpot(0), theAliDet(0), theAliDetUnit(aliDetUnit) {}
+    : theAliBeamSpot(nullptr), theAliDet(nullptr), theAliDetUnit(aliDetUnit) {}
   /// Non-virtual destructor: do not use as base class
   inline ~AlignableDetOrUnitPtr() {}
 
   inline AlignableDetOrUnitPtr& operator = (AlignableBeamSpot* aliBeamSpot) {
-    theAliBeamSpot = aliBeamSpot; theAliDet = 0; theAliDetUnit = 0; return *this;}
+    theAliBeamSpot = aliBeamSpot; theAliDet = nullptr; theAliDetUnit = nullptr; return *this;}
   inline AlignableDetOrUnitPtr& operator = (AlignableDet* aliDet) {
-    theAliBeamSpot = 0; theAliDet = aliDet; theAliDetUnit = 0; return *this;}
+    theAliBeamSpot = nullptr; theAliDet = aliDet; theAliDetUnit = nullptr; return *this;}
   inline AlignableDetOrUnitPtr& operator = (AlignableDetUnit* aliDetUnit) {
-    theAliBeamSpot = 0; theAliDet = 0; theAliDetUnit = aliDetUnit; return *this;}
+    theAliBeamSpot = nullptr; theAliDet = nullptr; theAliDetUnit = aliDetUnit; return *this;}
   // Default operator= and default copy constructor are fine, no need to code them here.
 
   // conversions to Alignable* etc.

Alignment/CommonAlignment/interface/AlignableNavigator.h

@@ -28,10 +28,10 @@ class AlignableNavigator
 public:
 
   /// Constructor from one or two Alignables
-  explicit AlignableNavigator(Alignable* tracker, Alignable* muon = 0);
+  explicit AlignableNavigator(Alignable* tracker, Alignable* muon = nullptr);
 
   /// Constructor from one or two Alignables
-  explicit AlignableNavigator(AlignableExtras* extras, Alignable* tracker, Alignable* muon = 0);
+  explicit AlignableNavigator(AlignableExtras* extras, Alignable* tracker, Alignable* muon = nullptr);
 
   /// Constructor from list of Alignbable
   explicit AlignableNavigator( const std::vector<Alignable*>& alignables );

Alignment/CommonAlignment/interface/SurveyResidual.h

@@ -83,7 +83,7 @@ class SurveyResidual
 
 bool SurveyResidual::valid() const
 {
-  return theMother != 0;
+  return theMother != nullptr;
 }
 
 #endif

Alignment/CommonAlignment/plugins/FilterOutLowPt.cc

@@ -30,13 +30,13 @@
 class FilterOutLowPt : public edm::stream::EDFilter<> {
 public:
   explicit FilterOutLowPt( const edm::ParameterSet & );
-  ~FilterOutLowPt();
+  ~FilterOutLowPt() override;
 
   static void fillDescriptions(edm::ConfigurationDescriptions&);
 
 private:
   virtual void beginJob() ;
-  virtual bool filter ( edm::Event &, const edm::EventSetup&); 
+  bool filter ( edm::Event &, const edm::EventSetup&) override; 
   virtual void endJob() ;
 
   // ----------member data --------

Alignment/CommonAlignment/src/Alignable.cc

@@ -21,9 +21,9 @@ Alignable::Alignable(align::ID id, const AlignableSurface& surf):
   theId(id),    // (finally get rid of one of the IDs!)
   theSurface(surf),
   theCachedSurface(surf),
-  theAlignmentParameters(0),
-  theMother(0),
-  theSurvey(0)
+  theAlignmentParameters(nullptr),
+  theMother(nullptr),
+  theSurvey(nullptr)
 {
 }
 
@@ -33,9 +33,9 @@ Alignable::Alignable(align::ID id, const RotationType& rot):
   theId(id),
   theSurface(PositionType(), rot),
   theCachedSurface(PositionType(), rot),
-  theAlignmentParameters(0),
-  theMother(0),
-  theSurvey(0)
+  theAlignmentParameters(nullptr),
+  theMother(nullptr),
+  theSurvey(nullptr)
 {
 }
 

Alignment/CommonAlignment/src/AlignableBeamSpot.cc

@@ -20,7 +20,7 @@
 //__________________________________________________________________________________________________
 AlignableBeamSpot::AlignableBeamSpot() : 
   Alignable( AlignableBeamSpot::detId().rawId(), AlignableSurface() ), 
-  theAlignmentPositionError(0),
+  theAlignmentPositionError(nullptr),
   theInitializedFlag(false)
 {
 

Alignment/CommonAlignment/src/AlignableDetOrUnitPtr.cc

@@ -38,6 +38,6 @@ const AlignmentPositionError* AlignableDetOrUnitPtr::alignmentPositionError() co
   if (theAliBeamSpot)     return theAliBeamSpot->alignmentPositionError();
   else if (theAliDet)     return theAliDet->alignmentPositionError();
   else if (theAliDetUnit) return theAliDetUnit->alignmentPositionError();
-  else                    return 0;
+  else                    return nullptr;
 }
 

Alignment/CommonAlignment/src/AlignableNavigator.cc

@@ -103,7 +103,7 @@ AlignableDetOrUnitPtr AlignableNavigator::alignableFromDetId( const DetId& detid
   throw cms::Exception("BadLogic") 
     << "[AlignableNavigator::alignableDetFromDetId] DetId " << detid.rawId() << " not found";
 
-  return static_cast<AlignableDet*>(0);
+  return static_cast<AlignableDet*>(nullptr);
 }
 
 //_____________________________________________________________________________

Alignment/CommonAlignment/src/MisalignmentScenarioBuilder.cc

@@ -9,7 +9,7 @@
 #include <string>
 #include <iostream>
 #include <sstream>
-#include <stdlib.h>
+#include <cstdlib>
 
 // Framework
 #include "FWCore/Utilities/interface/Exception.h"
@@ -108,7 +108,7 @@ void MisalignmentScenarioBuilder::decodeMovements_(const edm::ParameterSet &pSet
     // Apply movements to components
     std::vector<std::string> parameterSetNames;
     localParameters.getParameterSetNames( parameterSetNames, true );
-    if ( (*iter)->size() > 0 && parameterSetNames.size() > 0 )
+    if ( (*iter)->size() > 0 && !parameterSetNames.empty() )
       // Has components and remaining parameter sets
       this->decodeMovements_( localParameters, (*iter)->components() );
   }

Alignment/CommonAlignmentAlgorithm/interface/AlignmentIORoot.h

@@ -17,50 +17,50 @@ class AlignmentIORoot : public AlignmentIO
 {
 
   public:
-  virtual ~AlignmentIORoot() = default;
+  ~AlignmentIORoot() override = default;
   /// write AlignmentParameters 
   void writeAlignmentParameters (const align::Alignables& alivec, 
-				 const char* filename, int iter, bool validCheck, int& ierr );
+				 const char* filename, int iter, bool validCheck, int& ierr ) override;
 
   /// read AlignmentParameters 
   align::Parameters readAlignmentParameters (const align::Alignables& alivec, 
-				      const char* filename, int iter, int& ierr);
+				      const char* filename, int iter, int& ierr) override;
 
   /// write RigidBodyAlignmentParameters as applied on top of original positions
   void writeOrigRigidBodyAlignmentParameters (const align::Alignables& alivec, const char* filename,
-					      int iter, bool validCheck, int& ierr);
+					      int iter, bool validCheck, int& ierr) override;
 
   /// write Correlations 
   void writeCorrelations (const align::Correlations& cormap, 
-			  const char* filename, int iter, bool validCheck, int& ierr);
+			  const char* filename, int iter, bool validCheck, int& ierr) override;
 
   /// read Correlations 
   align::Correlations readCorrelations (const align::Alignables& alivec, 
-				 const char* filename, int iter, int& ierr);
+				 const char* filename, int iter, int& ierr) override;
 
   /// write Alignable current absolute positions 
   void writeAlignableAbsolutePositions (const align::Alignables& alivec, 
-					const char* filename, int iter, bool validCheck, int& ierr);
+					const char* filename, int iter, bool validCheck, int& ierr) override;
 
   /// read Alignable current absolute positions 
   AlignablePositions readAlignableAbsolutePositions (const align::Alignables& alivec,
-						     const char* filename, int iter, int& ierr);
+						     const char* filename, int iter, int& ierr) override;
 
   /// write Alignable original (before misalignment) absolute positions 
   void writeAlignableOriginalPositions (const align::Alignables& alivec, 
-					const char* filename, int iter, bool validCheck, int& ierr);
+					const char* filename, int iter, bool validCheck, int& ierr) override;
 
   /// read Alignable original (before misalignment) absolute positions 
   AlignablePositions readAlignableOriginalPositions (const align::Alignables& alivec,
-						     const char* filename, int iter, int& ierr);
+						     const char* filename, int iter, int& ierr) override;
 
   /// write Alignable relative positions (shift,rotation) 
   void writeAlignableRelativePositions (const align::Alignables& alivec, 
-					const char* filename, int iter, bool validCheck, int& ierr);
+					const char* filename, int iter, bool validCheck, int& ierr) override;
 
   /// read Alignable relative positions (shift,rotation) 
   AlignableShifts readAlignableRelativePositions (const align::Alignables& alivec,
-						  const char* filename, int iter, int& ierr);
+						  const char* filename, int iter, int& ierr) override;
 
 };
 

Alignment/CommonAlignmentMonitor/plugins/AlignmentMonitorAsAnalyzer.cc

@@ -66,15 +66,15 @@
 class AlignmentMonitorAsAnalyzer : public edm::EDAnalyzer {
    public:
       explicit AlignmentMonitorAsAnalyzer(const edm::ParameterSet&);
-      ~AlignmentMonitorAsAnalyzer();
+      ~AlignmentMonitorAsAnalyzer() override;
 
       typedef std::pair<const Trajectory*, const reco::Track*> ConstTrajTrackPair; 
       typedef std::vector<ConstTrajTrackPair> ConstTrajTrackPairCollection;
 
    private:
-      virtual void beginJob() override;
-      virtual void analyze(const edm::Event&, const edm::EventSetup&) override;
-      virtual void endJob() override;
+      void beginJob() override;
+      void analyze(const edm::Event&, const edm::EventSetup&) override;
+      void endJob() override;
 
       // ----------member data ---------------------------
       edm::InputTag m_tjTag;
@@ -103,9 +103,9 @@ class AlignmentMonitorAsAnalyzer : public edm::EDAnalyzer {
 AlignmentMonitorAsAnalyzer::AlignmentMonitorAsAnalyzer(const edm::ParameterSet& iConfig)
    : m_tjTag(iConfig.getParameter<edm::InputTag>("tjTkAssociationMapTag"))
    , m_aliParamStoreCfg(iConfig.getParameter<edm::ParameterSet>("ParameterStore"))
-   , m_alignableTracker(NULL)
-   , m_alignableMuon(NULL)
-   , m_alignmentParameterStore(NULL)
+   , m_alignableTracker(nullptr)
+   , m_alignableMuon(nullptr)
+   , m_alignmentParameterStore(nullptr)
 {
    std::vector<std::string> monitors = iConfig.getUntrackedParameter<std::vector<std::string> >( "monitors" );