ufcformat.py

finite element library for mathematic majored research

    ufc_code["value_dimension"] = __generate_switch("i", cases, "return 0;")

    # Generate code for evaluate_basis
    ufc_code["evaluate_basis"] = __generate_body(code["evaluate_basis"])

    # Generate code for evaluate_basis
    ufc_code["evaluate_basis_derivatives"] = __generate_body(code["evaluate_basis_derivatives"])

    # Generate code for evaluate_dof
    ufc_code["evaluate_dof"] = __generate_body(code["evaluate_dof"])

    # Generate code for inperpolate_vertex_values
    ufc_code["interpolate_vertex_values"] = remove_unused(__generate_body(code["interpolate_vertex_values"]))

    # Generate code for num_sub_elements
    ufc_code["num_sub_elements"] = "return %s;" % code["num_sub_elements"]

    # Generate code for sub_element
    num_sub_elements = eval(code["num_sub_elements"])
    if num_sub_elements == 1:
        ufc_code["create_sub_element"] = "return new %s();" % ufc_code["classname"]
    else:
        cases = ["return new %s_%d();" % (ufc_code["classname"], i) for i in range(num_sub_elements)]
        ufc_code["create_sub_element"] = __generate_switch("i", cases, "return 0;")

    return __generate_code(finite_element_combined, ufc_code, options)

def __generate_dof_map(code, form_data, options, prefix, label):
    "Generate code for ufc::dof_map"

    ufc_code = {}

    # Set class name
    ufc_code["classname"] = "%s_dof_map_%s" % (prefix, "_".join([str(i) for i in label]))

    # Generate code for members
    ufc_code["members"] = "\nprivate:\n\n  unsigned int __global_dimension;\n"

    # Generate code for constructor
    ufc_code["constructor"] = "__global_dimension = 0;"

    # Generate code for destructor
    ufc_code["destructor"] = "// Do nothing"

    # Generate code for signature
    ufc_code["signature"] = "return \"%s\";" % code["signature"]

    # Generate code for needs_mesh_entities
    cases = ["return %s;" % case for case in code["needs_mesh_entities"]]
    ufc_code["needs_mesh_entities"] = __generate_switch("d", cases, "return false;")

    # Generate code for init_mesh
    ufc_code["init_mesh"] = "__global_dimension = %s;\nreturn false;" % code["global_dimension"]

    # Generate code for init_cell
    ufc_code["init_cell"] = "// Do nothing"

    # Generate code for init_cell_finalize
    ufc_code["init_cell_finalize"] = "// Do nothing"

    # Generate code for global_dimension
    ufc_code["global_dimension"] = "return __global_dimension;"

    # Generate code for local dimension
    ufc_code["local_dimension"] = "return %s;" % code["local_dimension"]

    # Generate code for num_facet_dofs
    ufc_code["num_facet_dofs"] = "return %s;" % code["num_facet_dofs"]

    # Generate code for tabulate_dofs
    ufc_code["tabulate_dofs"] = __generate_body(code["tabulate_dofs"])

    # Generate code for tabulate_facet_dofs
    ufc_code["tabulate_facet_dofs"] = __generate_switch("facet", [__generate_body(case) for case in code["tabulate_facet_dofs"]])

    # Generate code for tabulate_coordinates
    ufc_code["tabulate_coordinates"] = __generate_body(code["tabulate_coordinates"])

    # Generate code for num_sub_dof_maps
    ufc_code["num_sub_dof_maps"] = "return %s;" % code["num_sub_dof_maps"]

    # Generate code for create_sub_dof_map
    num_sub_dof_maps = eval(code["num_sub_dof_maps"])
    if num_sub_dof_maps == 1:
        ufc_code["create_sub_dof_map"] = "return new %s();" % ufc_code["classname"]
    else:
        cases = ["return new %s_%d();" % (ufc_code["classname"], i) for i in range(num_sub_dof_maps)]
        ufc_code["create_sub_dof_map"] = __generate_switch("i", cases, "return 0;")


    return __generate_code(dof_map_combined, ufc_code, options)

