Tissue Forge Library Python API Reference

Returns

ParticleHandle*

Overload 2:

Particle constructor.

Automatically updates when running on a CUDA device.

Parameters

str (string) – JSON string
clusterId (int) – id of parent cluster, optional

Return type

Returns

ParticleHandle*

factory(nr_parts=0, positions=None, velocities=None, cluster_ids=None)

newType(_name: char const *) → TissueForge::ParticleType *

Particle type constructor.

New type is constructed from the definition of the calling type.

Parameters: _name (string) – name of the new type
Return type: ParticleType
Returns: ParticleType*

registerType() → HRESULT

Registers a type with the engine.

Note that this occurs automatically, unless noReg==true in constructor.

Return type: int
Returns: HRESULT

on_register() → void: A callback for when a type is registered

isRegistered() → bool

Tests whether this type is registered

Return type: boolean
Returns: true if registered

get() → TissueForge::ParticleType *

Get the type engine instance

Return type: ParticleType
Returns: ParticleType*

items() → TissueForge::ParticleList *: Get all particles of this type.

isCluster() → bool: Test whether the type is a cluster type

toString() → std::string: Get a JSON string representation

static fromString(str: std::string const &) → TissueForge::ParticleType *

Create from a JSON string representation.

The returned type is automatically registered with the engine.

Parameters: str (string) – a string, as returned by toString

__reduce__(): Helper for pickle.

class tissue_forge.Cluster

Bases: Particle

The cluster analogue to Particle.

class tissue_forge.ClusterParticleHandle(*args)

Bases: ParticleHandle

The cluster analogue to ParticleHandle.

These are special in that they can create particles of their constituent particle types, much like a ParticleType.

property radius_of_gyration: Radius of gyration

property center_of_mass: Center of mass

property centroid: Centroid

property moment_of_inertia: Moment of inertia

items = <function ClusterParticleHandle.items>

__call__(particle_type, *args, **kwargs)

Call self as a function.

Alias of _call

_call(*args) → TissueForge::ParticleHandle *

Overload 1:

Constituent particle constructor.

The created particle will belong to this cluster.

Automatically updates when running on a CUDA device.

Parameters

partType (ParticleType) – type of particle to create
position (FVector3) – position of new particle, optional
velocity (FVector3) – velocity of new particle, optional

Return type

Returns

ParticleHandle*

Overload 2:

Constituent particle constructor.

The created particle will belong to this cluster.

Automatically updates when running on a CUDA device.

Parameters

partType (ParticleType) – type of particle to create
str (string) – JSON string

Return type

Returns

ParticleHandle*

cluster() → TissueForge::Cluster *

Gets the actual cluster of this handle.

Return type: Cluster
Returns: Particle*

split(axis: fVector3 = None, random: bool * = None, time: FPTYPE * = None, normal: fVector3 = None, point: fVector3 = None) → TissueForge::ParticleHandle *

Split the cluster.

Parameters

axis (FVector3) – axis of split, optional
random (boolean) – divide by randomly and evenly allocating constituent particles, optional
time (float) – time at which to implement the split; currently not supported
normal (FVector3) – normal vector of cleavage plane, optional
point (FVector3) – point on cleavage plane, optional

Return type

Returns

ParticleHandle*

class tissue_forge.ClusterTypeSpec

Bases: ParticleTypeSpec

Interface for class-centric design of ClusterParticleType

types = None: List of constituent types of the cluster, if any

class tissue_forge.ClusterParticleType(noReg: bool const & = False)

Bases: ParticleType

The cluster analogue to ParticleType.

types: list of particle types that belong to this type.

hasType(type: ParticleType) → bool

Tests where this cluster has a particle type

Parameters: type (ParticleType) – type to test
Return type: boolean
Returns: true if this cluster has the type

get() → TissueForge::ClusterParticleType *

Get the type engine instance

Return type: ClusterParticleType
Returns: ClusterParticleType*

ParticleList and ParticleTypeList

class tissue_forge.ParticleList(*args)

A special list with convenience methods for working with sets of particles.

property virial: Virial tensor of particles in list

property radius_of_gyration: Radius of gyration of particles in list

property center_of_mass: Center of mass of particles in list

property centroid: Centroid of particles in list

property moment_of_inertia: Moment of inertia of particles in list

property positions: Position of each particle in list

property velocities: Velocity of each particle in list

