pycad/py_src/design.py

# $Id:$

"""
template for the Design which defines a regions and features
for a mesh generator.

@var __author__: name of author
@var __copyright__: copyrights
@var __license__: licence agreement
@var __url__: url entry point on documentation
@var __version__: version
@var __date__: date of the version
"""


__author__="Lutz Gross, l.gross@uq.edu.au"
__copyright__="""  Copyright (c) 2007 by ACcESS MNRF
                    http://www.access.edu.au
                Primary Business: Queensland, Australia"""
__license__="""Licensed under the Open Software License version 3.0
             http://www.opensource.org/licenses/osl-3.0.php"""
__url__="http://www.iservo.edu.au/esys/escript"
__version__="$Revision:$"
__date__="$Date:$"


from primitives import Primitive, ReversePrimitive, PropertySet, Point, Manifold1D, Manifold2D, Manifold3D
from xml.dom import minidom

class TagMap(object):
    """
    a class that allows to map tags to names
   
    tm=TagMap({5 : x })
    tm.setMap(a=1,x=4)
    assert tm.getTags("a") == [ 1 ]
    assert tm.getTags("x") == [ 5, 4 ]
    assert tm.map(x=10., a=20.) == { 5 : 10, 4: 10, 1 : 20 }

    """
    def __init__(self, mapping={}):
      """
      initizlizes the mapping. map defines an initial mapping from tag to a name.
      """
      self.__mapping={}
      for tag, name in mapping.items():
          if not isinstance(tag, int):
              raise TypeError("tag needs to be int")
          if not isinstance(name, str):
              raise TypeError("name needs to be a str.")
          self.__mapping[tag]=name
    def setMap(self,**kwargs):
      """
      set a new map where <name>=<tag> assigns the tag <tag> to name <name>. <tag> has to be integer.
      If <tag> has been assigned to a name before the mapping will be overwritten. Otherwise a new 
      mapping <tag> -> <name> is set. Notice that a single name can be assigned to different tags.
      """
      for  name, tag in kwargs.items():
          if not isinstance(tag, int):
             raise TypeError("tag needs to be int")
          self.__mapping[tag]=name
    def getTags(self,name=None):
        """
        returns a list of the tags assigned to name. If name is not present a list of tags is returned.
        """
        if name == None:
           out=self.__mapping.keys()
        else:
           out=[]
           for tag, arg in self.__mapping.items():
             if arg == name: out.append(tag)
        return out
    def getName(self,tag=None):
        """
        returns the name of a tag. If tag is not present a list of names is returned.
        """
        if tag == None:
           return list(set(self.__mapping.values()))
        else:
            return self.__mapping[tag]

    def getMapping(self):
        """
        returns a dictionary where the tags define the keys and the values the corresposnding names.
        """
        return self.__mapping

    def map(self,default=0,**kwargs):
        """
        returns a dictionary where the tags define the keys and the values give the values assigned to the tag via name 
        and kwargs:

        tm=TagMap(x=5)
        tm.setMap(a=1,x=4)
        print tm.map(x=10., a=20.) 
        { 5 : 10, 4: 10, 1 : 20 }
   
        the default is used for tags which map onto name with unspecified values
        """
        out={}
        for tag in self.__mapping:
           if kwargs.has_key(self.__mapping[tag]):
              out[tag]=kwargs[self.__mapping[tag]]
           else:
              out[tag]=default
        return out

    def insert(self,data,default=0,**kwargs):
        """
        inserts values into the L{esys.escript.Data} object according to the given values assigned to the keywords.
        the default is used for tags which map onto name with unspecified values
        """
        d=self.map(default=default,**kwargs)
        for t,v in d.items():
             data.setTaggedValue(t,v)
    def passToDomain(self,domain):
        """
        passes the tag map to  L{esys.escript.Domain} domain.
        """
        for tag, name in self.__mapping.items():
          domain.setTagMap(name,tag)
         
    def toDOM(self,dom):
         """
         adds object to dom
         """
         tm=dom.createElement("TagMap")
         dom.appendChild(tm)
         for tag,name in self.getMapping().items():
             item_dom=dom.createElement("map")
             tag_dom=dom.createElement("tag")
             name_dom=dom.createElement("name")
             tag_dom.appendChild(dom.createTextNode(str(tag)))
             name_dom.appendChild(dom.createTextNode(str(name)))
             item_dom.appendChild(tag_dom)
             item_dom.appendChild(name_dom)
             tm.appendChild(item_dom)
         return tm
    def fromDom(self,node):
        """
        fills from dom node
        """
        for node in node.childNodes:
           if isinstance(node, minidom.Element):
             if node.tagName == 'map':
               tag=int(node.getElementsByTagName("tag")[0].firstChild.nodeValue.strip())
               name=str(node.getElementsByTagName("name")[0].firstChild.nodeValue.strip())
               self.setMap(**{ name : tag })
        return

    def fillFromXML(self,iostream):
       """
       uses the xml file or string to set the mapping
       """
       if isinstance(iostream,str):
             dom=minidom.parseString(iostream)
       else:
           dom=minidom.parse(iostream)
       root=dom.getElementsByTagName('ESys')[0]
       for node in root.childNodes:
           if isinstance(node, minidom.Element):
              if node.tagName == 'TagMap':
                 self.fromDom(node)
                 return
             
          
    def writeXML(self,iostream=None):
         """
         writes XML serialization into the iostream or if not present returns the XML as string
         """
         dom=minidom.Document()
         esys=dom.createElement('ESys')
         esys.appendChild(self.toDOM(dom))
         dom.appendChild(esys)
         if iostream == None:
            return dom.toprettyxml()
         else:
            iostream.write(dom.toprettyxml())
        