def __generate_cell_integral(code, form_data, options, prefix, i):
    "Generate code for ufc::cell_integral"

    ufc_code = {}

    # Set class name
    ufc_code["classname"] = "%s_cell_integral_%d" % (prefix, i)

    # Generate code for members
    ufc_code["members"] = __generate_body(code["members"])

    # Generate code for constructor
    ufc_code["constructor"] = "// Do nothing"

    # Generate code for destructor
    ufc_code["destructor"] = "// Do nothing"

    # Generate code for tabulate_tensor
#    body  = __generate_jacobian(form_data.cell_dimension, Integral.CELL)
#    body += "\n"
    body = __generate_body(code["tabulate_tensor"])
#    ufc_code["tabulate_tensor"] = remove_unused(body)
    ufc_code["tabulate_tensor"] = body

    return __generate_code(cell_integral_combined, ufc_code, options)

def __generate_exterior_facet_integral(code, form_data, options, prefix, i):
    "Generate code for ufc::exterior_facet_integral"

    ufc_code = {}
    
    # Set class name
    ufc_code["classname"] = "%s_exterior_facet_integral_%d" % (prefix, i)

    # Generate code for members
    ufc_code["members"] = __generate_body(code["members"])

    # Generate code for constructor
    ufc_code["constructor"] = "// Do nothing"

    # Generate code for destructor
    ufc_code["destructor"] = "// Do nothing"

    # Generate code for tabulate_tensor
    switch = __generate_switch("facet", [__generate_body(case) for case in code["tabulate_tensor"][1]])
#    body  = __generate_jacobian(form_data.cell_dimension, Integral.EXTERIOR_FACET)
#    body += "\n"
    body = __generate_body(code["tabulate_tensor"][0])
    body += "\n"
    body += switch
#    ufc_code["tabulate_tensor"] = remove_unused(body)
    ufc_code["tabulate_tensor"] = body

    return __generate_code(exterior_facet_integral_combined, ufc_code, options)

def __generate_interior_facet_integral(code, form_data, options, prefix, i):
    "Generate code for ufc::interior_facet_integral"

    ufc_code = {}

    # Set class name
    ufc_code["classname"] = "%s_interior_facet_integral_%d" % (prefix, i)

    # Generate code for members
    ufc_code["members"] = __generate_body(code["members"])

    # Generate code for constructor
    ufc_code["constructor"] = "// Do nothing"

    # Generate code for destructor
    ufc_code["destructor"] = "// Do nothing"

    # Generate code for tabulate_tensor, impressive line of Python code follows
    switch = __generate_switch("facet0", [__generate_switch("facet1", [__generate_body(case) for case in cases]) for cases in code["tabulate_tensor"][1]])
#    body  = __generate_jacobian(form_data.cell_dimension, Integral.INTERIOR_FACET)
#    body += "\n"
    body = __generate_body(code["tabulate_tensor"][0])
    body += "\n"
    body += switch
#    ufc_code["tabulate_tensor"] = remove_unused(body)
    ufc_code["tabulate_tensor"] = body

    return __generate_code(interior_facet_integral_combined, ufc_code, options)