property forces: Net forces acting on each particle in list

__len__() → int

__getitem__(i: int)

reserve(_nr_parts: size_t) → HRESULT

Reserve enough storage for a given number of items.

Parameters: _nr_parts (int) – number of items
Return type: int
Returns: HRESULT

insert(*args) → uint16_t

Inserts the given particle into the list, returns the index of the item.

Parameters: particle (ParticleHandle) – particle to insert
Return type: int
Returns: uint16_t

remove(id: int32_t) → uint16_t

looks for the item with the given id and deletes it form the list

Parameters: id (int) – id to remove
Return type: int
Returns: uint16_t

extend(other: ParticleList) → void

inserts the contents of another list

Parameters: other (ParticleList) – another list

item(i: int32_t const &) → TissueForge::ParticleHandle *

looks for the item at the given index and returns it if found, otherwise returns NULL

Parameters: i (int) – index of lookup
Return type: ParticleHandle
Returns: ParticleHandle*

static all() → TissueForge::ParticleList *

returns an instance populated with all current particles

Return type: ParticleList
Returns: ParticleList*

sphericalPositions(origin: fVector3 = None) → std::vector< TissueForge::FVector3,std::allocator< TissueForge::FVector3 > >

Get the spherical coordinates of each particle

Parameters: origin (FVector3) – optional origin of coordinates; default is center of universe
Return type: std::vector< TissueForge::FVector3,std::allocator< TissueForge::FVector3 > >
Returns: std::vector<FVector3>

toString() → std::string

Get a JSON string representation

Return type: string
Returns: std::string

static fromString(str: std::string const &) → TissueForge::ParticleList *

Create from a JSON string representation

Parameters: str (string) –
Return type: ParticleList
Returns: ParticleList*

__reduce__(): Helper for pickle.

class tissue_forge.ParticleTypeList(*args)

A special list with convenience methods for working with sets of particle types.

property virial: Virial tensor of particles corresponding to all types in list

property radius_of_gyration: Radius of gyration of particles corresponding to all types in list

property center_of_mass: Center of mass of particles corresponding to all types in list

property centroid: Centroid of particles corresponding to all types in list

property moment_of_inertia: Moment of inertia of particles corresponding to all types in list

property positions: Position of each particle corresponding to all types in list

property velocities: Velocity of each particle corresponding to all types in list

property forces: Total net force acting on each particle corresponding to all types in list

__len__() → int

__getitem__(i: int)

reserve(_nr_parts: size_t) → HRESULT

Reserve enough storage for a given number of items.

Parameters: _nr_parts (int) – number of items
Return type: int
Returns: HRESULT

insert(*args) → uint16_t

Inserts the given particle type into the list, returns the index of the item.

Parameters: ptype (ParticleType) –
Return type: int
Returns: uint16_t

remove(id: int32_t) → uint16_t

looks for the item with the given id and deletes it form the list

Parameters: id (int) – id to remove
Return type: int
Returns: uint16_t

extend(other: ParticleTypeList) → void

inserts the contents of another list

Parameters: other (ParticleTypeList) – another list

item(i: int32_t const &) → TissueForge::ParticleType *

looks for the item at the given index and returns it if found, otherwise returns NULL

Parameters: i (int) – index of lookup
Return type: ParticleType
Returns: ParticleType*

static all() → TissueForge::ParticleTypeList *

returns an instance populated with all current particle types

Return type: ParticleTypeList
Returns: ParticleTypeList*

sphericalPositions(origin: fVector3 = None) → std::vector< TissueForge::FVector3,std::allocator< TissueForge::FVector3 > >

Get the spherical coordinates of each particle

Parameters: origin (FVector3) – optional origin of coordinates; default is center of universe
Return type: std::vector< TissueForge::FVector3,std::allocator< TissueForge::FVector3 > >
Returns: std::vector<FVector3>

toString() → std::string

Get a JSON string representation

Return type: string
Returns: std::string

static fromString(str: std::string const &) → TissueForge::ParticleTypeList *

Create from a JSON string representation

Parameters: str (string) –
Return type: ParticleTypeList
Returns: ParticleTypeList*

__reduce__(): Helper for pickle.

Potentials

class tissue_forge.tissue_forge._Potential

A Potential object is a compiled interpolation of a given function. The Universe applies potentials to particles to calculate the net force on them.

