format SciML Style

Author: ChrisRackauckas

Diff for: .JuliaFormatter.toml

@@ -0,0 +1 @@
+style = "sciml"

Diff for: .github/workflows/FormatCheck.yml

@@ -0,0 +1,42 @@
+name: format-check
+
+on:
+  push:
+    branches:
+      - 'master'
+      - 'release-'
+    tags: '*'
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        julia-version: [1]
+        julia-arch: [x86]
+        os: [ubuntu-latest]
+    steps:
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: ${{ matrix.julia-version }}
+
+      - uses: actions/checkout@v1
+      - name: Install JuliaFormatter and format
+        # This will use the latest version by default but you can set the version like so:
+        #
+        # julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter", version="0.13.0"))'
+        run: |
+          julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter"))'
+          julia  -e 'using JuliaFormatter; format(".", verbose=true)'
+      - name: Format check
+        run: |
+          julia -e '
+          out = Cmd(`git diff --name-only`) |> read |> String
+          if out == ""
+              exit(0)
+          else
+              @error "Some files have not been formatted !!!"
+              write(stdout, out)
+              exit(1)
+          end'

Diff for: deps/build.jl

@@ -1,22 +1,21 @@
 using PyCall
 
 if Sys.iswindows()
-	@warn("""
-					FEniCS is not known to run on Windows!
-					Please try installing from Windows Subsystem for Linux.
-		""")
+    @warn("""
+     			FEniCS is not known to run on Windows!
+     			Please try installing from Windows Subsystem for Linux.
+     """)
+end
+try
+    pyimport_conda("fenics", "fenics=2019.1.0", "conda-forge")
+    pyimport_conda("mshr", "mshr=2019.1.0", "conda-forge")
+catch ee
+    typeof(ee) <: PyCall.PyError || rethrow(ee)
+    @warn("""
+       	Python Dependancies not installed
+       	Please either:
+       	 - Rebuild PyCall using the path to FEniCS using
+       	 - `ENV["PYTHON"]="/path/to/FEniCS"; Pkg.build("PyCall"); Pkg.build("FEniCS")`
+       	 - Or install the Dependancies using the Docker image provided
+       """)
 end
-	try
-		pyimport_conda("fenics", "fenics=2019.1.0", "conda-forge")
-		pyimport_conda("mshr", "mshr=2019.1.0", "conda-forge")
-	catch ee
-		typeof(ee) <: PyCall.PyError || rethrow(ee)
-		@warn("""
-						Python Dependancies not installed
-						Please either:
-						 - Rebuild PyCall using the path to FEniCS using
-						 - `ENV["PYTHON"]="/path/to/FEniCS"; Pkg.build("PyCall"); Pkg.build("FEniCS")`
-						 - Or install the Dependancies using the Docker image provided
-				 """
-		)
-	end

Diff for: examples/acoustic.jl

@@ -3,54 +3,54 @@ using FEniCS
 
 c = 5000
 #problem variables, have been scaled down for faster test solution
-dt = 0.00004;
-global t = 0;
-T = 0.0004;
+dt = 0.00004
+global t = 0
+T = 0.0004
 
-mesh = RectangleMesh(Point([-2., -2.]),Point([2., 2.]),40,40)
-V = FunctionSpace(mesh,"Lagrange",1)
+mesh = RectangleMesh(Point([-2.0, -2.0]), Point([2.0, 2.0]), 40, 40)
+V = FunctionSpace(mesh, "Lagrange", 1)
 
 # Previous and current solution
-u1= interpolate(Constant(0.0), V)
-u0= interpolate(Constant(0.0), V)
+u1 = interpolate(Constant(0.0), V)
+u0 = interpolate(Constant(0.0), V)
 
 # Variational problem at each time
 u = TrialFunction(V)
 v = TestFunction(V)
 
-a = u*v*dx + dt*dt*c*c*inner(grad(u), grad(v))*dx
-L = 2*u1*v*dx-u0*v*dx
+a = u * v * dx + dt * dt * c * c * inner(grad(u), grad(v)) * dx
+L = 2 * u1 * v * dx - u0 * v * dx
 
-delta = Expression("sin(c*10*t)",degree=2,c=c,t=t)
+delta = Expression("sin(c*10*t)", degree = 2, c = c, t = t)
 
 #Define boundary conditions
-top ="on_boundary && near(x[1], 2)"
-BCT = DirichletBC(V,Constant(0.0),top)
+top = "on_boundary && near(x[1], 2)"
+BCT = DirichletBC(V, Constant(0.0), top)
 
-down ="on_boundary && near(x[1], -2)"
-BCD = DirichletBC(V,Constant(0.0),down)
+down = "on_boundary && near(x[1], -2)"
+BCD = DirichletBC(V, Constant(0.0), down)
 
 left = "on_boundary && near(x[0],-2)"
-BCL = DirichletBC(V,delta,left)
+BCL = DirichletBC(V, delta, left)
 
 right = "on_boundary && near(x[0],2)"
-BCR = DirichletBC(V,Constant(0.0),right)
+BCR = DirichletBC(V, Constant(0.0), right)
 
 #bcs = [BCL.pyobject,BCD.pyobject,BCT.pyobject,BCR.pyobject]
-bcs = [BCL.pyobject,BCD.pyobject,BCT.pyobject]
+bcs = [BCL.pyobject, BCD.pyobject, BCT.pyobject]
 
 #bc = DirichletBC(V, 0, "on_boundary")
 
-u=FeFunction(V)
+u = FeFunction(V)
 
 while t <= T
     A, b = assemble_system(a, L, bcs)
     delta.pyobject.t = t
-    [apply(bcc,b) for bcc in bcs]
+    [apply(bcc, b) for bcc in bcs]
     solve(A, vector(u), b)
-    assign(u0,u1)
-    assign(u1,u)
-    global t +=dt
+    assign(u0, u1)
+    assign(u1, u)
+    global t += dt
     #fenics.plot(u.pyobject,title="Acoustic wave Equation")#,mode="auto")
 
 end

Diff for: examples/acoustic_new_assemble.jl

@@ -3,50 +3,49 @@ using FEniCS
 
 c = 5000
 #problem variables
-dt = 0.000004;
-global t = 0;
-T = 0.004;
+dt = 0.000004
+global t = 0
+T = 0.004
 
-mesh = RectangleMesh(Point([-2., -2.]),Point([2., 2.]),40,40)
-V = FunctionSpace(mesh,"Lagrange",1)
+mesh = RectangleMesh(Point([-2.0, -2.0]), Point([2.0, 2.0]), 40, 40)
+V = FunctionSpace(mesh, "Lagrange", 1)
 
 # Previous and current solution
-u1= interpolate(Constant(0.0), V)
-u0= interpolate(Constant(0.0), V)
+u1 = interpolate(Constant(0.0), V)
+u0 = interpolate(Constant(0.0), V)
 
 # Variational problem at each time
 u = TrialFunction(V)
 v = TestFunction(V)
 
-a = u*v*dx + dt*dt*c*c*inner(grad(u), grad(v))*dx
-L = 2*u1*v*dx-u0*v*dx
+a = u * v * dx + dt * dt * c * c * inner(grad(u), grad(v)) * dx
+L = 2 * u1 * v * dx - u0 * v * dx
 
-delta = Expression("sin(c*10*t)",degree=2,c=c,t=t)
+delta = Expression("sin(c*10*t)", degree = 2, c = c, t = t)
 
 #Define boundary conditions
-top ="on_boundary && near(x[1], 2)"
-BCT = DirichletBC(V,Constant(0.0),top)
+top = "on_boundary && near(x[1], 2)"
+BCT = DirichletBC(V, Constant(0.0), top)
 
-down ="on_boundary && near(x[1], -2)"
-BCD = DirichletBC(V,Constant(0.0),down)
+down = "on_boundary && near(x[1], -2)"
+BCD = DirichletBC(V, Constant(0.0), down)
 
 left = "on_boundary && near(x[0],-2)"
-BCL = DirichletBC(V,delta,left)
+BCL = DirichletBC(V, delta, left)
 
 right = "on_boundary && near(x[0],2)"
-BCR = DirichletBC(V,Constant(0.0),right)
+BCR = DirichletBC(V, Constant(0.0), right)
 
-bcs_dir = [BCL,BCD,BCT,BCR]
-bcs_neu = [BCL,BCD,BCT]
+bcs_dir = [BCL, BCD, BCT, BCR]
+bcs_neu = [BCL, BCD, BCT]
 
-
-u=FeFunction(V)
+u = FeFunction(V)
 
 while t <= T
     delta.pyobject.t = t
-    lvsolve(a,L,u,bcs_dir) #linear variational solver
-    assign(u0,u1)
-    assign(u1,u)
-    global t +=dt
+    lvsolve(a, L, u, bcs_dir) #linear variational solver
+    assign(u0, u1)
+    assign(u1, u)
+    global t += dt
 end
 end#module

Diff for: examples/heat_equation.jl

@@ -13,20 +13,20 @@ using OrdinaryDiffEq
 using FEniCS
 
 mesh = UnitIntervalMesh(50)
-V = FunctionSpace(mesh,"P",1)
+V = FunctionSpace(mesh, "P", 1)
 u_str = "sin(2*pi*x[0]) * exp(-t*pow(2*pi, 2))"
 
 tspan = (0.0, 0.1)
-u = interpolate(Expression(u_str, degree=2, pi=Float64(pi), t=tspan[1]), V)
+u = interpolate(Expression(u_str, degree = 2, pi = Float64(pi), t = tspan[1]), V)
 
 bc = DirichletBC(V, 0.0, "on_boundary")
 dudt = TrialFunction(V)
 v = TestFunction(V)
 Dudt = FeFunction(V)
-F = dot(dudt, v)*dx + dot(grad(u), grad(v))*dx
+F = dot(dudt, v) * dx + dot(grad(u), grad(v)) * dx
 a = lhs(F)
 L = rhs(F)
