From 43d143d76e6adef73755a2f087ed949eeffbe53b Mon Sep 17 00:00:00 2001
From: Anna Ivagnes <s274001@studenti.polito.it>
Date: Wed, 13 Sep 2023 18:50:06 +0200
Subject: [PATCH] restore profiles and adjust tests

---
 bladex/__init__.py                            |   4 +-
 bladex/profile/__init__.py                    |   4 +-
 bladex/profile/customprofile.py               | 290 +++------
 bladex/profile/nacaprofile.py                 |  12 +-
 .../{profilebase.py => profileinterface.py}   | 261 +++++----
 tests/test_package.py                         |   4 -
 tests/test_profilebase.py                     | 549 ------------------
 tests/test_profileinterface.py                |  10 +
 tests/test_profiles.py                        |   6 +-
 9 files changed, 248 insertions(+), 892 deletions(-)
 rename bladex/profile/{profilebase.py => profileinterface.py} (86%)
 delete mode 100644 tests/test_profilebase.py
 create mode 100644 tests/test_profileinterface.py

diff --git a/bladex/__init__.py b/bladex/__init__.py
index ecc5d93..2605d9a 100644
--- a/bladex/__init__.py
+++ b/bladex/__init__.py
@@ -1,12 +1,12 @@
 """
 BladeX init
 """
-__all__ = ['ProfileBase', 'NacaProfile', 'CustomProfile', 'ReversePropeller',
+__all__ = ['ProfileInterface', 'NacaProfile', 'CustomProfile', 'ReversePropeller',
         'Blade', 'Shaft', 'Propeller', 'Deformation', 'ParamFile',
         'RBF', 'reconstruct_f', 'scipy_bspline']
 
 from .meta import *
-from .profile import ProfileBase
+from .profile import ProfileInterface
 from .profile import NacaProfile
 from .profile import CustomProfile
 from .blade import Blade
diff --git a/bladex/profile/__init__.py b/bladex/profile/__init__.py
index 88e90c8..3b44d32 100644
--- a/bladex/profile/__init__.py
+++ b/bladex/profile/__init__.py
@@ -1,8 +1,8 @@
 """
 Profile init
 """
-__all__ = ['ProfileBase', 'NacaProfile', 'CustomProfile']
+__all__ = ['ProfileInterface', 'NacaProfile', 'CustomProfile']
 
-from .profilebase import ProfileBase
+from .profileinterface import ProfileInterface
 from .nacaprofile import NacaProfile
 from .customprofile import CustomProfile
diff --git a/bladex/profile/customprofile.py b/bladex/profile/customprofile.py
index 68ef247..36227b3 100644
--- a/bladex/profile/customprofile.py
+++ b/bladex/profile/customprofile.py
@@ -8,11 +8,11 @@
 """
 
 import numpy as np
-from .profilebase import ProfileBase
+from .profileinterface import ProfileInterface
 from scipy.optimize import newton
 
 
-class CustomProfile(ProfileBase):
+class CustomProfile(ProfileInterface):
     """
     Provide custom profile, given the airfoil coordinates or the airfoil parameters,
     i.e. , chord percentages and length, nondimensional and maximum camber,
@@ -42,29 +42,31 @@ class CustomProfile(ProfileBase):
     :param float camber_max: the maximum camber at a certain airfoil section
     :param float thickness_max: the maximum thickness at a certain airfoil section
     """
-    def __init__(self, convention='british', **kwargs):
+    def __init__(self, **kwargs):
         super(CustomProfile, self).__init__()
-        self.convention = convention
 
         if set(kwargs.keys()) == set(
                 ['xup', 'yup', 'xdown', 'ydown']):
-            self.xup_coordinates = kwargs['xup']
-            self.yup_coordinates = kwargs['yup']
-            self.xdown_coordinates = kwargs['xdown']
-            self.ydown_coordinates = kwargs['ydown']
+            self._xup_coordinates = kwargs['xup']
+            self._yup_coordinates = kwargs['yup']
+            self._xdown_coordinates = kwargs['xdown']
+            self._ydown_coordinates = kwargs['ydown']
             self._check_coordinates()
+            self.generate_parameters(convention='british')
 
         elif set(kwargs.keys()) == set([
                 'chord_perc', 'camber_perc', 'thickness_perc',
-                'camber_max', 'thickness_max'
+                'camber_max', 'thickness_max' , 'chord_len'
         ]):
 
-            self.chord_percentage = kwargs['chord_perc']
-            self.camber_percentage = kwargs['camber_perc']
-            self.thickness_percentage = kwargs['thickness_perc']
-            self.camber_max = kwargs['camber_max']
-            self.thickness_max = kwargs['thickness_max']
+            self._chord_percentage = kwargs['chord_perc']
+            self._camber_percentage = kwargs['camber_perc']
+            self._thickness_percentage = kwargs['thickness_perc']
+            self._camber_max = kwargs['camber_max']
+            self._thickness_max = kwargs['thickness_max']
+            self._chord_length = kwargs['chord_len']
             self._check_parameters()
+            self.generate_coordinates(convention='british')
 
         else:
             raise RuntimeError(
@@ -72,54 +74,27 @@ def __init__(self, convention='british', **kwargs):
                 (xup, yup, xdown, ydown) or the section parameters (camber_perc, thickness_perc,
                 camber_max, thickness_max, chord_perc).""")
 
+    def generate_parameters(self, convention='british'):
+        return super().generate_parameters(convention)
+    
+    def generate_coordinates(self, convention='british'):
+        if convention == 'british':
+            self._compute_coordinates_british_convention()
+        elif convention == 'american':
+            self._compute_coordinates_american_convention()
 
-    def _check_parameters(self):
+    def _compute_coordinates_british_convention(self):
         """
-        Private method that checks whether the airfoil parameters defined
-        are provided correctly.
-        In particular, the chord, camber and thickness percentages are
-        consistent and have the same length.
+        Compute the coordinates of points on upper and lower profile according
+        to the British convention.
         """
