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.

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

def sfc_callbacks::scratch::mass_v0 (   itg  ) 

Compact version

Definition at line 16 of file scratch.py.

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

def sfc_callbacks::scratch::mass_v1 (   itg  ) 

More elaborate version

Definition at line 22 of file scratch.py.

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

def sfc_callbacks::scratch::mass_v2 (   itg  ) 

'Jacobi' version

Definition at line 30 of file scratch.py.

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

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.

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

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.

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

def sfc_callbacks::scratch::stiffness_short (   itg  ) 

alternative short version

Definition at line 78 of file scratch.py.

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

def sfc_callbacks::scratch::stiffness_v0 (   itg  ) 

grad-from-itg-version

Definition at line 87 of file scratch.py.

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

def sfc_callbacks::scratch::stiffness_v1 (   itg  ) 

symbolic-grad-version

Definition at line 40 of file scratch.py.

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

def sfc_callbacks::scratch::stiffness_v2 (   itg  ) 

'Manual Jacobi' version

Definition at line 57 of file scratch.py.

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

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

Definition at line 145 of file scratch.py.

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


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:

CallbackForm(name="mass_with_c", rank=2, num_coefficients=1, fe_list=fe_list, symbolic=True, quad_order=-1,
                      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 166 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.


Generated on Mon Aug 31 16:17:05 2009 for SyFi by  doxygen 1.5.9