For performance reasons, Tissue Forge implements potentials as interpolations, which can be much faster than evaluating the function directly.

A potential can be treated just like any callable object.

property min: float: Minimum distance of evaluation

property max: float: Maximum distance of evaluation

property cutoff: float: Cutoff distance

property domain: (<class 'float'>, <class 'float'>): Evaluation domain

property intervals: int: Evaluation intervals

property bound: bool: Bound flag

property r0: float: Potential r0 value

property shifted: bool: Shifted flag

property periodic: bool: Periodic flag

property r_square: bool: Potential r2 value

__call__(): Alias of _call

_call(*args) → FPTYPE

plot(s=None, force=True, potential=False, show=True, ymin=None, ymax=None, *args, **kwargs): Potential plot function

toString() → std::string

Get a JSON string representation

Return type: string
Returns: std::string

static fromString(str: std::string const &) → TissueForge::Potential *

Create from a JSON string representation

Parameters: str (string) –
Return type: Potential
Returns: Potential*

__reduce__(): Helper for pickle.

static lennard_jones_12_6(min: FPTYPE, max: FPTYPE, A: FPTYPE, B: FPTYPE, tol: FPTYPE * = None) → TissueForge::Potential *

Creates a 12-6 Lennard-Jones potential.

The Lennard Jones potential has the form:

\[\left( \frac{A}{r^{12}} - \frac{B}{r^6} \right)\]

Parameters

min (float) – The smallest radius for which the potential will be constructed.
max (float) – The largest radius for which the potential will be constructed.
A (float) – The first parameter of the Lennard-Jones potential.
B (float) – The second parameter of the Lennard-Jones potential.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.001 * (max - min).

Return type

Returns

Potential*

static lennard_jones_12_6_coulomb(min: FPTYPE, max: FPTYPE, A: FPTYPE, B: FPTYPE, q: FPTYPE, tol: FPTYPE * = None) → TissueForge::Potential *

Creates a potential of the sum of a 12-6 Lennard-Jones potential and a shifted Coulomb potential.

The 12-6 Lennard Jones - Coulomb potential has the form:

\[\left( \frac{A}{r^{12}} - \frac{B}{r^6} \right) + q \left( \frac{1}{r} - \frac{1}{max} \right)\]

Parameters

min (float) – The smallest radius for which the potential will be constructed.
max (float) – The largest radius for which the potential will be constructed.
A (float) – The first parameter of the Lennard-Jones potential.
B (float) – The second parameter of the Lennard-Jones potential.
q (float) – The charge scaling of the potential.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.001 * (max - min).

Return type

Returns

Potential*

static ewald(min: FPTYPE, max: FPTYPE, q: FPTYPE, kappa: FPTYPE, tol: FPTYPE * = None, periodicOrder: unsigned int * = None) → TissueForge::Potential *

Creates a real-space Ewald potential.

The Ewald potential has the form:

\[q \frac{\mathrm{erfc}\, ( \kappa r)}{r}\]

Parameters

min (float) – The smallest radius for which the potential will be constructed.
max (float) – The largest radius for which the potential will be constructed.
q (float) – The charge scaling of the potential.
kappa (float) – The screening distance of the Ewald potential.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.001 * (max - min).
periodicOrder (int) – Order of lattice periodicity along all periodic dimensions. Defaults to 0.

Return type

Returns

Potential*

static coulomb(q: FPTYPE, min: FPTYPE * = None, max: FPTYPE * = None, tol: FPTYPE * = None, periodicOrder: unsigned int * = None) → TissueForge::Potential *

Creates a Coulomb potential.

The Coulomb potential has the form:

\[\frac{q}{r}\]

Parameters

q (float) – The charge scaling of the potential.
min (float) – The smallest radius for which the potential will be constructed. Default is 0.01.
max (float) – The largest radius for which the potential will be constructed. Default is 2.0.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.001 * (max - min).
periodicOrder (int) – Order of lattice periodicity along all periodic dimensions. Defaults to 0.

Return type

Returns

Potential*

static coulombR(q: FPTYPE, kappa: FPTYPE, min: FPTYPE, max: FPTYPE, modes: unsigned int * = None) → TissueForge::Potential *

Creates a Coulomb reciprocal potential.

The Coulomb reciprocal potential has the form:

\[\frac{\pi q}{V} \sum_{||\mathbf{m}|| \neq 0} \frac{1}{||\mathbf{m}||^2} \exp \left( \left( i \mathbf{r}_{jk} - \left( \frac{\pi}{\kappa} \right)^{2} \mathbf{m} \right) \cdot \mathbf{m} \right)\]

Here \(V\) is the volume of the domain and \(\mathbf{m}\) is a reciprocal vector of the domain.

Parameters

q (float) – Charge scaling of the potential.
kappa (float) – Screening distance.
min (float) – Smallest radius for which the potential will be constructed.
max (float) – Largest radius for which the potential will be constructed.
modes (int) – Number of Fourier modes along each periodic dimension. Default is 1.

Return type

Returns

Potential*

static harmonic(k: FPTYPE, r0: FPTYPE, min: FPTYPE * = None, max: FPTYPE * = None, tol: FPTYPE * = None) → TissueForge::Potential *

Creates a harmonic bond potential.

The harmonic potential has the form:

\[k \left( r-r_0 \right)^2\]

Parameters

k (float) – The energy of the bond.
r0 (float) – The bond rest length.
min (float) – The smallest radius for which the potential will be constructed. Defaults to \(r_0 - r_0 / 2\).
max (float) – The largest radius for which the potential will be constructed. Defaults to \(r_0 + r_0 /2\).
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to \(0.01 \abs(max-min)\).

Return type

Returns

Potential*

static linear(k: FPTYPE, min: FPTYPE * = None, max: FPTYPE * = None, tol: FPTYPE * = None) → TissueForge::Potential *

Creates a linear potential.

The linear potential has the form:

\[k r\]

Parameters

k (float) – interaction strength; represents the potential energy peak value.
min (float) – The smallest radius for which the potential will be constructed. Defaults to 0.0.
max (float) – The largest radius for which the potential will be constructed. Defaults to 10.0.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.001.

Return type

Returns

Potential*

static harmonic_angle(k: FPTYPE, theta0: FPTYPE, min: FPTYPE * = None, max: FPTYPE * = None, tol: FPTYPE * = None) → TissueForge::Potential *

Creates a harmonic angle potential.

The harmonic angle potential has the form:

\[k \left(\theta-\theta_{0} \right)^2\]

Parameters

k (float) – The energy of the angle.
theta0 (float) – The minimum energy angle.
min (float) – The smallest angle for which the potential will be constructed. Defaults to zero.
max (float) – The largest angle for which the potential will be constructed. Defaults to PI.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.005 * (max - min).

Return type

Returns

Potential*

static harmonic_dihedral(k: FPTYPE, delta: FPTYPE, min: FPTYPE * = None, max: FPTYPE * = None, tol: FPTYPE * = None) → TissueForge::Potential *

Creates a harmonic dihedral potential.

The harmonic dihedral potential has the form:

\[k \left( \theta - \delta \right) ^2\]

Parameters

k (float) – energy of the dihedral.
delta (float) – minimum energy dihedral.
min (float) – The smallest angle for which the potential will be constructed. Defaults to zero.
max (float) – The largest angle for which the potential will be constructed. Defaults to PI.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.005 * (max - min).

Return type

Returns

Potential*

static cosine_dihedral(k: FPTYPE, n: int, delta: FPTYPE, tol: FPTYPE * = None) → TissueForge::Potential *

Creates a cosine dihedral potential.

The cosine dihedral potential has the form:

\[k \left( 1 + \cos( n \theta-\delta ) \right)\]

Parameters

k (float) – energy of the dihedral.
n (int) – multiplicity of the dihedral.
delta (float) – minimum energy dihedral.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.01.

Return type

Returns

Potential*

static well(k: FPTYPE, n: FPTYPE, r0: FPTYPE, min: FPTYPE * = None, max: FPTYPE * = None, tol: FPTYPE * = None) → TissueForge::Potential *

Creates a well potential.

Useful for binding a particle to a region.

The well potential has the form:

\[\frac{k}{\left(r_0 - r\right)^{n}}\]

Parameters

k (float) – potential prefactor constant, should be decreased for larger n.
n (float) – exponent of the potential, larger n makes a sharper potential.
r0 (float) – The extents of the potential, length units. Represents the maximum extents that a two objects connected with this potential should come apart.
min (float) – The smallest radius for which the potential will be constructed. Defaults to zero.
max (float) – The largest radius for which the potential will be constructed. Defaults to r0.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.01 * abs(min-max).