-
-        if self.chord_percentage is None:
-            raise ValueError('object "chord_perc" refers to an empty array.')
-        if self.camber_percentage is None:
-            raise ValueError('object "camber_perc" refers to an empty array.')
-        if self.thickness_percentage is None:
-            raise ValueError(
-                'object "thickness_perc" refers to an empty array.')
-        if self.camber_max is None:
-            raise ValueError('object "camber_max" refers to an empty array.')
-        if self.thickness_max is None:
-            raise ValueError('object "thickness_max" refers to an empty array.')
-
-        if not isinstance(self.chord_percentage, np.ndarray):
-            self.chord_percentage = np.asarray(self.chord_percentage,
-                                               dtype=float)
-        if not isinstance(self.camber_percentage, np.ndarray):
-            self.camber_percentage = np.asarray(self.camber_percentage,
-                                                dtype=float)
-        if not isinstance(self.thickness_percentage, np.ndarray):
-            self.thickness_percentage = np.asarray(self.thickness_percentage,
-                                                   dtype=float)
-        if not isinstance(self.camber_max, np.ndarray):
-            self.camber_max = np.asarray(self.camber_max, dtype=float)
-        if not isinstance(self.thickness_max, np.ndarray):
-            self.thickness_max = np.asarray(self.thickness_max, dtype=float)
-        if self.camber_max < 0:
-            raise ValueError('camber_max must be positive.')
-        if self.thickness_max < 0:
-            raise ValueError('thickness_max must be positive.')
-
-        # Therefore the arrays camber_percentage and thickness_percentage
-        # should have the same length of chord_percentage, equal to n_pos,
-        # which is the number of cuts along the chord line
-        if self.camber_percentage.shape != self.chord_percentage.shape:
-            raise ValueError('camber_perc and chord_perc must have same shape.')
-        if self.thickness_percentage.shape != self.chord_percentage.shape:
-            raise ValueError(
-                'thickness_perc and chord_perc must have same shape.')
-
+        self._xup_coordinates = self.chord_percentage*self.chord_length
+        self._xdown_coordinates = self._xup_coordinates.copy()
+        self._yup_coordinates = (self.camber_percentage*self.camber_max +
+                self.thickness_max/2*self.thickness_percentage)
+        self._ydown_coordinates = (self.camber_percentage*self.camber_max -
+                self.thickness_max/2*self.thickness_percentage)
+    
     def _compute_orth_camber_coordinates(self):
         """
         Compute the coordinates of points on upper and lower profile on the
@@ -134,13 +109,13 @@ def _compute_orth_camber_coordinates(self):
         for i in range(1, n_pos, 1):
             m[i] = (self.camber_percentage[i]-
                 self.camber_percentage[i-1])/(self.chord_percentage[i]-
-                    self.chord_percentage[i-1])*self.camber_max/self.chord_len
+                    self.chord_percentage[i-1])*self.camber_max/self.chord_length
 
         m_angle = np.arctan(m)
 
-        xup_tmp = (self.chord_percentage*self.chord_len -
+        xup_tmp = (self.chord_percentage*self.chord_length -
                 self.thickness_percentage*np.sin(m_angle)*self.thickness_max/2)
-        xdown_tmp = (self.chord_percentage*self.chord_len +
+        xdown_tmp = (self.chord_percentage*self.chord_length +
                 self.thickness_percentage*np.sin(m_angle)*self.thickness_max/2)
         yup_tmp = (self.camber_percentage*self.camber_max +
                 self.thickness_max/2*self.thickness_percentage*np.cos(m_angle))
@@ -152,150 +127,67 @@ def _compute_orth_camber_coordinates(self):
             yup_tmp[1], ydown_tmp[1] = yup_tmp[2]-1e-16, ydown_tmp[2]-1e-16
 
         return [xup_tmp, xdown_tmp, yup_tmp, ydown_tmp]
-
-    def _compute_coordinates_british_convention(self):
-        """
-        Compute the coordinates of points on upper and lower profile according
-        to the British convention.
-        """
-        self.xup_coordinates = self.chord_percentage
-        self.xdown_coordinates = self.xup_coordinates.copy()
-        self.yup_coordinates = (self.camber_percentage*self.camber_max +
-                self.thickness_max/2*self.thickness_percentage)
-        self.ydown_coordinates = (self.camber_percentage*self.camber_max -
-                self.thickness_max/2*self.thickness_percentage)
-        self._check_coordinates()
-
+        
     def _compute_coordinates_american_convention(self):
         """
         Compute the coordinates of points on upper and lower profile according
         to the American convention.
         """
-        [self.xup_coordinates, self.xdown_coordinates, self.yup_coordinates,
-            self.ydown_coordinates] = self._compute_orth_camber_coordinates()
+        [self._xup_coordinates, self._xdown_coordinates, self._yup_coordinates,
+            self._ydown_coordinates] = self._compute_orth_camber_coordinates()
 
-        self.ydown_coordinates = self.ydown_curve(
-                (self.chord_percentage).reshape(-1,1)).reshape(
+        self._ydown_coordinates = self.ydown_curve(
+                (self.chord_percentage*self.chord_length).reshape(-1,1)).reshape(
                         self.chord_percentage.shape)
-        self.xup_coordinates = self.chord_percentage
-        self.xdown_coordinates = self.xup_coordinates.copy()
-        self.yup_coordinates = (2*self.camber_max*self.camber_percentage -
+        self._yup_coordinates = (2*self.camber_max*self.camber_percentage -
                 self.ydown_coordinates)
 
-    def generate_coordinates(self, convention='british'):
-        """
-        Method that generates the coordinates of a general airfoil
-        profile, starting from the chord percentages and the related
-        nondimensional camber and thickness, the maximum values of thickness
-        and camber. The convention fot the coordinates generation
-        can be either British or American.
-        """
-        if convention == 'british':
-            self._compute_coordinates_british_convention()
-        elif convention == 'american':
-            self._compute_coordinates_american_convention()
-        else:
-            raise ValueError('Convention not recognized.')
-
-#    def adimensionalize(self):
-#        """
-#        Rescale coordinates of upper and lower profiles of section such that
-#        coordinates on x axis are between 0 and 1.
-#        """
-#        factor = abs(self.xup_coordinates[-1]-self.xup_coordinates[0])
-#        self.yup_coordinates *= 1/factor
-#        self.xdown_coordinates *= 1/factor
-#        self.ydown_coordinates *= 1/factor
-#        self.xup_coordinates *= 1/factor
-
-    def _compute_thickness_british_convention(self):
-        """
-        Generate parameters in British convention.
-        """
-        thickness = abs(self.yup_coordinates - self.ydown_coordinates)
-        self.thickness_max = np.max(thickness)
-        self.thickness_percentage = thickness/self.thickness_max
-
-    def _compute_thickness_american_convention(self):
-        """
-        Generate parameters in American convention.
-        """
-        n_pos = self.xup_coordinates.shape[0]
-        m = np.zeros(n_pos)
-        for i in range(1, n_pos, 1):
-            m[i] = (self.camber_percentage[i]-
-                self.camber_percentage[i-1])/(self.chord_percentage[i]-
-                    self.chord_percentage[i-1])*self.camber_max#/self.chord_len
-        m_angle = np.arctan(m)
-
-        # generating temporary profile coordinates orthogonal to the camber
-        # line
-        camber = self.camber_max*self.camber_percentage
-        ind_horizontal_camber = (np.sin(m_angle)==0)
-        def eq_to_solve(x):
-            spline_curve = self.ydown_curve(x.reshape(-1,1)).reshape(
-                    x.shape[0],)
-            line_orth_camber = (camber[~ind_horizontal_camber] +
-                    np.cos(m_angle[~ind_horizontal_camber])/
-                    np.sin(m_angle[~ind_horizontal_camber])*(
-                        self.chord_percentage[~ind_horizontal_camber]-x))
-            return spline_curve - line_orth_camber
-
-        xdown_tmp = self.xdown_coordinates.copy()
-        xdown_tmp[~ind_horizontal_camber] = newton(eq_to_solve,
-                xdown_tmp[~ind_horizontal_camber])
-        xup_tmp = (2*self.chord_percentage - xdown_tmp)
-        ydown_tmp = self.ydown_curve(xdown_tmp.reshape(-1,1)).reshape(
-                xdown_tmp.shape[0],)
-        yup_tmp = 2*self.camber_max*self.camber_percentage - ydown_tmp
-        if xup_tmp[1]<self.xup_coordinates[0]:
-            xup_tmp[1], xdown_tmp[1] = xup_tmp[2], xdown_tmp[2]
-            yup_tmp[1], ydown_tmp[1] = yup_tmp[2], ydown_tmp[2]
-
-        thickness = np.sqrt((xup_tmp-xdown_tmp)**2 + (yup_tmp-ydown_tmp)**2)
-        self.thickness_max = np.max(thickness)
-        self.thickness_percentage = thickness/self.thickness_max
-
-    def _generate_camber(self):
+    def _check_parameters(self):
         """
-        Generate camber percentage and camber max.
+        Private method that checks whether the airfoil parameters defined
+        are provided correctly.
+        In particular, the chord, camber and thickness percentages are
+        consistent and have the same length.
         """