class Design(object):
    """
    template for a design which defines the input for a mesh generator
    """
    def __init__(self,dim=3,element_size=1.,order=1,keep_files=False):
       """
       initializes a design 

       @param dim: patial dimension
       @param element_size: global element size
       @param order: element order
       @param keep_files: flag to keep work files.
       """ 
       self.clearItems()
       self.setElementSize(element_size)
       self.setDim(dim)
       self.setElementOrder(order)
       if keep_files:
          self.setKeepFilesOn()
       else:
          self.setKeepFilesOff()
    def setDim(self,dim=3):
        """
        sets the spatial dimension
        """
        if not dim  in [1,2,3]: 
           raise ValueError("only dimension 1, 2, 3 are supported.")
        self.__dim=dim
    def getDim(self,dim=3):
        """
        returns the spatial dimension
        """
        return self.__dim
    def setElementOrder(self,order=1):
        """
        sets the element order
        """
        if not order in [1,2]:
           raise ValueError("only element orser 1 or 2 is supported.")
        self.__order=order
        
    def getElementOrder(self):
        """
        returns the element order
        """
        return self.__order
        
    def setElementSize(self,element_size=1.):
        """
        set the global element size.
        """
        if element_size<=0.:
           raise ValueError("element size needs to be positive.")
        self.__element_size=element_size
        
    def getElementSize(self):
        """
        returns the global element size.
        """
        return self.__element_size
        
    def setKeepFilesOn(self):
        """
        work files are kept at the end of the generation
        """
        self.__keep_files=True
    def setKeepFilesOff(self):
        """
        work files are deleted at the end of the generation
        """
        self.__keep_files=False
    def keepFiles(self):
        """
        returns True if work files are kept
        """
        return self.__keep_files
    def addItems(self,*items):
       """
       adds items to the design
       """
       for i in range(len(items)):
          if not isinstance(items[i],(Primitive, ReversePrimitive)):
             raise TypeError("%s-th argument is not a Primitive object"%i)
       for i in items:
          self.__items.append(i)
    def getItems(self):
        """
        returns a list of the items used in the design
        """
        return self.__items
    def clearItems(self):
        """
        resets the items in design
        """
        self.__items=[]
    def getAllPrimitives(self):
        """
        returns a list of all primitives used to create the design.
        each primitve appears once. The primitives are ordered by their
        order of generation
        """
        prims=[]
        for i in self.getItems(): 
            for p in i.getPrimitives():
                if not p in prims: prims.append(p)
        prims.sort()
        return prims

    def setOptions(self,**kwargs):
        """
        sets options of the mesh generator

        @note: this method is typically overwritten by a particular Design implementation
        """
        pass
    def getMeshHandler(self):
        """
        returns a handle to a mesh meshing the design

        @note: this method has to be overwritten by a particular Design implementation
        """
        raise NotImplementedError()

    def getTagMap(self):
        """
        returns a L{TagMap} to map the names of L{PropertySet}s to tags
        """
        m={}
        for p in self.getAllPrimitives():
           if isinstance(p, PropertySet): m[ p.getTag() ] = p.getName()
        return TagMap(m)