Return type

Returns

Potential*

static glj(e: FPTYPE, m: FPTYPE * = None, n: FPTYPE * = None, k: FPTYPE * = None, r0: FPTYPE * = None, min: FPTYPE * = None, max: FPTYPE * = None, tol: FPTYPE * = None, shifted: bool * = None) → TissueForge::Potential *

Creates a generalized Lennard-Jones potential.

The generalized Lennard-Jones potential has the form:

\[\frac{\epsilon}{n-m} \left[ m \left( \frac{r_0}{r} \right)^n - n \left( \frac{r_0}{r} \right)^m \right]\]

Parameters

e (float) – effective energy of the potential.
m (float) – order of potential. Defaults to 3
n (float) – order of potential. Defaults to 2*m.
k (float) – mimumum of the potential. Defaults to 1.
r0 (float) – mimumum of the potential. Defaults to 1.
min (float) – The smallest radius for which the potential will be constructed. Defaults to 0.05 * r0.
max (float) – The largest radius for which the potential will be constructed. Defaults to 5 * r0.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.01.
shifted (boolean) – Flag for whether using a shifted potential. Defaults to true.

Return type

Returns

Potential*

static morse(d: FPTYPE * = None, a: FPTYPE * = None, r0: FPTYPE * = None, min: FPTYPE * = None, max: FPTYPE * = None, tol: FPTYPE * = None, shifted: bool * = None) → TissueForge::Potential *

Creates a Morse potential.

The Morse potential has the form:

\[d \left(1 - e^{ -a \left(r - r_0 \right) } \right)^2\]

Parameters

d (float) – well depth. Defaults to 1.0.
a (float) – potential width. Defaults to 6.0.
r0 (float) – equilibrium distance. Defaults to 0.0.
min (float) – The smallest radius for which the potential will be constructed. Defaults to 0.0001.
max (float) – The largest radius for which the potential will be constructed. Defaults to 3.0.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.001.
shifted (boolean) – Flag for whether using a shifted potential. Defaults to true.

Return type

Returns

Potential*

static overlapping_sphere(mu: FPTYPE * = None, kc: FPTYPE * = None, kh: FPTYPE * = None, r0: FPTYPE * = None, min: FPTYPE * = None, max: FPTYPE * = None, tol: FPTYPE * = None) → TissueForge::Potential *

Creates an overlapping-sphere potential from [OFPF+17].

The overlapping-sphere potential has the form:

\[\mu_{ij} s_{ij}(t) \hat{\mathbf{r}}_{ij} \log \left( 1 + \frac{||\mathbf{r}_{ij}|| - s_{ij}(t)}{s_{ij}(t)} \right) \text{ if } ||\mathbf{r}_{ij}|| < s_{ij}(t) ,\]

\[\mu_{ij}\left(||\mathbf{r}_{ij}|| - s_{ij}(t)\right) \hat{\mathbf{r}}_{ij} \exp \left( -k_c \frac{||\mathbf{r}_{ij}|| - s_{ij}(t)}{s_{ij}(t)} \right) \text{ if } s_{ij}(t) \leq ||\mathbf{r}_{ij}|| \leq r_{max} ,\]

\[0 \text{ otherwise} .\]

Osborne refers to \(\mu_{ij}\) as a “spring constant”, this controls the size of the force, and is the potential energy peak value. \(\hat{\mathbf{r}}_{ij}\) is the unit vector from particle \(i\) center to particle \(j\) center, \(k_C\) is a parameter that defines decay of the attractive force. Larger values of \(k_C\) result in a shaper peaked attraction, and thus a shorter ranged force. \(s_{ij}(t)\) is the is the sum of the radii of the two particles.

Parameters

mu (float) – interaction strength, represents the potential energy peak value. Defaults to 1.0.
kc (float) – decay strength of long range attraction. Larger values make a shorter ranged function. Defaults to 1.0.
kh (float) – Optionally add a harmonic long-range attraction, same as glj function. Defaults to 0.0.
r0 (float) – Optional harmonic rest length, only used if kh is non-zero. Defaults to 0.0.
min (float) – The smallest radius for which the potential will be constructed. Defaults to 0.001.
max (float) – The largest radius for which the potential will be constructed. Defaults to 10.0.
tol (float) – The tolerance to which the interpolation should match the exact potential. Defaults to 0.001.

