Refactoring: leaf material implementations renamed

Redmine: #1871

Core/Material/WavelengthIndependentMaterial.cpp → Core/Material/MaterialBySLDImpl.cpp

-#include "WavelengthIndependentMaterial.h"
+#include "MaterialBySLDImpl.h"
 #include "WavevectorInfo.h"
 
 namespace
@@ -16,41 +16,41 @@ inline double getWlPrefactor(double wavelength)
 }
 }
 
-WavelengthIndependentMaterial::WavelengthIndependentMaterial(const std::string& name, double sld,
+MaterialBySLDImpl::MaterialBySLDImpl(const std::string& name, double sld,
                                                              double abs_term,
                                                              kvector_t magnetization)
     : MagneticMaterialImpl(name, magnetization), m_sld(sld), m_abs_term(abs_term)
 {}
 
-WavelengthIndependentMaterial* WavelengthIndependentMaterial::clone() const
+MaterialBySLDImpl* MaterialBySLDImpl::clone() const
 {
-    return new WavelengthIndependentMaterial(*this);
+    return new MaterialBySLDImpl(*this);
 }
 
-complex_t WavelengthIndependentMaterial::refractiveIndex(double wavelength) const
+complex_t MaterialBySLDImpl::refractiveIndex(double wavelength) const
 {
     return std::sqrt(refractiveIndex2(wavelength));
 }
 
-complex_t WavelengthIndependentMaterial::refractiveIndex2(double wavelength) const
+complex_t MaterialBySLDImpl::refractiveIndex2(double wavelength) const
 {
     return 1.0 - getWlPrefactor(wavelength) * getSLD(m_sld, m_abs_term);
 }
 
-complex_t WavelengthIndependentMaterial::materialData() const
+complex_t MaterialBySLDImpl::materialData() const
 {
     return complex_t(m_sld, m_abs_term);
 }
 
-complex_t WavelengthIndependentMaterial::scalarSubtrSLD(const WavevectorInfo& wavevectors) const
+complex_t MaterialBySLDImpl::scalarSubtrSLD(const WavevectorInfo& wavevectors) const
 {
     double wavelength = wavevectors.getWavelength();
     return 1.0 / getWlPrefactor(wavelength) - getSLD(m_sld, m_abs_term);
 }
 
-void WavelengthIndependentMaterial::print(std::ostream& ostr) const
+void MaterialBySLDImpl::print(std::ostream& ostr) const
 {
-    ostr << "WavelengthIndependentMaterial:" << getName() << "<" << this << ">{ "
+    ostr << "MaterialBySLD:" << getName() << "<" << this << ">{ "
          << "sld=" << m_sld << ", absorp_term=" << m_abs_term
          << ", B=" << magnetization() << "}";
 }

Core/Material/WavelengthIndependentMaterial.h → Core/Material/MaterialBySLDImpl.h

@@ -2,8 +2,8 @@
 //
 //  BornAgain: simulate and fit scattering at grazing incidence
 //
-//! @file      Core/Material/WavelengthIndependentMaterial.h
-//! @brief     Defines class WavelengthIndependentMaterial.
+//! @file      Core/Material/MaterialBySLDImpl.h
+//! @brief     Defines class MaterialBySLDImpl.
 //!
 //! @homepage  http://www.bornagainproject.org
 //! @license   GNU General Public License v3 or higher (see COPYING)
@@ -13,8 +13,8 @@
 //
 // ************************************************************************** //
 
-#ifndef WAVELENGTHINDEPENDENTMATERIAL_H_
-#define WAVELENGTHINDEPENDENTMATERIAL_H_
+#ifndef MATERIALBYSLDIMPL_H_
+#define MATERIALBYSLDIMPL_H_
 
 #include "MagneticMaterialImpl.h"
 #include "Material.h"
@@ -22,15 +22,15 @@
 //! Material implementation based on wavelength-independent data (valid for a range of wavelengths)
 //! @ingroup materials
 
-class BA_CORE_API_ WavelengthIndependentMaterial : public MagneticMaterialImpl
+class BA_CORE_API_ MaterialBySLDImpl : public MagneticMaterialImpl
 {
 public:
     friend BA_CORE_API_ Material MaterialBySLD(const std::string&, double, double, kvector_t);
 
-    virtual ~WavelengthIndependentMaterial() = default;
+    virtual ~MaterialBySLDImpl() = default;
 
     //! Returns pointer to a copy of material
-    virtual WavelengthIndependentMaterial* clone() const override;
+    virtual MaterialBySLDImpl* clone() const override;
 
     //! Returns refractive index
     virtual complex_t refractiveIndex(double wavelength) const override;
@@ -54,7 +54,7 @@ public:
     virtual void print(std::ostream &ostr) const override;
 
 private:
-    WavelengthIndependentMaterial(const std::string& name, double sld, double abs_term,
+    MaterialBySLDImpl(const std::string& name, double sld, double abs_term,
                                   kvector_t magnetization);
 
     double m_sld; //!< product of number density and coherent scattering length
@@ -63,4 +63,4 @@ private:
                         //!< absorption cross-section normalized to wavelength
 };
 
-#endif /* WAVELENGTHINDEPENDENTMATERIAL_H_ */
+#endif /* MATERIALBYSLDIMPL_H_ */

Core/Material/MaterialFactoryFuncs.cpp

 #include "MaterialFactoryFuncs.h"
-#include "RefractiveCoefMaterial.h"
-#include "WavelengthIndependentMaterial.h"
+#include "MaterialBySLDImpl.h"
+#include "RefractiveMaterialImpl.h"
 
 Material HomogeneousMaterial(const std::string& name, complex_t refractive_index,
                                  kvector_t magnetization)
@@ -13,8 +13,8 @@ Material HomogeneousMaterial(const std::string& name, complex_t refractive_index
 Material HomogeneousMaterial(const std::string& name, double delta, double beta,
                                  kvector_t magnetization)
 {
-    std::unique_ptr<RefractiveCoefMaterial> mat_impl(
-        new RefractiveCoefMaterial(name, delta, beta, magnetization));
+    std::unique_ptr<RefractiveMaterialImpl> mat_impl(
+        new RefractiveMaterialImpl(name, delta, beta, magnetization));
     return Material(std::move(mat_impl));
 }
 
@@ -26,8 +26,8 @@ Material HomogeneousMaterial()
 Material MaterialBySLD(const std::string& name, double sld, double abs_term,
                        kvector_t magnetization)
 {
-    std::unique_ptr<WavelengthIndependentMaterial> mat_impl(
-        new WavelengthIndependentMaterial(name, sld, abs_term, magnetization));
+    std::unique_ptr<MaterialBySLDImpl> mat_impl(
+        new MaterialBySLDImpl(name, sld, abs_term, magnetization));
     return Material(std::move(mat_impl));
 }
 

Core/Material/RefractiveCoefMaterial.cpp → Core/Material/RefractiveMaterialImpl.cpp

-#include "RefractiveCoefMaterial.h"
+#include "RefractiveMaterialImpl.h"
 #include "WavevectorInfo.h"
 
-RefractiveCoefMaterial::RefractiveCoefMaterial(const std::string& name, double delta, double beta,
+RefractiveMaterialImpl::RefractiveMaterialImpl(const std::string& name, double delta, double beta,
                                                  kvector_t magnetization)
     : MagneticMaterialImpl(name, magnetization)
     , m_delta(delta)
     , m_beta(beta)
 {}
 
-RefractiveCoefMaterial* RefractiveCoefMaterial::clone() const
+RefractiveMaterialImpl* RefractiveMaterialImpl::clone() const
 {
-    return new RefractiveCoefMaterial(*this);
+    return new RefractiveMaterialImpl(*this);
 }
 
-complex_t RefractiveCoefMaterial::refractiveIndex(double) const
+complex_t RefractiveMaterialImpl::refractiveIndex(double) const
 {
     return complex_t(1.0 - m_delta, m_beta);
 }
 
-complex_t RefractiveCoefMaterial::refractiveIndex2(double) const
+complex_t RefractiveMaterialImpl::refractiveIndex2(double) const
 {
     complex_t result(1.0 - m_delta, m_beta);
     return result * result;
 }
 
-complex_t RefractiveCoefMaterial::materialData() const
+complex_t RefractiveMaterialImpl::materialData() const
 {
     return complex_t(m_delta, m_beta);
 }
 
-complex_t RefractiveCoefMaterial::scalarSubtrSLD(const WavevectorInfo& wavevectors) const
+complex_t RefractiveMaterialImpl::scalarSubtrSLD(const WavevectorInfo& wavevectors) const
 {
     double wavelength = wavevectors.getWavelength();
     double prefactor = M_PI/wavelength/wavelength;
     return prefactor * refractiveIndex2(wavelength);
 }
 
-void RefractiveCoefMaterial::print(std::ostream& ostr) const
+void RefractiveMaterialImpl::print(std::ostream& ostr) const
 {
-    ostr << "RefractiveCoefMaterial:" << getName() << "<" << this << ">{ "
+    ostr << "RefractiveMaterial:" << getName() << "<" << this << ">{ "
          << "delta=" << m_delta << ", beta=" << m_beta
          << ", B=" << magnetization() << "}";
 }

Core/Material/RefractiveCoefMaterial.h → Core/Material/RefractiveMaterialImpl.h

@@ -2,8 +2,8 @@
 //
 //  BornAgain: simulate and fit scattering at grazing incidence
 //
-//! @file      Core/Material/RefractiveCoefMaterial.h
-//! @brief     Defines class RefractiveCoefMaterial.
+//! @file      Core/Material/RefractiveMaterialImpl.h
+//! @brief     Defines class RefractiveMaterialImpl.
 //!
 //! @homepage  http://www.bornagainproject.org
 //! @license   GNU General Public License v3 or higher (see COPYING)
@@ -13,8 +13,8 @@
 //
 // ************************************************************************** //
 
-#ifndef REFRACTIVECOEFMATERIAL_H_
-#define REFRACTIVECOEFMATERIAL_H_
+#ifndef REFRACTIVEMATERIALIMPL_H_
+#define REFRACTIVEMATERIALIMPL_H_
 
 #include "MagneticMaterialImpl.h"
 #include "Material.h"
@@ -22,16 +22,16 @@
 //! Material implementation based on refractive coefficiencts (valid for one wavelength value only)
 //! @ingroup materials
 
-class BA_CORE_API_ RefractiveCoefMaterial : public MagneticMaterialImpl
+class BA_CORE_API_ RefractiveMaterialImpl : public MagneticMaterialImpl
 {
 public:
     friend BA_CORE_API_ Material HomogeneousMaterial(const std::string&, double, double,
                                                          kvector_t);
 
-    virtual ~RefractiveCoefMaterial() = default;
+    virtual ~RefractiveMaterialImpl() = default;
 
     //! Returns pointer to a copy of material
-    virtual RefractiveCoefMaterial* clone() const override;
+    virtual RefractiveMaterialImpl* clone() const override;
 
     //! Returns refractive index
     //! For this particular implementation returned value does not depend
@@ -62,11 +62,11 @@ public:
     virtual void print(std::ostream &ostr) const override;
 
 private:
-    RefractiveCoefMaterial(const std::string& name, double delta, double beta,
+    RefractiveMaterialImpl(const std::string& name, double delta, double beta,
                            kvector_t magnetization);
 
     double m_delta; //!< \f$\delta\f$ coefficient for refractive index \f$n = 1 - \delta + i \beta\f$
     double m_beta; //!< \f$\beta\f$ coefficient for refractive index \f$n = 1 - \delta + i \beta\f$
 };
 
-#endif /* REFRACTIVECOEFMATERIAL_H_ */
+#endif /* REFRACTIVEMATERIALIMPL_H_ */

Tests/UnitTests/Core/Other/MaterialTest.h

 #include "MaterialFactoryFuncs.h"
-#include "WavelengthIndependentMaterial.h"
-#include "RefractiveCoefMaterial.h"
+#include "MaterialBySLDImpl.h"
+#include "RefractiveMaterialImpl.h"
 #include "WavevectorInfo.h"
 #include "Rotations.h"
 #include "Units.h"