-        camber = (self.yup_coordinates + self.ydown_coordinates)/2
-        self.camber_max = abs(np.max(camber))
-        if self.camber_max == 0:
-            # symmetric profile
-            self.camber_percentage = np.zeros(camber.shape)
-        else:
-            # cambered profile
-            self.camber_percentage = camber/self.camber_max
 
-    def _generate_chord(self):
-        """
-        Generate chord length and chord percentages.
-        """
-        self.chord_percentage = (self.xup_coordinates -
-                np.min(self.xup_coordinates))/(
-            self.xup_coordinates[-1] - self.xup_coordinates[0])
+        if self._chord_percentage is None:
+            raise ValueError('object "chord_perc" refers to an empty array.')
+        if self._camber_percentage is None:
+            raise ValueError('object "camber_perc" refers to an empty array.')
+        if self._thickness_percentage is None:
+            raise ValueError(
+                'object "thickness_perc" refers to an empty array.')
+        if self._camber_max is None:
+            raise ValueError('object "camber_max" refers to an empty array.')
+        if self._thickness_max is None:
+            raise ValueError('object "thickness_max" refers to an empty array.')
 
+        if not isinstance(self._chord_percentage, np.ndarray):
+            self._chord_percentage = np.asarray(self._chord_percentage,
+                                               dtype=float)
+        if not isinstance(self._camber_percentage, np.ndarray):
+            self._camber_percentage = np.asarray(self._camber_percentage,
+                                                dtype=float)
+        if not isinstance(self.thickness_percentage, np.ndarray):
+            self._thickness_percentage = np.asarray(self.thickness_percentage,
+                                                   dtype=float)
+        if not isinstance(self.camber_max, np.ndarray):
+            self._camber_max = np.asarray(self._camber_max, dtype=float)
+        if not isinstance(self.thickness_max, np.ndarray):
+            self._thickness_max = np.asarray(self._thickness_max, dtype=float)
+        if self._camber_max < 0:
+            raise ValueError('camber_max must be positive.')
+        if self._thickness_max < 0:
+            raise ValueError('thickness_max must be positive.')
 
-    def generate_parameters(self, convention='british'):
-        """
-        Method that generates the parameters of a general airfoil profile
-        (chord length, chord percentages, camber max, thickness max, camber and
-        thickness percentages), starting from the upper and lower
-        coordinates of the section profile.
-        """
-        # generate camber and chord
-        self._generate_camber()
-        self._generate_chord()
-        # generate thickness according to the chosen convention
-        if convention == 'british' or self.camber_max == 0:
-            self._compute_thickness_british_convention()
-        elif convention == 'american' and self.camber_max != 0:
-
-            self._compute_thickness_american_convention()
-        else:
-            raise ValueError('Convention not recognized.')
+        # Therefore the arrays camber_percentage and thickness_percentage
+        # should have the same length of chord_percentage, equal to n_pos,
+        # which is the number of cuts along the chord line
+        if self._camber_percentage.shape != self._chord_percentage.shape:
+            raise ValueError('camber_perc and chord_perc must have same shape.')
+        if self._thickness_percentage.shape != self._chord_percentage.shape:
+            raise ValueError(
+                'thickness_perc and chord_perc must have same shape.')
 
     def _check_coordinates(self):
         """
@@ -346,18 +238,6 @@ def _check_coordinates(self):
         if self.xdown_coordinates.shape != self.ydown_coordinates.shape:
             raise ValueError('xdown and ydown must have same shape.')
 
-#        if not (np.isclose(self.ydown_coordinates[0],
-#                self.yup_coordinates[0], atol=1e-18) and
-#                np.isclose(self.ydown_coordinates[0], 0, atol=1e-6)):
-#            print('(ydown[0]=yup[0]=0) not satisfied, setting to 0.')
-#            self.ydown_coordinates[0] = self.yup_coordinates[0] = 0
-#
-#        if not (np.isclose(self.ydown_coordinates[-1],
-#                self.yup_coordinates[-1], atol=1e-18) and
-#                np.isclose(self.ydown_coordinates[-1], 0, atol=1e-6)):
-#            print('(ydown[-1]=yup[-1]=0) not satisfied, setting to 0.')
-#            self.ydown_coordinates[-1] = self.yup_coordinates[-1] = 0
-
         # The condition yup_coordinates >= ydown_coordinates must be satisfied
         # element-wise to the whole elements in the mentioned arrays.
         if not all(
@@ -378,4 +258,4 @@ def _check_coordinates(self):
 
         if not np.isclose(self.ydown_coordinates[-1], self.yup_coordinates[-1],
                 atol=1e-6):
-            raise ValueError('(ydown[0]=yup[0]) not satisfied.')
+            raise ValueError('(ydown[0]=yup[0]) not satisfied.')
\ No newline at end of file
diff --git a/bladex/profile/nacaprofile.py b/bladex/profile/nacaprofile.py
index 7e39c23..b7d0bb1 100644
--- a/bladex/profile/nacaprofile.py
+++ b/bladex/profile/nacaprofile.py
@@ -4,9 +4,9 @@
 """
 from scipy.interpolate import splev, splrep
 import numpy as np
-from .profilebase import ProfileBase
+from .profileinterface import ProfileInterface
 
-class NacaProfile(ProfileBase):
+class NacaProfile(ProfileInterface):
     """
     Generate 4- and 5-digit NACA profiles.
 
@@ -68,7 +68,8 @@ def __init__(self, digits, n_points=240, cosine_spacing=True):
         self.n_points = n_points
         self.cosine_spacing = cosine_spacing
         self._check_args()
-        self._generate_coordinates()
+        self.generate_coordinates()
+        self.generate_parameters(convention='british')
 
     def _check_args(self):
         """
@@ -84,7 +85,10 @@ def _check_args(self):
         if self.n_points < 0:
             raise ValueError('n_points must be positive.')
 
-    def _generate_coordinates(self):
+    def generate_parameters(self, convention='british'):
+        return super().generate_parameters(convention)
+
+    def generate_coordinates(self):
         """
         Private method that generates the coordinates of the NACA 4 or 5 digits
         airfoil profile. The method assumes a zero-thickness trailing edge, and
diff --git a/bladex/profile/profilebase.py b/bladex/profile/profileinterface.py
similarity index 86%
rename from bladex/profile/profilebase.py
rename to bladex/profile/profileinterface.py
index e283f53..0fbf337 100644
--- a/bladex/profile/profilebase.py
+++ b/bladex/profile/profileinterface.py
@@ -9,7 +9,7 @@
 from abc import ABC, abstractmethod
 from scipy.optimize import newton
 
-class ProfileBase(ABC, object):
+class ProfileInterface(ABC):
     """
     Base sectional profile of the propeller blade.
 
