SyFi 0.3
sfc_callbacks::scratch Namespace Reference

Functions

def boundary_callback
def mass_v0
def mass_v1
def mass_v2
def stiffness_v1
def stiffness_v2
def stiffness_short
def stiffness_v0
def nonlinear_boundary_F
def nonlinear_F
def stiffness_with_tokens_matrix

Variables

 print_forms = False
int nsd = 2
tuple polygon = SyFi.ReferenceTriangle()
tuple fe0 = SyFi.P0(polygon)
tuple fe1 = SyFi.Lagrange(polygon, 1)
tuple fe2 = SyFi.Lagrange(polygon, 2)
tuple vfe0 = SyFi.VectorP0(polygon)
tuple vfe1 = SyFi.VectorLagrange(polygon, 1)
tuple vfe2 = SyFi.VectorLagrange(polygon, 2)
tuple tfe0 = SyFi.TensorP0(polygon)
tuple tfe1 = SyFi.TensorLagrange(polygon, 1)
tuple tfe2 = SyFi.TensorLagrange(polygon, 2)
list fe_list = [fe1, fe1]
tuple form = UserForm(rank=2, num_coefficients=0, name="mass", fe_list=fe_list, symbolic=True, quad_order=-1)
tuple citg = form.cell_integral()
tuple mf
tuple itg = form.cell_integral()
tuple F = UserForm(rank=1, num_coefficients=2, name="F", fe_list=fe_list, symbolic=True, quad_order=-1)
tuple J = Jacobi(F)

Function Documentation

def sfc_callbacks::scratch::boundary_callback (   u,
  v,
  data 
)

Definition at line 6 of file scratch.py.

00007                                  :
00008     GinvT = data.GinvT()
00009     n     = data.n()
00010 
00011     Du = grad(u, GinvT)
00012     return inner(inner(n, Du), v)
00013 
00014 
00015 # example low level forms:

def sfc_callbacks::scratch::mass_v0 (   itg)
Compact version

Definition at line 16 of file scratch.py.

00017                 :
00018     """Compact version"""
00019     for i in range(itg.num_v_dofs(0)):
00020         for j in range(itg.num_v_dofs(1)):
00021             itg.A[(i,j)] = inner( itg.v_basis(0, i), itg.v_basis(1, j) )

def sfc_callbacks::scratch::mass_v1 (   itg)
More elaborate version

Definition at line 22 of file scratch.py.

00023                 :
00024     """More elaborate version"""
00025     for i in range(itg.num_v_dofs(0)):
00026         for j in range(itg.num_v_dofs(1)):
00027             u = itg.v_basis(0, i)
00028             v = itg.v_basis(1, j)
00029             itg.A[(i,j)] = inner(u, v)

def sfc_callbacks::scratch::mass_v2 (   itg)
'Jacobi' version

Definition at line 30 of file scratch.py.

00031                 :
00032     """'Jacobi' version"""
00033     dofs = itg.w_dofs(0)
00034     usum = itg.w_sum(0)
00035     for i in range(itg.num_v_dofs(0)):
00036         for j in range(itg.num_v_dofs(1)):
00037             u = diff(usum, dofs[i])
00038             v = itg.v_basis(1, j)
00039             itg.A[(i,j)] = inner(u, v)

def sfc_callbacks::scratch::nonlinear_boundary_F (   itg)
F_i(w,f) = \int_\dOmega f(x) e^{t \cdot u(x)} (n \cdot grad u) v_i(x) ds
   Coefficients:
      w (u from last iteration)
      f

Definition at line 103 of file scratch.py.

00104                              :
00105     """F_i(w,f) = \int_\dOmega f(x) e^{t \cdot u(x)} (n \cdot grad u) v_i(x) ds
00106        Coefficients:
00107           w (u from last iteration)
00108           f
00109     """
00110     GinvT = itg.GinvT()
00111     n     = itg.n()
00112     t     = itg.t()
00113 
00114     w = itg.w_sum(0)
00115     f = itg.w_sum(1)
00116 
00117     Dw  = grad(w, GinvT)
00118     nDw = inner(n, Dw)
00119     wn  = inner(n, w)
00120     wt  = inner(t, w)
00121     exp_wt = exp( wt )
00122 
00123     assert isinstance(n, matrix)
00124     assert isinstance(w, matrix)
00125     assert n.nops() == w.nops()
00126     assert not isinstance(wn.evalm(), matrix)
00127     assert not isinstance(wt.evalm(), matrix)
00128 
00129     tmp = f * exp_wt * nDw
00130 
00131     for i in range(itg.num_v_dofs(0)):
00132         v = itg.v_basis(0, i)
00133         itg.A[(i,)] = inner(tmp, v)
00134 

def sfc_callbacks::scratch::nonlinear_F (   itg)
Nonlinear test form F_i(w) = \int_\Omega w^2(x) w(x) v_i(x) dx]

Definition at line 135 of file scratch.py.

00136                     :
00137     """Nonlinear test form F_i(w) = \int_\Omega w^2(x) w(x) v_i(x) dx]"""
00138     w = itg.w_sum(0)
00139     w2 = inner(w, w)
00140     for i in range(itg.num_v_dofs(0)):
00141         v = itg.v_basis(0, i)
00142         itg.A[(i,)] = w2 * inner(w, v)
00143 
00144 

