← Back to branch summary

~njansson/dolfin/hpc

« back to all changes in this revision

Viewing changes to sandbox/meshordering/meshreordering

  • Committer: Niclas Jansson
  • Date: 2010-10-17 10:21:52 UTC
  • Revision ID: njansson@csc.kth.se-20101017102152-e6u3c9uwxa4z19c8
Minor fixes in configure.ac

Show diffs side-by-side

added added

removed removed

Lines of Context:
sandbox/meshordering/meshreordering
1
 
#!/usr/bin/env python
2
 
 
3
 
import sys
4
 
 
5
 
def main(argv):
6
 
 
7
 
    # Get dictionary of connectivities
8
 
    dic_connects = get_connects(argv[0])
9
 
 
10
 
    # Verify connectivities
11
 
    check_sort(dic_connects)
12
 
 
13
 
    check_2_1(dic_connects)
14
 
 
15
 
    check_3_2(dic_connects)
16
 
 
17
 
    check_3_1(dic_connects)
18
 
 
19
 
def check_2_1(dic_connects):
20
 
 
21
 
    dic21 = (2,1)
22
 
    dic20 = (2,0)
23
 
    dic10 = (1,0)
24
 
    non_inc = [0,1,2]
25
 
 
26
 
    print "\n ---- Verifying (2-1) ----"
27
 
    ok = True
28
 
 
29
 
    entities21 = dic_connects[dic21]
30
 
    entities20 = dic_connects[dic20]
31
 
    entities10 = dic_connects[dic10]
32
 
    # Inverting dictionary
33
 
    inv10 = {}
34
 
    for e10 in entities10:
35
 
        inv10[tuple(entities10[e10])] = [e10]
36
 
 
37
 
    for e21 in entities21:
38
 
        l = []
39
 
        # Get list of edges on cell/facet to compare against
40
 
        l21 = entities21[e21]
41
 
        # Get list of vertices for cell/facet
42
 
        l20 = entities20[e21]
43
 
        for n in non_inc:
44
 
            # Copy vertices and remove non-incident vertices
45
 
            le = [l2 for l2 in l20]
46
 
            le.remove(l20[n])
47
 
            # Look for the edge with these vertices
48
 
            l += inv10[tuple(le)]
49
 
        # If the two list are not equal, reordering is not OK
50
 
        if not l == l21:
51
 
            ok = False
52
 
            print "l:   ",l
53
 
            print "l21: ",l21
54
 
            print ""
55
 
 
56
 
    if ok and entities21:
57
 
        print " - OK"
58
 
    elif not ok:
59
 
        print " - NOT OK"
60
 
    else:
61
 
        print " - nothing to do"
62
 
 
63
 
 
64
 
def check_3_2(dic_connects):
65
 
 
66
 
    dic32 = (3,2)
67
 
    dic30 = (3,0)
68
 
    dic20 = (2,0)
69
 
    non_inc = [0,1,2,3]
70
 
 
71
 
    print "\n ---- Verifying (3-2) ----"
72
 
    ok = True
73
 
 
74
 
    entities32 = dic_connects[dic32]
75
 
    entities30 = dic_connects[dic30]
76
 
    entities20 = dic_connects[dic20]
77
 
    # Inverting dictionary
78
 
    inv20 = {}
79
 
    for e20 in entities20:
80
 
        inv20[tuple(entities20[e20])] = [e20]
81
 
 
82
 
    for e32 in entities32:
83
 
        l = []
84
 
        # Get list of facets on cell to compare against
85
 
        l32 = entities32[e32]
86
 
        # Get list of vertices for cell
87
 
        l30 = entities30[e32]
88
 
        for n in non_inc:
89
 
            le = [l3 for l3 in l30]
90
 
            le.remove(l30[n])
91
 
            # Look for the facet with these vertices
92
 
            l += inv20[tuple(le)]
93
 
        # If the two list are not equal, reordering is not OK
94
 
        if not l == l32:
95
 
            ok = False
96
 
            print "l:   ",l
97
 
            print "l32: ",l32
98
 
            print ""
99
 
 
100
 
    if ok and entities32:
101
 
        print " - OK"
102
 
    elif not ok:
103
 
        print " - NOT OK"
104
 
    else:
105
 
        print " - nothing to do"
106
 
 
107
 
 
108
 