@@ -38,17 +38,134 @@ class ProfileBase(ABC, object):
     :param numpy.ndarray trailing_edge: 2D coordinates of the airfoil's
         trailing edge. Default values are zeros
     """
+    @abstractmethod
+    def generate_parameters(self, convention='british'):
+        """
+        Abstract method that generates the airfoil parameters based on the
+        given coordinates.
 
-    def __init__(self, convention='british'):
-        self.convention = convention
-        self.xup_coordinates = None
-        self.xdown_coordinates = None
-        self.yup_coordinates = None
-        self.ydown_coordinates = None
-        self.chord_line = None
-        self.camber_line = None
-        self.leading_edge = np.zeros(2)
-        self.trailing_edge = np.zeros(2)
+        The method generates the airfoil's chord length, chord percentages,
+        maximum camber, camber percentages, maximum thickness, thickness percentages.
+        
+        :param str convention: convention of the airfoil coordinates. Default
+            value is 'british'
+        """
+        self._update_edges()
+        # compute chord parameters
+        self._chord_length = np.linalg.norm(self.leading_edge - self.trailing_edge)
+        self._chord_percentage = (self.xup_coordinates - np.min(self.xup_coordinates))/self._chord_length
+        # compute camber parameters
+        _camber = (self.yup_coordinates + self.ydown_coordinates)/2
+        self._camber_max = abs(np.max(_camber))
+        if self._camber_max == 0:
+            self._camber_percentage = np.zeros(self.xup_coordinates.shape[0])
+        elif self.camber_max != 0:
+            self._camber_percentage = _camber/self._camber_max
+        # compute thickness parameters
+        if convention == 'british' or self._camber_max==0:
+            _thickness = abs(self.yup_coordinates - self.ydown_coordinates)
+        elif convention == 'american':
+            _thickness = self._compute_thickness_american()
+        self._thickness_max = np.max(_thickness)
+        if self._thickness_max == 0:
+            self._thickness_percentage = np.zeros(self.xup_coordinates.shape[0])
+        elif self._thickness_max != 0:
+            self._thickness_percentage = _thickness/self._thickness_max
+
+    @abstractmethod
+    def generate_coordinates(self):
+        """
+        Abstract method that generates the airfoil coordinates based on the
+        given parameters.
+
+        The method generates the airfoil's upper and lower surfaces
+        coordinates. The method is called automatically when the airfoil
+        parameters are inserted by the user.
+
+        :param str convention: convention of the airfoil coordinates. Default
+            value is 'british'
+        """
+        pass
+
+    @property
+    def xup_coordinates(self):
+        return self._xup_coordinates
+    
+    @xup_coordinates.setter
+    def xup_coordinates(self, xup_coordinates):
+        self._xup_coordinates = xup_coordinates
+
+    @property
+    def xdown_coordinates(self):
+        return self._xdown_coordinates
+    
+    @xdown_coordinates.setter
+    def xdown_coordinates(self, xdown_coordinates):
+        self._xdown_coordinates = xdown_coordinates
+
+    @property
+    def yup_coordinates(self):
+        return self._yup_coordinates    
+
+    @yup_coordinates.setter
+    def yup_coordinates(self, yup_coordinates):
+        self._yup_coordinates = yup_coordinates
+    
+    @property
+    def ydown_coordinates(self):
+        return self._ydown_coordinates
+    
+    @ydown_coordinates.setter
+    def ydown_coordinates(self, ydown_coordinates):
+        self._ydown_coordinates = ydown_coordinates
+
+    @property
+    def chord_length(self):
+        return self._chord_length
+    
+    @chord_length.setter
+    def chord_length(self, chord_length):
+        self._chord_length = chord_length
+
+    @property
+    def chord_percentage(self):
+        return self._chord_percentage
+    
+    @chord_percentage.setter
+    def chord_percentage(self, chord_percentage):
+        self._chord_percentage = chord_percentage
+
+    @property
+    def camber_max(self):
+        return self._camber_max
+    
+    @camber_max.setter
+    def camber_max(self, camber_max):
+        self._camber_max = camber_max
+
+    @property
+    def camber_percentage(self):
+        return self._camber_percentage
+    
+    @camber_percentage.setter
+    def camber_percentage(self, camber_percentage):
+        self._camber_percentage = camber_percentage
+
+    @property
+    def thickness_max(self):
+        return self._thickness_max
+    
+    @thickness_max.setter
+    def thickness_max(self, thickness_max):
+        self._thickness_max = thickness_max
+
+    @property
+    def thickness_percentage(self):
+        return self._thickness_percentage
+
+    @thickness_percentage.setter
+    def thickness_percentage(self, thickness_percentage):
+        self._thickness_percentage = thickness_percentage
 
     def _update_edges(self):
         """
@@ -61,6 +178,8 @@ def _update_edges(self):
         trailing edge, hence both the leading and the trailing edges are always
         unique.
         """
+        self.leading_edge = np.zeros(2)
+        self.trailing_edge = np.zeros(2)
         if np.fabs(self.xup_coordinates[0] - self.xdown_coordinates[0]) > 1e-4:
             raise ValueError('Airfoils must have xup_coordinates[0] '\
                             'almost equal to xdown_coordinates[0]')
@@ -324,56 +443,6 @@ def reference_point(self):
         ]
         return np.asarray(reference_point)
 
-    @property
-    def chord_length(self):
-        """
-        Measure the l2-norm (Euclidean distance) between the leading edge
-        and the trailing edge.
-
-        :return: chord length
-        :rtype: float
-        """
-        self._update_edges()
-        return np.linalg.norm(self.leading_edge - self.trailing_edge)
-    
-    @property
-    def chord_percentage(self):
-        """
-        Return the percentage of the chord coordinates with respect to the
-        chord length of the airfoil.
-
-        :return: chord length percentage
-        :rtype: float
-        """
-        return (self.xup_coordinates - np.min(self.xup_coordinates))/self.chord_length
-    
-    def _camber(self):
-        """
-        Compute the camber line of the airfoil.
-        """
-        return (self.yup_coordinates + self.ydown_coordinates)/2
-    
-    @property
-    def camber_max(self):
-        """
-        Return the maximum camber of the airfoil.
-
-        :return: maximum camber
-        :rtype: float
-        """
-        return abs(np.max(self._camber()))
-    
-    @property
-    def camber_percentage(self):
-        """
-        Return the percentage of the camber coordinates with respect to the
-        maximum camber of the airfoil.
-        """
-        if self.camber_max == 0:
-            return np.zeros(self.xup_coordinates.shape[0])
-        else:
-            return abs(self._camber())/self.camber_max
-    
     def _compute_thickness_american(self):
         """
         Compute the thickness of the airfoil using the American standard
@@ -382,14 +451,14 @@ def _compute_thickness_american(self):
         n_pos = self.xup_coordinates.shape[0]
         m = np.zeros(n_pos)
         for i in range(1, n_pos, 1):
-            m[i] = (self.camber_percentage[i]-
-                self.camber_percentage[i-1])/(self.chord_percentage[i]-
-                self.chord_percentage[i-1])*self.camber_max/self.chord_length
+            m[i] = (self._camber_percentage[i]-
+                self._camber_percentage[i-1])/(self._chord_percentage[i]-
+                self._chord_percentage[i-1])*self._camber_max/self._chord_length
         m_angle = np.arctan(m)
 
         # generating temporary profile coordinates orthogonal to the camber
         # line
