Relationships - Houdini online help

Overview

Relationships are a special type of data that describe which objects affect which other objects.

The important thing to remember about relationships is that they take time to calculate, so to optimize the simulation, you should only create relationships between objects that really need to interact, and you should look for ways to use one-way relationships (where one object affects another but not the other way around) instead of mutual relationships (where two objects affect each other). Of course in the real world all objects affect all other objects, but in the simulation you should set up relationships only as needed to decrease the work Houdini has to do to run the simulation.

Establishing relationships

You can establish relationships in the network using the Merge node. Parameters on the merge node establish what kind of relationship the merged objects have, and whether it creates one way relationships (objects to the left in the input order affect objects to the right) or mutual relationships. It also has an Activation parameter, which you can use to animate the relationship.

Each relationship also has its own node. These relationship-specific nodes let you configure the relationship (such as by attaching anchor subdata to the Constraint relationship).

The Apply relationship node lets you “stamp” relationships, building a large number of relationships procedurally (for example, building a chain of linked rigid body objects). Apply Relationship requires a relationship DOP node (such as Hard Constraint) to work.

See the following relationship nodes for more information:

Apply relationship — creates multiple relationships procedurally.
Collision — allows two dynamic objects to collide with one another.
Empty — creates no meaningful relationship, but lets you establish solve order.
Group — creates groups like the Group dynamics node.
Hard constraint — creates a hard constraint.
Pump — makes a dynamic object a pump for a fluid object (moves fluid).
Sink — makes a dynamic object a sink for a fluid object (removes fluid).
Source — makes a dynamic object a source for a fluid object (creates fluid).
Spring — creates a spring constraint.
Two state constraint — creates a constraint that flips between two states based threshold conditions.

Types of relationships

Some common relationships in Houdini simulations are collision (one object will bounce off another), constraint (one object is constrained by some aspect of another, for example, to stay within a certain distance), fluid sinks (an object removes volume from a fluid object) and fluid sources (an object adds volume to a fluid object).

Rigid body collision relationships

If two objects have no collision relationship, they will pass through each other.
If two objects have a one way collision relationship, the affector object will not change, but the affected object will bounce off. Because this only requires the solver to calculate the effect of the collision on one object instead of two, this is more efficient than a more realistic mutual collision.

This is useful for efficiently representing modeling between light and heavy or immobile objects, where the light object’s impact would have no visible effect on the position of the heavy object.
If two objects have a mutual collision relationship, they will bounce off each other. This requires simultaneous solving (see below).

To speed up the simulation, you should try to only set up collision relationships between objects can actually collide, and look for opportunities to use one-way collisions instead of mutual.

Note

To manually set up collision relationships, you must first turn off the Make objects mutual affectors option on the RBD Solver node.

When this option is on (the default), it automatically makes all active objects collide with each other, for the sake of convenience (so you don’t have set up relationships manually).

Constraint relationships

A constraint relationship establishes a relationship between an object and an anchor.

A pin constraint constrains an object to stay a certain distance from a goal anchor (as if it was connected to the anchor by a rigid stick, but could otherwise swing freely). A spring constraint applies forces to try to keep an object anchor a certain distance from a goal anchor. Goal anchors can be the location of another object, or world space locations.

In Houdini 8, the only type of relationship was a collision relationship. Since Houdini 9, constraints are also relationships. If the interaction you're modeling doesn’t need collision detection (for example, you're modeling a chain as series of object-to-object constraints but you don’t care about whether the chain self-collides), you can set up constraint relationships without collision relationships, which will solve much faster than with collisions.

Fluid sinks and sources

Source and sink relationships establish relationships between objects and fluid boxes, so that the object creates or removes fluid from the box.

The affector matrix

The details view includes an item in the left-side tree called Affector matrix which shows relationships in the simulation as a table.

Empty	No relationship.
Blue	One-way relationship (the row object affects the column object).
Green	Mutual relationship (the row object and the column object affect each other).
Yellow	Relationship with no effect. For example, if you have a static RBD object (its Make active object parameter is off), and you merge it together with other objects with mutual collisions (or one way collisions affecting the static object), the collision relationship has no effect, because static objects don’t move.

Relationships and solve order

Relationships are largely arbitrary — what they do depends on what the solver chooses to do with them — but they do affect solve order. See solving for more information on how relationships affect how Houdini solves the simulation.