Return type

Returns

Potential*

static power(k: FPTYPE * = None, r0: FPTYPE * = None, alpha: FPTYPE * = None, min: FPTYPE * = None, max: FPTYPE * = None, tol: FPTYPE * = None) → TissueForge::Potential *

Creates a power potential.

The power potential the general form of many of the potential functions, such as linear, etc. power has the form:

\[k (r-r_0)^{\alpha}\]

Parameters

k (float) – interaction strength, represents the potential energy peak value. Defaults to 1
r0 (float) – potential rest length, zero of the potential, defaults to 0.
alpha (float) – Exponent, defaults to 1.
min (float) – minimal value potential is computed for, defaults to r0 / 2.
max (float) – cutoff distance, defaults to 3 * r0.
tol (float) – Tolerance, defaults to 0.01.

Return type

Returns

Potential*

static dpd(alpha: FPTYPE * = None, gamma: FPTYPE * = None, sigma: FPTYPE * = None, cutoff: FPTYPE * = None, shifted: bool * = None) → TissueForge::Potential *

Creates a Dissipative Particle Dynamics potential.

The Dissipative Particle Dynamics force has the form:

\[\mathbf{F}_{ij} = \mathbf{F}^C_{ij} + \mathbf{F}^D_{ij} + \mathbf{F}^R_{ij}\]

The conservative force is:

\[\mathbf{F}^C_{ij} = \alpha \left(1 - \frac{r_{ij}}{r_c}\right) \mathbf{e}_{ij}\]

The dissapative force is:

\[\mathbf{F}^D_{ij} = -\gamma \left(1 - \frac{r_{ij}}{r_c}\right)^{2}(\mathbf{e}_{ij} \cdot \mathbf{v}_{ij}) \mathbf{e}_{ij}\]

The random force is:

\[\mathbf{F}^R_{ij} = \sigma \left(1 - \frac{r_{ij}}{r_c}\right) \xi_{ij}\Delta t^{-1/2}\mathbf{e}_{ij}\]

Parameters

alpha (float) – interaction strength of the conservative force. Defaults to 1.0.
gamma (float) – interaction strength of dissapative force. Defaults to 1.0.
sigma (float) – strength of random force. Defaults to 1.0.
cutoff (float) – cutoff distance. Defaults to 1.0.
shifted (boolean) – Flag for whether using a shifted potential. Defaults to false.

Return type

Returns

Potential*

class tissue_forge.tissue_forge.Potential

Bases: _Potential

custom = <function Potential.custom>

class tissue_forge.tissue_forge.DPDPotential(alpha: FPTYPE, gamma: FPTYPE, sigma: FPTYPE, cutoff: FPTYPE, shifted: bool)

Bases: _Potential

alpha: strength of conserative interaction

gamma: strength of dissapative interaction

sigma: strength of random interaction

static fromPot(pot: _Potential) → TissueForge::DPDPotential *

Convert basic potential to DPD.

If the basic potential is not DPD, then NULL is returned.

Parameters: pot (Potential) –
Return type: DPDPotential
Returns: DPDPotential*

toString() → std::string

Get a JSON string representation

Return type: string
Returns: std::string

static fromString(str: std::string const &) → TissueForge::DPDPotential *

Create from a JSON string representation

Parameters: str (string) –
Return type: DPDPotential
Returns: Potential*

__reduce__(): Helper for pickle.

Forces

class tissue_forge.tissue_forge.Force

Force is a metatype, in that Tissue Forge has lots of different instances of force functions, that have different attributes, but only have one base type.

Forces are one of the fundamental processes in Tissue Forge that cause objects to move.

bind_species(a_type: ParticleType, coupling_symbol: std::string const &) → HRESULT

Bind a force to a species.

When a force is bound to a species, the magnitude of the force is scaled by the concentration of the species.

Parameters

a_type (ParticleType) – particle type containing the species
coupling_symbol (string) – symbol of the species

Return type

int

Returns

HRESULT

static berendsen_tstat(tau: FPTYPE const &) → TissueForge::Berendsen *

Creates a Berendsen thermostat.

The thermostat uses the target temperature \(T_0\) from the object to which it is bound. The Berendsen thermostat effectively re-scales the velocities of an object in order to make the temperature of that family of objects match a specified temperature.

The Berendsen thermostat force has the function form:

\[\frac{\mathbf{p}}{\tau_T} \left(\frac{T_0}{T} - 1 \right),\]

where \(\mathbf{p}\) is the momentum, \(T\) is the measured temperature of a family of particles, \(T_0\) is the control temperature, and \(\tau_T\) is the coupling constant. The coupling constant is a measure of the time scale on which the thermostat operates, and has units of time. Smaller values of \(\tau_T\) result in a faster acting thermostat, and larger values result in a slower acting thermostat.

Parameters: tau (float) – time constant that determines how rapidly the thermostat effects the system.
Return type: Berendsen
Returns: Berendsen*

static random(std: FPTYPE const &, mean: FPTYPE const &, duration: FPTYPE const & = 0.01) → TissueForge::Gaussian *

Creates a random force.

A random force has a randomly selected orientation and magnitude.

Orientation is selected according to a uniform distribution on the unit sphere.

Magnitude is selected according to a prescribed mean and standard deviation.

Parameters

std (float) – standard deviation of magnitude
mean (float) – mean of magnitude
duration (float) – duration of force. Defaults to 0.01.

Return type

Gaussian

Returns

Gaussian*

static friction(coef: FPTYPE const &) → TissueForge::Friction *

Creates a friction force.

A friction force has the form:

\[- \frac{|| \mathbf{v} ||}{\tau} \mathbf{v} ,\]

where \(\mathbf{v}\) is the velocity of a particle and \(\tau\) is a time constant.

Parameters: coef (float) – time constant
Return type: Friction
Returns: Friction*

toString() → std::string

Get a JSON string representation

Return type: string
Returns: std::string

static fromString(str: std::string const &) → TissueForge::Force *

Create from a JSON string representation

Parameters: str (string) –
Return type: Force
Returns: Force*

__reduce__(): Helper for pickle.

class tissue_forge.tissue_forge._CustomForce(*args)

Bases: Force

A custom force function.

The force is updated according to an update frequency.

static fromForce(f: Force) → TissueForge::CustomForce *

Convert basic force to CustomForce.

If the basic force is not a CustomForce, then NULL is returned.

Parameters: f (Force) –
Return type: CustomForce
Returns: CustomForce*

class tissue_forge.tissue_forge.CustomForce(*args)

Bases: _CustomForce

Creates an instance from an underlying custom python function

Parameters

f (PyObject) – python function. Takes no arguments and returns a three-component vector.
period (float) – period at which the force is updated.

property value

Current value of the force.

This can be set to a function that takes no arguments and returns a 3-component list of floats.

property period: Period of the force

static fromForce(f: Force) → TissueForge::py::CustomForcePy *

Convert basic force to CustomForcePy.

If the basic force is not a CustomForcePy, then NULL is returned.

Parameters: f (Force) –
Return type: CustomForcePy
Returns: CustomForcePy*

class tissue_forge.tissue_forge.ForceSum

Bases: Force

f1

f2

static fromForce(f: Force) → TissueForge::ForceSum *

Convert basic force to force sum.

If the basic force is not a force sum, then NULL is returned.

Parameters: f (Force) –
Return type: ForceSum
Returns: ForceSum*

class tissue_forge.tissue_forge.Berendsen

Bases: Force

Berendsen force.

Create one with Force.berendsen_tstat.

itau: time constant

static fromForce(f: Force) → TissueForge::Berendsen *

Convert basic force to Berendsen.

If the basic force is not a Berendsen, then NULL is returned.

Parameters: f (Force) –
Return type: Berendsen
Returns: Berendsen*

class tissue_forge.tissue_forge.Gaussian

Bases: Force

Random force.

Create one with Force.random.

std: standard deviation of magnitude

mean: mean of magnitude

durration_steps: duration of force.

static fromForce(f: Force) → TissueForge::Gaussian *

Convert basic force to Gaussian.

If the basic force is not a Gaussian, then NULL is returned.

Parameters: f (Force) –
Return type: Gaussian
Returns: Gaussian*

class tissue_forge.tissue_forge.Friction

Bases: Force

Friction force.

Create one with Force.friction.

coef: time constant

static fromForce(f: Force) → TissueForge::Friction *

Convert basic force to Friction.

If the basic force is not a Friction, then NULL is returned.

Parameters: f (Force) –
Return type: Friction
Returns: Friction*

Fluxes

class tissue_forge.Fluxes