def check_3_1(dic_connects):
109
 
 
110
 
    dic31 = (3,1)
111
 
    dic30 = (3,0)
112
 
    dic10 = (1,0)
113
 
    non_inc = [(0,1), (0,2), (0,3), (1,2), (1,3), (2,3)]
114
 
 
115
 
    print "\n ---- Verifying (3-1) ----"
116
 
    ok = True
117
 
 
118
 
    entities31 = dic_connects[dic31]
119
 
    entities30 = dic_connects[dic30]
120
 
    entities10 = dic_connects[dic10]
121
 
    # Inverting dictionary
122
 
    inv10 = {}
123
 
    for e10 in entities10:
124
 
        inv10[tuple(entities10[e10])] = [e10]
125
 
 
126
 
    for e31 in entities31:
127
 
        l = []
128
 
        # Get list of edges on cell to compare against
129
 
        l31 = entities31[e31]
130
 
        # Get list of vertices for cell
131
 
        l30 = entities30[e31]
132
 
        for nc in non_inc:
133
 
            # Copy vertices and remove non-incident vertices
134
 
            le = [l3 for l3 in l30]
135
 
            for n in nc:
136
 
                le.remove(l30[n])
137
 
            # Look for the facet with these vertices
138
 
            l += inv10[tuple(le)]
139
 
        # If the two list are not equal, reordering is not OK
140
 
        if not l == l31:
141
 
            ok = False
142
 
            print "l:   ",l
143
 
            print "l31: ",l31
144
 
            print ""
145
 
 
146
 
    if ok and entities31:
147
 
        print " - OK"
148
 
    elif not ok:
149
 
        print " - NOT OK"
150
 
    else:
151
 
        print " - nothing to do"
152
 
 
153
 
 
154
 
def check_sort(dic_connects):
155
 
 
156
 
    # Connectivities that should be sorted lexicographically
157
 
    sort_dics = [(1,0), (2,0), (3,0)]
158
 
 
159
 
    print "\n ---- Verifying that vertices are sorted on all mesh entities ----"
160
 
    for dic in sort_dics:
161
 
        ok = True
162
 
        print " -", dic
163
 
        # Get dictionary of entities
164
 
        ent_dic = dic_connects[dic]
165
 
        if ent_dic:
166
 
            for entity in ent_dic:
167
 
                # Get list of vertices
168
 
                l = ent_dic[entity]
169
 
                # Copy list
170
 
                ls = [s for s in l]
171
 
                # Sort original list and compare lists
172
 
                l.sort()
173
 
                if not l == ls:
174
 
                    ok = False
175
 
            if ok:
176
 
                print " - OK"
177
 
            else:
178
 
                print " - NOT OK"
179
 
 
180
 
        else:
181
 
            print " - nothing to do"
182
 
 
183
 
def get_connects(name):
184
 
 
185
 
    # Supported connectivities
186
 
    connects = [(1,0), (2,0), (3,0), (2,1), (3,1), (3,2)]
187
 
    # Look for this
188
 
 
189
 
    dic = {}
190
 
    for entry in connects:
191
 
        dic[entry] = {}
192
 
 
193
 
    # Read file, and get lines
194
 
    f = open(name, "r")
195
 
    lines = f.read().split("\n")
196
 
    f.close()
197
 
    # Remove blank lines
198
 
    lines = [line for line in lines if line.split()]
199
 
 
200
 
    # Loop lines and check for supported connectivities
201
 
    entry = ()
202
 
    ints = ["0", "1", "2", "3"]
203
 
    for line in lines:
204
 
        if not ("--" in line or ":" in line):
205
 
            entry = ()
206
 
        if "Connect" in line and "--" in line:
207
 
            words = line.split(" ")
208
 
            entry = tuple([int(w.replace(":","")) for w in words if w.replace(":","") in ints])
209
 
            if not entry in connects:
210
 
                entry = ()
211
 
            line = ""
212
 
 
213
 
        if entry and line:
214
 
            if ":" in line:
215
 
                entity = line.split(":")[0].split(" ")[-1]
216
 
                vals = [int(v) for v in line.split(":")[1].split(" ") if v]
217
 
                dic[entry][int(entity)] = vals
218
 
 
219
 
    return dic
220
 
 
221
 
if __name__ == "__main__":
222
 
    sys.exit(main(sys.argv[1:]))