Creates an access on an object.
A generic access can be created using the following Lisp syntax:
(make-access object_reference controller direction)
the make-access function requires the following arguments:
The dimension of the controller provided as an argument depends on the type of object being accessed. For example, for a string, the controller should have one dimension, and be a value between 0 and 1 (representing the endpoints of the string). For a circular membrane, however, a two-dimensional controller is necessary; the first dimension is a distance from the center (0-1), and the second dimension is an angle in degrees. Details about the accesses on specific objects can be found in the object reference page entries themselves.
Different objects use different directions of movement. The following is a list of possible direction types:
Details about the direction in which an object can be accessed can be found in the object reference page entries themselves. For each type of object, a subset of these directions of movement is appropriate. For example, a bi-string can have accesses in either the 'trans0 or 'trans1 direction (first and second transverse directions). A closed-closed-tube or closed-open-tube can only be accessed in the long (longitudinal) direction. Membranes and plates are accessed in the normal direction (this is “normal” in the mathematical sense, i.e. at right angles to both dimensions of the membrane). The 'decoded direction is explained in the access options, below.
All objects can additionally be accessed using “decoded” accesses. To understand these, you need to know that internally, Modalys discretizes objects in space. Imagine a membrane covered with discrete points. Modalys can really only compute accesses on a per-point basis. When you say you'd like an access at (0.3 0.4) on a membrane, this location is probably not exactly on a point, so Modalys actually takes a weighting of four points to approximate your ac- cess. Using “decoded” accesses permits you to bypass this “point translation phase” (PTP) and directly say how much of each point you would like. So if you want to access the middle of a mono-dimensional string with 10 modes and 9 points, you could write either of these two statements:
(make-access my-string (const .5) 'trans0)
or:
(make-access my-string (const 0 0 0 0 1 0 0 0 0) 'decoded)
As you can see, using a decoded accesses allows you to do some slightly weird things, like being able to “spread” your access over half of the string by typing:
(make-access my-string (const .2 .2 .2 .2 .2 0 0 0 0) 'decoded)
Unfortunately, the disadvantage to all of this is that in most cases, you can't know exactly how many points Modalys used for a given object, and you also can't know exactly how the points are laid out on the object surface. So what's the use of this? Well, in two cases you do know the number of points — when you used compiled accesses (see the make-compiled-access explanation) and when you use (make-object 'read-from-file ...) to create your model.
Accesses can be shared - in other words, one access can be used for multiple connections. Beware though that in some cases the physical equations might not subsequently be solvable and error messages will be issued during synthesis. This is often the case if you try to impose a certain position at a certain access, with a 'position connection for example, and at the same time trying to impose a certain speed to the same location, with a 'strike interaction, for example.
Generally, however, it can be safer (and conceptually easier, even though slightly more computationally expensive) to create an access for each use, such as an access for a point-output at the same location as an input force, etc....