Merge branch '32-more-google-style' into 'master'

Resolve "Make file/function namings google compliant"

Closes #32

See merge request !33

CMake/FindBeamModel.cmake

@@ -9,7 +9,7 @@ find_package(PackageHandleStandardArgs)
 
 find_path(
     BEAMMODEL_INCLUDE_DIR
-    NAMES EveryBeam/Station.h
+    NAMES EveryBeam/station.h
     HINTS ${BEAMMODEL_ROOT_DIR}
     PATH_SUFFIXES include
 )

cpp/CMakeLists.txt

@@ -9,15 +9,15 @@ add_subdirectory(telescope)
 
 #------------------------------------------------------------------------------
 add_library(everybeam SHARED
-  Antenna.cc
-  ElementResponse.cc
-  BeamFormer.cc
-  Element.cc
+  antenna.cc
+  element_response.cc
+  beamformer.cc
+  element.cc
   load.cc
   coords/ITRFConverter.cc
   coords/ITRFDirection.cc
   LofarMetaDataUtil.cc
-  Station.cc
+  station.cc
   telescope/lofar.cc
   gridded_response/lofargrid.cc
 )
@@ -32,12 +32,12 @@ install (
   DESTINATION lib)
 
 install (FILES
-  Antenna.h
-  BeamFormer.h
-  Element.h
-  ElementResponse.h
+  antenna.h
+  beamformer.h
+  element.h
+  element_response.h
   LofarMetaDataUtil.h
-  Station.h
+  station.h
   # Related to new API:
   load.h
   options.h

cpp/LofarMetaDataUtil.cc

@@ -22,7 +22,8 @@
 // $Id$
 
 #include "LofarMetaDataUtil.h"
-#include "common/MathUtil.h"
+#include "common/math_utils.h"
+#include "common/casa_utils.h"
 
 #include <casacore/measures/Measures/MDirection.h>
 #include <casacore/measures/Measures/MPosition.h>
@@ -76,21 +77,11 @@ using namespace casacore;
 
 typedef std::array<vector3r_t, 16> TileConfig;
 
-// TODO: can be deprecated in favor of common::hasColumn from CasaUtil.h
-bool hasColumn(const Table &table, const string &column) {
-  return table.tableDesc().isColumn(column);
-}
-
 // TODO: utility is not used at all
 bool hasSubTable(const Table &table, const string &name) {
   return table.keywordSet().isDefined(name);
 }
 
-// TODO: can be deprecated in favor of common::getSubTable from CasaUtil.h
-Table getSubTable(const Table &table, const string &name) {
-  return table.keywordSet().asTable(name);
-}
-
 TileConfig readTileConfig(const Table &table, unsigned int row) {
   ROArrayQuantColumn<Double> c_tile_offset(table, "TILE_ELEMENT_OFFSET", "m");
 
@@ -194,7 +185,7 @@ BeamFormer::Ptr make_tile(unsigned int id, const vector3r_t &position,
 
     Antenna::Ptr antenna = Element::Ptr(
         new Element(antenna_coordinate_system, element_response, id));
-    tile->add_antenna(antenna);
+    tile->AddAntenna(antenna);
   }
 
   return tile;
@@ -202,7 +193,8 @@ BeamFormer::Ptr make_tile(unsigned int id, const vector3r_t &position,
 
 BeamFormer::Ptr readAntennaField(const Table &table, unsigned int id,
                                  ElementResponse::Ptr element_response) {
-  Antenna::CoordinateSystem coordinate_system = readCoordinateSystem(table, id);
+  Antenna::CoordinateSystem coordinate_system =
+      common::readCoordinateSystem(table, id);
   //     std::cout << "coordinate_system: " << std::endl;
   //     std::cout << "  axes.p: " << coordinate_system.axes.p[0] << ", " <<
   //     coordinate_system.axes.p[1] << ", " << coordinate_system.axes.p[2] <<
@@ -249,7 +241,7 @@ BeamFormer::Ptr readAntennaField(const Table &table, unsigned int id,
 
     antenna->m_enabled[0] = !aips_flag(0, i);
     antenna->m_enabled[1] = !aips_flag(1, i);
-    beam_former->add_antenna(antenna);
+    beam_former->AddAntenna(antenna);
   }
   return beam_former;
 }
@@ -290,7 +282,7 @@ BeamFormer::Ptr readAntennaFieldAartfaac(const Table &table,
 vector3r_t readStationPhaseReference(const Table &table, unsigned int id) {
   vector3r_t phase_reference = {0.0, 0.0, 0.0};
   const string columnName("LOFAR_PHASE_REFERENCE");
-  if (hasColumn(table, columnName)) {
+  if (common::hasColumn(table, columnName)) {
     ROScalarMeasColumn<MPosition> c_reference(table, columnName);
     MPosition mReference =
         MPosition::Convert(c_reference(id), MPosition::ITRF)();
@@ -321,22 +313,22 @@ Station::Ptr readStation(const MeasurementSet &ms, unsigned int id,
   station->setPhaseReference(readStationPhaseReference(ms.antenna(), id));
 
   // Read antenna field information.
-  ROScalarColumn<String> telescope_name_col(getSubTable(ms, "OBSERVATION"),
-                                            "TELESCOPE_NAME");
+  ROScalarColumn<String> telescope_name_col(
+      common::getSubTable(ms, "OBSERVATION"), "TELESCOPE_NAME");
   string telescope_name = telescope_name_col(0);
 
   if (telescope_name == "LOFAR") {
-    Table tab_field = getSubTable(ms, "LOFAR_ANTENNA_FIELD");
+    Table tab_field = common::getSubTable(ms, "LOFAR_ANTENNA_FIELD");
     tab_field = tab_field(tab_field.col("ANTENNA_ID") == static_cast<Int>(id));
 
     // The Station will consist of a BeamFormer that combines the fields
     // coordinate system is ITRF
     // phase reference is station position
     auto beam_former = BeamFormer::Ptr(new BeamFormer(
-        Antenna::identity_coordinate_system, station->phaseReference()));
+        Antenna::IdentityCoordinateSystem, station->phaseReference()));
 
     for (size_t i = 0; i < tab_field.nrow(); ++i) {
-      beam_former->add_antenna(
+      beam_former->AddAntenna(
           readAntennaField(tab_field, i, station->get_element_response()));
     }
 
@@ -344,24 +336,24 @@ Station::Ptr readStation(const MeasurementSet &ms, unsigned int id,
     // If There is only one field, the top level beamformer is not needed
     // and the station antenna can be set the the beamformer of the field
 
-    station->set_antenna(beam_former);
+    station->SetAntenna(beam_former);
 
     size_t field_id = 0;
     size_t element_id = 0;
     Antenna::CoordinateSystem coordinate_system =
-        readCoordinateSystem(tab_field, field_id);
+        common::readCoordinateSystem(tab_field, field_id);
     auto model = station->get_element_response();
     // TODO: rotate coordinate system for antenna
     auto element =
         Element::Ptr(new Element(coordinate_system, model, element_id));
-    station->set_element(element);
+    station->SetElement(element);
   } else if (telescope_name == "AARTFAAC") {
-    ROScalarColumn<String> ant_type_col(getSubTable(ms, "OBSERVATION"),
+    ROScalarColumn<String> ant_type_col(common::getSubTable(ms, "OBSERVATION"),
                                         "AARTFAAC_ANTENNA_TYPE");
     string ant_type = ant_type_col(0);
 
-    Table tab_field = getSubTable(ms, "ANTENNA");
-    station->set_antenna(readAntennaFieldAartfaac(tab_field, ant_type, id));
+    Table tab_field = common::getSubTable(ms, "ANTENNA");
+    station->SetAntenna(readAntennaFieldAartfaac(tab_field, ant_type, id));
   }
 
   return station;
@@ -370,7 +362,7 @@ Station::Ptr readStation(const MeasurementSet &ms, unsigned int id,
 MDirection readTileBeamDirection(const casacore::MeasurementSet &ms) {
   MDirection tileBeamDir;
 
-  Table fieldTable = getSubTable(ms, "FIELD");
+  Table fieldTable = common::getSubTable(ms, "FIELD");
 
   if (fieldTable.nrow() != 1) {
     throw std::runtime_error(
@@ -378,7 +370,7 @@ MDirection readTileBeamDirection(const casacore::MeasurementSet &ms) {
         "library.");
   }
 
-  if (hasColumn(fieldTable, "LOFAR_TILE_BEAM_DIR")) {
+  if (common::hasColumn(fieldTable, "LOFAR_TILE_BEAM_DIR")) {
     ROArrayMeasColumn<MDirection> tileBeamCol(fieldTable,
                                               "LOFAR_TILE_BEAM_DIR");
     tileBeamDir = *(tileBeamCol(0).data());

cpp/LofarMetaDataUtil.h

@@ -28,8 +28,8 @@
 // Utility functions to read the meta data relevant for simulating the beam from
 // LOFAR observations stored in MS format.
 
-#include "Station.h"
-#include "ElementResponse.h"
+#include "station.h"
+#include "element_response.h"
 
 #include <casacore/ms/MeasurementSets/MeasurementSet.h>
 #include <casacore/ms/MeasurementSets/MSAntennaColumns.h>
@@ -77,4 +77,4 @@ casacore::MDirection readTileBeamDirection(const casacore::MeasurementSet &ms);
 
 }  // namespace everybeam
 
-#endif
+#endif  // EVERYBEAM_LOFARMETADATAUTIL_H

cpp/Antenna.cc → cpp/antenna.cc

-#include "Antenna.h"
+#include "antenna.h"
 
-#include "common/MathUtil.h"
+#include "common/math_utils.h"
 
 namespace everybeam {
-vector3r_t Antenna::transform_to_local_direction(const vector3r_t &direction) {
+vector3r_t Antenna::TransformToLocalDirection(const vector3r_t &direction) {
   vector3r_t local_direction{
       dot(m_coordinate_system.axes.p, direction),
       dot(m_coordinate_system.axes.q, direction),

cpp/Antenna.h → cpp/antenna.h

@@ -5,13 +5,13 @@
 #include <memory>
 #include <iostream>
 
-#include "common/Types.h"
+#include "common/types.h"
 
 namespace everybeam {
 
 /**
  * @brief (Virtual) class describing an antenna, and computing the corresponding
- * response() and arrayFactor().
+ * Response() and ArrayFactor().
  *
  */
 class Antenna {
@@ -57,7 +57,7 @@ class Antenna {
     constexpr static vector3r_t zero_origin = {0.0, 0.0, 0.0};
   };
 
-  constexpr static CoordinateSystem identity_coordinate_system{
+  constexpr static CoordinateSystem IdentityCoordinateSystem{
       CoordinateSystem::zero_origin, CoordinateSystem::identity_axes};
 
   typedef std::shared_ptr<Antenna> Ptr;
@@ -116,7 +116,7 @@ class Antenna {
         m_enabled{true, true} {}
 
   /**
-   * @brief Compute the %Antenna response
+   * @brief Compute the %Antenna Response
    *
    * @param time Time, modified Julian date, UTC, in seconds (MJD(UTC), s).
    * @param freq Frequency of the plane wave (Hz).
@@ -124,20 +124,20 @@ class Antenna {
    * @param options
    * @return matrix22c_t Jones matrix
    */
-  matrix22c_t response(real_t time, real_t freq, const vector3r_t &direction,
+  matrix22c_t Response(real_t time, real_t freq, const vector3r_t &direction,
                        const Options &options = {}) {
     // Transform direction and directions in options to local coordinatesystem
-    vector3r_t local_direction = transform_to_local_direction(direction);
+    vector3r_t local_direction = TransformToLocalDirection(direction);
     Options local_options = {
         .freq0 = options.freq0,
-        .station0 = transform_to_local_direction(options.station0),
-        .tile0 = transform_to_local_direction(options.tile0),
+        .station0 = TransformToLocalDirection(options.station0),
+        .tile0 = TransformToLocalDirection(options.tile0),
         .rotate = options.rotate,
-        .east = transform_to_local_direction(options.east),
-        .north = transform_to_local_direction(options.north)};
-    matrix22c_t response =
-        local_response(time, freq, local_direction, local_options);
-    return response;
+        .east = TransformToLocalDirection(options.east),
+        .north = TransformToLocalDirection(options.north)};
+    matrix22c_t Response =
+        LocalResponse(time, freq, local_direction, local_options);
+    return Response;
   }
 
   /**
@@ -149,15 +149,15 @@ class Antenna {
    * @param options
    * @return diag22c_t
    */
-  diag22c_t arrayFactor(real_t time, real_t freq, const vector3r_t &direction,
+  diag22c_t ArrayFactor(real_t time, real_t freq, const vector3r_t &direction,
                         const Options &options = {}) {
     // Transform direction and directions in options to local coordinatesystem
-    vector3r_t local_direction = transform_to_local_direction(direction);
+    vector3r_t local_direction = TransformToLocalDirection(direction);
     Options local_options = {
         .freq0 = options.freq0,
-        .station0 = transform_to_local_direction(options.station0),
-        .tile0 = transform_to_local_direction(options.tile0)};
-    return local_arrayFactor(time, freq, local_direction, local_options);
+        .station0 = TransformToLocalDirection(options.station0),
+        .tile0 = TransformToLocalDirection(options.tile0)};
+    return LocalArrayFactor(time, freq, local_direction, local_options);
   }
 
   CoordinateSystem m_coordinate_system;
@@ -165,17 +165,17 @@ class Antenna {
   bool m_enabled[2];
 
  private:
-  virtual matrix22c_t local_response(real_t time, real_t freq,
+  virtual matrix22c_t LocalResponse(real_t time, real_t freq,
                                     const vector3r_t &direction,
                                     const Options &options) const = 0;
 
-  virtual diag22c_t local_arrayFactor(real_t time, real_t freq,
+  virtual diag22c_t LocalArrayFactor(real_t time, real_t freq,
                                      const vector3r_t &direction,
                                      const Options &options) const {
     return {1.0, 1.0};
   }
 
-  vector3r_t transform_to_local_direction(const vector3r_t &direction);
+  vector3r_t TransformToLocalDirection(const vector3r_t &direction);
 };
 
 }  // namespace everybeam

cpp/BeamFormer.cc → cpp/beamformer.cc

-#include "BeamFormer.h"
+#include "beamformer.h"
 
-#include "common/Constants.h"
-#include "common/MathUtil.h"
+#include "common/constants.h"
+#include "common/math_utils.h"
 
 #include <cmath>
 
 namespace everybeam {
-vector3r_t BeamFormer::transform_to_local_position(const vector3r_t &position) {
+vector3r_t BeamFormer::TransformToLocalPosition(const vector3r_t &position) {
   // Get antenna position relative to coordinate system origin
   vector3r_t dposition{position[0] - m_coordinate_system.origin[0],
                        position[1] - m_coordinate_system.origin[1],
@@ -21,17 +21,17 @@ vector3r_t BeamFormer::transform_to_local_position(const vector3r_t &position) {
   return local_position;
 }
 
-std::vector<std::complex<double>> BeamFormer::compute_geometric_response(
+std::vector<std::complex<double>> BeamFormer::ComputeGeometricResponse(
     const double freq, const vector3r_t &direction) const {
   // Initialize and fill result vector by looping over antennas
-  std::vector<std::complex<double>> result(m_antennas.size());
-  for (auto &antenna : m_antennas) {
+  std::vector<std::complex<double>> result(antennas_.size());
+  for (auto &antenna : antennas_) {
     const double dl = direction[0] * (antenna->m_phase_reference_position[0] -
-                                      m_local_phase_reference_position[0]) +
+                                      local_phase_reference_position_[0]) +
                       direction[1] * (antenna->m_phase_reference_position[1] -
-                                      m_local_phase_reference_position[1]) +
+                                      local_phase_reference_position_[1]) +
                       direction[2] * (antenna->m_phase_reference_position[2] -
-                                      m_local_phase_reference_position[2]);
+                                      local_phase_reference_position_[2]);
 
     double phase = -2 * M_PI * dl / (common::c / freq);
     result.push_back({std::sin(phase), std::cos(phase)});
@@ -40,28 +40,28 @@ std::vector<std::complex<double>> BeamFormer::compute_geometric_response(
 }
 
 std::vector<std::pair<std::complex<double>, std::complex<double>>>
-BeamFormer::compute_weights(const vector3r_t &pointing, double freq) const {
+BeamFormer::ComputeWeights(const vector3r_t &pointing, double freq) const {
   // Get geometric response for pointing direction
-  auto geometric_response = compute_geometric_response(freq, pointing);
+  auto geometric_response = ComputeGeometricResponse(freq, pointing);
 
   // Initialize and fill result
   double weight_sum[2] = {0.0, 0.0};
   std::vector<std::pair<std::complex<double>, std::complex<double>>> result(
       geometric_response.size());
-  for (std::size_t antenna_idx = 0; antenna_idx < m_antennas.size();
+  for (std::size_t antenna_idx = 0; antenna_idx < antennas_.size();
        ++antenna_idx) {
     // Compute conjugate of geometric response
     auto phasor_conj = std::conj(geometric_response[antenna_idx]);
     // Compute the delays in x/y direction
     result.push_back(
-        {phasor_conj * (1.0 * m_antennas[antenna_idx]->m_enabled[0]),
-         phasor_conj * (1.0 * m_antennas[antenna_idx]->m_enabled[1])});
-    weight_sum[0] += (1.0 * m_antennas[antenna_idx]->m_enabled[0]);
-    weight_sum[1] += (1.0 * m_antennas[antenna_idx]->m_enabled[1]);
+        {phasor_conj * (1.0 * antennas_[antenna_idx]->m_enabled[0]),
+         phasor_conj * (1.0 * antennas_[antenna_idx]->m_enabled[1])});
+    weight_sum[0] += (1.0 * antennas_[antenna_idx]->m_enabled[0]);
+    weight_sum[1] += (1.0 * antennas_[antenna_idx]->m_enabled[1]);
   }
 
   // Normalize the weight by the number of antennas
-  for (std::size_t antenna_idx = 0; antenna_idx < m_antennas.size();
+  for (std::size_t antenna_idx = 0; antenna_idx < antennas_.size();
        ++antenna_idx) {
     result[antenna_idx].first /= weight_sum[0];
     result[antenna_idx].second /= weight_sum[1];
@@ -70,23 +70,23 @@ BeamFormer::compute_weights(const vector3r_t &pointing, double freq) const {
   return result;
 }
 
-matrix22c_t BeamFormer::local_response(real_t time, real_t freq,
+matrix22c_t BeamFormer::LocalResponse(real_t time, real_t freq,
                                       const vector3r_t &direction,
                                       const Options &options) const {
   // Weights based on pointing direction of beam
-  auto weights = compute_weights(options.station0, options.freq0);
+  auto weights = ComputeWeights(options.station0, options.freq0);
   // Weights based on direction of interest
-  auto geometric_response = compute_geometric_response(freq, direction);
+  auto geometric_response = ComputeGeometricResponse(freq, direction);
 
   matrix22c_t result = {0};
-  for (unsigned int antenna_idx = 0; antenna_idx < m_antennas.size();
+  for (unsigned int antenna_idx = 0; antenna_idx < antennas_.size();
        ++antenna_idx) {
-    auto antenna = m_antennas[antenna_idx];
+    auto antenna = antennas_[antenna_idx];
     auto antenna_weight = weights[antenna_idx];
     auto antenna_geometric_reponse = geometric_response[antenna_idx];
 
     matrix22c_t antenna_response =
-        antenna->response(time, freq, direction, options);
+        antenna->Response(time, freq, direction, options);
 
     result[0][0] += antenna_weight.first * antenna_geometric_reponse *
                     antenna_response[0][0];

cpp/BeamFormer.h → cpp/beamformer.h

@@ -4,8 +4,8 @@
 #include <complex>
 #include <vector>
 
-#include "Element.h"
-#include "common/Types.h"
+#include "element.h"
+#include "common/types.h"
 
 namespace everybeam {
 class BeamFormer : public Antenna {
@@ -17,8 +17,8 @@ class BeamFormer : public Antenna {
    *
    */
   BeamFormer() : Antenna() {
-    m_local_phase_reference_position =
-        transform_to_local_position(m_phase_reference_position);
+    local_phase_reference_position_ =
+        TransformToLocalPosition(m_phase_reference_position);
   }
 
   /**
@@ -28,8 +28,8 @@ class BeamFormer : public Antenna {
    */
   BeamFormer(const CoordinateSystem &coordinate_system)
       : Antenna(coordinate_system) {
-    m_local_phase_reference_position =
-        transform_to_local_position(m_phase_reference_position);
+    local_phase_reference_position_ =
+        TransformToLocalPosition(m_phase_reference_position);
   }
 
   /**
@@ -42,14 +42,14 @@ class BeamFormer : public Antenna {
   BeamFormer(CoordinateSystem coordinate_system,
              vector3r_t phase_reference_position)
       : Antenna(coordinate_system, phase_reference_position) {
-    m_local_phase_reference_position =
-        transform_to_local_position(m_phase_reference_position);
+    local_phase_reference_position_ =
+        TransformToLocalPosition(m_phase_reference_position);
   }
 
   BeamFormer(vector3r_t phase_reference_position)
       : Antenna(phase_reference_position) {
-    m_local_phase_reference_position =
-        transform_to_local_position(m_phase_reference_position);
+    local_phase_reference_position_ =
+        TransformToLocalPosition(m_phase_reference_position);
   }
 
   /**
@@ -57,24 +57,24 @@ class BeamFormer : public Antenna {
    *
    * @param antenna
    */
-  void add_antenna(Antenna::Ptr antenna) { m_antennas.push_back(antenna); }
+  void AddAntenna(Antenna::Ptr antenna) { antennas_.push_back(antenna); }
 
  private:
   vector3r_t
-      m_local_phase_reference_position;  // in coordinate system of Antenna
+      local_phase_reference_position_;  // in coordinate system of Antenna
 
   // Transform position vector into a local position vector
-  vector3r_t transform_to_local_position(const vector3r_t &position);
+  vector3r_t TransformToLocalPosition(const vector3r_t &position);
 
   // Compute the BeamFormer response in certain direction of arrival (ITRF, m)
   // and return (Jones) matrix of response
-  virtual matrix22c_t local_response(real_t time, real_t freq,
+  virtual matrix22c_t LocalResponse(real_t time, real_t freq,
                                     const vector3r_t &direction,
                                     const Options &options) const override;
 
-  // Compute the local arrayFactor, with arrayFactor a vectorial
+  // Compute the local ArrayFactor, with ArrayFactor a vectorial
   // "representation" of Jones matrix
-  virtual diag22c_t local_arrayFactor(real_t time, real_t freq,
+  virtual diag22c_t LocalArrayFactor(real_t time, real_t freq,
                                      const vector3r_t &direction,
                                      const Options &options) const override {
     return {1.0, 1.0};
@@ -83,18 +83,16 @@ class BeamFormer : public Antenna {
   // Compute the geometric response for all the antennas in the BeamFormer based
   // on the probing frequency and a specified direction (either pointing dir or
   // dir of interest).
-  std::vector<std::complex<double>> compute_geometric_response(
+  std::vector<std::complex<double>> ComputeGeometricResponse(
       const double freq, const vector3r_t &direction) const;
 
   // Compute the weights based on the pointing direction of the beam and the
   // beam reference frequence.
   std::vector<std::pair<std::complex<double>, std::complex<double>>>
-  compute_weights(const vector3r_t &direction, double freq) const;
+  ComputeWeights(const vector3r_t &direction, double freq) const;
 
   // List of antennas in BeamFormer
-  // TODO: Maybe refactor to _m_antennas to indicate m_antennas is a private
-  // attribute
-  std::vector<Antenna::Ptr> m_antennas;
+  std::vector<Antenna::Ptr> antennas_;
 };
 }  // namespace everybeam
 #endif

cpp/common/CMakeLists.txt

 install (FILES
+  constants.h
   casa_utils.h
-  Constants.h
-  MathUtil.h
-  MutablePtr.h
-  Types.h
+  math_utils.h
+  mutable_ptr.h
+  types.h
 DESTINATION "include/${CMAKE_PROJECT_NAME}/common")

cpp/common/casa_utils.h

@@ -24,8 +24,8 @@
 #ifndef EVERYBEAM_COMMON_CASAUTIL_H_
 #define EVERYBEAM_COMMON_CASAUTIL_H_
 
-#include "Types.h"
-#include "./../Antenna.h"
+#include "types.h"
+#include "./../antenna.h"
 
 #include <cassert>
 
@@ -49,8 +49,8 @@ namespace common {
  * @param id Id of the antenna field in the station (int)
  * @return Antenna::CoordinateSystem
  */
-Antenna::CoordinateSystem readCoordinateSystem(const casacore::Table &table,
-                                               unsigned int id) {
+inline Antenna::CoordinateSystem readCoordinateSystem(
+    const casacore::Table &table, unsigned int id) {
   casacore::ArrayQuantColumn<casacore::Double> c_position(table, "POSITION",
                                                           "m");
   casacore::ArrayQuantColumn<casacore::Double> c_axes(table, "COORDINATE_AXES",
@@ -88,7 +88,7 @@ Antenna::CoordinateSystem readCoordinateSystem(const casacore::Table &table,
  * @return true If column present
  * @return false If column not present
  */
-bool hasColumn(const casacore::Table &table, const string &column) {
+inline bool hasColumn(const casacore::Table &table, const string &column) {
   return table.tableDesc().isColumn(column);
 }
 
@@ -99,7 +99,8 @@ bool hasColumn(const casacore::Table &table, const string &column) {
  * @param name Name of sub table (str)
  * @return Table (casacore::Table)
  */
-casacore::Table getSubTable(const casacore::Table &table, const string &name) {
+inline casacore::Table getSubTable(const casacore::Table &table,
+                                   const string &name) {
   return table.keywordSet().asTable(name);
 }
 }  // namespace common

cpp/common/Constants.h → cpp/common/constants.h

-// Constants.h: %Constants used in this library.
+// constants.h: %Constants used in this library.
 //
 // Copyright (C) 2013
 // ASTRON (Netherlands Institute for Radio Astronomy)
@@ -26,7 +26,7 @@
 // \file
 // %Constants used in this library.
 
-#include "Types.h"
+#include "types.h"
 
 namespace everybeam {
 namespace common {

cpp/common/MathUtil.h → cpp/common/math_utils.h

-// MathUtil.h: Various mathematical operations on vectors and matrices.
+// math_utils.h: Various mathematical operations on vectors and matrices.
 //
 // Copyright (C) 2013
 // ASTRON (Netherlands Institute for Radio Astronomy)
@@ -26,7 +26,7 @@
 // \file
 // Various mathematical operations on vectors and matrices.
 
-#include "Types.h"
+#include "types.h"
 
 namespace everybeam {
 

cpp/common/MutablePtr.h → cpp/common/mutable_ptr.h

-// MutablePtr.h: Representation of an LBA antenna field.
+// mutableptr.h: Representation of an LBA antenna field.
 //
 // Copyright (C) 2013
 // ASTRON (Netherlands Institute for Radio Astronomy)
@@ -44,7 +44,7 @@ namespace common {
  *
  * \code
  * #include<iostream>
- * #include "MutablePtr.h"
+ * #include "mutable_ptr.h"
  *
  * class Msg {
  * public:

cpp/common/Singleton.h → cpp/common/singleton.h

@@ -3,7 +3,7 @@ namespace common {
 template <typename T>
 class Singleton {
  public:
-  static std::shared_ptr<T> getInstance() {
+  static std::shared_ptr<T> GetInstance() {
     static std::shared_ptr<T> instance(new T());  // Guaranteed to be destroyed.
                                                   // Instantiated on first use.
     return instance;

cpp/common/Types.h → cpp/common/types.h

-// Types.h: Types used in this library.
+// types.h: Types used in this library.
 //
 // Copyright (C) 2013
 // ASTRON (Netherlands Institute for Radio Astronomy)
@@ -102,4 +102,4 @@ std::ostream &operator<<(std::ostream &out, const std::array<T, N> &obj) {
 
 }  // namespace everybeam
 
-#endif
+#endif  // EVERYBEAM_TYPES_H

cpp/coords/ITRFConverter.h

@@ -6,7 +6,7 @@
 // \file
 // Functor that maps J2000 to an ITRF direction.
 
-#include "./../common/Types.h"
+#include "./../common/types.h"
 
 #include <casacore/measures/Measures/MeasFrame.h>
 #include <casacore/measures/Measures/MeasConvert.h>

cpp/coords/ITRFDirection.h

@@ -26,7 +26,7 @@
 // \file
 // Functor that maps time to an ITRF direction.
 
-#include "./../common/Types.h"
+#include "./../common/types.h"
 
 #include <casacore/measures/Measures/MeasFrame.h>
 #include <casacore/measures/Measures/MeasConvert.h>

cpp/coords/coord_utils.h

 #ifndef EVERYBEAM_COORDS_COORDUTILS_H_
 #define EVERYBEAM_COORDS_COORDUTILS_H_
 
-#include "./../common/Types.h"
+#include "./../common/types.h"
 #include <casacore/measures/Measures/MCDirection.h>
 
 namespace everybeam {

cpp/Element.cc → cpp/element.cc

-#include "Element.h"
-#include "common/MathUtil.h"
+#include "element.h"
+#include "common/math_utils.h"
 
 namespace everybeam {
-matrix22c_t Element::local_response(real_t time, real_t freq,
+matrix22c_t Element::LocalResponse(real_t time, real_t freq,
                                    const vector3r_t &direction, size_t id,
                                    const Options &options) const {
   vector2r_t thetaphi = cart2thetaphi(direction);
 
   matrix22c_t result;
   static_assert(sizeof(std::complex<double>[2][2]) == sizeof(matrix22c_t));
-  m_element_response->response(
+  m_element_response->Response(
       id, freq, thetaphi[0], thetaphi[1],
       reinterpret_cast<std::complex<double>(&)[2][2]>(result));
 
@@ -25,9 +25,9 @@ matrix22c_t Element::local_response(real_t time, real_t freq,
   return result;
 }
 
-matrix22c_t Element::local_response(real_t time, real_t freq,
+matrix22c_t Element::LocalResponse(real_t time, real_t freq,
                                    const vector3r_t &direction,
                                    const Options &options) const {
-  return local_response(time, freq, direction, m_id, options);
+  return LocalResponse(time, freq, direction, m_id, options);
 }
 }  // namespace everybeam

cpp/Element.h → cpp/element.h

@@ -4,9 +4,9 @@
 #include <complex>
 #include <memory>
 
-#include "Antenna.h"
-#include "ElementResponse.h"
-#include "common/Types.h"
+#include "antenna.h"
+#include "element_response.h"
+#include "common/types.h"
 
 namespace everybeam {
 
@@ -42,12 +42,12 @@ class Element : public Antenna {
    * @param options
    * @return matrix22c_t
    */
-  matrix22c_t local_response(real_t time, real_t freq,
+  matrix22c_t LocalResponse(real_t time, real_t freq,
                             const vector3r_t &direction, size_t id,
                             const Options &options) const;
 
  private:
-  virtual matrix22c_t local_response(
+  virtual matrix22c_t LocalResponse(
       real_t time, real_t freq, const vector3r_t &direction,
       const Options &options) const final override;