1	# $Id:$
2
3	"""
4	template for the Design which defines a regions and features
5	for a mesh generator.
6
7	@var __author__: name of author
8	@var __copyright__: copyrights
9	@var __license__: licence agreement
10	@var __url__: url entry point on documentation
11	@var __version__: version
12	@var __date__: date of the version
13	"""
14
15
16	__author__="Lutz Gross, l.gross@uq.edu.au"
17	__copyright__=""" Copyright (c) 2007 by ACcESS MNRF
18	http://www.access.edu.au
19	Primary Business: Queensland, Australia"""
20	__license__="""Licensed under the Open Software License version 3.0
21	http://www.opensource.org/licenses/osl-3.0.php"""
22	__url__="http://www.iservo.edu.au/esys/escript"
23	__version__="$Revision:$"
24	__date__="$Date:$"
25
26
27	from primitives import Primitive, ReversePrimitive, PropertySet, Point, Manifold1D, Manifold2D, Manifold3D
28	from xml.dom import minidom
29
30	class TagMap(object):
31	"""
32	a class that allows to map tags to names
33
34	tm=TagMap({5 : x })
35	tm.setMap(a=1,x=4)
36	assert tm.getTags("a") == [ 1 ]
37	assert tm.getTags("x") == [ 5, 4 ]
38	assert tm.map(x=10., a=20.) == { 5 : 10, 4: 10, 1 : 20 }
39
40	"""
41	def __init__(self, mapping={}):
42	"""
43	initizlizes the mapping. map defines an initial mapping from tag to a name.
44	"""
45	self.__mapping={}
46	for tag, name in mapping.items():
47	if not isinstance(tag, int):
48	raise TypeError("tag needs to be int")
49	if not isinstance(name, str):
50	raise TypeError("name needs to be a str.")
51	self.__mapping[tag]=name
52	def setMap(self,**kwargs):
53	"""
54	set a new map where <name>=<tag> assigns the tag <tag> to name <name>. <tag> has to be integer.
55	If <tag> has been assigned to a name before the mapping will be overwritten. Otherwise a new
56	mapping <tag> -> <name> is set. Notice that a single name can be assigned to different tags.
57	"""
58	for name, tag in kwargs.items():
59	if not isinstance(tag, int):
60	raise TypeError("tag needs to be int")
61	self.__mapping[tag]=name
62	def getTags(self,name=None):
63	"""
64	returns a list of the tags assigned to name. If name is not present a list of tags is returned.
65	"""
66	if name == None:
67	out=self.__mapping.keys()
68	else:
69	out=[]
70	for tag, arg in self.__mapping.items():
71	if arg == name: out.append(tag)
72	return out
73	def getName(self,tag=None):
74	"""
75	returns the name of a tag. If tag is not present a list of names is returned.
76	"""
77	if tag == None:
78	return list(set(self.__mapping.values()))
79	else:
80	return self.__mapping[tag]
81
82	def getMapping(self):
83	"""
84	returns a dictionary where the tags define the keys and the values the corresposnding names.
85	"""
86	return self.__mapping
87
88	def map(self,default=0,**kwargs):
89	"""
90	returns a dictionary where the tags define the keys and the values give the values assigned to the tag via name
91	and kwargs:
92
93	tm=TagMap(x=5)
94	tm.setMap(a=1,x=4)
95	print tm.map(x=10., a=20.)
96	{ 5 : 10, 4: 10, 1 : 20 }
97
98	the default is used for tags which map onto name with unspecified values
99	"""
100	out={}
101	for tag in self.__mapping:
102	if kwargs.has_key(self.__mapping[tag]):
103	out[tag]=kwargs[self.__mapping[tag]]
104	else:
105	out[tag]=default
106	return out
107
108	def insert(self,data,default=0,**kwargs):
109	"""
110	inserts values into the L{esys.escript.Data} object according to the given values assigned to the keywords.
111	the default is used for tags which map onto name with unspecified values
112	"""
113	d=self.map(default=default,**kwargs)
114	for t,v in d.items():
115	data.setTaggedValue(t,v)
116	def passToDomain(self,domain):
117	"""
118	passes the tag map to L{esys.escript.Domain} domain.
119	"""
120	for tag, name in self.__mapping.items():
121	domain.setTagMap(name,tag)
122
123	def toDOM(self,dom):
124	"""
125	adds object to dom
126	"""
127	tm=dom.createElement("TagMap")
128	dom.appendChild(tm)
129	for tag,name in self.getMapping().items():
130	item_dom=dom.createElement("map")
131	tag_dom=dom.createElement("tag")
132	name_dom=dom.createElement("name")
133	tag_dom.appendChild(dom.createTextNode(str(tag)))
134	name_dom.appendChild(dom.createTextNode(str(name)))
135	item_dom.appendChild(tag_dom)
136	item_dom.appendChild(name_dom)
137	tm.appendChild(item_dom)
138	return tm
139	def fromDom(self,node):
140	"""
141	fills from dom node
142	"""
143	for node in node.childNodes:
144	if isinstance(node, minidom.Element):
145	if node.tagName == 'map':
146	tag=int(node.getElementsByTagName("tag")[0].firstChild.nodeValue.strip())
147	name=str(node.getElementsByTagName("name")[0].firstChild.nodeValue.strip())
148	self.setMap(**{ name : tag })
149	return
150
151	def fillFromXML(self,iostream):
152	"""
153	uses the xml file or string to set the mapping
154	"""
155	if isinstance(iostream,str):
156	dom=minidom.parseString(iostream)
157	else:
158	dom=minidom.parse(iostream)
159	root=dom.getElementsByTagName('ESys')[0]
160	for node in root.childNodes:
161	if isinstance(node, minidom.Element):
162	if node.tagName == 'TagMap':
163	self.fromDom(node)
164	return
165
166
167
168	def writeXML(self,iostream=None):
169	"""
170	writes XML serialization into the iostream or if not present returns the XML as string
171	"""
172	dom=minidom.Document()
173	esys=dom.createElement('ESys')
174	esys.appendChild(self.toDOM(dom))
175	dom.appendChild(esys)
176	if iostream == None:
177	return dom.toprettyxml()
178	else:
179	iostream.write(dom.toprettyxml())
180
181	class Design(object):
182	"""
183	template for a design which defines the input for a mesh generator
184	"""
185	def __init__(self,dim=3,element_size=1.,order=1,keep_files=False):
186	"""
187	initializes a design
188
189	@param dim: patial dimension
190	@param element_size: global element size
191	@param order: element order
192	@param keep_files: flag to keep work files.
193	"""
194	self.clearItems()
195	self.setElementSize(element_size)
196	self.setDim(dim)
197	self.setElementOrder(order)
198	if keep_files:
199	self.setKeepFilesOn()
200	else:
201	self.setKeepFilesOff()
202	def setDim(self,dim=3):
203	"""
204	sets the spatial dimension
205	"""
206	if not dim in [1,2,3]:
207	raise ValueError("only dimension 1, 2, 3 are supported.")
208	self.__dim=dim
209	def getDim(self,dim=3):
210	"""
211	returns the spatial dimension
212	"""
213	return self.__dim
214	def setElementOrder(self,order=1):
215	"""
216	sets the element order
217	"""
218	if not order in [1,2]:
219	raise ValueError("only element orser 1 or 2 is supported.")
220	self.__order=order
221
222	def getElementOrder(self):
223	"""
224	returns the element order
225	"""
226	return self.__order
227
228	def setElementSize(self,element_size=1.):
229	"""
230	set the global element size.
231	"""
232	if element_size<=0.:
233	raise ValueError("element size needs to be positive.")
234	self.__element_size=element_size
235
236	def getElementSize(self):
237	"""
238	returns the global element size.
239	"""
240	return self.__element_size
241
242	def setKeepFilesOn(self):
243	"""
244	work files are kept at the end of the generation
245	"""
246	self.__keep_files=True
247	def setKeepFilesOff(self):
248	"""
249	work files are deleted at the end of the generation
250	"""
251	self.__keep_files=False
252	def keepFiles(self):
253	"""
254	returns True if work files are kept
255	"""
256	return self.__keep_files
257	def addItems(self,*items):
258	"""
259	adds items to the design
260	"""
261	for i in range(len(items)):
262	if not isinstance(items[i],(Primitive, ReversePrimitive)):
263	raise TypeError("%s-th argument is not a Primitive object"%i)
264	for i in items:
265	self.__items.append(i)
266	def getItems(self):
267	"""
268	returns a list of the items used in the design
269	"""
270	return self.__items
271	def clearItems(self):
272	"""
273	resets the items in design
274	"""
275	self.__items=[]
276	def getAllPrimitives(self):
277	"""
278	returns a list of all primitives used to create the design.
279	each primitve appears once. The primitives are ordered by their
280	order of generation
281	"""
282	prims=[]
283	for i in self.getItems():
284	for p in i.getPrimitives():
285	if not p in prims: prims.append(p)
286	prims.sort()
287	return prims
288
289	def setOptions(self,**kwargs):
290	"""
291	sets options of the mesh generator
292
293	@note: this method is typically overwritten by a particular Design implementation
294	"""
295	pass
296	def getMeshHandler(self):
297	"""
298	returns a handle to a mesh meshing the design
299
300	@note: this method has to be overwritten by a particular Design implementation
301	"""
302	raise NotImplementedError()
303
304	def getTagMap(self):
305	"""
306	returns a L{TagMap} to map the names of L{PropertySet}s to tags
307	"""
308	m={}
309	for p in self.getAllPrimitives():
310	if isinstance(p, PropertySet): m[ p.getTag() ] = p.getName()
311	return TagMap(m)