def sfc_callbacks::scratch::stiffness_short (   itg)
alternative short version

Definition at line 78 of file scratch.py.

00079                         :
00080     """alternative short version"""
00081     print "Non-working prototype!"
00082     #f, g = itg.w_sums(0, 1) # TODO: do it like this?
00083     for (i, j) in itg.indices:
00084         u, v    = itg.v_basis_functions(i, j) # TODO: do it like this?
00085         Du, Dv  = itg.v_basis_function_gradients(i, j) # TODO: do it like this?
00086         itg.A[(i,j)] = inner(Du, Dv)

def sfc_callbacks::scratch::stiffness_v0 (   itg)
grad-from-itg-version

Definition at line 87 of file scratch.py.

00088                      :
00089     """grad-from-itg-version"""
00090     print "Non-working prototype!"
00091     for i in range(itg.num_v_dofs(0)):
00092         for j in range(itg.num_v_dofs(1)):
00093             u  = itg.v_basis(0, i)
00094             v  = itg.v_basis(1, j)
00095 
00096             Du = itg.grad_v(0, i) # TODO: do it like this?
00097             Dv = itg.grad_v(1, j)
00098 
00099             itg.A[(i,j)] = inner(Du, Dv)
00100 
00101 
00102 # example nonlinear forms for automatic Jacobi creation:

def sfc_callbacks::scratch::stiffness_v1 (   itg)
symbolic-grad-version

Definition at line 40 of file scratch.py.

00041                      :
00042     """symbolic-grad-version"""
00043     GinvT = itg.GinvT()
00044 
00045     for i in range(itg.num_v_dofs(0)):
00046         for j in range(itg.num_v_dofs(1)):
00047             u  = itg.v_basis(0, i)
00048             v  = itg.v_basis(1, j)
00049 
00050             Du = grad(u, GinvT)
00051             Dv = grad(v, GinvT)
00052 
00053             #Du = itg.add_token(Du) # TODO: do it like this?
00054             #Dv = itg.add_token(Dv)
00055 
00056             itg.A[(i,j)] = inner(Du, Dv)

def sfc_callbacks::scratch::stiffness_v2 (   itg)
'Manual Jacobi' version

Definition at line 57 of file scratch.py.

00058                      :
00059     """'Manual Jacobi' version"""
00060     GinvT = itg.GinvT()
00061 
00062     dofs = itg.w_dofs(0)
00063     usum = itg.w_sum(0)
00064 
00065     Du = grad(usum, GinvT)
00066 
00067     for i in range(itg.num_v_dofs(0)):
00068         for j in range(itg.num_v_dofs(1)):
00069             v  = itg.v_basis(1, j)
00070             Dv = grad(v, GinvT)
00071 
00072             integrand = inner(Du, Dv)
00073             itg.A[(i,j)] = diff(integrand, dofs[i])
00074 
00075 
00076 
00077 # example prototype forms for alternate syntax:

def sfc_callbacks::scratch::stiffness_with_tokens_matrix (   u,
  v,
  M,
  data 
)

Definition at line 145 of file scratch.py.

00146                                                :
00147     GinvT = data.GinvT()
00148 
00149     Du = grad(u, GinvT)
00150     Dv = grad(v, GinvT)
00151 
00152     # create manual temporary variables:
00153     Du = data.add_token("Du", Du)
00154     Dv = data.add_token("Dv", Dv)
00155 
00156     return inner(M * Du, Dv)
00157 
00158 


Variable Documentation

tuple sfc_callbacks::scratch::citg = form.cell_integral()

Definition at line 184 of file scratch.py.

tuple sfc_callbacks::scratch::F = UserForm(rank=1, num_coefficients=2, name="F", fe_list=fe_list, symbolic=True, quad_order=-1)

Definition at line 227 of file scratch.py.

Definition at line 167 of file scratch.py.

Definition at line 168 of file scratch.py.

Definition at line 169 of file scratch.py.

Definition at line 178 of file scratch.py.

tuple sfc_callbacks::scratch::form = UserForm(rank=2, num_coefficients=0, name="mass", fe_list=fe_list, symbolic=True, quad_order=-1)

Definition at line 180 of file scratch.py.

tuple sfc_callbacks::scratch::itg = form.cell_integral()

Definition at line 220 of file scratch.py.

tuple sfc_callbacks::scratch::J = Jacobi(F)

Definition at line 238 of file scratch.py.

Initial value:
00001 CallbackForm(name="mass_with_c", rank=2, num_coefficients=1, fe_list=fe_list, symbolic=True, quad_order=-1,
00002                       cell_integrands=[mass_with_c_callback])

Definition at line 200 of file scratch.py.

Definition at line 164 of file scratch.py.

Definition at line 161 of file scratch.py.

Definition at line 173 of file scratch.py.

Definition at line 174 of file scratch.py.

Definition at line 175 of file scratch.py.

Definition at line 170 of file scratch.py.

Definition at line 171 of file scratch.py.

Definition at line 172 of file scratch.py.

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines