diff --git a/2Dedge_pre.jl b/2Dedge_pre.jl
new file mode 100644
index 0000000..61aca9a
--- /dev/null
+++ b/2Dedge_pre.jl
@@ -0,0 +1,56 @@
+#####################################################################################################
+
+"""
+standard isotropic CLE edge dislocation solution
+"""
+function ulin_edge_isotropic(X, b, ν)
+    x, y = X[1,:], X[2,:]
+    r² = x.^2 + y.^2
+    ux = b/(2*π) * ( angle.(x + im*y) + (x .* y) ./ (2*(1-ν) * r²) )
+    uy = -b/(2*π) * ( (1-2*ν)/(4*(1-ν)) * log.(r²) + - 2 * y.^2 ./ (4*(1-ν) * r²) )
+    return [ux'; uy']
+end
+
+"""
+lattice corrector to CLE edge solution; cf EOS paper
+"""
+function xi_solver(Y::Vector, b; TOL = 1e-10, maxnit = 5)
+   ξ1(x::Real, y::Real, b) = x - b * angle.(x + im * y) / (2*π)
+   dξ1(x::Real, y::Real, b) = 1 + b * y / (x^2 + y^2) / (2*π)
+    y = Y[2]
+    x = y
+    for n = 1:maxnit
+        f = ξ1(x, y, b) - Y[1]
+        if abs(f) <= TOL; break; end
+        x = x - f / dξ1(x, y, b)
+    end
+    if abs(ξ1(x, y, b) - Y[1]) > TOL
+        warn("newton solver did not converge at Y = $Y; returning input")
+        return Y
+    end
+    return [x, y]
+end
+
+"""
+EOSShapeev edge dislocation solution
+"""
+function ulin_edge_eos(X, b, ν)
+    Xmod = zeros(2, size(X, 2))
+    for n = 1:size(X,2)
+        Xmod[:, n] = xi_solver(X[1:2,n], b)
+    end
+    return ulin_edge_isotropic(Xmod, b, ν)
+end
+
+function edge_predictor!(at::AbstractAtoms; b = 1.0, xicorr = true, ν = 0.25)
+   X = positions(at) |> mat
+   if xicorr
+      X[1:2,:] += ulin_edge_eos(X, b, ν)
+   else
+      X[1:2,:] += ulin_edge_isotropic(X, b, ν)
+   end
+   set_positions!(at, X)
+   return at
+end
+
+#####################################################################################################
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..e130799
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,39 @@
+##
+#  CMake script for the step-6 tutorial program:
+##
+
+# Set the name of the project and target:
+SET(TARGET "test")
+
+# Declare all source files the target consists of. Here, this is only
+# the one step-X.cc file, but as you expand your project you may wish
+# to add other source files as well. If your project becomes much larger,
+# you may want to either replace the following statement by something like
+#    FILE(GLOB_RECURSE TARGET_SRC  "source/*.cc")
+#    FILE(GLOB_RECURSE TARGET_INC  "include/*.h")
+#    SET(TARGET_SRC ${TARGET_SRC}  ${TARGET_INC}) 
+# or switch altogether to the large project CMakeLists.txt file discussed
+# in the "CMake in user projects" page accessible from the "User info"
+# page of the documentation.
+SET(TARGET_SRC
+  ${TARGET}.cc
+  )
+
+# Usually, you will not need to modify anything beyond this point...
+
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12)
+
+FIND_PACKAGE(deal.II 9.0.0 QUIET
+  HINTS ${deal.II_DIR} ${DEAL_II_DIR} ../ ../../ $ENV{DEAL_II_DIR}
+  )
+IF(NOT ${deal.II_FOUND})
+  MESSAGE(FATAL_ERROR "\n"
+    "*** Could not locate a (sufficiently recent) version of deal.II. ***\n\n"
+    "You may want to either pass a flag -DDEAL_II_DIR=/path/to/deal.II to cmake\n"
+    "or set an environment variable \"DEAL_II_DIR\" that contains this path."
+    )
+ENDIF()
+
+DEAL_II_INITIALIZE_CACHED_VARIABLES()
+PROJECT(${TARGET})
+DEAL_II_INVOKE_AUTOPILOT()
diff --git a/IDX.jl b/IDX.jl
new file mode 100644
index 0000000..c6025d2
--- /dev/null
+++ b/IDX.jl
@@ -0,0 +1,245 @@
+# Read the coarse mesh from deal ii mesh, construct the geom
+# deal ii: bilinear mesh or tri-linear mesh
+# Author: Yangshuai Wang, 2019
+
+# TODO: Full the struct...
+
+# include("Tools.jl") I don't want include this, seems silly...
+
+# call JuLIPMaterials for edge dislocation 3D
+# include("./JuLIPMaterialsCodes/src/JuLIPMaterials.jl")
+# include("./JuLIPMaterialsCodes/src/Si.jl")
+# include("./JuLIPMaterialsCodes/src/CauchyBorn_Si.jl")
+
+# for getting basic geometry
+include("getX.jl")
+include("Tools.jl")
+
+# for read information from deal ii
+include("readIO.jl")
+
+# for 2D edge
+include("2Dedge_pre.jl")
+
+
+using JuLIP
+
+# index information including the hanging nodes
+struct IDX
+    
+    idx::Array{Int64, 1}    # find each atom in which element
+    iclo::Array{Int64, 1}  # find closest atom
+    hanging_index::Array{Any, 1}
+    hanging_info::Array{Any, 1}
+    hanging_coeff::Array{Any, 1}
+    
+end
+
+# * Do not need input.
+IDX() = IDX(idx, iclo, hanging_index, hanging_info, hanging_coeff) 
+
+# Main function
+function updateIDX(xa::Array{Float64, 2}, oldmeshname::Any, meshname::String, filename::String, ii::Any; task = "3DPoint")
+# Input: meshname, mesh file name from deal ii, "grid-0.msh"...
+#        filename, constraints information from deal ii, "constraints-0.txt"...
+#        L, differenet meaning for different task
+#        task, 2DPoint, 2DDislocation, 3DPoint and 3DDislocation
+# Output: IDX structure...
+        
+    # read mesh from deal ii
+    X1, T1 = read_mesh_msh_dealii_3D(meshname)
+    LX1 = maximum(xa) * X1
+    if oldmeshname == []
+        nX, nT = size(LX1, 2), size(T1, 2)
+        h, oT = zeros(nT), zeros(3, nT)
+        for j = 1:nT 
+            xTj = LX1[:, T1[:, j]]
+            h[j] = norm(xTj[:, 1].-xTj[:, 2], Inf)
+            oT[:, j] = 1/8 * sum(xTj, 2)
+        end
+        idxnew = 0 * Array{Int64, 1}(size(xa, 2))
+        iclonew = 0 * Array{Int64, 1}(nX)
+        for i = 1:nT
+            idxnew[find(maximum(abs.(xa .- oT[:, i]), 1)' .<= h[i]/2 + 1e-10)] = i
+        end
+        for k = 1:nX
+            iclonew[k] = indmin(sum(abs2, xa .- LX1[:, k], 1))  # find the closest atom
+        end         
+    else 
+        X0, T0 = read_mesh_msh_dealii_3D(oldmeshname) 
+        LX0 = maximum(xa) * X0
+        δX = copy(LX1[:, (size(LX0,2)+1):end])
+        iclo = 0 * Array{Int64, 1}(size(δX, 2))
+        for k = 1:size(δX, 2)
+            iclo[k] = indmin(sum(abs2, xa .- δX[:, k], 1))  # find the closest atom
+        end
+        iclonew = [ii.iclo; iclo]
+        idxnew = [ii.idx; 0]  # need improve...
+    end
+
+    # read constraints from deal ii 
+    hanging_index, hanging_info, hanging_coeff = read_constraints_dealii_3D(filename)
+
+    return IDX(idxnew, iclonew, hanging_index, hanging_info, hanging_coeff)
+      
+    
+end
+
+@inline function myindmin(xa::Array{Float64,2}, X::Array{Float64,2}) 
+I = 0 * Array{Int64,1}(size(X, 2))
+@simd for k = 1:size(X, 2)
+        @inbounds a = sum(abs2, xa .- X[:, k], 1)
+        I[k] = indmin(a)
+      end 
+    return I
+end
+
+@inline function get_initial_idx(h::Float64, oT::Array{Float64,2})   
+    ixa = get_div_index(xa, h) 
+    ioT = get_div_index(oT, h) 
+    AA = set_index!(ioT)
+    idx = get_index(ixa, AA)
+    Idx = update_index(idx, oT)
+    return Idx
+end
+
+@inline get_div_index(x::Union{Array{Float64,2}, Array{Int64,1}}, h::Float64) = map(Int64, div.(x, h+1e-6)+1.0)
+
+@inline function set_index!(ioT::Array{Int64,2})
+    noT = Int64(maximum(ioT))
+    AA = 0 * Array{Int64,3}(noT, noT, noT)
+    @simd for i = 1:size(ioT, 2)
+        AA[ioT[1, i], ioT[2, i], ioT[3, i]] = i
+    end
+    return AA
+end
+
+@inline function get_index(ixa::Array{Int64,2}, AA::Array{Int64,3})
+    nxa = size(xa, 2)
+    idx = 0 * Array{Int64,1}(nxa)
+    @simd for j = 1:nxa
+        idx[j] = AA[ixa[1, j], ixa[2, j], ixa[3, j]]
+    end
+    return idx
+end
+
+@inline function update_index(idx::Array{Int64,1}, oT::Array{Float64,2})
+    Idx = Array{Int64,1}[]
+    @simd for z = 1:length(oT)
+        iz = findin(idx, z)
+        push!(Idx, iz)
+    end
+    return Idx
+end
+    
+function update_Idx(Idx::Array{Array{Int64,1},1}, η::Array{Float64,1}, ngT::Array{Int64,2}, gT::Array{Int64,2}, ngX::Array{Float64,2}, gX::Array{Float64,2}, oT::Array{Float64,2})
+    n_ngT, n_gT = size(ngT, 2), size(gT, 2)
+    k = (n_ngT - n_gT) ÷ 7
+    ITref = sortperm(η, rev=true)[1:k]  # the index that to be refined 
+    InonTref = setdiff(1:n_gT, ITref)
+    nonTref = gT[:, InonTref]
+    Tref = gT[:, ITref] # get_T of to be refined
+    # find interiori points for each Tref
+    oo = zeros(3, k)
+    Iint = 0 * Array{Int64,1}(k) 
+    @simd for ii = 1:k
+        oo[:, ii] = 1/8 * sum(gX[:, Tref[:, ii]], 2)
+        Iint[ii] = find(maximum(abs.(ngX .- oo[:, ii]), 1)' .<= 1e-3)[1]
+    end
+    Idxnew = initial_empty(n_ngT)
+    in_ig = setdiff_T(n_gT-k, ngT, nonTref)
+    Idxnew[in_ig] = Idx[InonTref]
+    @simd for j = 1:k
+        index_in_Tref = Idx[ITref[j]] 
+        xa_in_I = xa[:, index_in_Tref] 
+        oT_in_Tref = 1/size(xa_in_I, 2)*sum(xa_in_I, 2)#oT[:, ITref[j]]
+        delta_xa_in_I = map(Int64, sign.(xa_in_I .- oT_in_Tref)[:])
+        idx_matrix = map_sign_to_idx!(delta_xa_in_I) 
+        
+        # silly implementation
+        Isilly = initial_empty(8)
+        for m = 1:length(index_in_Tref)
+            push!(Isilly[index_tensor[idx_matrix[1,m], idx_matrix[2,m], idx_matrix[3,m]]], m)
+        end
+        for isi = 1:8
+            ooo = 1/size(xa[:, index_in_Tref[Isilly[isi]]], 2)*sum(xa[:, index_in_Tref[Isilly[isi]]], 2)
+            oook = indmin(sum(abs2, oT .- ooo, 1))
+            Idxnew[oook] = index_in_Tref[Isilly[isi]]
+        end
+                    
+        
+# fast implementation -- need debug !        
+#         index_in_newgeom = findin(ngT[:], Iint[j]) 
+#         iii = get_div_index(index_in_newgeom, 8.0)
+#         sorted_refined_element = sortcols((hcat(mod.(index_in_newgeom, 8).+1, iii)'))[2, :]  
+#         @simd for m = 1:length(index_in_Tref)
+#             iiii = sorted_refined_element[index_tensor[idx_matrix[1,m], idx_matrix[2,m], idx_matrix[3,m]]]
+#             push!(Idxnew[iiii], index_in_Tref[m])
+#         end
+    end
+    return Idxnew
+end
+
+@inline function initial_empty(n_ngT::Int64)
+    Idxnew = Array{Int64,1}[]
+    @simd for i = 1:n_ngT
+        push!(Idxnew, Array{Int64, 1}[])
+    end
+    return Idxnew
+end
+
+@inline function setdiff_T(nn::Int64, ngT::Array{Int64,2}, nonTref::Array{Int64,2})
+    in_ig = 0 * Array{Int64,1}(nn)
+    @simd for g = 1:nn
+        in_ig[g] = findin(ngT[1, :], nonTref[1, g])[1]
+    end
+    return in_ig
+end
+
+function compute_iδ(ngX::Array{Float64,2}, ngT::Array{Int64,2}, gX::Array{Float64,2}, Idxnew::Array{Array{Int64,1},1})
+    δX = ngX[:, (size(gX, 2)+1):end]
+    δidx = 0 * Array{Int64, 1}(size(δX, 2))
+    @simd for d = 1:size(δX, 2)
+        iδx = size(gX, 2) + d
+        iδx_neigh = get_div_index(findin(ngT[:], iδx), 8.0)
+        II = Idxnew[iδx_neigh[1]]
+        @simd for i = 2:length(iδx_neigh)
+            @inbounds II = vcat(II, Idxnew[iδx_neigh[i]])
+        end
+        δx_neigh_xa = xa[:, II]
+        δidx[d] = II[indmin(sum(abs2, δx_neigh_xa .- δX[:,d], 1))] # II[...]
+    end
+    return δidx
+end
+
+# index_tensor = 0 * Array{Int64, 3}(3, 3, 3)
+# index_tensor[1, 1, 1] = 7
+# index_tensor[2:3, 1, 1] = 8
+# index_tensor[2:3, 1, 2:3] = 5
+# index_tensor[1, 1, 2:3] = 6
+# index_tensor[1, 2:3, 1] = 3
+# index_tensor[2:3, 2:3, 1] = 4
+# index_tensor[2:3, 2:3, 2:3] = 1
+# index_tensor[1, 2:3, 2:3] = 2;
+
+index_tensor = 0 * Array{Int64, 3}(2, 2, 2)
+index_tensor[1, 1, 1] = 7
+index_tensor[2, 1, 1] = 8
+index_tensor[2, 1, 2] = 5
+index_tensor[1, 1, 2] = 6
+index_tensor[1, 2, 1] = 3
+index_tensor[2, 2, 1] = 4
+index_tensor[2, 2, 2] = 1
+index_tensor[1, 2, 2] = 2;
+
+function map_sign_to_idx!(S::Array{Int64,1})
+    for i = 1:length(S)
+        if S[i] == -1
+            S[i] = 1
+        else
+            S[i] = 2
+        end
+    end
+    return reshape(S, 3, length(S)÷3)
+end   
+
diff --git a/Tools.jl b/Tools.jl
new file mode 100644
index 0000000..96b17ad
--- /dev/null
+++ b/Tools.jl
@@ -0,0 +1,275 @@
+# Do not need a module here
+# Useful or Unuseful tools
+# module Tools
+
+# a very stupid package
+using GeometricalPredicates
+
+using PyPlot
+# using DelimitedFiles for Julia 1.0
+
+# export TriInterp, Tribasisfunc, plot2dBC
+
+# bilinear basis function
+# No.k nodal basis, k = 1, 2, 3, 4, check!
+# 4--3
+# 1--2
+function BilinearBasisFunc(x1, x2, x3, x4, x, k)
+    if k == 1 
+        return (x3[1] - x[1, :]) .* (x[2, :] - x3[2]) / ( (x3[1] - x1[1]) * (x1[2] - x3[2]) )
+    end
+    if k == 2
+        return (x[1, :] - x4[1]) .* (x[2, :] - x4[2]) / ( (x2[1] - x4[1]) * (x2[2] - x4[2]) )
+    end
+    if k == 3
+        return (x[1, :] - x1[1]) .* (x1[2] - x[2, :]) / ( (x3[1] - x1[1]) * (x1[2] - x3[2]) )
+    end
+    if k == 4
+        return (x2[1] - x[1, :]) .* (x2[2] - x[2, :]) / ( (x2[1] - x4[1]) * (x2[2] - x4[2]) )
+    end
+end   
+
+# Interpolation by using basis function in one element using Vectorization
+# Much faster than normal
+# xx can be all atoms in the element
+# return w should be weight matrix
+function BilinearInterpVec(x, u, xx)
+    x1 = x[:, 1]; x2 = x[:, 2]; x3 = x[:, 3]; x4 = x[:, 4];
+    n = size(xx, 2)
+    uu = zeros(2, n)
+    ux = u[1, :]; uy = u[2, :];
+    w = zeros(n, 4)
+    for k = 1:4
+        w[:, k] = BilinearBasisFunc(x1, x2, x3, x4, xx, k)
+        uu[1, :] += w[:, k] * ux[k]
+        uu[2, :] += w[:, k] * uy[k]
+    end
+    return uu, w
+end
+
+# for bilinear grid
+# maybe useless since mesh information is from deal ii
+function element(H::Float64) 
+   
+    N = Int64(R / H + 1) 
+    n = N - 1
+    # allocate the elements
+    T = zeros(Int64, 4, n^2)   
+    idx = 0
+    for icol = 1:n, irow = 1:n
+        a = (icol-1)*(n+1)+irow
+        idx += 1
+        T[:,idx] = [a; a+1; a+n+2; a+n+1]  
+    end
+    
+    t = linspace(0.0, R, N)
+    O = ones(N)
+    X = A * [(t * O')[:]'; (O * t')[:]']
+    Xvecs = [[(t * O')[:]'; (O * t')[:]']; zeros(N^2)'] |> vecs
+    
+    return X, Xvecs, T
+    
+end
+
+# normolized the position to [1.0, 2.0]
+@inline function mymap(X::Array{Float64,2})
+     x = X[1, :]; y = X[2, :]
+     xmax = maximum(x); ymax = maximum(y)
+     x = 1.5 + x ./ (2*xmax)
+     y = 1.5 + y ./ (2*ymax)  # 
+     return hcat(x, y)'
+end
+
+# a very inefficient implementation
+# maybe need inline function
+function Intriangleineff(xa, T)
+    ind = []
+    xamap = mymap(xa)
+    # write it as inline function
+    xaPoint = xapoint(xamap)
+    tic()
+    @simd for iT = 1:size(T, 2)
+        @inbounds xTpre = mymap(X[:, T[:, iT]])
+        xT = consxT(xTpre)
+        mytri = Primitive(xT[1], xT[2], xT[3])
+        @inbounds i = [intriangle(mytri, xaPoint[i]) for i in 1:size(xamap, 2)]
+        #@inbounds push!(ind, [intriangle(mytri, xaPoint[i]) for i in 1:size(xamap, 2)])
+    end
+    toc()
+
+end
+
+@inline xapoint(xamap::Array{Float64,2}) = [Point(xamap[1, i], xamap[2, i]) for i in 1:size(xamap, 2)]
+
+@inline consxT(xTpre::Array{Float64,2}) = [Point(xTpre[1, 1], xTpre[2, 1]); Point(xTpre[1, 2], xTpre[2, 2]); 
+                                           Point(xTpre[1, 3], xTpre[2, 3])]
+
+@inline checkPoint(mytri, xa) = [intriangle(mytri, xaPoint[i]) for i in 1:size(xamap, 2)]
+
+# inefficeient, calculate all 3 and then choose
+@inline function Tribasisfunc(xT, x)
+    # No.k nodal basis of triangulate interpolation
+    # k = 1, 2, 3
+    # xT should be a 2*3 matrix
+
+    A = [ones(1, 3); xT]' \ [1.0 0.0 0.0; 0.0 1.0 0.0; 0.0 0.0 1.0]
+    M = hcat(ones(size(x, 2), 1), x') * A
+    
+    return M # N * 3 matrix
+
+end  
+
+@inline function TriInterp(x, u, xx)
+    # Triangulate interpolation using basis function in one element
+    # xx can be all atoms in the element
+    # return w which should be the weighted matrix
+    # x should be a 2*3 matrix
+    uu = zeros(2, size(xx, 2))
+    ux = u[1, :]; uy = u[2, :];
+    w = zeros(size(xx, 2), 3)
+    M = Tribasisfunc(x, xx)
+    @simd for k = 1:3      
+        w[:, k] = M[:, k]
+        @inbounds uu[1, :] += w[:, k] * ux[k]
+        @inbounds uu[2, :] += w[:, k] * uy[k]
+    end
+    return uu, w
+end
+
+
+# reference bilinear basis function
+# 4-3
+# 1-2
+ϕ_1(ξ, η) = (1 - ξ) .* (1 - η)
+ϕ_2(ξ, η) = ξ .* (1 - η)
+ϕ_3(ξ, η) = ξ .* η
+ϕ_4(ξ, η) = (1 - ξ) .* η
+
+function biInterp(x::Array{Float64, 2}, U::Array{Float64, 2})
+    # w should be 4*N
+#     w = hcat((1 - x[1, :]).*(1 - x[2, :]), 
+#              x[1, :] .* (1 - x[2, :]), 
+#              x[1, :] .* x[2, :],
+#              (1 - x[1, :]) .* x[2, :])'
+    ξ, η = x[1, :], x[2, :] 
+    w = hcat(ϕ_1(ξ, η), ϕ_2(ξ, η), 
+             ϕ_3(ξ, η), ϕ_4(ξ, η))'
+    u = U * w
+    return w, u
+end
+
+function para2square(X::Array{Float64,2}, x)
+    # transformation from T to Tref
+    # ξ = a1 + a2 * x + a3 * y + a4 * x * y
+    # η = b1 + b2 * x + b3 * y + b4 * x * y
+    # X = [0 1 1.5 0.5; 0 0 √3/2 √3/2] should be 2*4 matrix
+    # x = [1 0] should be 2*N matrix
+    A = [1 X[1, 1] X[2, 1] X[1, 1]*X[2, 1] 0 0 0 0;
+         1 X[1, 2] X[2, 2] X[1, 2]*X[2, 2] 0 0 0 0;
+         1 X[1, 3] X[2, 3] X[1, 3]*X[2, 3] 0 0 0 0;
+         1 X[1, 4] X[2, 4] X[1, 4]*X[2, 4] 0 0 0 0;
+         0 0 0 0 1 X[1, 1] X[2, 1] X[1, 1]*X[2, 1];
+         0 0 0 0 1 X[1, 2] X[2, 2] X[1, 2]*X[2, 2];
+         0 0 0 0 1 X[1, 3] X[2, 3] X[1, 3]*X[2, 3];
+         0 0 0 0 1 X[1, 4] X[2, 4] X[1, 4]*X[2, 4];]
+    b = [0; 1; 1; 0; 0; 0; 1; 1;]
+    a = A \ b
+    x = reshape(a, 4, 2)' * hcat(ones(size(x, 2)), x[1, :], x[2, :], x[1, :].*x[2, :])'
+end
+
+
+# reference trilinear basis function
+#   8-7
+# 5-6
+#   4-3
+# 1-2
+ϕ3_1(x, y, z) = 1/8 * (1 - x) .* (1 - y) .* (1 - z)
+ϕ3_2(x, y, z) = 1/8 * (1 + x) .* (1 - y) .* (1 - z)
+ϕ3_3(x, y, z) = 1/8 * (1 + x) .* (1 + y) .* (1 - z)
+ϕ3_4(x, y, z) = 1/8 * (1 - x) .* (1 + y) .* (1 - z)
+ϕ3_5(x, y, z) = 1/8 * (1 - x) .* (1 - y) .* (1 + z)
+ϕ3_6(x, y, z) = 1/8 * (1 + x) .* (1 - y) .* (1 + z)
+ϕ3_7(x, y, z) = 1/8 * (1 + x) .* (1 + y) .* (1 + z)
+ϕ3_8(x, y, z) = 1/8 * (1 - x) .* (1 + y) .* (1 + z)
+
+function triInterp(x::Array{Float64, 2}, U::Array{Float64, 2})
+    # w should be 8*N
+    x1, x2, x3 = x[1, :], x[2, :], x[3, :] 
+    w = hcat(ϕ3_1(x1, x2, x3), ϕ3_2(x1, x2, x3), ϕ3_3(x1, x2, x3), ϕ3_4(x1, x2, x3),
+             ϕ3_5(x1, x2, x3), ϕ3_6(x1, x2, x3), ϕ3_7(x1, x2, x3), ϕ3_8(x1, x2, x3))'
+    u = U * w
+    return w, u
+end
+
+function hex2cube(X::Array{Float64,2}, x)
+    # transformation from T to Tref
+    # ξ = a1 + a2*x + a3*y + a4*z + a5*x*y + a6*x*z + a7*y*z + a8*x*y*z
+    # η = b1 + b2*x + b3*y + b4*z + b5*x*y + b6*x*z + b7*y*z + b8*x*y*z
+    # γ = c1 + c2*x + c3*y + c4*z + c5*x*y + c6*x*z + c7*y*z + c8*x*y*z
+    # X should be 3*8 matrix
+    # x should be 2*N matrix
+    A1 = zeros(size(X, 2), size(X, 2))
+    O = copy(A1)
+    for i = 1:size(X, 2)
+        A1[i, :] = [1 X[1, i] X[2, i] X[3, i] X[1, i]*X[2, i] X[1, i]*X[3, i] X[2, i]*X[3, i] X[1, i]*X[2, i]*X[3, i] ]
+    end
+    A = [A1 O O; O A1 O; O O A1]
+    b = [-1; 1; 1; -1; -1; 1; 1; -1;
+         -1; -1; 1; 1; -1; -1; 1; 1;
+         -1; -1; -1; -1; 1; 1; 1; 1;] # should be 24*1
+    a = A \ b
+    x = reshape(a, 8, 3)' * hcat(ones(size(x, 2)), x[1, :], x[2, :], x[3, :], x[1, :].*x[2, :], x[1, :].*x[3, :], x[2, :].*x[3, :], x[1, :].*x[2, :].*x[3, :])'
+end
+
+
+
+#####################################################################################################
+
+function plot2dBC(at::JuLIP.Atoms{Float64, Int64}; iBC=nothing)
+    
+    x, y, _ = xyz(at)
+    plot(x, y, "ro", markersize=6) 
+    if iBC != nothing
+        plot(x[iBC], y[iBC], "go", markersize=6)
+    end
+    axis("equal")
+    
+end 
+
+function plot3dBC(at; iBC=nothing)
+    
+    X = positions(at) |> mat 
+    plot3D(X[1,:], X[2,:], X[3, :], "ro", markersize=4)
+    
+    if iBC != nothing
+        l = copy(iBC)
+        o = [l/2, l/2, l/2]
+        I = []
+        for i = 1:size(X, 2)
+            x = X[:, i]
+            if abs(x[1]-o[1])>l/2-1.8 || abs(x[2]-o[2])>l/2-1.8 || abs(x[3]-o[3])>l/2-1.8
+                push!(I, i)
+            end
+        end
+        plot3D(X[1,I], X[2,I], X[3, I], "go", markersize=4)
+    end
+    
+end 
+
+# Only for square mesh
+# maybe useful
+# nodes in the fine mesh position
+function idxElement2Atom(X, T, xref, t::Int64)
+    idxint = Int64[]; idx = Int64[]
+    vertex = X[:, T[:, t]]
+    v1 = vertex[:, 1]; v2 = vertex[:, 3];
+    h = v2[1] - v1[1];
+    midpoint = [0.5*(v1[1]+v2[1]), 0.5*(v1[2]+v2[2])]
+    iint = find((abs.(midpoint[1] .- xref[1, :]) .< h/2) .& (abs.(midpoint[2] .- xref[2, :]) .< h/2))
+    i = find((abs.(midpoint[1] .- xref[1, :]) .<= h/2) .& (abs.(midpoint[2] .- xref[2, :]) .<= h/2))
+    push!(idxint, iint...)
+    push!(idx, i...)
+    return idxint, idx 
+end
+
+# end
\ No newline at end of file
diff --git a/coeff.txt b/coeff.txt
new file mode 100644
index 0000000..5a2a580
--- /dev/null
+++ b/coeff.txt
@@ -0,0 +1 @@
+0.6
diff --git a/debug.ipynb b/debug.ipynb
new file mode 100644
index 0000000..a3a86ad
--- /dev/null
+++ b/debug.ipynb
@@ -0,0 +1,295 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "using JuLIP"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "JuLIP.Atoms{Float64,Int64}\n",
+       "  X: Array{StaticArrays.SArray{Tuple{3},Float64,1,3}}((16384,))\n",
+       "  P: Array{StaticArrays.SArray{Tuple{3},Float64,1,3}}((16384,))\n",
+       "  M: Array{Float64}((16384,)) [63.546, 63.546, 63.546, 63.546, 63.546, 63.546, 63.546, 63.546, 63.546, 63.546  …  63.546, 63.546, 63.546, 63.546, 63.546, 63.546, 63.546, 63.546, 63.546, 63.546]\n",
+       "  Z: Array{Int64}((16384,)) [29, 29, 29, 29, 29, 29, 29, 29, 29, 29  …  29, 29, 29, 29, 29, 29, 29, 29, 29, 29]\n",
+       "  cell: StaticArrays.SArray{Tuple{3,3},Float64,2,9}\n",
+       "  pbc: StaticArrays.SArray{Tuple{3},Bool,1,3}\n",
+       "  calc: JuLIP.NullCalculator JuLIP.NullCalculator()\n",
+       "  cons: JuLIP.NullConstraint JuLIP.NullConstraint()\n",
+       "  data: Dict{Any,JuLIP.JData}\n"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "at = bulk(:Cu, cubic=true) * 16"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8192"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "length(at)÷2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3×3 StaticArrays.SArray{Tuple{3,3},Float64,2,9}:\n",
+       " 57.76   0.0    0.0 \n",
+       "  0.0   57.76   0.0 \n",
+       "  0.0    0.0   57.76"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "at.cell"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3-element StaticArrays.SArray{Tuple{3},Float64,1,3}:\n",
+       " 55.955\n",
+       " 54.15 \n",
+       " 27.075"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "at.X[8191]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Coding the projection-QCE to test the algorithm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "map_sign_to_idx! (generic function with 1 method)"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# include the function\n",
+    "using JuLIP, HDF5, JLD, PyPlot, Optim, LineSearches\n",
+    "include(\"./Juliacodes/myplot.jl\")\n",
+    "include(\"./Juliacodes/geom.jl\")\n",
+    "include(\"./Juliacodes/solver.jl\")\n",
+    "include(\"./Juliacodes/IDX.jl\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "PyPlot.Figure(PyObject <Figure size 640x480 with 1 Axes>)"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# 1. compute the atomistic solution and the initial mesh\n",
+    "L = 32\n",
+    "at = bulk(:Al, cubic=true) * L\n",
+    "r0 = rnn(:Al)\n",
+    "oc = 0.5*maximum(mat(at.X))*ones(3)\n",
+    "_, imid = findmin(sum(abs2, mat(at.X).-oc, 1))\n",
+    "at = bulk(:Al, cubic=true) * L\n",
+    "deleteat!(at, imid)\n",
+    "calc = LennardJones(σ = r0) * C2Shift(1.5*r0)\n",
+    "set_calculator!(at, calc)\n",
+    "set_constraint!(at, FixedCell(at))\n",
+    "figure(0)\n",
+    "myplotA(mat(at.X))\n",
+    "xa = copy(mat(at.X))\n",
+    "if !isfile(string(\"3DPoint\", L, \".jld\"))\n",
+    "    xold = copy(mat(at.X))\n",
+    "    tic()\n",
+    "    minimise!(at, verbose = 2, precond = :id)\n",
+    "    println(\"  Reference time: \")\n",
+    "    toc()\n",
+    "    xnew = copy(mat(at.X))\n",
+    "    u = xnew .- xold\n",
+    "    save(string(\"3DPoint\", L, \".jld\"), \"u\", u)\n",
+    "end\n",
+    "initial_grid = \"grid-0.msh\"\n",
+    "initial_cons = \"constraints-0.txt\"\n",
+    "geom = readmsh(at, initial_grid, initial_cons, L, 0)\n",
+    "initial = zeros(2, size(geom.X, 2) - length(geom.hanging_index))\n",
+    "Idx = get_initial_idx(geom.h[1], geom.oT)\n",
+    "idx = myindmin(xa, geom.X)\n",
+    "myplotgeom(geom);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "get_index_n (generic function with 1 method)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "function get_index_n(Idx, iA_in_T)\n",
+    "    i = Idx[iA_in_T[1]]\n",
+    "    for j = 2:length(iA_in_T)\n",
+    "        i = vcat(i, Idx[iA_in_T[j]]...)\n",
+    "    end\n",
+    "    return i\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The number of the atomistic region: 393213\n"
+     ]
+    }
+   ],
+   "source": [
+    "println(\"The number of the atomistic region: \", length(xa))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The atomistic configuration is a 32*32*32 cell.\n"
+     ]
+    }
+   ],
+   "source": [
+    "L = 32\n",
+    "println(\"The atomistic configuration is a \", L, \"*\", L, \"*\", L, \" cell.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Julia 0.6.4",
+   "language": "julia",
+   "name": "julia-0.6"
+  },
+  "language_info": {
+   "file_extension": ".jl",
+   "mimetype": "application/julia",
+   "name": "julia",
+   "version": "0.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/geom.jl b/geom.jl
new file mode 100644
index 0000000..d047163
--- /dev/null
+++ b/geom.jl
@@ -0,0 +1,255 @@
+# Read the coarse mesh from deal ii mesh, construct the geom
+# deal ii: bilinear mesh or tri-linear mesh
+# Author: Yangshuai Wang, 2019
+
+# TODO: Full the struct...
+
+# include("Tools.jl") I don't want include this, seems silly...
+
+# call JuLIPMaterials for edge dislocation 3D
+include("./JuLIPMaterialsCodes/src/JuLIPMaterials.jl")
+include("./JuLIPMaterialsCodes/src/Si.jl")
+include("./JuLIPMaterialsCodes/src/CauchyBorn_Si.jl")
+
+# for getting basic geometry
+include("getX.jl")
+include("Tools.jl")
+
+# for read information from deal ii
+include("readIO.jl")
+
+# for 2D edge
+include("2Dedge_pre.jl")
+
+
+using JuLIP, PyPlot
+
+# at should not in this function
+struct dealii_geom
+    
+    s::String  # task
+    L::Int64  # model params
+    i::Int64  # step info
+    at::JuLIP.Atoms{Float64, Int64}  # atomistic scaled Atoms
+    X::Array{Float64, 2}  # mesh position
+    T::Array{Int64, 2}  # mesh index
+    ifree::Array{Int64, 1}  # think about this, whether ifree or ibc ???
+#     idx::Array{Int64, 1}    # find each atom in which element
+#     iclo::Array{Int64, 1}  # find closest atom
+    A::Array{Float64, 2}   # A indicates the dimension
+    oT::Array{Float64, 2}  # coodinate of mid-point of element
+    h::Array{Float64, 1}  # mesh size
+    dh::Array{Float64, 1}  # distance from defect
+    hmin::Float64  # minimum mesh 
+    hanging_index::Array{Any, 1}
+    hanging_info::Array{Any, 1}
+    hanging_coeff::Array{Any, 1}
+    
+end
+
+# * Do not need input.
+dealii_geom() = dealii_geom(s, L, i, at, X, T, ifree, A, oT, h, dh, hmin, hanging_index, hanging_info, hanging_coeff) 
+
+# Main function
+function readmsh(at::JuLIP.Atoms{Float64, Int64}, meshname::String, filename::String, L::Int64, i::Int64; task = "3DPoint")
+# Input: meshname, mesh file name from deal ii, "grid-0.msh"...
+#        filename, constraints information from deal ii, "constraints-0.txt"
+#        L, differenet meaning for different task
+#        task, 2DPoint, 2DDislocation, 3DPoint and 3DDislocation
+# Output: geom structure...
+    
+    if task == "2DPoint"
+    
+        # read mesh from deal ii
+        Xo, To = read_mesh_msh_dealii(meshname)
+
+        # scaled square mesh
+        X = L * Xo .- L / 2 
+
+        # deformation A
+        A = [1.0 sin(π/6); 0.0 cos(π/6)]
+        lay = 3; # outside layer
+        va = 0; # only for single vacancy + multi-vacan
+        # va = [-3, -2, -1, 0, 1, 2, 3] # micro-crack
+
+        # form the atomistic configuration with vacancy
+        x, ibc = getX(A, L+2*lay, va, :parallel, layer=lay, task=task)
+
+        # construct at
+        at = Atoms(:X, x)
+        set_calculator!(at, lennardjones()*SplineCutoff(1.8, 2.7))
+        set_constraint!(at, FixedCell2D(at, clamp=ibc));
+        
+        xa = mat(x)[1:2, :]
+
+        # get DoF
+        ifree = setdiff(1:size(xa, 2), ibc)
+        xrefa = xa[:, ifree]
+        xref = A\xrefa
+
+        # obtain the index of each element
+        idx = Array{Int64, 1}(zeros(length(ifree))) # exists no overlap!!
+        for i = size(To, 2):-1:1
+            _, ii = idxElement2Atom(X, To, xref, i)
+            idx[ii] = i
+        end
+        
+        # read constraints from deal ii
+        hanging_index, hanging_info, hanging_coeff = read_constraints_dealii(filename)
+    
+        return dealii_geom(L, i, X, To, ifree, idx, A, at, hanging_index, hanging_info, hanging_coeff)
+        
+    end
+    
+    if task == "2DDislocation"
+        
+        # read mesh from deal ii
+        Xo, To = read_mesh_msh_dealii(meshname)
+
+        # deformation A
+        A = [1.0 sin(π/6); 0.0 cos(π/6)]
+        lay = 3; va = 0; 
+        
+        # form the atomistic configuration 
+        x, ibc = getX(A, L+2*lay, va, :parallel, layer=lay, task=task)
+        at = Atoms(:X, x)
+        
+        # with dislocation predictor...
+        X = positions(at)
+        # find center-atom
+        F = [1.0 0.0 0.0; 0.0 √3 0.0; 0.0 0.0 1.0]
+        x0 = JVec([0.5 * diag(F)[1:2]; 0.0])
+        _ , I0 = findmin([norm(x - x0) for x in X])
+        # dislocation core
+        tcore = JVec([0.5, √3/6, 0.0])
+        xc = X[I0] + tcore
+        # shift configuration to move core to 0
+        X = [x - xc for x in positions(at)]
+        set_positions!(at, X)
+        # remove the center-atom
+        deleteat!(at, I0)
+        # apply dislocation FF predictor
+        edge_predictor!(at; b=1.0, xicorr=true, ν=0.25)
+        X = [x + tcore for x in positions(at)]
+        set_positions!(at, X)
+        
+        # scaled square mesh
+        xa = A \ mat(at.X)[1:2, :]
+        Lmax = maximum(abs.(xa))
+        X = 2 * Lmax * Xo - Lmax
+        
+        Rqm = Lmax - 5
+        r = norm.(positions(at))
+        Ifree = find(r .<= Rqm)
+        set_calculator!(at, lennardjones()*SplineCutoff(1.8, 2.7))
+        set_constraint!(at, JuLIP.Constraints.FixedCell2D(at; free = Ifree))
+        
+        
+        nT = size(To, 2)
+        oT = zeros(2, nT)
+        h = zeros(nT)
+        for j = 1:nT 
+            xTj = X[:, To[:, j]]
+            h[j] = norm(xTj[:, 1].-xTj[:, 2], Inf)
+            oT[:, j] = 1/4 * sum(xTj, 2)
+        end        
+        tic()
+        idx = 0 * Array{Int64, 1}(size(xa, 2))
+        for i = 1:size(To, 2)
+            idx[find(maximum(abs.(xa .- oT[:, i]), 1)' .<= h[i]/2 + 1e-10)] = i
+        end
+        toc()
+           
+        # read constraints from deal ii
+        hanging_index, hanging_info, hanging_coeff = read_constraints_dealii(filename)
+    
+        return dealii_geom(X, To, Ifree, idx, A, hanging_index, hanging_info, hanging_coeff)
+        
+    end
+        
+    if task == "3DPoint"
+        
+        # read mesh from deal ii
+        Xo, To = read_mesh_msh_dealii_3D(meshname)
+        
+        # scaled cubic mesh
+        xa = mat(at.X)
+        Lmax = maximum(xa)
+        X = Lmax * Xo
+        
+        # boundary part, define casually, do not used.
+        ifree = [0]
+        A = [1.0 0.0 0.0; 0.0 √3 0.0; 0.0 0.0 1.0]
+        
+        od = get_data(at, "defpos")
+        nX, nT = size(Xo, 2), size(To, 2)
+        h, dh, oT = zeros(nT), zeros(nT), zeros(3, nT)
+        @simd for j = 1:nT 
+            xTj = X[:, To[:, j]]
+            h[j] = norm(xTj[:, 1].-xTj[:, 2], Inf)
+            oT[:, j] = 1/8 * sum(xTj, 2)
+            dh[j] = minimum(sqrt.(sum(abs2, oT[:,j] .- od, 1)))
+        end
+        hmin = minimum(h)
+
+        # read constraints from deal ii 
+        hanging_index, hanging_info, hanging_coeff = read_constraints_dealii_3D(filename)
+
+        return dealii_geom(task, L, i, at, X, To, ifree, A, oT, h, dh, hmin, hanging_index, hanging_info, hanging_coeff)
+        
+    end
+    
+    if task == "3DDislocation"
+        
+        # read mesh from deal ii
+        Xo, To = read_mesh_msh_dealii_3D(meshname)
+
+        # construct atoms
+        at, _ = Si.edge110(:Si, L)
+        set_constraint!(at, FixedCell(at))
+        
+        # scaled cubic mesh
+        xa = mat(at.X)
+        Lmax = maximum(abs.(xa))
+        Lmin = minimum(xa)
+        LL = Lmax - Lmin
+        X = LL * Xo + Lmin
+        ########################### better to put the at in the middle...or change the cluster coefficient...
+        
+        # boundary part
+        ifree = [0]
+        A = [1.0 0.0 0.0; 0.0 √3 0.0; 0.0 0.0 1.0]
+        
+        nT = size(To, 2)
+        oT = zeros(3, nT)
+        h = zeros(nT)
+        for j = 1:nT 
+            xTj = X[:, To[:, j]]
+            h[j] = norm(xTj[:, 1].-xTj[:, 2], Inf)
+            oT[:, j] = 1/8 * sum(xTj, 2)
+        end
+        
+        tic()
+        idx = 0 * Array{Int64, 1}(size(xa, 2))
+        for i = 1:size(To, 2)
+            idx[find(maximum(abs.(xa .- oT[:, i]), 1)' .<= h[i]/2 + 1e-10)] = i
+        end
+        toc()
+        # !!!!!! NEED IT EFFECIENT !!!!!!!!!!!
+        
+        # read constraints from deal ii 
+        hanging_index, hanging_info, hanging_coeff = read_constraints_dealii_3D(filename)
+        
+        return dealii_geom(X, To, ifree, idx, A, hanging_index, hanging_info, hanging_coeff)
+    end
+    
+end
+
+
+@inline findinT(xa::Array{Float64,2}, oT::Array{Float64,2}, h::Array{Float64,1}) = find(maximum(abs.(xa .- oT[:, i]), 1)' .<= h[i]/2 + 1e-10)
+
+
+
+
+
+
diff --git a/getX.jl b/getX.jl
new file mode 100644
index 0000000..673df68
--- /dev/null
+++ b/getX.jl
@@ -0,0 +1,189 @@
+# Construct the configuration
+# A: non-singular matrix
+# L: size, default layer = 0 means no DBC 
+# vacancies position
+# Author: Yangshuai Wang, Date: 11/26/2018
+
+using JuLIP
+
+function getX(A::Array{Float64, 2}, L::Int64, vacancies, shape::Symbol; layer=0, task="2DPoint")
+
+    # 六边形结构
+    if shape == :hexagon
+        X, iBC = hexregion(L; layer=layer)
+    end
+    # 正方形结构
+    if shape == :square
+        X, iBC = squregion(L; layer=layer)
+    end
+    # 平行四边形结构
+    if shape == :parallel
+        X, iBC = parregion(A, L, vacancies=vacancies, layer=layer, task=task)
+    end
+    # 圆形结构
+    if shape == :ball
+        X, iBC = balregion(L; layer=layer)
+    end    
+    return X, iBC
+    
+end
+    
+function squregion(L::T; layer=0) where {T <: Number}
+    
+    t = linspace(-L/2, L/2, L+1)
+    o = ones(L+1)
+    X = [(t * o')[:]'; (o * t')[:]']
+    
+    X = [X; zeros(size(X, 2))'] |> vecs
+    iBC = IBC(Int(L+1); k=layer)
+    return X, iBC
+        
+end
+    
+function parregion(A::Array{Float64, 2}, L::T; vacancies=0, layer=0, task="2DPoint") where {T <: Number}
+    
+    # linspace ...
+    t = linspace(-L/2, L/2, L+1)
+    o = ones(L+1)
+    X = A * [(t * o')[:]'; (o * t')[:]']
+    
+    # vacancies defined here (for single vacancy & crack)
+    # vacancies like this [-2, -1, 0, 1, 2, ...]
+    if task == "2DPoint"
+        iva = Int64((L+2)*L/2+1) + vacancies
+    else
+        iva = 0
+    end
+    
+    # need rewise to multi-vacancy
+    # iva1 = Int64( (L+2)*((L+2-2*layer)/4 + layer) )   # L IS NOT CORRECT! MAN!!
+    # iva2 = Int64( (L+1)*((L+2-2*layer)/4 + layer) + (L+2-2*layer)/4*3 + layer )
+    # iva3 = Int64( (L+1)*((L+2-2*layer)/4*3 + layer) + (L+2-2*layer)/4 + layer )
+    # iva4 = Int64( (L+2)*((L+2-2*layer)/4*3 + layer) ) 
+    # iva = [iva1..., iva2..., iva3..., iva4]
+    
+    iremain = setdiff(1:size(X, 2), iva)
+    X = X[:, iremain]
+    X = [X; zeros(size(X, 2))'] |> vecs  
+    
+    # (only for single vacancy/four corner vacancies now)
+    iBC = IBC(Int64(L+1); k=layer)
+    iBCva = iBC_update!(iBC, iva)
+    return X, iBCva
+        
+end
+    
+# copy from AC2D codes
+function hexregion(L::T; layer=0) where T <: Number
+    # lattice directions, auxiliary operators
+    a1 = [1, 0]
+    Q6 = [cos(pi/3) -sin(pi/3); sin(pi/3) cos(pi/3)]
+    a2 = Q6 * a1
+    a3 = Q6 * a2
+
+    # no atomistic core first
+    K0 = 0
+    X = a1 * 0.0
+    nX = 2 * K0 + 1
+    c = [nX, nX, 1, 1, 1, nX]
+    idx = [0 for i=1:L]
+    L1 = 2 * K0
+    L2 = 0
+    for j = 1:Int(L)
+        
+        L1 += 1; o1 = ones(1, L1)
+        L2 += 1; o2 = ones(1, L2)
+
+        X = hcat(X, (X[:, c[1]] + a1) * o2 .+ a3 * collect(0:L2-1)', 
+                    (X[:, c[2]] + a2) * o1 .- a1 * collect(0:L1-1)',  
+                    (X[:, c[3]] + a3) * o2 .- a2 * collect(0:L2-1)', 
+                    (X[:, c[4]] - a1) * o2 .- a3 * collect(0:L2-1)', 
+                    (X[:, c[5]] - a2) * o1 .+ a1 * collect(0:L1-1)', 
+                    (X[:, c[6]] - a3) * o2 .+ a2 * collect(0:L2-1)')
+
+        c[1] = c[6] + L2 - 1 
+        if j == 1
+            c[1] = c[1] + 1
+        end
+        c[2] = c[1] + L2
+        c[3] = c[2] + L1
+        c[4] = c[3] + L2
+        c[5] = c[4] + L2
+        c[6] = c[5] + L1
+        
+        idx[j] = size(X, 2)
+
+    end
+
+    X = [X; zeros(size(X, 2))'] |> vecs
+    iBC = collect(idx[Int(L-layer)]+1:idx[end]) 
+    
+    return X, iBC
+    
+end
+
+function balregion(L::T; layer=0) where {T <: Number}
+    
+    A = [1.0 sin(π/6); 0.0 cos(π/6)]
+    t = linspace(-L, L, 2L+1)
+    o = ones(2L+1)
+    X = A*[(t * o')[:]'; (o * t')[:]']
+    X = X[:, find(sqrt.(sum(abs2, X, 1)) .< L)]
+    iFree = find(sqrt.(sum(abs2, X, 1)) .< L-layer)
+    
+    X = [X; zeros(size(X, 2))'] |> vecs
+    iBC = setdiff(1:length(X), iFree)
+    
+    return X, iBC
+    
+end
+
+function IBC(N::Int64; k=0)
+
+    i1 = collect(1:k*N)
+    i2 = collect(N^2-k*N+1:N^2)
+    i3 = []; i4 = [];
+    for i = 1:k
+        i3 = vcat(i3, collect(i:N:N^2-N+i))
+        i4 = vcat(i4, collect(N-i+1:N:N^2-i+1))
+    end
+    idx = [i1; i2; i3; i4]
+    idx = unique(idx)
+    idx = sort(idx)
+    
+    return idx
+    
+end  
+            
+function iBC_update!(iBC, iva)
+    
+    # now only for sigle vacancy!
+    n = length(iBC)
+    # println(iBC[Int(n/2)+1:end])
+    iBC = vcat(iBC[1:Int(n/2)], iBC[Int(n/2)+1:end] .- 1)
+    
+    # multi-vacancies!
+    # n = length(iBC)
+    # I = copy(iBC)
+    # only for four vacancies, should develop to any nv...
+    # for i = 1:n
+    #     if iBC[i] < iva[1]
+    #         I[i] = iBC[i]
+    #         elseif iva[1] < iBC[i] < iva[2]
+    #             I[i] = iBC[i] - 1
+    #         elseif iva[2] < iBC[i] < iva[3]
+    #             I[i] = iBC[i] - 2
+    #         elseif iva[3] < iBC[i] < iva[4]
+    #             I[i] = iBC[i] - 3
+    #     else
+    #         I[i] = iBC[i] - 4
+    #     end
+    # return I
+    # end
+    
+    # micro-crack!
+    # nv = length(iva)
+    # n = length(iBC)
+    # iBC = vcat(iBC[1:Int(n/2)], iBC[Int(n/2)+1:end] - nv)    
+          
+end
\ No newline at end of file
diff --git a/iteration.txt b/iteration.txt
new file mode 100644
index 0000000..00750ed
--- /dev/null
+++ b/iteration.txt
@@ -0,0 +1 @@
+3
diff --git a/myplot.jl b/myplot.jl
new file mode 100644
index 0000000..d321166
--- /dev/null
+++ b/myplot.jl
@@ -0,0 +1,40 @@
+function myplotgeom(geom)
+    Ii = [1 2 3 4 1 2 3 4 5 6 7 8; 2 3 4 1 5 6 7 8 6 7 8 5]
+    for iT = 1:size(geom.T, 2)
+        T = geom.T[:, iT]
+        for iI = 1:12
+            i = Ii[:, iI]
+            xx = geom.X[:, T[i]]
+            plot3D(xx[1,:], xx[2,:], xx[3,:], "bo-", linewidth=0.7, markersize=4)
+        end
+    end     
+    xticks([])
+    yticks([])
+    zticks([])
+    pause(0.5)
+end
+
+function myplotA(x::Array{Float64,2})
+    plot3D(x[1,:], x[2,:], x[3,:], "ro", markersize=1)
+    xticks([])
+    yticks([])
+    zticks([])
+    pause(0.5)
+end
+
+function myplotQCE(geom, x::Array{Float64,2})
+    Ii = [1 2 3 4 1 2 3 4 5 6 7 8; 2 3 4 1 5 6 7 8 6 7 8 5]
+    for iT = 1:size(geom.T, 2)
+        T = geom.T[:, iT]
+        for iI = 1:12
+            i = Ii[:, iI]
+            xx = geom.X[:, T[i]]
+            plot3D(xx[1,:], xx[2,:], xx[3,:], "bo-", linewidth=0.7, markersize=4)
+        end
+    end    
+    plot3D(x[1,:], x[2,:], x[3,:], "ro", markersize=1)
+    xticks([])
+    yticks([])
+    zticks([])
+    pause(0.5)   
+end
\ No newline at end of file
diff --git a/readIO.jl b/readIO.jl
new file mode 100644
index 0000000..f2f1ce4
--- /dev/null
+++ b/readIO.jl
@@ -0,0 +1,143 @@
+#####################################################################################################
+# should be put into "read.jl"
+
+# read mesh information in 2D
+function read_mesh_msh_dealii(fn::AbstractString)
+open(fn, "r") do io
+    read_mesh_msh_dealii(io)
+    end
+end
+
+function read_mesh_msh_dealii(io)
+    dim = 2
+    thisLine = io |> readline |> strip
+    thisLine = io |> readline |> strip
+    NV = parse(Int, thisLine)
+	X = zeros(dim+2, NV)
+    for i in 1:NV
+        thisLine = io |> readline |>  strip
+        d = readdlm(IOBuffer(thisLine), Float64)
+		X[:,i] = d
+    end
+    
+    thisLine = io |> readline |> strip
+    thisLine = io |> readline |> strip
+    thisLine = io |> readline |> strip
+    NV = parse(Int, thisLine)
+    T = Array{Int64, 2}(zeros(dim+7, NV))
+    for i in 1:NV
+        thisLine = io |> readline |>  strip
+        d = readdlm(IOBuffer(thisLine), Int64)
+		T[:,i] = d
+    end
+    return X[2:3, :], T[6:end, :]
+end
+
+
+# read mesh information in 3D
+function read_mesh_msh_dealii_3D(fn::AbstractString)
+open(fn, "r") do io
+    read_mesh_msh_dealii_3D(io)
+    end
+end
+
+function read_mesh_msh_dealii_3D(io)
+    dim = 3
+    thisLine = io |> readline |> strip
+    thisLine = io |> readline |> strip
+    NV = parse(Int, thisLine)
+	X = zeros(dim+1, NV)
+    for i in 1:NV
+        thisLine = io |> readline |>  strip
+        d = readdlm(IOBuffer(thisLine), Float64)
+		X[:,i] = d
+    end
+    
+    thisLine = io |> readline |> strip
+    thisLine = io |> readline |> strip
+    thisLine = io |> readline |> strip
+    NV = parse(Int, thisLine)
+    T = Array{Int64, 2}(zeros(dim+10, NV))
+    for i in 1:NV
+        thisLine = io |> readline |>  strip
+        d = readdlm(IOBuffer(thisLine), Int64)
+		T[:,i] = d
+    end
+    return X[2:4, :], T[6:end, :]
+end
+
+
+# read haning nodes function in 2D
+function read_constraints_dealii(fn::AbstractString)
+    open(fn, "r") do f
+        Con = []
+        line = 1
+        while !eof(f)
+            thisLine = f |> readline |>  strip
+            d = readdlm(IOBuffer(thisLine))
+            push!(Con, d)     
+            line += 1
+        end
+
+        for i = 1:line-1
+            Con[i][2] = parse(Int64, split(Con[i][2], ":")[1])
+        end
+    
+        c = zeros(2, line-1)
+        for i = 1:2
+            for j = 1:line-1
+                c[i, j] = Con[j][i]
+            end
+        end
+        
+        hanging_nodes_index = Array{Int64}(c[1, :])[1:2:end]
+        hanging_nodes_info = [Array{Int64}(c[2, :][2*i-1:2*i]) for i = 1:length(hanging_nodes_index)]
+        hanging_nodes_coeff = [[0.5, 0.5] for i = 1:length(hanging_nodes_index)]
+        
+        return hanging_nodes_index, hanging_nodes_info, hanging_nodes_coeff
+    end
+end
+
+
+# read haning nodes function in 3D
+function read_constraints_dealii_3D(fn::AbstractString)
+    open(fn, "r") do f
+        Con = []
+        line = 1
+        while !eof(f)
+            thisLine = f |> readline |>  strip
+            d = readdlm(IOBuffer(thisLine)) 
+            push!(Con, d)     
+            line += 1
+        end
+        
+        for i = 1:line-1
+            Con[i][2] = parse(Int64, split(Con[i][2], ":")[1])           
+        end
+          
+        c = Array{Int64, 2}(zeros(2, line-1))
+        d = Array{Float64, 2}(zeros(2, line-1))
+        for i = 1:2
+            for j = 1:line-1
+                c[i, j] = Con[j][i]
+            end
+        end
+        
+        d[1, :] = copy(c[1, :])
+        for j = 1:line-1
+            d[2, j] = Con[j][3]
+        end
+               
+        hanging_nodes_index = unique(c[1, :])
+        hanging_nodes_info = []
+        hanging_nodes_coeff = []
+        for i =1:length(hanging_nodes_index)
+            push!(hanging_nodes_info, c[2, findin(c[1, :], hanging_nodes_index[i])])  
+            push!(hanging_nodes_coeff, d[2, findin(d[1, :], hanging_nodes_index[i])])
+        end
+        
+        return hanging_nodes_index, hanging_nodes_info, hanging_nodes_coeff
+    end
+end
+
+#####################################################################################################
\ No newline at end of file
diff --git a/run.cc b/run.cc
new file mode 100644
index 0000000..15724a1
--- /dev/null
+++ b/run.cc
@@ -0,0 +1,234 @@
+/* ---------------------------------------------------------------------
+ *
+ * Adaptive multigrid: Read solution or estimated_error_per_cell of each step, output mesh information
+ *
+ * ---------------------------------------------------------------------
+ *
+ * Author: Yangshuai Wang, Shanghai Jiao Tong University, 2019
+ */
+
+// Hanging nodes are the ones that are constrained by a call to DoFTools::hanging_node_constraints.
+// Hence, you could just call that function on an otherwise empty ConstraintMatrix (or AffineConstraints) object constraints
+// and call constraints.print(std::cout).
+// A different possibility is to just print the locations of all the degrees of freedom via a call to DoFTools::write_gnuplot_dof_support_point_info.
+
+
+#include <deal.II/base/quadrature_lib.h>
+#include <deal.II/base/function_lib.h>
+
+#include <deal.II/dofs/dof_handler.h>
+#include <deal.II/dofs/dof_tools.h>
+
+#include <deal.II/fe/fe_values.h>
+
+#include <deal.II/grid/tria.h>
+#include <deal.II/grid/grid_generator.h>
+
+// #include <deal.II/lac/dynamic_sparsity_pattern.h>
+// #include <deal.II/lac/full_matrix.h>
+// #include <deal.II/lac/precondition.h>
+// #include <deal.II/lac/solver_cg.h>
+// #include <deal.II/lac/sparse_matrix.h>
+#include <deal.II/lac/vector.h>
+
+#include <deal.II/numerics/data_out.h>
+#include <deal.II/numerics/vector_tools.h>
+
+#include <fstream> // for reading and writing
+
+#include <deal.II/fe/fe_q.h>
+// grid_in.h:
+#include <deal.II/grid/grid_out.h>
+#include <deal.II/grid/grid_in.h>
+
+#include <deal.II/lac/constraint_matrix.h>
+#include <deal.II/grid/grid_refinement.h>
+#include <deal.II/numerics/error_estimator.h>
+
+#include <iostream> // add
+#include<string> // add
+
+using namespace dealii;
+using namespace std; // add
+
+template <int dim>
+class Mesh
+{
+public:
+  Mesh ();
+
+  void run ();
+
+private:
+  void setup_system ();
+  void refine_grid (const unsigned int cycle); // actually no cycle here, just step by step
+  void output_results (const unsigned int cycle) const;
+
+  Triangulation<dim> triangulation;
+
+  FE_Q<dim>          fe;
+  DoFHandler<dim>    dof_handler;
+  ConstraintMatrix     constraints;
+  
+};
+
+template <int dim>
+Mesh<dim>::Mesh ()
+  :
+  fe (1),
+  dof_handler (triangulation)
+{}
+
+template <int dim>
+void Mesh<dim>::setup_system ()
+{
+  dof_handler.distribute_dofs (fe);
+
+  constraints.clear ();
+  DoFTools::make_hanging_node_constraints (dof_handler,
+                                           constraints);
+
+  constraints.close ();
+}
+
+template <int dim>
+void Mesh<dim>::refine_grid (const unsigned int cycle)
+{
+  Vector<float> estimated_error_per_cell (triangulation.n_active_cells());
+
+  {
+    ifstream est;
+    est.open("estimator-" + std::to_string(cycle) + ".txt");
+    for (unsigned int i=0; i<triangulation.n_active_cells(); ++i)
+    {est >> estimated_error_per_cell[i]; }
+    est.close();
+  }
+
+  float c = 0.1;
+  // {
+  //   ifstream coeff;
+  //   coeff.open("coeff.txt");
+  //   coeff >> c; 
+  //   coeff.close();
+  // }
+
+  GridRefinement::refine_and_coarsen_fixed_number (triangulation,
+                                                   estimated_error_per_cell,
+                                                   c, 0.0);
+
+  // ys: print the vector
+  // std::cout << " estimated_error_per_cell: "
+  //               << estimated_error_per_cell
+  //               << std::endl;
+
+  triangulation.execute_coarsening_and_refinement ();
+}
+
+template <int dim>
+void Mesh<dim>::output_results (const unsigned int cycle) const
+{
+  // mesh information
+  {
+    GridOut grid_out;
+    std::ofstream output ("grid-" + std::to_string(cycle) + ".msh");
+    grid_out.write_msh (triangulation, output);
+  }
+
+  {
+    GridOut grid_out;
+    std::ofstream output ("grid-" + std::to_string(cycle) + ".eps");
+    grid_out.write_eps (triangulation, output);
+  }
+  // constraints information
+  {
+    std::ofstream mycon ("constraints-" + std::to_string(cycle) + ".txt");
+    constraints.print(mycon);
+    cout << "Save constraints completed" << endl;
+  }
+}
+
+template <int dim>
+void Mesh<dim>::run ()
+{ 
+  unsigned int num;
+  // // please change here only!
+  {
+    ifstream itnum;
+    itnum.open("iteration.txt");
+    itnum >> num; 
+    itnum.close();
+  }
+  //unsigned int num = 2;
+  // please change here only!
+
+  for (unsigned int cycle=num; cycle<num+2; ++cycle) // 2 is fixed for one adaptive
+    {
+      std::cout << "Cycle " << cycle << ':' << std::endl;
+
+      if (cycle == num)
+        // GridIn here
+        // {
+        //   GridGenerator::hyper_cube (triangulation);
+        //   triangulation.refine_global (3);
+        // }
+        { GridIn<dim> grid_in;
+          grid_in.attach_triangulation (triangulation);
+          std::ifstream input_file ("grid-" + std::to_string(num) + ".msh");  // change here
+          grid_in.read_msh (input_file);
+        }
+      else
+      refine_grid (cycle);
+
+
+      std::cout << "   Number of active cells:       "
+                << triangulation.n_active_cells()
+                << std::endl;
+
+      setup_system ();
+
+      std::cout << "   Number of degrees of freedom: "
+                << dof_handler.n_dofs()
+                << std::endl;
+
+      output_results (cycle);
+    }
+}
+
+int main ()
+{
+
+  try
+    {
+      //Mesh<2> AdapMG;
+      Mesh<3> AdapMG;
+      AdapMG.run ();
+    }
+
+  catch (std::exception &exc)
+    {
+      std::cerr << std::endl << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+      std::cerr << "Exception on processing: " << std::endl
+                << exc.what() << std::endl
+                << "Aborting!" << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+
+      return 1;
+    }
+
+  catch (...)
+    {
+      std::cerr << std::endl << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+      std::cerr << "Unknown exception!" << std::endl
+                << "Aborting!" << std::endl
+                << "----------------------------------------------------"
+                << std::endl;
+      return 1;
+    }
+
+  return 0;
+}
diff --git a/run_AdapMGQCE.jl b/run_AdapMGQCE.jl
new file mode 100644
index 0000000..8e964ab
--- /dev/null
+++ b/run_AdapMGQCE.jl
@@ -0,0 +1,63 @@
+
+# include the function
+using JuLIP, HDF5, JLD, PyPlot, Optim, LineSearches
+include("./Juliacodes/subfunction.jl")
+
+
+################################################################################################
+# 1. compute the atomistic solution and construct the initial mesh
+# FCC-Al, L*L*L cube
+L = 16
+println("The atomistic configuration (Cu) is a ", L, "*", L, "*", L, " cell.")
+at = construct_a_sing(:Cu, L)
+# record the reference position
+xold = copy(mat(at.X))
+xa = copy(xold)
+
+# plot the atomistic configuration that should be solved
+solve_refa(L, at, xold)
+figure(0)
+myplotA(mat(at.X))
+
+# construct the initial geometry
+println("Construct the initial mesh !")
+geom, idx, Idx, initial = construct_ini_geom(L, at, xa)
+inigeom = deepcopy(geom)
+iniIdx = copy(Idx)
+# the initial mesh is in Figure 0
+myplotgeom(geom)
+################################################################################################
+
+
+################################################################################################
+# 2. solve the QCE problem
+# NEED UPDATE！
+# begin with the geom generated above
+oldgeom = geom
+iA_in_T = []
+c = 0.6
+println("QCE description to solve !")
+nX = size(geom.X, 2)
+while true # or nX be the limit # geom.hmin >= 4.0 can not be this
+
+    println("Step ", i, " Begin !")
+
+    # pre_solve
+    # println("The number of the atomistic region: ", length(iA))
+    # check_element_in_C -> Aregion (or all_element_resetgeom)
+    figure(i)
+    iA_in_T = find(geom.h .< htol+1) # find(geom.dh .< 4+12*(i-4)) # find(geom.h .< htol) ??? 
+    iA = get_index_n(Idx, iA_in_T)
+    myplotQCE(geom, xa[:, iA])
+    idxAB, iB = atAbuf_info(at, iA)
+    atAbuf = construct_atAbuf(idxAB)
+
+    # solve
+    u = solve_QCE(atAbuf, geom, iA, idx, initial, optimiser, relxnit)
+    
+    println("Step ", i, " Done !")
+
+end
+################################################################################################
+
+
diff --git a/solver.jl b/solver.jl
new file mode 100644
index 0000000..4660659
--- /dev/null
+++ b/solver.jl
@@ -0,0 +1,193 @@
+using JuLIP, Optim, LineSearches, HDF5, JLD
+
+# need the basis interpolation
+include("Tools.jl")
+
+# deal with hanging nodes
+# extend to hanging nodes version (newest version!)
+# to more general case, not only 0.5...
+function extendU(geom, Uold)
+    Idof = setdiff(1:N, geom.hanging_index)
+    U = zeros(size(geom.A, 1), size(geom.X, 2)) 
+    U[:, Idof] = copy(Uold)
+    @simd for i = 1:length(geom.hanging_index)
+        # U[:, Ihang[i]] = 0.5*(U[:, geom.hanging_info[i][1]]+U[:, geom.hanging_info[i][2]])
+        @inbounds U[:, geom.hanging_index[i]] = geom.hanging_coeff[i]' * U[:, geom.hanging_info[i]]
+    end   
+    return U
+end
+
+# need in other .jl file...
+"""
+Write a txt file to be read by deal-ii ifstream
+! The input u must be a vector so far!
+"""
+function write_estimator(filename, u)
+	dl = "\t"
+	nu = length(u)
+	nloop = Int64(floor(nu/11))
+	open(filename, "w") do f
+		#println(f, nu, dl)
+		for i = 1:nloop
+			n = (i-1)*11
+			println(f, dl, u[n+1], dl, u[n+2], dl, u[n+3], dl, u[n+4], dl, u[n+5], dl, u[n+6], dl, u[n+7], dl, u[n+8], dl, u[n+9], dl, u[n+10], dl, u[n+11])
+		end
+		str = "\t"
+		for i = (11*nloop+1):nu
+			str = str*string(u[i])*dl
+		end
+		println(f, str)
+	end
+end
+
+function write_iter_number(filename, num)
+	dl = "\t"
+	open(filename, "w") do f
+		println(f, num)
+	end
+end
+
+function write_refine_coeff(filename, cc)
+	dl = "\t"
+	open(filename, "w") do f
+		println(f, cc)
+	end
+end
+
+# use the interpolation to get the initial...
+# need old layer geom
+function get_initial(geom, oldgeom, U)
+    
+    xc = oldgeom.X
+    Tc = oldgeom.T
+    N = size(geom.X, 2)
+    Ihang = geom.hanging_index
+    Nhang = length(Ihang)
+    Idof = setdiff(1:N, Ihang)
+    xf = geom.X[:, Idof]
+    # can be written as a interpolation function actually
+    u = zeros(2, N-Nhang)
+    for i = 1:size(xf, 2)
+        # need revise
+        # check in which old mesh element
+        for j = 1:size(Tc, 2)
+            xT = xc[:, Tc[:, j]]
+            if (xT[1, 1] <= xf[1, i] <= xT[1, 3]) & (xT[2, 1] <= xf[2, i] <= xT[2, 3])
+                xsq = para2square(xT, xf[:, i])
+                uT = U[:, Tc[:, j]]
+                @inbounds w, uu = biInterp(xsq, uT)
+                u[:, i] = copy(uu)
+            end
+        end
+    end
+    return u
+end
+
+function get_index_n(Idx, iA_in_T)
+    i = Idx[iA_in_T[1]]
+    for j = 2:length(iA_in_T)
+        i = vcat(i, Idx[iA_in_T[j]]...)
+    end
+    return i
+end
+
+function gradientQCE(atAbuf, geom, x)
+    
+    dE = zeros(3, size(x, 2))
+    for k in setdiff(1:nT, iTref)
+        X = geom.X[:, geom.T[:, k]]'
+        u = x[:, length(idxAB).+geom.T[:, k]]
+        wX_T = geom.h[1] * wX .+ X[1,:]
+        for i = 1:27
+            Du = compute_Du(X, geom.h[1], wX_T[1,i], wX_T[2,i], wX_T[3,i], u) # prob ????
+            dE[:, length(iA)+1:end] += len[k] * w[i] * CauchyBorn.grad(W, eye(3)+Du)
+        end
+    end
+    
+    # recompute the buf displacement
+    δu = zeros(3, length(idxAB))
+    # iB = setdiff(idxAB, iA)
+    iB_in_T = myindmin(geom.oT, xa[:,iB])
+    # iI = findin(idxAB, iB)
+    for iiB = 1:length(iB_in_idxAB)
+        δu[:, iB_in_idxAB[iiB]] = compute_u(xa[:,iB[iiB]], geom.X[:,geom.T[:,iB_in_T[iiB]]], x[:,length(iA).+geom.T[:,iB_in_T[iiB]]], geom.h[1])
+    end
+    
+    # EA   
+    δu[:, iB_in_idxAB] = copy(ubuf)
+    δu[:, iA_in_idxAB] = x[:, length(iA)]
+    set_positions!(atAbuf, mat(atAbuf.X) + δu) # where X is from interpolated
+    dE[:, 1:length(iA)] = forces(atAbuf)[:, iA]
+    
+    return dE
+end
+
+
+function energyQCE(atAbuf, geom, x)
+    # the input x contains two parts: the first is idxAB, the second is geom.X 
+    # maybe the displacement u is better
+    
+    iA_in_idxAB = findin(idxAB, iA)
+    iB_in_idxAB = setdiff(1:length(idxAB), iA_in_idxAB)
+    iB = idxAB[iB_in_idxAB]
+    
+    # EC
+    EC = 0
+    for k in setdiff(1:nT, iTref)
+        X = geom.X[:, geom.T[:, k]]'
+        u = x[:, length(idxAB).+geom.T[:, k]]
+        wX_T = geom.h[1] * wX .+ X[1,:]
+        for i = 1:27
+            Du = compute_Du(X, geom.h[1], wX_T[1,i], wX_T[2,i], wX_T[3,i], u) # prob ????
+            EC += len[k] * w[i] * W(eye(3)+Du) 
+        end
+    end
+    
+    # recompute the buf displacement
+    δu = zeros(3, length(idxAB))
+    # iB = setdiff(idxAB, iA)
+    iB_in_T = myindmin(geom.oT, xa[:,iB])
+    # iI = findin(idxAB, iB)
+    for iiB = 1:length(iB_in_idxAB)
+        δu[:, iB_in_idxAB[iiB]] = compute_u(xa[:,iB[iiB]], geom.X[:,geom.T[:,iB_in_T[iiB]]], x[:,length(iA).+geom.T[:,iB_in_T[iiB]]], geom.h[1])
+    end
+    
+    # EA   
+    δu[:, iB_in_idxAB] = copy(ubuf)
+    δu[:, iA_in_idxAB] = x[:, length(iA)]
+    set_positions!(atAbuf, mat(atAbuf.X) + δu) # where X is from interpolated
+    EA = 0
+    for isite in iA_in_idxAB
+        EA += site_energy(atAbuf.calc, atAbuf, isite)
+    end
+    
+    E = EA + EC
+    return E
+end
+
+# maybe try static array
+@inline function mydot(x::Array{Float64,2})
+    S = x[1, :]
+    @simd for j = 2:size(x,1)
+        @inbounds S .*= x[j, :]
+    end
+    return S
+end
+
+# fast implementation in each element
+function compute_u(x, X, U, h)
+    # X should be 3*8
+    # U should be 3*8
+    # x should be 3*27 (for integral) or 3*N (for interpolation)
+    ϕ = zeros(size(x,2), 8)
+    for i = 1:8
+        unϕ = (1 .- abs.(x.-X[:,i])/h)
+        ϕ[:, i] = mydot(unϕ) 
+    end
+    u = U * ϕ'
+    return u
+end
+# compute_Du shoule at least 3, \partial_x, \partial_y, \partial_z
+
+
+    
diff --git a/subfunction.jl b/subfunction.jl
new file mode 100644
index 0000000..0d5bd98
--- /dev/null
+++ b/subfunction.jl
@@ -0,0 +1,124 @@
+# include the function
+using JuLIP, HDF5, JLD, PyPlot, Optim, LineSearches
+include("myplot.jl")
+include("geom.jl")
+include("solver.jl")
+include("IDX.jl")
+
+function construct_a_sing(symbol, L)
+    at = bulk(symbol, cubic=true) * L
+    xdef = [1/2 1/2 1/2]' * at.cell[1]
+    idef = indmin(sum(abs2, mat(at.X) .- xdef, 1))
+    
+    at = bulk(symbol, cubic=true) * L
+    deleteat!(at, idef)
+    set_data!(at, "defpos", xdef)
+    # EAM potential, third nearest neighbour interaction
+    pth = "/Users/yswang/.julia/v0.6/JuLIP/data/"
+    calc = JuLIP.Potentials.FinnisSinclair(pth*"pcu.plt", pth*"fcu.plt")
+    set_calculator!(at, calc)
+    set_constraint!(at, FixedCell(at)) # periodic boundary condition
+    return at
+end
+
+function solve_refa(L, at, xold)
+    # calculate the reference solution to compare
+    if !isfile(string("3DAlPoint", L, ".jld"))
+        tic()
+        # relax the criteria to 1e-4
+        minimise!(at, verbose = 2, gtol = 1e-4, precond = :id)
+        println("  Reference time: ")
+        ta = toc()
+        xnew = copy(mat(at.X))
+        u = xnew .- xold
+        save(string("Time3DAlPoint", L, ".jld"), "ta", ta)
+        save(string("3DAlPoint", L, ".jld"), "u", u)
+    end
+    # ua = load(string("3DAlPoint", L, ".jld"), "u") # no need
+end
+
+function construct_ini_geom(L, at, xa)
+    initial_grid = "grid-0.msh"
+    initial_cons = "constraints-0.txt"
+    geom = readmsh(at, initial_grid, initial_cons, L, 0)
+    initial = zeros(2, size(geom.X, 2) - length(geom.hanging_index))
+    # allocate each atoms to each element
+    Idx = get_initial_idx(geom.h[1], geom.oT)
+    idx = myindmin(xa, geom.X)
+    return geom, idx, Idx, initial
+end
+
+function write_all(η, i, c)
+    estname = string("estimator-", i, ".txt")
+    write_estimator(estname, η)
+    # write the iteration number
+    itername = string("iteration.txt")
+    write_iter_number(itername, i-1)
+    # write the refinement coefficient
+    coefname = string("coeff.txt")
+    write_refine_coeff(coefname, c)
+end
+
+function atAbuf_info(at, iA)
+    nlist = neighbourlist(at)
+    idxAB = nlist.j[findin(nlist.i, iA)]
+    idxAB = unique(idxAB)
+    iA_in_idxAB = findin(idxAB, iA)
+    iB_in_idxAB = setdiff(1:length(idxAB), iA_in_idxAB)    # iB = setdiff(idxAB, iA)
+    iB = idxAB[iB_in_idxAB]
+    return idxAB, iB
+end
+
+function construct_atAbuf(idxAB)
+    # construct the atAbuf to calculate the A energy
+    XvecsA = xa[:, idxAB] |> vecs
+    atAbuf = Atoms(:Al, XvecsA)
+    set_pbc!(atAbuf, false) # not pbc!s
+    set_cell!(atAbuf, 5*copy(atAbuf.cell))
+    # EAM potential, third nearest neighbour interaction
+    pth = "/Users/yswang/.julia/v0.6/JuLIP/data/"
+    calc = JuLIP.Potentials.FinnisSinclair(pth*"pcu.plt", pth*"fcu.plt")
+    set_calculator!(atAbuf, calc)
+    set_constraint!(atAbuf, FixedCell(atAbuf))
+    return atAbuf
+end
+
+function solve_QCE(atAbuf, geom, iA, idx, initial, optimiser, relxnit)    
+    # construct the objective function (E & G) for QCE !
+    obj_fqce = x -> energyQCE(atAbuf, geom, x)
+    obj_g!qce = (g, x) -> copy!(g, gradientQCE(atAbuf, geom, x))
+    
+    # call Optim package to solve
+    u = optimize(obj_fqce, obj_g!qce, initial, optimiser，Optim.Options(f_tol = 1e-32, g_tol = 1e-4,
+                                        store_trace = false,
+                                        extended_trace = false,
+                                        callback = nothing,
+                                        show_trace = true))
+    # save important informatins in one loop
+    filename = string("step_", i, ".jld")
+    save(filename, "u", u) 
+    return u
+end  
+
+function update_info_QCE(geom, i, L, Idx, η, idx)
+    oldgeom = geom
+    newgridname = string("grid-", i, ".msh")
+    newconstraintname = string("constraints-", i, ".txt")
+    geom = readmsh(at, newgridname, newconstraintname, L, i)
+    Idx = update_Idx(Idx, η, geom.T, oldgeom.T, geom.X, oldgeom.X, geom.oT)
+    δidx = compute_iδ(geom.X, geom.T, oldgeom.X, Idx)  # check !
+    idx = [idx; δidx]
+    i = i + 1
+    return i, idx, Idx, geom 
+end
+
+function solve_a(at, initial, optimiser)
+    obj_f = x -> energy(at, x)
+    obj_g! = (g, x) -> copy!(g, gradient(at, x))
+    results = Optim.optimize(obj_f, obj_g!, initial, optimiser,
+                            Optim.Options( f_tol = 1e-32, g_tol = 1e-4,
+                                        store_trace = false,
+                                        extended_trace = false,
+                                        callback = nothing,
+                                        show_trace = true ))
+end
\ No newline at end of file