We Keep Coding

Best practices for removing Documents/Edges with Graph Traversals (AQL and Python)

As AQL doesn't support deleting edges and vertices directly. I'd like to know how I'm able to delete a set of nodes/edges obtained by Graph traversals.
My current code for obtaining the Edges and Nodes is quite easy and works:
LET edgeKeys = (FOR v, e, p IN 1..1000 INBOUND 'TestNode/Node_3'
GRAPH 'testGraph'
RETURN e._key)
LET nodeKeys = (FOR v, e, p IN 1..1000 INBOUND 'TestNode/Node_3'
GRAPH 'testGraph'
RETURN v._key)
In the Tutorial there are two different commands used for removing several Edges and one Node:
LET r = (FOR key IN edgeKeys REMOVE key IN knows)
REMOVE 'eve' IN persons
This command works, but I got several Edges and several Nodes. I tried to modify the command to (both of them are executed after the first two commands):
FOR nkey IN nodeKeys REMOVE nkey IN TestNode
FOR ekey IN edgeKeys REMOVE ekey IN TestEdge
But that won't work, swapping them is the same. Both of them executed independently are fine. In the same Statement I'm getting the following error:
Query: AQL: document not found (while executing)
I'm able to understand why this error appears, but what's the proper way to work around it?
Seems, just abusing the REMOVE command isn't valid either:
REMOVE nodeKeys IN TestNode
Query: AQL: invalid document type (while executing)
As this is a little more complicated than the regular AQL I'm using in my Python-Code I wonder how I'd use it later in Python Code?
For now I'd use the FOR-command to obtain a list of keys and in the iteration just use collection.delete(key).
Yet using a longer AQL-Statement seems to be cleaner than doing a hybrid-command in AQL and Python.
What would be the recommended way to execute the working AQL-command in Python? (And how would it look?)

How to create two dimensional set objects under pyomo.environ module

I tried to create a LP model by using pyomo.environ. However, I'm having a hard time on creating sets. For my problem, I have to create two sets. One set is from a bunch of nodes, and the other one is from several arcs between nodes. I create a network by using Networkx to store my nodes and arcs.
The node data is saved like (Longitude, Latitude) in tuple form. The arcs are saved as (nodeA, nodeB), where nodeA and nodeB are both coordinates in tuple.
So, a node is something like:
(-97.97516252657978, 30.342243012086083)
And, an arc is something like:
((-97.97516252657978, 30.342243012086083),
(-97.976196300350608, 30.34247219922803))
The way I tried to create a set is as following:
# import pyomo.envrion as pe
# create a model m
m = pe.ConcreteModel()
# network is an object I created by Networkx module
m.node_set = pe.Set(initialize= self.network.nodes())
m.arc_set = pe.Set(initialize= self.network.edges())
However, I kept getting an error message on arc_set.
ValueError: The value=(-97.97516252657978, 30.342243012086083,
-97.976196300350608, 30.34247219922803) does not have dimension=2,
which is needed for set=arc_set
I found it's weird that somehow my arc_set turned into one tuple instead of two. Then I tried to convert my nodes and arcs into string but still got the error.
Could somebody show me some hint? Or how do delete this bug?
Thanks!