-        camber = self.camber_max*self.camber_percentage
+        camber = self._camber_max*self._camber_percentage
         ind_horizontal_camber = (np.sin(m_angle)==0)
         def eq_to_solve(x):
             spline_curve = self.ydown_curve(x.reshape(-1,1)).reshape(
@@ -397,74 +466,21 @@ def eq_to_solve(x):
             line_orth_camber = (camber[~ind_horizontal_camber] +
                 np.cos(m_angle[~ind_horizontal_camber])/
                 np.sin(m_angle[~ind_horizontal_camber])*(
-                    self.chord_percentage[~ind_horizontal_camber]-x))
+                    self._chord_percentage[~ind_horizontal_camber]*self._chord_length-x))
             return spline_curve - line_orth_camber
 
         xdown_tmp = self.xdown_coordinates.copy()
         xdown_tmp[~ind_horizontal_camber] = newton(eq_to_solve,
             xdown_tmp[~ind_horizontal_camber])
-        xup_tmp = (2*self.chord_percentage - xdown_tmp)
+        xup_tmp = (2*self._chord_percentage*self._chord_length - xdown_tmp)
         ydown_tmp = self.ydown_curve(xdown_tmp.reshape(-1,1)).reshape(
             xdown_tmp.shape[0],)
-        yup_tmp = 2*self.camber_max*self.camber_percentage - ydown_tmp
+        yup_tmp = 2*self._camber_max*self._camber_percentage - ydown_tmp
         if xup_tmp[1]<self.xup_coordinates[0]:
             xup_tmp[1], xdown_tmp[1] = xup_tmp[2], xdown_tmp[2]
             yup_tmp[1], ydown_tmp[1] = yup_tmp[2], ydown_tmp[2]
         return np.sqrt((xup_tmp-xdown_tmp)**2 + (yup_tmp-ydown_tmp)**2)
