cleanup: unused arguments commented out

CMakeLists.txt

@@ -44,12 +44,17 @@ set (CMAKE_CXX_EXTENSIONS OFF)
 add_definitions (-DNOCTAssert)
 
 add_compile_options (-Wall)
-add_compile_options (-funroll-loops -fstrict-aliasing)
+add_compile_options (-Wunused)
+add_compile_options (-Wextra)
+#add_compile_options (-Werror)
+
+add_compile_options (-funroll-loops)
+add_compile_options (-fstrict-aliasing)
 
 option (USE_STATIC_LIBRARIES "Link with static libraries if available" ON)
 if (NOT ${USE_STATIC_LIBRARIES})
     add_compile_options (-fPIE -fPIC)
-    set (CMAKE_EXE_LINKER_FLAGS  "${CMAKE_EXE_LINKER_FLAGS} -pie")
+    add_link_options (-pie)
 endif ()
 
 # compiler dependent flags
@@ -62,7 +67,6 @@ if ( ${CMAKE_CXX_COMPILER_ID} STREQUAL "Intel" )
     endif ()
 
 elseif (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
-    add_compile_options (-Werror)
     add_compile_options (-Wsign-compare)
     add_compile_options (-Wunused-variable)
     add_compile_options (-Warray-bounds)

CMakeModules/FindH5Hut.cmake

@@ -48,4 +48,5 @@ ENDIF (HAVE_API2_FUNCTIONS)
 # mode:cmake
 # cmake-tab-width: 4
 # indent-tabs-mode:nil
+# require-final-newline: nil
 # End:

src/AbstractObjects/Object.cpp

@@ -91,7 +91,7 @@ Object *Object::makeTemplate
 }
 
 
-Object *Object::makeInstance(const string &name, Statement &, const Parser *) {
+Object *Object::makeInstance(const string &/*name*/, Statement &, const Parser *) {
     throw ParseError("Object::makeInstance()", "Object \"" + getOpalName() +
                      "\" cannot be called as a macro.");
 }

src/AbstractObjects/Table.cpp

@@ -33,7 +33,7 @@ Table::~Table() {
 }
 
 
-bool Table::canReplaceBy(Object *newObject) {
+bool Table::canReplaceBy(Object */*newObject*/) {
     return false;
 }
 

src/Algorithms/CavityAutophaser.cpp

@@ -261,8 +261,8 @@ std::pair<double, double> CavityAutophaser::optimizeCavityPhase(double initialPh
     return status;
 }
 
-double CavityAutophaser::track(Vector_t R,
-                               Vector_t P,
+double CavityAutophaser::track(Vector_t /*R*/,
+                               Vector_t /*P*/,
                                double t,
                                const double dt,
                                const double phase,

src/Algorithms/Ctunes.cpp

@@ -44,7 +44,7 @@ TUNE_class::~TUNE_class(void)
 
 }
 
-int TUNE_class::lombAnalysis(std::vector<double> &x, std::vector<double> &y, int nhis, double Norm)
+int TUNE_class::lombAnalysis(std::vector<double> &x, std::vector<double> &y, int /*nhis*/, double Norm)
 /*-----------------------------------------------------------------------------
  *  Launch Lomb analysis and plot results
  *  =======================================
@@ -143,7 +143,7 @@ int TUNE_class::lombAnalysis(std::vector<double> &x, std::vector<double> &y, int
 }
 
 
-int TUNE_class::lombAnalysis(double *x, double *y, int Ndat, int nhis)
+int TUNE_class::lombAnalysis(double *x, double *y, int Ndat, int /*nhis*/)
 /*-----------------------------------------------------------------------------
  *  Launch Lomb analysis and plot results
  *  =======================================

src/Algorithms/Hamiltonian.cpp

@@ -27,7 +27,7 @@ Hamiltonian::series_t Hamiltonian::drift(const double& gamma0)
 
 Hamiltonian::series_t Hamiltonian::rbend(double& beta0,
                             double& gamma0,
-                            double& q,
+                            double& /*q*/,
                             double& h,
                             double& k0)
 {
@@ -77,8 +77,8 @@ Hamiltonian::series_t Hamiltonian::sbend(const double& gamma0,
 Hamiltonian::series_t Hamiltonian::bendFringe(
                 double& beta0,
                 double& gamma0,
-                double& h,
-                double& k0,
+                double& /*h*/,
+                double& /*k0*/,
                 series_t& ax,
                 series_t& az)
 {
@@ -114,7 +114,7 @@ Hamiltonian::series_t Hamiltonian::bendFringe(
 
 
 Hamiltonian::series_t Hamiltonian::quadrupole(const double& gamma0,
-                                              const double& q,
+                                              const double& /*q*/,
                                               const double& k1)
 {
     double beta0 = this->getBeta_m(gamma0);

src/Algorithms/LieMapper.cpp

@@ -103,11 +103,11 @@ void LieMapper::setMap(const DragtFinnMap<3> &map) {
 }
 
 
-void LieMapper::visitBeamBeam(const BeamBeam &map) {
+void LieMapper::visitBeamBeam(const BeamBeam &/*map*/) {
     // *** MISSING *** Map for beam-beam.
 }
 
-void LieMapper::visitBeamStripping(const BeamStripping &map) {
+void LieMapper::visitBeamStripping(const BeamStripping &/*map*/) {
     // *** MISSING *** Map for beam stripping.
 }
 
@@ -116,7 +116,7 @@ void LieMapper::visitCCollimator(const CCollimator &coll) {
 }
 
 
-void LieMapper::visitComponent(const Component &comp) {
+void LieMapper::visitComponent(const Component &/*comp*/) {
     // *** MISSING *** Map for arbitrary component.
 }
 
@@ -170,7 +170,7 @@ void LieMapper::visitLambertson(const Lambertson &lamb) {
 }
 
 
-void LieMapper::visitMarker(const Marker &marker) {
+void LieMapper::visitMarker(const Marker &/*marker*/) {
     // Do nothing.
 }
 
@@ -222,7 +222,7 @@ void LieMapper::visitPatch(const Patch &patch) {
     applyTransform(patch.getPatch());
 }
 
-void LieMapper::visitProbe(const Probe &prob) {
+void LieMapper::visitProbe(const Probe &/*prob*/) {
     // Do nothing.
 }
 
@@ -298,7 +298,7 @@ void LieMapper::visitRBend(const RBend &bend) {
 }
 
 
-void LieMapper::visitParallelPlate(const ParallelPlate &pplate) {
+void LieMapper::visitParallelPlate(const ParallelPlate &/*pplate*/) {
     // Do nothing.
 }
 
@@ -456,9 +456,9 @@ void LieMapper::applyDrift(double length)
 }
 
 
-void LieMapper::applyEntranceFringe(double angle, double curve,
-                                    const BMultipoleField &field,
-                                    double scale) {
+void LieMapper::applyEntranceFringe(double /*angle*/, double /*curve*/,
+                                    const BMultipoleField &/*field*/,
+                                    double /*scale*/) {
     // *** MISSING *** map terms for entrance fringe.
     //  double hx = scale * field.normal(1);
     //  double ex = hx * tan(angle);
@@ -466,9 +466,9 @@ void LieMapper::applyEntranceFringe(double angle, double curve,
 }
 
 
-void LieMapper::applyExitFringe(double angle, double curve,
-                                const BMultipoleField &field,
-                                double scale) {
+void LieMapper::applyExitFringe(double /*angle*/, double /*curve*/,
+                                const BMultipoleField &/*field*/,
+                                double /*scale*/) {
     // *** MISSING *** map terms for exit fringe.
     //  double hx = scale * field.normal(1);
     //  double ex = hx * tan(angle);
@@ -476,7 +476,7 @@ void LieMapper::applyExitFringe(double angle, double curve,
 }
 
 
-void LieMapper::applyTransform(const Euclid3D &euclid, double refLength) {
+void LieMapper::applyTransform(const Euclid3D &euclid, double /*refLength*/) {
     if(! euclid.isIdentity()) {
         // build rotation matrix and compute additional drift length.
         double s2 = (euclid.M(0, 2) * euclid.getX() +

src/Algorithms/MapAnalyser.cpp

@@ -134,6 +134,7 @@ void MapAnalyser::linTAnalyze(const fMatrix_t& tMatrix){
         }
     }
 
+    // :FIXME: why commented out? To be removed?
     cfMatrix_t tempM = eigenVecM ;
     //cfMatrix_t tempInvM = eigenVecM ;
     cfMatrix_t tempValM = eigenValM ;
@@ -151,16 +152,10 @@ void MapAnalyser::linTAnalyze(const fMatrix_t& tMatrix){
     invEigenVecM= invertMatrix_m(eigenVecM);
     cfMatrix_t cblocktMatrix = getBlockDiagonal_m(tMatrix, eigenVecM, invEigenVecM);
 
-
-
-    for (int i=0; i<6; i++){
-
-    }
-
     FVector<std::complex<double>, 3> betaTunes, betaTunes2;
     FVector<double, 3> betaTunes3;
 
-
+    // :FIXME: why commented out
     //rearrangeEigen(eigenValM, eigenVecM);
 
     for (int i = 0; i < 3; i++){
@@ -185,6 +180,7 @@ void MapAnalyser::linTAnalyze(const fMatrix_t& tMatrix){
 
         IpplTimings::stopTimer(mapAnalysis_m);
         //TODO: do something with the tunes etc
+        //:FIXME: are there some plans what to do?
     }
 
 }
@@ -515,10 +511,10 @@ MapAnalyser::cfMatrix_t MapAnalyser::invertMatrix_m(const cfMatrix_t& M){
 
 }
 
-
+#if 0
 //TODO Work in progress
 void MapAnalyser::rearrangeEigen_m(cfMatrix_t& eigenVal, cfMatrix_t& EigenVec){
-/*#ifdef PHIL_WRITE
+#ifdef PHIL_WRITE
     std::ofstream out;
     out.open("OUT.txt", std::ios::app);
 #endif
@@ -559,6 +555,6 @@ void MapAnalyser::rearrangeEigen_m(cfMatrix_t& eigenVal, cfMatrix_t& EigenVec){
             }
 
          }
-
-    }*/
+    }
 }
+#endif

src/Algorithms/OrbitThreader.cpp

@@ -142,7 +142,7 @@ void OrbitThreader::execute() {
     processElementRegister();
 }
 
-void OrbitThreader::integrate(const IndexMap::value_t &activeSet, size_t maxSteps, double maxDrift) {
+void OrbitThreader::integrate(const IndexMap::value_t &activeSet, size_t /*maxSteps*/, double maxDrift) {
     static size_t step = 0;
     CoordinateSystemTrafo labToBeamline = itsOpalBeamline_m.getCSTrafoLab2Local();
     const double oldPathLength = pathLength_m;

src/Algorithms/ParallelCyclotronTracker.cpp

@@ -1085,12 +1085,8 @@ void ParallelCyclotronTracker::visitSolenoid(const Solenoid &solenoid) {
  *
  * @param pplate
  */
-void ParallelCyclotronTracker::visitParallelPlate(const ParallelPlate &pplate) {//do nothing
-
-    //*gmsg << "ParallelPlate: not in use in ParallelCyclotronTracker!" << endl;
-
-    //buildupFieldList(startField, endField, elptr);
-
+void ParallelCyclotronTracker::visitParallelPlate(const ParallelPlate &/*pplate*/) {
+    //do nothing
 }
 
 /**
@@ -1607,7 +1603,7 @@ struct adder : public std::unary_function<double, void> {
  * @return
  */
 bool ParallelCyclotronTracker::getTunes(dvector_t &t, dvector_t &r, dvector_t &z,
-                                        int lastTurn, double &nur, double &nuz) {
+                                        int lastTurn, double &/*nur*/, double &/*nuz*/) {
     TUNE_class *tune;
 
     int Ndat = t.size();
@@ -3053,7 +3049,7 @@ void ParallelCyclotronTracker::finalizeTracking_m(dvector_t& Ttime,
 }
 
 
-void ParallelCyclotronTracker::seoMode_m(double& t, const double dt, bool& finishedTurn,
+void ParallelCyclotronTracker::seoMode_m(double& t, const double dt, bool& /*finishedTurn*/,
                                          dvector_t& Ttime, dvector_t& Tdeltr,
                                          dvector_t& Tdeltz, ivector_t& TturnNumber)
 {

src/Algorithms/ParallelSliceTracker.cpp

@@ -170,16 +170,6 @@ void ParallelSliceTracker::printRFPhases() {
         << endl;
 }
 
-void ParallelSliceTracker::applyEntranceFringe(double angle, double curve,
-        const BMultipoleField &field, double scale) {
-}
-
-
-void ParallelSliceTracker::applyExitFringe(double angle, double curve,
-        const BMultipoleField &field, double scale) {
-}
-
-
 void ParallelSliceTracker::execute() {
 
     Inform msg("ParallelSliceTracker", *gmsg);
@@ -473,7 +463,7 @@ void ParallelSliceTracker::dumpStats(long long step) {
 }
 
 
-void ParallelSliceTracker::switchElements(double scaleMargin) {
+void ParallelSliceTracker::switchElements(double /*scaleMargin*/) {
 
     double margin = 1.0;
 

src/Algorithms/ParallelSliceTracker.h

@@ -90,7 +90,6 @@ public:
     virtual void visitSolenoid(const Solenoid &);
     virtual void visitSource(const Source &);
     virtual void visitParallelPlate(const ParallelPlate &);
-
     virtual void execute();
 
     /// Apply the algorithm to a beam line.
@@ -141,10 +140,10 @@ private:
     CoordinateSystemTrafo referenceToLabCSTrafo_m;
 
     // Fringe fields for entrance and exit of magnetic elements.
-    void applyEntranceFringe(double edge, double curve,
-                             const BMultipoleField &field, double scale);
-    void applyExitFringe(double edge, double curve,
-                         const BMultipoleField &field, double scale);
+    void applyEntranceFringe(double /*edge*/, double /*curve*/,
+                             const BMultipoleField &/*field*/, double /*scale*/) {};
+    void applyExitFringe(double /*edge*/, double /*curve*/,
+                         const BMultipoleField &/*field*/, double /*scale*/) {};
 
     void FieldsOutput(double z, double Ex, double Ey, double Ez,
                       double Bx, double By, double Bz);
@@ -188,11 +187,11 @@ inline void ParallelSliceTracker::visitBeamBeam(const BeamBeam &bb) {
     itsOpalBeamline_m.visit(bb, *this, itsBunch_m);
 }
 
-inline void ParallelSliceTracker::visitCCollimator(const CCollimator &coll) {
+inline void ParallelSliceTracker::visitCCollimator(const CCollimator &/*coll*/) {
     // itsOpalBeamline_m.visit(coll, *this, itsBunch_m);
 }
 
-inline void ParallelSliceTracker::visitFlexibleCollimator(const FlexibleCollimator &coll) {
+inline void ParallelSliceTracker::visitFlexibleCollimator(const FlexibleCollimator &/*coll*/) {
     // itsOpalBeamline_m.visit(coll, *this, itsBunch_m);
 }
 
@@ -239,7 +238,7 @@ inline void ParallelSliceTracker::visitProbe(const Probe &prob) {
 }
 
 
-inline void ParallelSliceTracker::visitRBend(const RBend &bend) {
+inline void ParallelSliceTracker::visitRBend(const RBend &/*bend*/) {
     // itsOpalBeamline_m.visit(bend, *this, itsBunch_m);
 }
 
@@ -257,7 +256,7 @@ inline void ParallelSliceTracker::visitRFQuadrupole(const RFQuadrupole &rfq) {
     itsOpalBeamline_m.visit(rfq, *this, itsBunch_m);
 }
 
-inline void ParallelSliceTracker::visitSBend(const SBend &bend) {
+inline void ParallelSliceTracker::visitSBend(const SBend &/*bend*/) {
     // itsOpalBeamline_m.visit(bend, *this, itsBunch_m);
 }
 
@@ -280,18 +279,18 @@ inline void ParallelSliceTracker::visitSource(const Source &source) {
     itsOpalBeamline_m.visit(source, *this, itsBunch_m);
 }
 
-inline void ParallelSliceTracker::visitParallelPlate(const ParallelPlate &pplate) {
+inline void ParallelSliceTracker::visitParallelPlate(const ParallelPlate &/*pplate*/) {
     //do nothing.
 }
 
 inline void ParallelSliceTracker::kickParticles() {
 }
 
-inline void ParallelSliceTracker::updateSpaceOrientation(const bool &move) {
+inline void ParallelSliceTracker::updateSpaceOrientation(const bool &/*move*/) {
     itsBunch_m->calcBeamParameters();
 }
 
-inline void ParallelSliceTracker::kickReferenceParticle(const Vector_t &externalE, const Vector_t &externalB) {
+inline void ParallelSliceTracker::kickReferenceParticle(const Vector_t &/*externalE*/, const Vector_t &/*externalB*/) {
 }
 
 inline void ParallelSliceTracker::writePhaseSpace(const long long step, const double &sposRef) {
@@ -334,7 +333,7 @@ inline void ParallelSliceTracker::writePhaseSpace(const long long step, const do
     }
 }
 
-inline void ParallelSliceTracker::writeLastStepPhaseSpace(const long long step, const double &sposRef) {
+inline void ParallelSliceTracker::writeLastStepPhaseSpace(const long long /*step*/, const double &sposRef) {
     Inform msg("ParallelSliceTracker");
     if(itsBunch_m->isValid_m) {
         Vector_t externalE, externalB;

src/Algorithms/ParallelTTracker.cpp

@@ -995,7 +995,7 @@ void ParallelTTracker::prepareEmission() {
 
 }
 
-void ParallelTTracker::writePhaseSpace(const long long step, bool psDump, bool statDump) {
+void ParallelTTracker::writePhaseSpace(const long long /*step*/, bool psDump, bool statDump) {
     extern Inform *gmsg;
     Inform msg("OPAL ", *gmsg);
     Vector_t externalE, externalB;

src/Algorithms/ThickMapper.cpp

@@ -141,7 +141,7 @@ void ThickMapper::visitLambertson(const Lambertson &lamb) {
 }
 
 
-void ThickMapper::visitMarker(const Marker &marker) {
+void ThickMapper::visitMarker(const Marker &/*marker*/) {
     // Do nothing.
 }
 
@@ -213,7 +213,7 @@ void ThickMapper::visitMultipole(const Multipole &mult) {
     //std::cerr << "==> Leaving ThickMapper::visitMultipole(...)" << std::endl;
 }
 
-void ThickMapper::visitProbe(const Probe &prob) {
+void ThickMapper::visitProbe(const Probe &/*prob*/) {
     // Do nothing.
 }
 
@@ -516,7 +516,7 @@ void ThickMapper::visitSolenoid(const Solenoid &solenoid) {
 }
 
 
-void ThickMapper::visitParallelPlate(const ParallelPlate &pplate) {
+void ThickMapper::visitParallelPlate(const ParallelPlate &/*pplate*/) {
     // Do nothing.
 }
 
@@ -567,7 +567,7 @@ void ThickMapper::applyDrift(double length) {
 }
 
 
-void ThickMapper::applyEntranceFringe(double angle, double curve,
+void ThickMapper::applyEntranceFringe(double angle, double /*curve*/,
                                       const BMultipoleField &field, double scale) {
     // *** MISSING *** Higher order terms for entrance fringe.
     double ca = cos(angle);
@@ -603,7 +603,7 @@ void ThickMapper::applyEntranceFringe(double angle, double curve,
 }
 
 
-void ThickMapper::applyExitFringe(double angle, double curve,
+void ThickMapper::applyExitFringe(double angle, double /*curve*/,
                                   const BMultipoleField &field, double scale) {
     // *** MISSING *** Higher order terms for exit fringe.
     double ca = cos(angle);

src/Algorithms/ThickTracker.cpp

@@ -60,14 +60,14 @@ ThickTracker::ThickTracker(const Beamline &beamline,
 
 ThickTracker::ThickTracker(const Beamline &beamline,
                            PartBunchBase<double, 3> *bunch,
-                           Beam &beam,
+                           Beam &/*beam*/,
                            DataSink &ds,
                            const PartData &reference,
                            bool revBeam, bool revTrack,
-                           const std::vector<unsigned long long> &maxSteps,
+                           const std::vector<unsigned long long> &/*maxSteps*/,
                            double zstart,
                            const std::vector<double> &zstop,
-                           const std::vector<double> &dt,
+                           const std::vector<double> &/*dt*/,
                            const int& truncOrder)
     : Tracker(beamline, bunch, reference, revBeam, revTrack)
     , hamiltonian_m(truncOrder)

src/Algorithms/ThickTracker.h

@@ -378,12 +378,12 @@ private:
     IpplTimings::TimerRef mapTracking_m;    ///< track particles trough maps of elements_m
 };
 
-inline void ThickTracker::visitAlignWrapper(const AlignWrapper &wrap) {
+inline void ThickTracker::visitAlignWrapper(const AlignWrapper &/*wrap*/) {
 //     itsOpalBeamline_m.visit(wrap, *this, itsBunch_m);
     this->throwElementError_m("AlignWrapper");
 }
 
-inline void ThickTracker::visitBeamBeam(const BeamBeam &bb) {
+inline void ThickTracker::visitBeamBeam(const BeamBeam &/*bb*/) {
 //     itsOpalBeamline_m.visit(bb, *this, itsBunch_m);
     this->throwElementError_m("BeamBeam");
 }
@@ -392,25 +392,25 @@ inline void ThickTracker::visitBeamStripping(const BeamStripping &bstp) {
     itsOpalBeamline_m.visit(bstp, *this, itsBunch_m);
 }
 
-inline void ThickTracker::visitCCollimator(const CCollimator &coll) {
+inline void ThickTracker::visitCCollimator(const CCollimator &/*coll*/) {
 //     itsOpalBeamline_m.visit(coll, *this, itsBunch_m);
     this->throwElementError_m("CCollimator");
 }
 
 
-inline void ThickTracker::visitCorrector(const Corrector &corr) {
+inline void ThickTracker::visitCorrector(const Corrector &/*coll*/) {
 //     itsOpalBeamline_m.visit(corr, *this, itsBunch_m);
     this->throwElementError_m("Corrector");
 }
 
 
-inline void ThickTracker::visitDegrader(const Degrader &deg) {
+inline void ThickTracker::visitDegrader(const Degrader &/*deg*/) {
 //     itsOpalBeamline_m.visit(deg, *this, itsBunch_m);
     this->throwElementError_m("Degrader");
 }
 
 
-inline void ThickTracker::visitDiagnostic(const Diagnostic &diag) {
+inline void ThickTracker::visitDiagnostic(const Diagnostic &/*diag*/) {
 //     itsOpalBeamline_m.visit(diag, *this, itsBunch_m);
     this->throwElementError_m("Diagnostic");
 }
@@ -430,25 +430,25 @@ inline void ThickTracker::visitDrift(const Drift &drift) {
 }
 
 
-inline void ThickTracker::visitFlexibleCollimator(const FlexibleCollimator &coll) {
+inline void ThickTracker::visitFlexibleCollimator(const FlexibleCollimator &/*coll*/) {
 //     itsOpalBeamline_m.visit(coll, *this, itsBunch_m);
     this->throwElementError_m("FlexibleCollimator");
 }
 
 
-inline void ThickTracker::visitLambertson(const Lambertson &lamb) {
+inline void ThickTracker::visitLambertson(const Lambertson &/*lamb*/) {
 //     itsOpalBeamline_m.visit(lamb, *this, itsBunch_m);
     this->throwElementError_m("Lambertson");
 }
 
 
-inline void ThickTracker::visitMarker(const Marker &marker) {
+inline void ThickTracker::visitMarker(const Marker &/*marker*/) {
 //     itsOpalBeamline_m.visit(marker, *this, itsBunch_m);
 //     this->throwElementError_m("Marker");
 }
 
 
-inline void ThickTracker::visitMonitor(const Monitor &mon) {
+inline void ThickTracker::visitMonitor(const Monitor &/*mon*/) {
 //     itsOpalBeamline_m.visit(mon, *this, itsBunch_m);
     this->throwElementError_m("Monitor");
 }
@@ -473,30 +473,30 @@ inline void ThickTracker::visitMultipole(const Multipole &mult) {
                                          length));
 }
 
-inline void ThickTracker::visitProbe(const Probe &prob) {
+inline void ThickTracker::visitProbe(const Probe &/*probe*/) {
 //     itsOpalBeamline_m.visit(prob, *this, itsBunch_m);
     this->throwElementError_m("Probe");
 }
 
 
-inline void ThickTracker::visitRBend(const RBend &bend) {
+inline void ThickTracker::visitRBend(const RBend &/*bend*/) {
 //     itsOpalBeamline_m.visit(bend, *this, itsBunch_m);
     this->throwElementError_m("RBend");
 }
 
 
-inline void ThickTracker::visitRFCavity(const RFCavity &as) {
+inline void ThickTracker::visitRFCavity(const RFCavity &/*as*/) {
 //     itsOpalBeamline_m.visit(as, *this, itsBunch_m);
     this->throwElementError_m("RFCavity");
 }
 
-inline void ThickTracker::visitTravelingWave(const TravelingWave &as) {
+inline void ThickTracker::visitTravelingWave(const TravelingWave &/*as*/) {
 //     itsOpalBeamline_m.visit(as, *this, itsBunch_m);
     this->throwElementError_m("TravelingWave");
 }
 
 
-inline void ThickTracker::visitRFQuadrupole(const RFQuadrupole &rfq) {
+inline void ThickTracker::visitRFQuadrupole(const RFQuadrupole &/*rfq*/) {
 //     itsOpalBeamline_m.visit(rfq, *this, itsBunch_m);
     this->throwElementError_m("RFQuadrupole");
 }
@@ -554,25 +554,25 @@ inline void ThickTracker::visitSBend(const SBend &bend) {
 }
 
 
-inline void ThickTracker::visitSeparator(const Separator &sep) {
+inline void ThickTracker::visitSeparator(const Separator &/*sep*/) {
 //     itsOpalBeamline_m.visit(sep, *this, itsBunch_m);
     this->throwElementError_m("Separator");
 }
 
 
-inline void ThickTracker::visitSeptum(const Septum &sept) {
+inline void ThickTracker::visitSeptum(const Septum &/*sept*/) {
 //     itsOpalBeamline_m.visit(sept, *this, itsBunch_m);
     this->throwElementError_m("Septum");
 }
 
 
-inline void ThickTracker::visitSolenoid(const Solenoid &solenoid) {
+inline void ThickTracker::visitSolenoid(const Solenoid &/*solenoid*/) {
 //     itsOpalBeamline_m.visit(solenoid, *this, itsBunch_m);
     this->throwElementError_m("Solenoid");
 }
 
 
-inline void ThickTracker::visitParallelPlate(const ParallelPlate &pplate) {
+inline void ThickTracker::visitParallelPlate(const ParallelPlate &/*pplate*/) {
 //     itsOpalBeamline_m.visit(pplate, *this, itsBunch_m);
     this->throwElementError_m("ParallelPlate");
 }

src/Algorithms/TransportMapper.cpp

@@ -173,7 +173,7 @@ void TransportMapper::visitLambertson(const Lambertson &lamb) {
 }
 
 
-void TransportMapper::visitMarker(const Marker &marker) {
+void TransportMapper::visitMarker(const Marker &/*marker*/) {
     // Do nothing.
 }
 
@@ -204,7 +204,7 @@ void TransportMapper::visitPatch(const Patch &patch) {
     if(back_path) transform = Inverse(transform);
     applyTransform(transform, 0.0);
 }
-void TransportMapper::visitProbe(const Probe &prob) {
+void TransportMapper::visitProbe(const Probe &/*prob*/) {
     // Do nothing.
 }
 
@@ -393,7 +393,7 @@ void TransportMapper::visitSolenoid(const Solenoid &solenoid) {
 }
 
 
-void TransportMapper::visitParallelPlate(const ParallelPlate &pplate) {
+void TransportMapper::visitParallelPlate(const ParallelPlate &/*pplate*/) {
     // Do nothing.
 }
 

src/Aperture/Aperture.cpp

@@ -251,7 +251,7 @@ Aperture::A_Tline::const_iterator Aperture::end() const {
     return itsTable.end();
 }
 
-double Aperture::getBETXMAX(const A_row &row, int i1, int i2) const {
+double Aperture::getBETXMAX(const A_row &row, int /*i1*/, int /*i2*/) const {
     double max;
     double nslice = Attributes::getReal(itsAttr[NSLICE]);
     max = row.Interpol[0].Beta_x;
@@ -261,7 +261,7 @@ double Aperture::getBETXMAX(const A_row &row, int i1, int i2) const {
     return max;
 }
 
-double Aperture::getBETYMAX(const A_row &row, int i1, int i2) const {
+double Aperture::getBETYMAX(const A_row &row, int /*i1*/, int /*i2*/) const {
     double max;
     double nslice = Attributes::getReal(itsAttr[NSLICE]);
     max = row.Interpol[0].Beta_y;
@@ -272,7 +272,7 @@ double Aperture::getBETYMAX(const A_row &row, int i1, int i2) const {
     return max;
 }
 
-double Aperture::getAPERTMIN(const A_row &row, int i1, int i2) const {
+double Aperture::getAPERTMIN(const A_row &row, int /*i1*/, int /*i2*/) const {
     double min;