Underneath the hood, Pyomo "flattens" all indexing sets. That is, it removes nested tuples so that each set member is a single tuple of scalar values. This is generally consistent with other algebraic modeling languages, and helps to make sure that we can consistently (and correctly) retrieve component members regardless of how the user attempted to query them.
In your case, Pyomo will want each member of the the arc set as a single 4-member tuple. There is a utility in PyUtilib that you can use to flatten your tuples when constructing the set:
from pyutilib.misc import flatten
m.arc_set = pe.Set(initialize=(tuple(flatten(x)) for x in self.network.edges())
You can also perform some error checking, in this case to make sure that all edges start and end at known nodes:
from pyutilib.misc import flatten
m.node_set = pe.Set( initialize=self.network.nodes() )
m.arc_set = pe.Set(
within=m.node_set*m.node_set,
initialize=(tuple(flatten(x)) for x in self.network.edges() )
This is particularly important for models like this where you are using floating point numbers as indices, and subtle round-off errors can produce indices that are nearly the same but not mathematically equal.
There has been some discussion among the developers to support both structured and flattened indices, but we have not quite reached consensus on how to best support it in a backwards compatible manner.

Abaqus Python getByBoundingBox command

I have a 2D part in Abaqus with many partitions and I therefore want to select many edges with the getByBoundingBox command to create a surface set. This is the bit of code I have:
p = mdb.models['Model-1'].parts['Plate']
s = p.edges
edges = s.getByBoundingBox((0,0.02,0,0.003,0.04,0))
p.Surface(side1Edges=edges, name='r1')
But it gives me the following error: "edges = s.getByBoundingBox((0,0.02,0,0.003,0.04,0)) TypeError: arg1; found tuple, expecting float".
Any advice much appreciated.

The corners of the bounding box should be provided as 6 separate numbers and not as a single tuple. The solution is very simple, just change the leading "((" and trailing "))" to single "(" and ")". So the call looks like this s.getByBoundingBox(0,0.02,0,0.003,0.04,0).

this comes quite late but in case anyone enters and has the same doubt:
When telling to Abaqus which edge/face/element you are actually selecting, sometimes you need to specify the "ID" of that object, that's why it's asking for a float instead of a tuple in the error message. This can be solved as:
You select the edge/face/node/element you want:
edge = s.getByBoundingBox((0,0.02,0,0.003,0.04,0))
Create a intermediate variable to know the "ID" of the element:
edge_id = edge.id
You now can refenciate it in the dialog for creating surfaces:
p.Surface(side1Edges=p.edges[edge_id], name='r1')
In this case, you're telling Abaqus to select the edge with the id "edge_id" from all the edges that your part "p" has.
This happens many times and you've to be aware what Abaqus is expecting from the code. Sometimes can be the object itselft, a tuple of elements or simply a float expressed as a tupple e.g: edge = (number, )
Regards

I tried the modified code on a 2D plate with the following code
p = mdb.models['Model-1'].parts['Plate']
s = p.edges
edges=s.getByBoundingBox(0,0,0,25,25,1)
And it does not crash. But its not really clear how you can create a surface using this. You need to use a different strategy to achieve what you want. You can find create a surface using the 'pointOn' method.

Scene object selective export using Blender Python API 2.6

I am writing a custom export script to parse all the objects in a blender file, filter them by name, then check to make sure that they meet some specific criteria.
I am using Blender 2.68a. I've created a blender file with some basic 2d and 3d meshes, as well as some that should fail my test criteria. I am working in the internal Python console inside of Blender. This is the only way to work with the blender python API, as their python environment is customized.
I've sorted how to iterate through the objects using a for loop and the D.objects iterator, then check for name matches using regular expressions, and then get a mesh from the object using:
mesh = obj.to_mesh(C.scene, True, 'RENDER') #where obj is an bpy.data.object[index] in the scene
mesh.update(True, True)
mesh.polygons[index].<long list of possible functions>
lets me access an array of polygons to know if there is a set of vertices with edges that form a polygon, and what their key values are.
What I can't sort out is how to determine from the python console if a poly is a face or just a poly. Is there a built in function, or what tests can i perform to programmatically determine this? For example, I can have a mesh 4 vertices with 4 edges that do not have a face, and I do not want to export this, but if i were to edit the same 4 vertices/edges and put a face on it, then it becomes a desirable export.
Can anyone explain the bpy.data.object data structure or explain where the "faces" are stored? it seems as though it would be a property of the npolys themselves, but the API does not make it obvious. Any assistance in clarifying this would be greatly appreciated. Cheers.

So, i asked this question on the blender.org forums, http://www.blender.org/forum/viewtopic.php?t=28286&postdays=0&postorder=asc&start=0 and a very helpful individual has helped me over the past few days each time I got stuck in my own efforts to plow through this.
The short list of answers is:
1) All polygons are faces. If it isnt stored as a polygon, it isnt a face.
2) using the to_mesh() function on an object returns a copy of the function, and so any selections that are done to the copy are not reflected by the context and therefore the methodology I was using was flawed. The only way to access the live object is through use of:
bpy.data.objects[<index or object name>].data.vertices[<index>].co[<0,1,2> which correspond to x,y,z respectively]
bpy.data.objects[<index or object name>].data.polygons[<index>].edge_keys
The first one gives you access to an ordered index of all the vertices in the object(assuming it is of type 'MESH'), and their coordinates.
The second one gives you access to an 2d array of ordered pairs which represent edges. The numbers it contains within the tuples correspond to the index value in the vertices list from the first command, and so you can get the coordinates which the edge goes between.
One can also create a new BMesh object and copy the object you are interested in into the BMesh. This gives you a lot more functionality that you can't access on the live object. The code in answer 3 shows an example of this.
3)see below for answer to my question regarding checking faces in a mesh.
it turns out that one way to determine if an object has faces and all edges are a part of a face is to use the following code snippet written by a helpful user, CoDEmanX on the above thread.
import bpy, bmesh
for ob in bpy.context.scene.objects:
if ob.type != 'MESH':
continue
bm = bmesh.new()
bm.from_object(ob, bpy.context.scene)
if len(bm.faces) > 0 and 0 not in (len(e.link_faces) for e in bm.edges):
print(ob.name, "is valid")
else:
print(ob.name, "has errors")
I changed this a little bit, as i didnt want it to loop through all the objects, and instead i've got this as a function that returns true if the object passed in is valid and false otherwise. This lets me serialize my calls so that my addon only tries to validate the objects which have a name which matches a regex.
def validate(obj):
import bpy, bmesh
if obj.type == 'MESH':
bm = bmesh.new()
bm.from_object(obj, bpy.context.scene)
if len(bm.faces) > 0 and 0 not in (len(e.link_faces) for e in bm.edges):
return True
return False

