Splitting

Tissue Forge supports modeling processes associated with a particle dividing into two particles, called splitting. In the simplest case, a particle can spawn a new particle in a mass- and volume-preserving split operation under the assumption that the spawned (child) and spawning (parent) particles are identical. During particle splitting, the parent and child particles are randomly placed exactly in contact at the initial position of the parent particle, and both have the same velocity as the parent before the split. The split operation on a particle occurs when calling the Particle method split, which returns the child particle.

import tissue_forge as tf
class SplittingType(tf.ParticleTypeSpec):
    pass

splitting_type = SplittingType.get()
parent_particle = splitting_type()
child_particle = parent_particle.split()

The Particle split method can customize a number of details about particle splitting by passing certain arguments, including the direction of the split (random by default), relative size of the resulting particles (equal by default), allocation of any carried species (equal by total species by default), and type of the resulting particles (equal to the split particle by default). For example, passing only a float tells Tissue Forge the ratio of the volume of the newly created particle to the volume of the particle before the split,

# Split the particle again and produce a new particle with
# a volume equal to 25% of the volume of the parent particle before
# before the split
smaller_particle = parent_particle.split(0.25)

In general, the following always hold true during particle splitting,

  • The two resulting particles are in contact.

  • The total mass, volume, and any species amounts of the two resulting particles are equal to those of the split particle just before the split.

  • The center of mass of the two resulting particles are the same as that of the split particle just before the split.

For details on using various particle splitting features, refer to the Tissue Forge API Reference.

Splitting Clusters

Clusters introduce details of morphology and constituent particles to the process of splitting. Tissue Forge provides support for specifying a number of details concerning how, where and when a cluster divides. The split operation on a cluster also occurs when calling split, though the corresponding cluster method supports a variable number of arguments that define the details of the split. In general, cluster splitting occurs according to a cleavage plane that intersects the cluster, where the constituent particles of the parent cluster before the split are allocated to the parent and child clusters on either side of the intersecting plane.

In the simplest case, a cluster can be divided by randomly selecting a cleavage plane at the center of mass of the cluster. Such a case is implemented by calling split without arguments, as with a particle,

class MyClusterType(tf.ClusterParticleTypeSpec):
    types = [splitting_type]

my_cluster_type = MyClusterType.get()
my_cluster = my_cluster_type()
my_cluster_d1 = my_cluster.split()

split accepts optional keyword arguments normal and point to define a cleavage plane. If only a normal vector is given, split uses the center of mass of the cluster as the point. For example, to split a cluster along the x axis,

my_cluster_d2 = my_cluster.split(normal=[1., 0., 0.])

or to specify the full normal/point form,

my_cluster_d3 = my_cluster.split(normal=[x, y, z], point=[px, py, pz])

split also supports splitting a cluster along an axis at the center of mass of the cluster, where a random cleavage plane is generated that contains the axis. This case can be implemented by using the optional keyword argument axis.

my_cluster_d4 = my_cluster.split(axis=[x, y, z])

split can also split the cluster by randomly selecting half of the particles in a cluster and assigning them to a child cluster by using the random argument,

my_cluster_d5 = my_cluster.split(random=True)