-
-    def _thickness(self):
-        """
-        Compute the thickness of the airfoil using the British standard
-        definition.
-        """
-        if self.convention == 'british' or self.camber_max==0:
-            return abs(self.yup_coordinates - self.ydown_coordinates)
-        elif self.convention == 'american' and self.camber_max!=0:
-            return self._compute_thickness_american()
-        else:
-            raise ValueError('convention must be either british or american')
-        
-    @property
-    def thickness_max(self):
-        """
-        Return the maximum thickness of the airfoil.
-
-        :return: maximum thickness
-        :rtype: float
-        """
-        thickness = self._thickness()
-        return np.max(thickness)
-
-    @property
-    def thickness_percentage(self):
-        """
-        Return the percentage of the thickness coordinates with respect to the
-        maximum thickness of the airfoil.
-        """
-        thickness = self._thickness
-        return thickness/self.thickness_max
-
-    def _compute_coordinates_british_convention(self):
-        """
-        Compute the coordinates of points on upper and lower profile according
-        to the British convention.
-        """
-        self.xup_coordinates = self.chord_percentage*self.chord_length
-        self.xdown_coordinates = self.xup_coordinates.copy()
-        self.yup_coordinates = (self.camber_percentage*self.camber_max +
-                self.thickness_max/2*self.thickness_percentage)
-        self.ydown_coordinates = (self.camber_percentage*self.camber_max -
-                self.thickness_max/2*self.thickness_percentage)
-
-    @property
-    def thickness_percentage(self):
-        """
-        Return the percentage of the thickness coordinates with respect to the
-        maximum thickness of the airfoil.
-        """
-        thickness = self._thickness()
-        return thickness/self.thickness_max
-
+ 
     def max_thickness(self, n_interpolated_points=None):
         """
         Return the airfoil's maximum thickness.
@@ -681,7 +697,6 @@ def scale(self, factor, translate=True):
             self.yup_coordinates *= factor
             self.ydown_coordinates *= factor
 
-
     def plot(self,
              profile=True,
              chord_line=False,
diff --git a/tests/test_package.py b/tests/test_package.py
index 111494a..ec36a65 100644
--- a/tests/test_package.py
+++ b/tests/test_package.py
@@ -6,10 +6,6 @@
 import numpy as np
 
 class TestPackage(TestCase):
-    def test_import_blade_1(self):
-        from bladex import ProfileBase
-        profile = ProfileBase()
-
     def test_import_blade_2(self):
         from bladex import CustomProfile
         vec = np.array([1.2, 2.4])
diff --git a/tests/test_profilebase.py b/tests/test_profilebase.py
deleted file mode 100644
index 8159e04..0000000
--- a/tests/test_profilebase.py
+++ /dev/null
@@ -1,549 +0,0 @@
-import os
-from unittest import TestCase
-from bladex.profile import profilebase as pb
-import numpy as np
-import matplotlib.pyplot as plt
-
-
-def create_sample_profile():
-    """
-    xup_coordinates, yup_coordinates, xdown_coordinates, ydown_coordinates
-    """
-    profile = pb.ProfileBase()
-    profile.xup_coordinates = np.linspace(-1.0, 1.0, 5)
-    profile.yup_coordinates = np.array([0.0, 0.75, 1.0, 0.75, 0.0])
-    profile.xdown_coordinates = np.linspace(-1.0, 1.0, 5)
-    profile.ydown_coordinates = np.zeros(5)
-    return profile
-
-
-def create_sample_profile_2():
-    """
-    xup_coordinates != xdown_coordinates elementwise
-    """
-    profile = pb.ProfileBase()
-    profile.xup_coordinates = np.linspace(-1.0, 1.0, 5)
-    profile.yup_coordinates = np.array([0.0, 0.75, 1.0, 0.75, 0.0])
-    profile.xdown_coordinates = np.linspace(-1.0, 1.0, 5)
-    profile.xdown_coordinates[2] = 0.1
-    profile.ydown_coordinates = np.zeros(5)
-    return profile
-
-
-def create_sample_profile_3():
-    """
-    Coordinates of unit circle (i.e. x^2+y^2=1)
-    """
-    profile = pb.ProfileBase()
-    profile.xup_coordinates = np.linspace(-1.0, 1.0, num=250)
-    profile.yup_coordinates = np.sqrt(1 - np.power(profile.xup_coordinates, 2))
-    profile.xdown_coordinates = np.linspace(-1.0, 1.0, num=250)
-    profile.ydown_coordinates = -np.sqrt(
-        1 - np.power(profile.xup_coordinates, 2))
-    return profile
-
-
-class TestProfileBase(TestCase):
-    def test_xup_init(self):
-        profile = pb.ProfileBase()
-        assert profile.xup_coordinates is None
-
-    def test_yup_init(self):
-        profile = pb.ProfileBase()
-        assert profile.yup_coordinates is None
-
-    def test_xdown_init(self):
-        profile = pb.ProfileBase()
-        assert profile.xdown_coordinates is None
-
-    def test_ydown_init(self):
-        profile = pb.ProfileBase()
-        assert profile.ydown_coordinates is None
-
-    def test_chord_init(self):
-        profile = pb.ProfileBase()
-        assert profile.chord_line is None
-
-    def test_camber_init(self):
-        profile = pb.ProfileBase()
-        assert profile.camber_line is None
-
-    def test_leading_edge_size(self):
-        profile = pb.ProfileBase()
-        assert profile.leading_edge.size == 2
-
-    def test_trailing_edge_size(self):
-        profile = pb.ProfileBase()
-        assert profile.trailing_edge.size == 2
-
-    def test_leading_edge_init(self):
-        profile = pb.ProfileBase()
-        np.testing.assert_equal(profile.leading_edge, np.zeros(2))
-
-    def test_trailing_edge_init(self):
-        profile = pb.ProfileBase()
-        np.testing.assert_equal(profile.trailing_edge, np.zeros(2))
-
-    def test_update_edges_exceptions(self):
-        profile = create_sample_profile()
-        profile.xdown_coordinates[0] = 0.1
-        with self.assertRaises(ValueError):
-            profile._update_edges()
-
-    def test_update_edges_exceptions_2(self):
-        profile = create_sample_profile()
-        profile.xdown_coordinates[-1] = 0.1
-        with self.assertRaises(ValueError):
-            profile._update_edges()
-
-    def test_update_edges_leading_edge(self):
-        profile = create_sample_profile()
-        profile.yup_coordinates[-1] = 1.0
-        profile._update_edges()
-        np.testing.assert_equal(profile.leading_edge, np.array([-1.0, 0.0]))
-
-    def test_update_edges_trailing_edge(self):
-        profile = create_sample_profile()
-        profile._update_edges()
-        np.testing.assert_equal(profile.trailing_edge, np.array([1.0, 0.0]))
-
-    def test_update_edges_trailing_edge_finite(self):
-        profile = create_sample_profile()
-        profile.yup_coordinates[-1] = 1.0
-        profile._update_edges()
-        np.testing.assert_equal(profile.trailing_edge, np.array([1.0, 0.5]))
-
-    def test_interpolate_crds_exceptions_1(self):
-        profile = pb.ProfileBase()
-        with self.assertRaises(TypeError):
-            profile.interpolate_coordinates(num=500.5, radius=1.0)
-
-    def test_interpolate_crds_exceptions_2(self):
-        profile = pb.ProfileBase()
-        with self.assertRaises(ValueError):
-            profile.interpolate_coordinates(num=-500, radius=1.0)
-
-    def test_interpolate_crds_exceptions_3(self):
-        profile = pb.ProfileBase()
-        with self.assertRaises(ValueError):
-            profile.interpolate_coordinates(num=500, radius=-1.0)
-
-    def test_interpolate_coordinates_xup(self):
-        profile = create_sample_profile_3()
-        xup_actual = profile.interpolate_coordinates(num=500, radius=10)[0]
-        xup_expected = np.load('tests/test_datasets/interp_xup_unit_circle.npy')
-        np.testing.assert_almost_equal(xup_actual, xup_expected)
-
-    def test_interpolate_coordinates_yup(self):
-        profile = create_sample_profile_3()
-        yup_actual = profile.interpolate_coordinates(num=500, radius=10)[2]
-        yup_expected = np.load('tests/test_datasets/interp_yup_unit_circle.npy')
-        np.testing.assert_almost_equal(yup_actual, yup_expected, decimal=5)
-
-    def test_interpolate_coordinates_xdown(self):
-        profile = create_sample_profile_3()
-        xdown_actual = profile.interpolate_coordinates(num=500, radius=10)[1]
-        xdown_expected = np.load(
-            'tests/test_datasets/interp_xdown_unit_circle.npy')
-        np.testing.assert_almost_equal(xdown_actual, xdown_expected)
-
-    def test_interpolate_coordinates_ydown(self):
-        profile = create_sample_profile_3()
-        ydown_actual = profile.interpolate_coordinates(num=500, radius=10)[3]
-        ydown_expected = np.load(
-            'tests/test_datasets/interp_ydown_unit_circle.npy')
-        np.testing.assert_almost_equal(ydown_actual, ydown_expected, decimal=5)
-
-    def test_chord_line_shape(self):
-        profile = create_sample_profile()
-        profile.compute_chord_line(n_interpolated_points=None)
-        assert profile.chord_line.shape == (2, 5)
-
-    def test_chord_line(self):
-        profile = create_sample_profile()
-        profile.compute_chord_line(n_interpolated_points=None)
-        expected_chord = np.array([np.linspace(-1, 1, 5), np.zeros(5)])
-        np.testing.assert_equal(profile.chord_line, expected_chord)
-
-    def test_chord_line_interpolated(self):
-        # Interpolation by keyword
-        profile = create_sample_profile()
-        profile.compute_chord_line(n_interpolated_points=500)
-        assert profile.chord_line.shape == (2, 500)
-
-    def test_chord_line_interpolated_2(self):
-        # Interpolation because x_up != x_down elementwise
-        profile = create_sample_profile_2()
-        profile.compute_chord_line(n_interpolated_points=None)
-        assert profile.chord_line.shape == (2, 500)
-
-    def test_camber_line_shape(self):
-        profile = create_sample_profile()
-        profile.compute_camber_line(n_interpolated_points=None)
-        assert profile.camber_line.shape == (2, 5)
-
-    def test_camber_line(self):
-        profile = create_sample_profile()
-        profile.compute_camber_line(n_interpolated_points=None)
-        expected_camber = np.array(
-            [np.linspace(-1, 1, 5),
-             np.array([0, 0.375, 0.5, 0.375, 0])])
-        np.testing.assert_equal(profile.camber_line, expected_camber)
-
-    def test_camber_line_interpolated(self):
-        profile = create_sample_profile()
-        profile.compute_camber_line(n_interpolated_points=500)
-        assert profile.camber_line.shape == (2, 500)
-
-    def test_camber_line_interpolated_2(self):
-        profile = create_sample_profile_2()
-        profile.compute_camber_line(n_interpolated_points=None)
-        assert profile.camber_line.shape == (2, 500)
-
-    def test_deform_camber_exceptions(self):
-        profile = create_sample_profile()
-        with self.assertRaises(TypeError):
-            profile.deform_camber_line()
-
-    def test_deform_camber(self):
-        profile = create_sample_profile()
-        profile.deform_camber_line(
-            percent_change=100, n_interpolated_points=None)
-        expected_deformed_camber = np.array(
-            [np.linspace(-1.0, 1.0, 5),
-             np.array([0.0, 0.75, 1.0, 0.75, 0.0])])
-        np.testing.assert_equal(profile.camber_line, expected_deformed_camber)
-
-    def test_deform_camber_yup(self):
-        profile = create_sample_profile()
-        profile.deform_camber_line(
-            percent_change=100, n_interpolated_points=None)
-        expected_yup_coordinates = np.array([0.0, 1.125, 1.5, 1.125, 0.0])
-        np.testing.assert_equal(profile.yup_coordinates,
-                                expected_yup_coordinates)
-
-    def test_deform_camber_ydown(self):
-        profile = create_sample_profile()
-        profile.deform_camber_line(
-            percent_change=100, n_interpolated_points=None)
-        expected_ydown_coordinates = np.array([0.0, 0.375, 0.5, 0.375, 0.0])
-        np.testing.assert_equal(profile.ydown_coordinates,
-                                expected_ydown_coordinates)
-
-    def test_deform_camber_interpolated(self):
-        profile = create_sample_profile()
-        profile.deform_camber_line(percent_change=50, n_interpolated_points=500)
-        assert profile.camber_line[1].size == 500
-
-    def test_deform_camber_interpolated_2(self):
-        profile = create_sample_profile_2()
-        profile.deform_camber_line(
-            percent_change=50, n_interpolated_points=None)
-        assert profile.camber_line[1].size == 500
-
-    def test_reference_point_shape(self):
-        profile = create_sample_profile()
-        assert profile.reference_point.size == 2
-
-    def test_reference_point(self):
-        profile = create_sample_profile()
-        np.testing.assert_equal(profile.reference_point, np.zeros(2))
-
-    def test_chord_length(self):
-        profile = create_sample_profile()
-        assert profile.chord_length == 2.0
-
-    def test_max_thickness(self):
-        profile = create_sample_profile()
-        thickness = profile.max_thickness(n_interpolated_points=None)
-        assert thickness == 1.0
-
-    def test_max_thickness_interpolated(self):
-        profile = create_sample_profile()
-        thickness = profile.max_thickness(n_interpolated_points=500)
-        np.testing.assert_almost_equal(thickness, 1.0, decimal=4)
-
-    def test_max_thickness_interpolated_2(self):
-        profile = create_sample_profile_2()
-        thickness = profile.max_thickness(n_interpolated_points=None)
-        np.testing.assert_almost_equal(thickness, 1.0, decimal=4)
-
-    def test_max_camber(self):
-        profile = create_sample_profile()
-        camber_max = profile.max_camber(n_interpolated_points=None)
-        assert camber_max == 0.5
-
-    def test_max_camber_interpolated(self):
-        profile = create_sample_profile()
-        camber_max = profile.max_camber(n_interpolated_points=500)
-        np.testing.assert_almost_equal(camber_max, 0.5, decimal=5)
-
-    def test_max_camber_interpolated_2(self):
-        profile = create_sample_profile_2()
-        camber_max = profile.max_camber(n_interpolated_points=None)
-        np.testing.assert_almost_equal(camber_max, 0.5, decimal=5)
-
-    def test_max_camber_negative(self):
-        profile = create_sample_profile()
-        profile.ydown_coordinates = np.array([0.0, -0.75, -1.0, -0.75, 0.0])
-        profile.yup_coordinates = np.zeros(5)
-        camber_max = profile.max_camber(n_interpolated_points=None)
-        assert camber_max == -0.5
-
-    def test_rotate_exceptions(self):
-        profile = pb.ProfileBase()
-        with self.assertRaises(ValueError):
-            profile.rotate(rad_angle=None, deg_angle=None)
-
-    def test_rotate_exceptions_2(self):
-        profile = pb.ProfileBase()
-        with self.assertRaises(ValueError):
-            profile.rotate(rad_angle=np.pi, deg_angle=180)
-
-    def test_rotate_in_degrees_xup(self):
-        profile = create_sample_profile()
-        profile.rotate(deg_angle=135)
-        rotated_xup_coordinates = np.array(
-            [0.70710678, -0.1767767, -0.70710678, -0.88388348, -0.70710678])
-        np.testing.assert_almost_equal(profile.xup_coordinates,
-                                       rotated_xup_coordinates)
-
-    def test_rotate_in_degrees_yup(self):
-        profile = create_sample_profile()
-        profile.rotate(deg_angle=135)
-        rotated_yup_coordinates = np.array(
-            [-0.70710678, -0.88388348, -0.70710678, -0.1767767, 0.70710678])
-        np.testing.assert_almost_equal(profile.yup_coordinates,
-                                       rotated_yup_coordinates)
-
-    def test_rotate_in_degrees_xdown(self):
-        profile = create_sample_profile()
-        profile.rotate(deg_angle=135)
-        rotated_xdown_coordinates = np.array(
-            [0.70710678, 0.35355339, 0.0, -0.35355339, -0.70710678])
-        np.testing.assert_almost_equal(profile.xdown_coordinates,
-                                       rotated_xdown_coordinates)
-
-    def test_rotate_in_degrees_ydown(self):
-        profile = create_sample_profile()
-        profile.rotate(deg_angle=135)
-        rotated_ydown_coordinates = np.array(
-            [-0.70710678, -0.35355339, 0.0, 0.35355339, 0.70710678])
-        np.testing.assert_almost_equal(profile.ydown_coordinates,
-                                       rotated_ydown_coordinates)
-
-    def test_rotate_in_radians_xup(self):
-        profile = create_sample_profile()
-        profile.rotate(rad_angle=3 * np.pi / 4)
-        rotated_xup_coordinates = np.array(
-            [0.70710678, -0.1767767, -0.70710678, -0.88388348, -0.70710678])
-        np.testing.assert_almost_equal(profile.xup_coordinates,
-                                       rotated_xup_coordinates)
-
-    def test_rotate_in_radians_yup(self):
-        profile = create_sample_profile()
-        profile.rotate(rad_angle=3 * np.pi / 4)
-        rotated_yup_coordinates = np.array(
-            [-0.70710678, -0.88388348, -0.70710678, -0.1767767, 0.70710678])
-        np.testing.assert_almost_equal(profile.yup_coordinates,
-                                       rotated_yup_coordinates)
-
-    def test_rotate_in_radians_xdown(self):
-        profile = create_sample_profile()
-        profile.rotate(rad_angle=3 * np.pi / 4)
-        rotated_xdown_coordinates = np.array(
-            [0.70710678, 0.35355339, 0.0, -0.35355339, -0.70710678])
-        np.testing.assert_almost_equal(profile.xdown_coordinates,
-                                       rotated_xdown_coordinates)
-
-    def test_rotate_in_radians_ydown(self):
-        profile = create_sample_profile()
-        profile.rotate(rad_angle=3 * np.pi / 4)
-        rotated_ydown_coordinates = np.array(
-            [-0.70710678, -0.35355339, 0.0, 0.35355339, 0.70710678])
-        np.testing.assert_almost_equal(profile.ydown_coordinates,
-                                       rotated_ydown_coordinates)
-
-    def test_translate_exceptions(self):
-        profile = pb.ProfileBase()
-        with self.assertRaises(TypeError):
-            profile.translate()
-
-    def test_translate_xup(self):
-        profile = create_sample_profile()
-        profile.translate(translation=[1.0, 2.0])
-        translated_xup_coordinates = np.array([0.0, 0.5, 1.0, 1.5, 2.0])
-        np.testing.assert_equal(profile.xup_coordinates,
-                                translated_xup_coordinates)
-
-    def test_translate_yup(self):
-        profile = create_sample_profile()
-        profile.translate(translation=[1.0, 2.0])
-        translated_yup_coordinates = np.array([2.0, 2.75, 3.0, 2.75, 2.0])
-        np.testing.assert_equal(profile.yup_coordinates,
-                                translated_yup_coordinates)
-
-    def test_translate_xdown(self):
-        profile = create_sample_profile()
-        profile.translate(translation=[1.0, 2.0])
-        translated_xdown_coordinates = np.array([0.0, 0.5, 1.0, 1.5, 2.0])
-        np.testing.assert_equal(profile.xdown_coordinates,
-                                translated_xdown_coordinates)
-
-    def test_translate_ydown(self):
-        profile = create_sample_profile()
-        profile.translate(translation=[1.0, 2.0])
-        translated_ydown_coordinates = np.array([2.0, 2.0, 2.0, 2.0, 2.0])
-        np.testing.assert_equal(profile.ydown_coordinates,
-                                translated_ydown_coordinates)
-
-    def test_reflect_xup(self):
-        profile = create_sample_profile()
-        profile.reflect()
-        flipped_xup_coordinates = np.array([1.0, 0.5, 0.0, -0.5, -1.0])
-        np.testing.assert_equal(profile.xup_coordinates,
-                                flipped_xup_coordinates)
-
-    def test_reflect_yup(self):
-        profile = create_sample_profile()
-        profile.reflect()
-        flipped_yup_coordinates = np.array([0.0, -0.75, -1.0, -0.75, 0.0])
-        np.testing.assert_equal(profile.yup_coordinates,
-                                flipped_yup_coordinates)
-
-    def test_reflect_xdown(self):
-        profile = create_sample_profile()
-        profile.reflect()
-        flipped_xdown_coordinates = np.array([1.0, 0.5, 0.0, -0.5, -1.0])
-        np.testing.assert_equal(profile.xdown_coordinates,
-                                flipped_xdown_coordinates)
-
-    def test_reflect_ydown(self):
-        profile = create_sample_profile()
-        profile.reflect()
-        flipped_ydown_coordinates = np.array([0.0, 0.0, 0.0, 0.0, 0.0])
-        np.testing.assert_equal(profile.ydown_coordinates,
-                                flipped_ydown_coordinates)
-
-    def test_scale_exceptions(self):
-        profile = pb.ProfileBase()
-        with self.assertRaises(TypeError):
-            profile.scale()
-
-    def test_scale_xup(self):
-        profile = create_sample_profile()
-        profile.scale(factor=1.5)
-        scaled_xup_coordinates = np.array([-1.5, -0.75, 0.0, 0.75, 1.5])
-        np.testing.assert_equal(profile.xup_coordinates, scaled_xup_coordinates)
-
-    def test_scale_yup(self):
-        profile = create_sample_profile()
-        profile.scale(factor=1.5)
-        scaled_yup_coordinates = np.array([0.0, 1.125, 1.5, 1.125, 0.0])
-        np.testing.assert_equal(profile.yup_coordinates, scaled_yup_coordinates)
-
-    def test_scale_xdown(self):
-        profile = create_sample_profile()
-        profile.scale(factor=1.5)
-        scaled_xdown_coordinates = np.array([-1.5, -0.75, 0.0, 0.75, 1.5])
-        np.testing.assert_equal(profile.xdown_coordinates,
-                                scaled_xdown_coordinates)
-
-    def test_scale_ydown(self):
-        profile = create_sample_profile()
-        profile.scale(factor=1.5)
-        scaled_ydown_coordinates = np.array([0.0, 0.0, 0.0, 0.0, 0.0])
-        np.testing.assert_equal(profile.ydown_coordinates,
-                                scaled_ydown_coordinates)
-
-    def test_plot_exceptions(self):
-        profile = create_sample_profile()
-        with self.assertRaises(ValueError):
-            profile.plot(outfile=1.2)
-
-    def test_plot_no_coordinates(self):
-        profile = create_sample_profile()
-        profile.xup_coordinates = None
-        with self.assertRaises(ValueError):
-            profile.plot()
-
-    def test_plot_profile(self):
-        profile = create_sample_profile()
-        profile.plot(
-            profile=True,
-            chord_line=False,
-            camber_line=False,
-            ref_point=False,
-            outfile=None)
-        plt.close()
-
-    def test_plot_chord_exception(self):
-        profile = create_sample_profile()
-        with self.assertRaises(ValueError):
-            profile.plot(
-                profile=True,
-                chord_line=True,
-                camber_line=False,
-                ref_point=False,
-                outfile=None)
-
-    def test_plot_chord_line(self):
-        profile = create_sample_profile()
-        profile.compute_chord_line()
-        profile.plot(
-            profile=True,
-            chord_line=True,
-            camber_line=False,
-            ref_point=False,
-            outfile=None)
-        plt.close()
-
-    def test_plot_camber_exception(self):
-        profile = create_sample_profile()
-        with self.assertRaises(ValueError):
-            profile.plot(
-                profile=True,
-                chord_line=False,
-                camber_line=True,
-                ref_point=False,
-                outfile=None)
-
-    def test_plot_camber_line(self):
-        profile = create_sample_profile()
-        profile.compute_camber_line()
-        profile.plot(
-            profile=True,
-            chord_line=False,
-            camber_line=True,
-            ref_point=False,
-            outfile=None)
-        plt.close()
-
-    def test_plot_ref_point(self):
-        profile = create_sample_profile()
-        profile.plot(
-            profile=True,
-            chord_line=False,
-            camber_line=False,
-            ref_point=True,
-            outfile=None)
-        plt.close()
-
-    def test_plot_all(self):
-        profile = create_sample_profile()
-        profile.compute_camber_line()
-        profile.compute_chord_line()
-        profile.plot(
-            profile=True,
-            chord_line=True,
-            camber_line=True,
-            ref_point=True,
-            outfile=None)
-        plt.close()
-
-    def test_plot_save(self):
-        profile = create_sample_profile()
-        profile.plot(outfile='tests/test_datasets/test_plot.png')
-        plt.close()
-        self.assertTrue(os.path.isfile('tests/test_datasets/test_plot.png'))
-        self.addCleanup(os.remove, 'tests/test_datasets/test_plot.png')
diff --git a/tests/test_profileinterface.py b/tests/test_profileinterface.py
new file mode 100644
index 0000000..1216855
--- /dev/null
+++ b/tests/test_profileinterface.py
@@ -0,0 +1,10 @@
+import os
+from unittest import TestCase
+from bladex import ProfileInterface
+import numpy as np
+import matplotlib.pyplot as plt
+
+class TestProfileInterface(TestCase):
+    def test_instantiation(self):
+        with self.assertRaises(TypeError):
+            ProfileInterface()
\ No newline at end of file
diff --git a/tests/test_profiles.py b/tests/test_profiles.py
index 9b8122c..1b590c8 100644
--- a/tests/test_profiles.py
+++ b/tests/test_profiles.py
@@ -1,7 +1,7 @@
 from unittest import TestCase
 import numpy as np
 
-from  bladex import CustomProfile, NacaProfile, ProfileBase
+from  bladex import CustomProfile, NacaProfile, ProfileInterface
 
 def create_custom_profile():
     """
@@ -16,7 +16,7 @@ def create_custom_profile():
 
 class TestCustomProfile(TestCase):
     def test_inheritance_custom(self):
-        self.assertTrue(issubclass(CustomProfile, ProfileBase))
+        self.assertTrue(issubclass(CustomProfile, ProfileInterface))
 
     def test_xup_member(self):
         profile = create_custom_profile()
@@ -124,7 +124,7 @@ def test_trailing_edge_x(self):
 
 class TestNacaProfile(TestCase):
     def test_inheritance_naca(self):
-        self.assertTrue(issubclass(NacaProfile, ProfileBase))
+        self.assertTrue(issubclass(NacaProfile, ProfileInterface))
 
     def test_digits_member(self):
         profile = NacaProfile(digits='0012', n_points=240)