Abaqus Scripting: Finding a varying number of faces using findat

I'm trying to run a parametric study using Abaqus scripting. It's going to create a shell geometry and then partition it a varying number of times depending on how many times I specify.
My problem is that I'm trying to apply a centrifugal force and to do that I have to find all faces in the part. Is there a simple way to select a whole part? Its easy to calculate a coordinate system for each face, but I'm having trouble trying to combine them all into a value that Abaqus accepts.
Abaqus requires the coordinates to specified as follows, ((x1,y1,z1),), ((x2,y2,z2),)......... ((xn,yn,zn),)
I have been trying to use a while loop (shown below) to create a tuple with the coordinates but it does not like the extra set of brackets put either side. It also won't accept a string.
El = 1 #Used as a counter for how many partitions
allFaceCoords = ()
while El <= NumOfElLength:
regionCentreSpan = (Length/NumOfElLength)*0.5+((El-1)*(Length/NumOfElLength)) # Creates z coord
regionCentre = (CentreLineXCord, 0.0, regionCentreSpan) # Put x,y,z coords in one value
faceCoords =((regionCentre),) # Abaqus wants each repeating unit as ((x,y,z),)
allFaceCoords = allFaceCoords + (faceCoords,) # To add all the coordinates into 1 tuple
El=El+1
facesAll = faces.findAt((allFaceCoords,))
Any ideas how I could achieve this would be much a appreactiated.
Cheers, Matt

try using the commands:
mdb.models['Model-1'].parts['part_name'].faces.getBoundingBox(,,,)
or
mdb.models['Model-1'].parts['skt_R_board'].faces.getByBoundingSphere(
or
mdb.models['Model-1'].parts['skt_R_board'].faces.index[#]