-p = (u=u, Dudt=Dudt, bc=bc, a=a, L=L)
+p = (u = u, Dudt = Dudt, bc = bc, a = a, L = L)
 
 function f!(dudt_vec, u_vec, p, t)
     assign(p.u, u_vec)
@@ -37,18 +37,18 @@ end
 u0_vec = get_array(u)
 t_final = 0.1
 prob = ODEProblem(f!, u0_vec, tspan, p)
-u_true = interpolate(Expression(u_str, degree=2, pi=Float64(pi), t=tspan[2]), V)
+u_true = interpolate(Expression(u_str, degree = 2, pi = Float64(pi), t = tspan[2]), V)
 
 # some algorithms to try:
 # alg = ImplicitEuler(autodiff=false)
 # alg = Rosenbrock23(autodiff=false)
 # alg = Rodas5(autodiff=false)
 
-alg = KenCarp4(autodiff=false)
-sol = OrdinaryDiffEq.solve(prob, alg, reltol=1e-6, abstol=1e-6)
+alg = KenCarp4(autodiff = false)
+sol = OrdinaryDiffEq.solve(prob, alg, reltol = 1e-6, abstol = 1e-6)
 
 vec_sol = get_array(p.u)
 vec_true = get_array(u_true)
-@test vec_sol ≈ vec_true rtol=1e-2
+@test vec_sol≈vec_true rtol=1e-2
 
 end#module

Diff for: examples/tutorial1.jl

@@ -1,26 +1,26 @@
 module Tutorial1
 using FEniCS
 
-mesh = UnitSquareMesh(8,8)
-V = FunctionSpace(mesh,"P",1)
-u_D = Expression("1+x[0]*x[0]+2*x[1]*x[1]", degree=2)
+mesh = UnitSquareMesh(8, 8)
+V = FunctionSpace(mesh, "P", 1)
+u_D = Expression("1+x[0]*x[0]+2*x[1]*x[1]", degree = 2)
 u = TrialFunction(V)
-bc1 = DirichletBC(V,u_D, "on_boundary")
+bc1 = DirichletBC(V, u_D, "on_boundary")
 v = TestFunction(V)
 f = Constant(-6.0)
-a = dot(grad(u),grad(v))*dx
-L = f*v*dx
-U=FeFunction(V)
-lvsolve(a,L,U,bc1) #linear variational solver
+a = dot(grad(u), grad(v)) * dx
+L = f * v * dx
+U = FeFunction(V)
+lvsolve(a, L, U, bc1) #linear variational solver
 #lvsolve(a,L,U,bc1,solver_parameters=Dict("linear_solver"=>"lu"),form_compiler_parameters=Dict("optimize"=>true))
-error_L2= errornorm(u_D, U, norm="L2")
+error_L2 = errornorm(u_D, U, norm = "L2")
 
 #get_array(L) #this returns an array for the stiffness matrix
 #get_array(U) #this returns an array for the solution values
 #vtkfile = File("poisson/solution.pvd")
 #vtkfile << U.pyobject #exports the solution to a vtkfile
-File("poisson/solutionnew.pvd",U)
-vertex_values_u_D = compute_vertex_values(u_D,mesh)
-vertex_values_u = compute_vertex_values(U,mesh)
-error_max = maximum(abs.(vertex_values_u_D-vertex_values_u))
+File("poisson/solutionnew.pvd", U)
+vertex_values_u_D = compute_vertex_values(u_D, mesh)
+vertex_values_u = compute_vertex_values(U, mesh)
+error_max = maximum(abs.(vertex_values_u_D - vertex_values_u))
 end#module

Diff for: examples/tutorial2.jl

@@ -1,22 +1,22 @@
 module Tutorial2
 using FEniCS
-domain = Circle(Point([0.0,0.0]),1)
-mesh = generate_mesh(domain,16)
-V = FunctionSpace(mesh,"P",2)
+domain = Circle(Point([0.0, 0.0]), 1)
+mesh = generate_mesh(domain, 16)
+V = FunctionSpace(mesh, "P", 2)
 w_D = Constant(0)
 
-bc = DirichletBC(V,w_D,"on_boundary")
-beta =8
+bc = DirichletBC(V, w_D, "on_boundary")
+beta = 8
 R0 = 0.6
 p = Expression("4*exp(-pow(beta, 2)*(pow(x[0], 2) + pow(x[1] - R0, 2)))",
-degree=1, beta=beta, R0=R0)
+               degree = 1, beta = beta, R0 = R0)
 w = TrialFunction(V)
 v = TestFunction(V)
-a = dot(grad(w), grad(v))*dx
-L = p*v*dx
-w=FeFunction(V)
-lvsolve(a,L,w,bc)
-p = interpolate(p,V)
+a = dot(grad(w), grad(v)) * dx
+L = p * v * dx
+w = FeFunction(V)
+lvsolve(a, L, w, bc)
+p = interpolate(p, V)
 
 vtkfile_w = File("poisson_membrane/deflection.pvd")
 vtkfile_w << w.pyobject