def __generate_form(code, form_data, options, prefix):
    "Generate code for ufc::form"

    ufc_code = {}

    # Set class name
    ufc_code["classname"] = prefix

    # Generate code for members
    ufc_code["members"] = ""

    # Generate code for constructor
    ufc_code["constructor"] = "// Do nothing"

    # Generate code for destructor
    ufc_code["destructor"] = "// Do nothing"

    # Generate code for signature
    ufc_code["signature"] = "return \"%s\";" % __generate_body(code["signature"])

    # Generate code for rank
    ufc_code["rank"] = "return %s;" % code["rank"]

    # Generate code for num_coefficients
    ufc_code["num_coefficients"] = "return %s;" % code["num_coefficients"]
    
    # Generate code for num_cell_integrals
    ufc_code["num_cell_integrals"] = "return %s;" % code["num_cell_integrals"]

    # Generate code for num_exterior_facet_integrals
    ufc_code["num_exterior_facet_integrals"] = "return %s;" % code["num_exterior_facet_integrals"]
    
    # Generate code for num_interior_facet_integrals
    ufc_code["num_interior_facet_integrals"] = "return %s;" % code["num_interior_facet_integrals"]

    # Generate code for create_finite_element
    num_cases = form_data.num_arguments
    cases = ["return new %s_finite_element_%d();" % (prefix, i) for i in range(num_cases)]
    ufc_code["create_finite_element"] = __generate_switch("i", cases, "return 0;")

    # Generate code for create_dof_map
    num_cases = form_data.num_arguments
    cases = ["return new %s_dof_map_%d();" % (prefix, i) for i in range(num_cases)]
    ufc_code["create_dof_map"] = __generate_switch("i", cases, "return 0;")

    # Generate code for cell_integral
    num_cases = form_data.num_cell_integrals
    cases = ["return new %s_cell_integral_%d();" % (prefix, i) for i in range(num_cases)]
    ufc_code["create_cell_integral"] = __generate_switch("i", cases, "return 0;")

    # Generate code for exterior_facet_integral
    num_cases = form_data.num_exterior_facet_integrals
    cases = ["return new %s_exterior_facet_integral_%d();" % (prefix, i) for i in range(num_cases)]
    ufc_code["create_exterior_facet_integral"] = __generate_switch("i", cases, "return 0;")

    # Generate code for interior_facet_integral
    num_cases = form_data.num_interior_facet_integrals
    cases = ["return new %s_interior_facet_integral_%d();" % (prefix, i) for i in range(num_cases)]
    ufc_code["create_interior_facet_integral"] = __generate_switch("i", cases, "return 0;")

    return __generate_code(form_combined, ufc_code, options)

def __generate_jacobian(cell_dimension, integral_type):
    "Generate code for computing jacobian"

    # Choose space dimension
    if cell_dimension == 2:
        jacobian = jacobian_2D
        facet_determinant = facet_determinant_2D
    else:
        jacobian = jacobian_3D
        facet_determinant = facet_determinant_3D
    
    # Check if we need to compute more than one Jacobian
    if integral_type == Integral.CELL:
        code  = jacobian % {"restriction":  ""}
        code += "\n\n"
        code += scale_factor
    elif integral_type == Integral.EXTERIOR_FACET:
        code  = jacobian % {"restriction":  ""}
        code += "\n\n"
        code += facet_determinant % {"restriction": "", "facet" : "facet"}
    elif integral_type == Integral.INTERIOR_FACET:
        code  = jacobian % {"restriction": choose_map[Restriction.PLUS]}
        code += "\n\n"
        code += jacobian % {"restriction": choose_map[Restriction.MINUS]}
        code += "\n\n"
        code += facet_determinant % {"restriction": choose_map[Restriction.PLUS], "facet": "facet0"}

    return code

def __generate_switch(variable, cases, default = ""):
    "Generate switch statement from given variable and cases"

    # Special case: no cases
    if len(cases) == 0:
        return default

    # Special case: one case
    if len(cases) == 1:
        return cases[0]

    # Create switch
    code = "switch ( %s )\n{\n" % variable
    for i in range(len(cases)):
        code += "case %d:\n%s\n  break;\n" % (i, indent(cases[i], 2))
    code += "}"
    if not default == "":
        code += "\n" + default
    
    return code

def __generate_body(declarations):
    "Generate function body from list of declarations or statements"
    if not isinstance(declarations, list):
        declarations = [declarations]
    lines = []
    for declaration in declarations:
        if isinstance(declaration, tuple):
            lines += ["%s = %s;" % declaration]
        else:
            lines += ["%s" % declaration]
    return "\n".join(lines)

def __generate_code(format_string, code, options):
    "Generate code according to format string and code dictionary"

    # Fix indentation
    for key in code:
        if "no-" + key in options:
            code[key] = "// Not generated (compiled with -fno-" + key + ")"
        if not key in ["classname", "members"]:
            code[key] = indent(code[key], 4)

    # Generate code
    return format_string % code