diff --git a/cpp/aterms/atermconfig.cc b/cpp/aterms/atermconfig.cc
index ae76af50ec4801b66b139e44e31736d992ece236..beb5b073f756a45d1de90e708f23a855e831a130 100644
--- a/cpp/aterms/atermconfig.cc
+++ b/cpp/aterms/atermconfig.cc
@@ -25,16 +25,10 @@
 #include <algorithm>
 
 using everybeam::ATermSettings;
-using everybeam::aterms::ATermBeam;
-using everybeam::aterms::ATermConfig;
-using everybeam::aterms::DLDMATerm;
-using everybeam::aterms::EveryBeamATerm;
-using everybeam::aterms::FitsATerm;
-using everybeam::aterms::H5ParmATerm;
-using everybeam::aterms::PAFBeamTerm;
-using everybeam::aterms::ParsetProvider;
 using everybeam::coords::CoordinateSystem;
 
+namespace everybeam {
+namespace aterms {
 void ATermConfig::Read(const casacore::MeasurementSet& ms,
                        const ParsetProvider& reader,
                        const std::string& ms_filename) {
@@ -300,3 +294,5 @@ everybeam::Options ATermConfig::ConvertToEBOptions(
   options.element_response_model = element_response_enum;
   return options;
 }
+}  // namespace aterms
+}  // namespace everybeam
diff --git a/cpp/aterms/h5parmaterm.cc b/cpp/aterms/h5parmaterm.cc
index 8088b32ba56db26983b6d78c1ceea54351dd513f..877d62efd20a08c3989ca0a6f3a5c7feb74dba65 100644
--- a/cpp/aterms/h5parmaterm.cc
+++ b/cpp/aterms/h5parmaterm.cc
@@ -79,14 +79,14 @@ void H5ParmATerm::Open(const std::vector<std::string>& filenames) {
 
 bool H5ParmATerm::Calculate(std::complex<float>* buffer, double time,
                             double frequency, size_t, const double*) {
-  bool outdated = std::fabs(time - last_aterm_update_) > update_interval_;
+  const bool outdated = std::fabs(time - last_aterm_update_) > update_interval_;
   if (!outdated) return false;
   last_aterm_update_ = time;
 
-  hsize_t time_index_amplitude = amplitude_soltab_[0].GetTimeIndex(time);
-  hsize_t time_index_phase = phase_soltab_[0].GetTimeIndex(time);
-  bool recalculate_amplitude = (time_index_amplitude != last_ampl_index_);
-  bool recalculate_phase = (time_index_phase != last_phase_index_);
+  const hsize_t time_index_amplitude = amplitude_soltab_[0].GetTimeIndex(time);
+  const hsize_t time_index_phase = phase_soltab_[0].GetTimeIndex(time);
+  const bool recalculate_amplitude = (time_index_amplitude != last_ampl_index_);
+  const bool recalculate_phase = (time_index_phase != last_phase_index_);
 
   // Initialize placeholders for the y coefficient expansions only once for
   // efficiency reasons
@@ -131,12 +131,12 @@ bool H5ParmATerm::Calculate(std::complex<float>* buffer, double time,
 
 void H5ParmATerm::ReadCoeffs(SolTab& soltab, const std::string& station_name,
                              std::vector<float>& coeffs, hsize_t time_index) {
-  size_t n_times = 1;
-  size_t timestep = 1;
+  const size_t n_times = 1;
+  const size_t timestep = 1;
 
   // Not yet relevant
-  size_t freq_start = 0, n_freq = 1, freq_step = 1;
-  size_t pol = 0;
+  const size_t freq_start = 0, n_freq = 1, freq_step = 1;
+  const size_t pol = 0;
 
   for (size_t idx = 0; idx < coeffs.size(); ++idx) {
     coeffs[idx] = soltab.GetValues(station_name, time_index, n_times, timestep,
diff --git a/cpp/circularsymmetric/vlabeam.cc b/cpp/circularsymmetric/vlabeam.cc
index 9ed4e2714881fade24b96e30b7c324bd9f103569..ceb9ea800f159c758d5cdb069e965aad5747c9ad 100644
--- a/cpp/circularsymmetric/vlabeam.cc
+++ b/cpp/circularsymmetric/vlabeam.cc
@@ -12,7 +12,7 @@ std::array<double, 5> VLABeam::GetCoefficients(const std::string& bandName,
                                                double freq) {
   char band = '?';
 
-  size_t sharp = bandName.find('#');
+  const size_t sharp = bandName.find('#');
   if (sharp != std::string::npos) {
     if (sharp > 5 && bandName.substr(0, 5) == "EVLA_") band = bandName[5];
   }
@@ -24,7 +24,7 @@ std::array<double, 5> VLABeam::GetCoefficients(const std::string& bandName,
   auto coeffmap = GetCoefficients();
 
   const std::array<double, 5>* coeff;
-  double freqMHz = freq * 1e-6;
+  const double freqMHz = freq * 1e-6;
   std::map<int, std::array<double, 5>>::iterator low, prev;
   low = coeffmap.lower_bound(freqMHz);
   if (low == coeffmap.end()) {
diff --git a/cpp/circularsymmetric/voltagepattern.cc b/cpp/circularsymmetric/voltagepattern.cc
index 2ac1cb0f5803ba5d60e336b6456d1b2ddc3678a8..d2f8abb45ac8b26fc30d9abcdbef08a71ccfce36 100644
--- a/cpp/circularsymmetric/voltagepattern.cc
+++ b/cpp/circularsymmetric/voltagepattern.cc
@@ -14,9 +14,9 @@ using everybeam::circularsymmetric::VoltagePattern;
 void VoltagePattern::EvaluatePolynomial(const UVector<double>& coefficients,
                                         bool invert) {
   // This comes from casa's: void PBMath1DIPoly::fillPBArray(), wideband case
-  size_t nsamples = 10000;
-  size_t nfreq = frequencies_.size();
-  size_t ncoef = coefficients.size() / nfreq;
+  const size_t nsamples = 10000;
+  const size_t nfreq = frequencies_.size();
+  const size_t ncoef = coefficients.size() / nfreq;
   values_.resize(nsamples * nfreq);
   inverse_increment_radius_ = double(nsamples - 1) / maximum_radius_arc_min_;
   double* output = values_.data();
@@ -83,9 +83,9 @@ const double* VoltagePattern::InterpolateValues(
 }
 
 double VoltagePattern::LmMaxSquared(double frequency_hz) const {
-  double factor =
+  const double factor =
       (180.0 / M_PI) * 60.0 * frequency_hz * 1.0e-9;  // arcminutes * GHz
-  double rmax = maximum_radius_arc_min_ / factor;
+  const double rmax = maximum_radius_arc_min_ / factor;
   return rmax * rmax;
 }
 
@@ -95,12 +95,12 @@ void VoltagePattern::Render(std::complex<float>* aterm, size_t width,
                             double phase_centre_dec, double pointing_ra,
                             double pointing_dec, double phase_centre_dl,
                             double phase_centre_dm, double frequency_hz) const {
-  double lmMaxSq = LmMaxSquared(frequency_hz);
+  const double lm_max_sq = LmMaxSquared(frequency_hz);
 
   UVector<double> interpolated_values;
   const double* vp = InterpolateValues(frequency_hz, interpolated_values);
 
-  double factor =
+  const double factor =
       (180.0 / M_PI) * 60.0 * frequency_hz * 1.0e-9;  // arcminutes * GHz
   double l0, m0;
   ImageCoordinates::RaDecToLM(pointing_ra, pointing_dec, phase_centre_ra,
@@ -122,7 +122,7 @@ void VoltagePattern::Render(std::complex<float>* aterm, size_t width,
       m -= m0;
       double r2 = l * l + m * m;
       double out;
-      if (r2 > lmMaxSq) {
+      if (r2 > lm_max_sq) {
         out = 1e-4;
       } else {
         double r = std::sqrt(r2) * factor;
@@ -142,12 +142,12 @@ void VoltagePattern::Render(std::complex<float>* aterm, size_t width,
 void VoltagePattern::Render(std::complex<float>* aterm, double phase_centre_ra,
                             double phase_centre_dec, double pointing_ra,
                             double pointing_dec, double frequency_hz) const {
-  double lmMaxSq = LmMaxSquared(frequency_hz);
+  const double lm_max_sq = LmMaxSquared(frequency_hz);
 
   UVector<double> interpolated_values;
   const double* vp = InterpolateValues(frequency_hz, interpolated_values);
 
-  double factor =
+  const double factor =
       (180.0 / M_PI) * 60.0 * frequency_hz * 1.0e-9;  // arcminutes * GHz
 
   // TODO: probably not all conversions needed?
@@ -161,13 +161,13 @@ void VoltagePattern::Render(std::complex<float>* aterm, double phase_centre_ra,
   ImageCoordinates::RaDecToLM(ra, dec, pointing_ra, pointing_dec, l, m);
   l -= l0;
   m -= m0;
-  double r2 = l * l + m * m;
+  const double r2 = l * l + m * m;
   double out;
-  if (r2 > lmMaxSq) {
+  if (r2 > lm_max_sq) {
     out = 1e-4;
   } else {
-    double r = std::sqrt(r2) * factor;
-    int indx = int(r * inverse_increment_radius_);
+    const double r = std::sqrt(r2) * factor;
+    const int indx = int(r * inverse_increment_radius_);
     out = vp[indx] * (1.0 - 1e-4) + 1e-4;
   }
 
diff --git a/cpp/griddedresponse/phasedarraygrid.cc b/cpp/griddedresponse/phasedarraygrid.cc
index d2ed4522f17a8381d587b71f1cc39fc26bc7b0b4..aef135122aa3ca10dbfec8c38095d3d5123e3859 100644
--- a/cpp/griddedresponse/phasedarraygrid.cc
+++ b/cpp/griddedresponse/phasedarraygrid.cc
@@ -71,7 +71,8 @@ void PhasedArrayGrid::CalculateAllStations(std::complex<float>* buffer,
   SetITRFVectors(time);
 
   if (use_differential_beam_) {
-    double sb_freq = use_channel_frequency_ ? frequency : subband_frequency_;
+    const double sb_freq =
+        use_channel_frequency_ ? frequency : subband_frequency_;
     inverse_central_gain_.resize(phasedarraytelescope.GetNrStations());
     for (size_t i = 0; i != phasedarraytelescope.GetNrStations(); ++i) {
       inverse_central_gain_[i] = aocommon::MC2x2F(
@@ -86,9 +87,9 @@ void PhasedArrayGrid::CalculateAllStations(std::complex<float>* buffer,
   }
 
   // Prepare threads
-  for (size_t i = 0; i != nthreads_; ++i) {
-    threads_[i] = std::thread(&PhasedArrayGrid::CalcThread, this, buffer, time,
-                              frequency);
+  for (auto& thread : threads_) {
+    thread = std::thread(&PhasedArrayGrid::CalcThread, this, buffer, time,
+                         frequency);
   }
 
   for (size_t y = 0; y != height_; ++y) {
@@ -99,7 +100,7 @@ void PhasedArrayGrid::CalculateAllStations(std::complex<float>* buffer,
   }
 
   lane.write_end();
-  for (size_t i = 0; i != nthreads_; ++i) threads_[i].join();
+  for (auto& thread : threads_) thread.join();
 }
 
 void PhasedArrayGrid::SetITRFVectors(double time) {
diff --git a/cpp/hamaker/hamakercoeff.cc b/cpp/hamaker/hamakercoeff.cc
index 67007feb6ed43a04853d438bbc470bb4d848db96..6ccbf67f858da9a8194854df9aa5f080918c01d8 100644
--- a/cpp/hamaker/hamakercoeff.cc
+++ b/cpp/hamaker/hamakercoeff.cc
@@ -3,6 +3,7 @@
 
 #include "hamakercoeff.h"
 
+namespace everybeam {
 H5::CompType GetComplexDoubleType() {
   H5::CompType complex_type(sizeof(std::complex<double>));
   complex_type.insertMember("r", 0, H5::PredType::NATIVE_DOUBLE);
@@ -140,3 +141,4 @@ void HamakerCoefficients::PrintCoefficients() {
   }
   std::cout << std::endl;
 }
+}  // namespace everybeam
diff --git a/cpp/hamaker/hamakercoeff.h b/cpp/hamaker/hamakercoeff.h
index 71eb1dba8e5582589cd6a886887a76a06ee14fde..cbcf5c9432642a70c04f70643902fb8b0d4f20d1 100644
--- a/cpp/hamaker/hamakercoeff.h
+++ b/cpp/hamaker/hamakercoeff.h
@@ -1,8 +1,8 @@
 // Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#ifndef HAMAKER_COEFF_H
-#define HAMAKER_COEFF_H
+#ifndef EVERYBEAM_HAMAKER_COEFF_H_
+#define EVERYBEAM_HAMAKER_COEFF_H_
 
 #include <iostream>
 #include <string>
@@ -13,6 +13,7 @@
 
 #include <H5Cpp.h>
 
+namespace everybeam {
 //! Hamaker coefficients
 class HamakerCoefficients {
  public:
@@ -88,5 +89,5 @@ class HamakerCoefficients {
   std::string dataset_name_ = "coeff";
   const unsigned int dataset_rank_ = 4;
 };
-
+}  // namespace everybeam
 #endif
diff --git a/cpp/hamaker/hamakerelementresponse.h b/cpp/hamaker/hamakerelementresponse.h
index 9564eb98415c614ef357f8dfccfcd03b14d576af..f8d0021d462bfc80c6af8d4b0e23dda8fc74e371 100644
--- a/cpp/hamaker/hamakerelementresponse.h
+++ b/cpp/hamaker/hamakerelementresponse.h
@@ -1,8 +1,8 @@
 // Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#ifndef HAMAKER_ELEMENTRESPONSE_H
-#define HAMAKER_ELEMENTRESPONSE_H
+#ifndef EVERYBEAM_HAMAKER_ELEMENTRESPONSE_H_
+#define EVERYBEAM_HAMAKER_ELEMENTRESPONSE_H_
 
 #include "../elementresponse.h"
 #include "hamakercoeff.h"
diff --git a/cpp/oskar/oskar.h b/cpp/oskar/oskar.h
index 872cf6015ad9f02dfe7db18a9b3a6c3d751d2c0e..3d401cdfba5dd446d7c52641a9bd97563dc40167 100644
--- a/cpp/oskar/oskar.h
+++ b/cpp/oskar/oskar.h
@@ -1,6 +1,9 @@
 // Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+#ifndef EVERYBEAM_OSKAR_H_
+#define EVERYBEAM_OSKAR_H_
+
 #include "oskar_vector_types.h"
 #include "oskar_helper.h"
 
@@ -15,3 +18,5 @@ void oskar_evaluate_spherical_wave_sum_double(
     const int num_points, const double* theta, const double* phi_x,
     const double* phi_y, const int l_max, const std::complex<double>* alpha,
     std::complex<double>* pattern);
+
+#endif
\ No newline at end of file
diff --git a/cpp/oskar/oskardatafile.cc b/cpp/oskar/oskardatafile.cc
index 978bcc66f772f67198d0d607005b2325817405be..f6ddc84fc8568fdb6b97e8917f041c3cb9c77205 100644
--- a/cpp/oskar/oskardatafile.cc
+++ b/cpp/oskar/oskardatafile.cc
@@ -5,6 +5,8 @@
 
 #include <iostream>
 
+namespace everybeam {
+
 Datafile::Datafile(const std::string& filename) {
   // Open file
   std::cout << "read oskar datafile: " << filename << std::endl;
@@ -31,3 +33,4 @@ std::shared_ptr<Dataset> Datafile::Get(const unsigned int freq) {
   map_.insert({freq, dataset_ptr});
   return dataset_ptr;
 }
+}  // namespace everybeam
\ No newline at end of file
diff --git a/cpp/oskar/oskardatafile.h b/cpp/oskar/oskardatafile.h
index 36bdfc64ef4dc6f5ecdf0251445ed6d483161090..418d08ff9e8e392a059c8d2566b2530410fa082e 100644
--- a/cpp/oskar/oskardatafile.h
+++ b/cpp/oskar/oskardatafile.h
@@ -1,8 +1,8 @@
 // Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#ifndef OSKAR_DATAFILE_H
-#define OSKAR_DATAFILE_H
+#ifndef EVERYBEAM_OSKAR_DATAFILE_H_
+#define EVERYBEAM_OSKAR_DATAFILE_H_
 
 #include <string>
 #include <memory>
@@ -13,6 +13,8 @@
 
 #include "oskardataset.h"
 
+namespace everybeam {
+
 //! Oskar datafile interface
 class Datafile {
  public:
@@ -29,5 +31,6 @@ class Datafile {
   std::unique_ptr<H5::H5File> h5_file_;
   mutable std::mutex mutex_;
 };
+}  // namespace everybeam
 
 #endif
\ No newline at end of file
diff --git a/cpp/oskar/oskardataset.cc b/cpp/oskar/oskardataset.cc
index 1bfabc975f2cee96fa78ce5236da8efecdf40b0b..3557f18e9164a028ededefc9870cc419c153d468 100644
--- a/cpp/oskar/oskardataset.cc
+++ b/cpp/oskar/oskardataset.cc
@@ -9,6 +9,8 @@
 #include <limits>
 #include "oskardataset.h"
 
+namespace everybeam {
+
 Dataset::Dataset(H5::H5File& h5_file, const unsigned int freq) {
   H5::DataSet dataset;
   const int freq_mhz = (int)(freq / 1e6);
@@ -95,3 +97,4 @@ std::complex<double>* Dataset::GetAlphaPtr(const unsigned int element) {
   size_t index = GetIndex(element);
   return data_.data() + index;
 }
+}  // namespace everybeam
diff --git a/cpp/oskar/oskardataset.h b/cpp/oskar/oskardataset.h
index 66c81d4a8997a48674b110c2ee3803de5496bc95..c92f1d66f4cd33e654d6debc2a3426d64539fb3a 100644
--- a/cpp/oskar/oskardataset.h
+++ b/cpp/oskar/oskardataset.h
@@ -1,14 +1,15 @@
 // Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-#ifndef OSKAR_DATASET_H
-#define OSKAR_DATASET_H
+#ifndef EVERYBEAM_OSKAR_DATASET_H_
+#define EVERYBEAM_OSKAR_DATASET_H_
 
 #include <complex>
 #include <vector>
 
 #include <H5Cpp.h>
 
+namespace everybeam {
 //! OSKAR dataset
 class Dataset {
  public:
@@ -40,5 +41,5 @@ class Dataset {
   size_t nr_coeffs_;
   size_t l_max_;
 };
-
+}  // namespace everybeam
 #endif
diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt
index bfcd85e3a5658b11838a1174028c0f4ff908f99c..e8806dc6a07326eaeedde447044200b9a7fe658d 100644
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@@ -13,11 +13,9 @@ pybind11_add_module(
   pyeverybeam wrappers/pyutils.cc wrappers/pyload.cc wrappers/pytelescope.cc
   wrappers/pylobes.cc wrappers/wrapper.cc)
 
-target_include_directories(pyeverybeam PUBLIC ${CASACORE_INCLUDE_DIR})
 target_include_directories(pyeverybeam
                            PUBLIC "$<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/cpp>")
 target_link_libraries(pyeverybeam PUBLIC everybeam)
-target_link_libraries(pyeverybeam PUBLIC ${CASACORE_LIBRARIES})
 set_target_properties(pyeverybeam PROPERTIES OUTPUT_NAME everybeam)
 
 add_subdirectory(test)