A flux is defined between a pair of types, and acts on the state vector between a pair of instances.

The indices of the species in each state vector are most likely different, so Tissue Forge tracks the indices in each type, and the transport constatants.

A flux between a pair of types, and pair of respective species needs:

(1) type A, (2) type B, (3) species id in A, (4) species id in B, (5) transport constant.

Allocates Flux as a single block, member pointers point to offsets in these blocks.

Allocated size is: sizeof(Fluxes) + 2 * alloc_size * sizeof(int32) + alloc_size * sizeof(FPTYPE)

static flux(A: ParticleType, B: ParticleType, name: std::string const &, k: FPTYPE const &, decay: FPTYPE const & = 0.0) → TissueForge::Fluxes *

Alias of fluxFick.

Parameters

A (ParticleType) – first type
B (ParticleType) – second type
name (string) – name of species
k (float) – transport coefficient
decay (float) – optional decay. Defaults to 0.0.

Return type

Returns

Fluxes*

static fluxFick(A: ParticleType, B: ParticleType, name: std::string const &, k: FPTYPE const &, decay: FPTYPE const & = 0.0) → TissueForge::Fluxes *

Creates and binds a Fickian diffusion flux.

Fickian diffusion flux implements the analogous reaction:

\[a.S \leftrightarrow b.S ; k \left(1 - \frac{r}{r_{cutoff}} \right)\left(a.S - b.S\right) ,\]

\[a.S \rightarrow 0 ; \frac{d}{2} a.S ,\]

\[b.S \rightarrow 0 ; \frac{d}{2} b.S ,\]

where \(a.S\) is a chemical species located at object \(a\), and likewise for \(b\), \(k\) is the flux constant, \(r\) is the distance between the two objects, \(r_{cutoff}\) is the global cutoff distance, and \(d\) is an optional decay term.

Automatically updates when running on a CUDA device.

Parameters

A (ParticleType) – first type
B (ParticleType) – second type
name (string) – name of species
k (float) – transport coefficient
decay (float) – optional decay. Defaults to 0.0.

Return type

Returns

Fluxes*

static secrete(A: ParticleType, B: ParticleType, name: std::string const &, k: FPTYPE const &, target: FPTYPE const &, decay: FPTYPE const & = 0.0) → TissueForge::Fluxes *

Creates a secretion flux by active pumping.

Secretion flux implements the analogous reaction:

\[a.S \rightarrow b.S ; k \left(1 - \frac{r}{r_{cutoff}} \right)\left(a.S - a.S_{target} \right) ,\]

\[a.S \rightarrow 0 ; \frac{d}{2} a.S ,\]

\[b.S \rightarrow 0 ; \frac{d}{2} b.S ,\]

where \(a.S\) is a chemical species located at object \(a\), and likewise for \(b\), \(k\) is the flux constant, \(r\) is the distance between the two objects, \(r_{cutoff}\) is the global cutoff distance, and \(d\) is an optional decay term.

Automatically updates when running on a CUDA device.

Parameters

A (ParticleType) – first type
B (ParticleType) – second type
name (string) – name of species
k (float) – transport coefficient
target (float) – target concentration
decay (float) – optional decay. Defaults to 0.0

Return type

Returns

Fluxes*

static uptake(A: ParticleType, B: ParticleType, name: std::string const &, k: FPTYPE const &, target: FPTYPE const &, decay: FPTYPE const & = 0.0) → TissueForge::Fluxes *

Creates an uptake flux by active pumping.

Uptake flux implements the analogous reaction:

\[a.S \rightarrow b.S ; k \left(1 - \frac{r}{r_{cutoff}}\right)\left(b.S - b.S_{target} \right)\left(a.S\right) ,\]

\[a.S \rightarrow 0 ; \frac{d}{2} a.S ,\]

\[b.S \rightarrow 0 ; \frac{d}{2} b.S ,\]

where \(a.S\) is a chemical species located at object \(a\), and likewise for \(b\), \(k\) is the flux constant, \(r\) is the distance between the two objects, \(r_{cutoff}\) is the global cutoff distance, and \(d\) is an optional decay term.

Automatically updates when running on a CUDA device.

Parameters

A (ParticleType) – first type
B (ParticleType) – second type
name (string) – name of species
k (float) – transport coefficient
target (float) – target concentration
decay (float) – optional decay. Defaults to 0.0

Return type