Lint fixes

FIAT/brezzi_douglas_marini.py

@@ -9,6 +9,7 @@
                   polynomial_set, nedelec)
 from FIAT.check_format_variant import check_format_variant
 
+
 class BDMDualSet(dual_set.DualSet):
     def __init__(self, ref_el, degree, variant, quad_deg):
 

FIAT/check_format_variant.py

@@ -1,21 +1,22 @@
 import re
 import warnings
 
+
 def check_format_variant(variant, degree, element):
     if variant is None:
-       variant = "point"
-       warnings.simplefilter('always', DeprecationWarning)
-       warnings.warn('Variant of '+ element + ' element will change from point evaluation to integral evaluation.'
-                     ' You should project into variant="integral"', DeprecationWarning)
-       #Replace by the following in a month time
-       #variant = "integral"
+        variant = "point"
+        warnings.simplefilter('always', DeprecationWarning)
+        warnings.warn('Variant of ' + element + ' element will change from point evaluation to integral evaluation.'
+                      ' You should project into variant="integral"', DeprecationWarning)
+        # Replace by the following in a month time
+        # variant = "integral"
 
     if not (variant == "point" or "integral" in variant):
         raise ValueError('Choose either variant="point" or variant="integral"'
                          'or variant="integral(Quadrature degree)"')
 
     if variant == "integral":
-        #quadrature is so high to ensure that the interpolant of curl/divergence-free functions is still curl/divergence-free
+        # quadrature is so high to ensure that the interpolant of curl/divergence-free functions is still curl/divergence-free
         quad_deg = 5 * (degree + 1)
         variant = "integral"
     elif re.match('^integral\(\d+\)$', variant):

FIAT/functional.py

@@ -410,8 +410,8 @@ def __init__(self, ref_el, Q, P_at_qpts, edge):
             pt_dict[pt] = [(wgt*phi*t[i], (i, )) for i in range(sd)]
         super().__init__(ref_el, (sd, ), pt_dict, {}, "IntegralMomentOfEdgeTangentEvaluation")
 
-class IntegralMomentOfEdgeTangentEvaluation(Functional):
 
+class IntegralMomentOfEdgeTangentEvaluation(Functional):
     r"""
     \int_e v\cdot t p ds
 
@@ -433,6 +433,7 @@ def __init__(self, ref_el, Q, P_at_qpts, edge):
             pt_dict[pt] = [(wgt*phi*t[i], (i, )) for i in range(sd)]
         super().__init__(ref_el, (sd, ), pt_dict, {}, "IntegralMomentOfEdgeTangentEvaluation")
 
+
 class PointFaceTangentEvaluation(Functional):
     """Implements the evaluation of a tangential component of a
     vector at a point on a facet of codimension 1."""
@@ -528,7 +529,6 @@ class IntegralMomentOfFaceTangentEvaluation(Functional):
     :arg facet: which facet.
     """
     def __init__(self, ref_el, Q, P_at_qpts, facet):
-        #import ipdb; ipdb.set_trace()
         P_at_qpts = [[P_at_qpts[0][i], P_at_qpts[1][i], P_at_qpts[2][i]]
                      for i in range(P_at_qpts.shape[1])]
         n = ref_el.compute_scaled_normal(facet)
@@ -538,17 +538,15 @@ def __init__(self, ref_el, Q, P_at_qpts, facet):
         weights = Q.get_weights()
         pt_dict = OrderedDict()
         for pt, wgt, phi in zip(pts, weights, P_at_qpts):
-#             pt_dict[pt] = [(wgt*(-n[2]*phi[1]+n[1]*phi[2]), (0, )),
-#                            (wgt*(n[2]*phi[0]-n[0]*phi[2]), (1, )),
-#                            (wgt*(-n[1]*phi[0]+n[0]*phi[1]), (2, ))]
-             phixn = [phi[1]*n[2] - phi[2]*n[1],
-                      phi[2]*n[0] - phi[0]*n[2],
-                      phi[0]*n[1] - phi[1]*n[0]]
-             pt_dict[pt] = [(wgt*(-n[2]*phixn[1]+n[1]*phixn[2]), (0, )),
-                            (wgt*(n[2]*phixn[0]-n[0]*phixn[2]), (1, )),
-                            (wgt*(-n[1]*phixn[0]+n[0]*phixn[1]), (2, ))]
+            phixn = [phi[1]*n[2] - phi[2]*n[1],
+                     phi[2]*n[0] - phi[0]*n[2],
+                     phi[0]*n[1] - phi[1]*n[0]]
+            pt_dict[pt] = [(wgt*(-n[2]*phixn[1]+n[1]*phixn[2]), (0, )),
+                           (wgt*(n[2]*phixn[0]-n[0]*phixn[2]), (1, )),
+                           (wgt*(-n[1]*phixn[0]+n[0]*phixn[1]), (2, ))]
         super().__init__(ref_el, (sd, ), pt_dict, {}, "IntegralMomentOfFaceTangentEvaluation")
 
+
 class PointScaledNormalEvaluation(Functional):
     """Implements the evaluation of the normal component of a vector at a
     point on a facet of codimension 1, where the normal is scaled by

FIAT/nedelec.py

@@ -11,6 +11,7 @@
 import numpy
 from FIAT.check_format_variant import check_format_variant
 
+
 def NedelecSpace2D(ref_el, k):
     """Constructs a basis for the 2d H(curl) space of the first kind
     which is (P_k)^2 + P_k rot( x )"""

FIAT/raviart_thomas.py

@@ -11,6 +11,7 @@
 from itertools import chain
 from FIAT.check_format_variant import check_format_variant
 
+
 def RTSpace(ref_el, deg):
     """Constructs a basis for the the Raviart-Thomas space
     (P_k)^d + P_k x"""