TVB DataTypes, as a dictionary between multiple algorithms.
The Connectivity datatype.
Bases: tvb.basic.neotraits._core.HasTraits
parent_connectivity : tvb.datatypes.connectivity.Connectivity.parent_connectivity = Attr(field_type=<class ‘str’>, default=None, required=False)
saved_selection : tvb.datatypes.connectivity.Connectivity.saved_selection = List(of=<class ‘int’>, default=(), required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
| Returns: | a matrix of he same size as weights, with 1 where weight > 0, and 0 in rest |
|---|
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
The nodes are lying inside an annulus.
The nodes are positioined in a 3D grid inside the cube centred at the origin and with edges parallel to the axes, with an edge length of 2*max_radius.
The nodes positions are distributed on a sphere. See: http://mathworld.wolfram.com/SphericalCoordinates.html
If flat is true, then theta=0.0, the nodes are lying inside a circle.
r : radial theta: azimuthal polar: phi
The nodes are lying on a torus. See: http://mathworld.wolfram.com/Torus.html
If no tract lengths data are available, this can be used to calculate the Euclidean distance between region centres to use as a proxy.
Invoke the compute methods for computable attributes that haven’t been set during initialization.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Overwrite from superclass and add number of regions field (as title on DataStructure tree)
This one generates some defaults. For more specific motifs, generate invoking each method separetly.
A sequence of indices of rows/colums. These permute rows/columns so that the first half would belong to the first hemisphere If there is no hemisphere information returns the identity permutation
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
| Parameters: | idx – Region IDX |
|---|---|
| Returns: | True when hemispheres information is present and it shows that the current node is in the right |
hemisphere. When hemispheres info is not present, return True for the second half of the indices and False otherwise.
Generates an all-to-all closed unweighted undirected graph with equidistant nodes. Self-connections are not included.
Generates a closed unweighted directed graph with equidistant nodes. Depending on the centres it could be a box or a ring.
Generates a closed unweighted undirected graph with equidistant nodes. Depending on the centres it could be a box or a ring.
Generates a linear (open chain) unweighted directed graph with equidistant nodes.
Generates a linear (open chain) unweighted undirected graph with equidistant nodes.
Declares an integer This is different from Attr(field_type=int). The former enforces int subtypes This allows all integer types, including numpy ones that can be safely cast to the declared type according to numpy rules
Declares an integer This is different from Attr(field_type=int). The former enforces int subtypes This allows all integer types, including numpy ones that can be safely cast to the declared type according to numpy rules
Similar to :method:`ordered_weights`
Similar to ordered_weights()
Similar to ordered_weights()
This view of the weights matrix lists all left hemisphere nodes before the right ones. It is used by viewers of the connectivity.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it
Taking the entity field saved_selection, convert indexes in that array into labels.
Scale the connection strengths (weights) and return the scaled matrix. Three simple types of scaling are supported. The scaling_mode is one of the following:
- ‘tract’: Scale by a value such that the maximum absolute value of a single
- connection is 1.0. (Global scaling)
- ‘region’: Scale by a value such that the maximum absolute value of the
- cumulative input to any region is 1.0. (Global-wise scaling)
None: does nothing.
Convert the time delays between regions in physical units into an array of linear indices into the simulator’s history attribute.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Transforms the weights matrix into a binary (unweighted) matrix
Remove the values from the main diagonal (self-connections)
If all region labels are prefixed with L or R, then compute hemisphere side with that.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Compute vector of indices of regions in connectivity which are not in the given region mapping.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Bases: tvb.basic.neotraits._core.HasTraits
Wrapper Class to gather necessary entities for a surface-based simulation. To be used when preparing a simulation launch.
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Invoke the compute methods for computable attributes that haven’t been set during initialisation.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Define shortcut for retrieving the number of triangles of the surface held by a RegionMapping.
Define shortcut for retrieving the number of vertices of the surface held by a RegionMapping.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Define shortcut for retrieving the triangles of the surface held by a RegionMapping.
The Equation datatypes.
Bases: tvb.datatypes.equations.TemporalApplicableEquation
An Alpha function belonging to the Exponential function family.
parameters : tvb.datatypes.equations.Alpha.parameters = Attr(field_type=<class ‘dict’>, default=<function Alpha.<lambda> at 0x7f71b3cc6b00>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.TemporalApplicableEquation
A Cosine equation.
parameters : tvb.datatypes.equations.Cosine.parameters = Attr(field_type=<class ‘dict’>, default=<function Cosine.<lambda> at 0x7f71b3cc6a70>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.FiniteSupportEquation
A special case for ‘discrete’ spaces, such as the regions, where each point in the space is effectively just assigned a value.
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.HRFKernelEquation
A difference of two exponential functions to define a kernel for the bold monitor.
Parameters :
- \(\tau_1\): Time constant of the second exponential function [s]
- \(\tau_2\): Time constant of the first exponential function [s].
- \(f_1\) : Frequency of the first sine function [Hz].
- \(f_2\) : Frequency of the second sine function [Hz].
- \(amp_1\): Amplitude of the first exponential function.
- \(amp_2\): Amplitude of the second exponential function.
- \(a\) : Amplitude factor after normalization.
Reference:
[P_2000] Alex Polonsky, Randolph Blake, Jochen Braun and David J. Heeger (2000). Neuronal activity in human primary visual cortex correlates with perception during binocular rivalry. Nature Neuroscience 3: 1153-1159
parameters : tvb.datatypes.equations.DoubleExponential.parameters = Attr(field_type=<class ‘dict’>, default=<function DoubleExponential.<lambda> at 0x7f71b3cc6dd0>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
Generate a discrete representation of the equation for the space represented by var.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.FiniteSupportEquation
A Mexican-hat function approximated by the difference of Gaussians functions.
parameters : tvb.datatypes.equations.DoubleGaussian.parameters = Attr(field_type=<class ‘dict’>, default=<function DoubleGaussian.<lambda> at 0x7f71b3cc67a0>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.basic.neotraits._core.HasTraits
Base class for Equation data types.
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Builds from the given data dictionary the equation for the specified field name. The dictionary should have the data collapsed.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Generate a discrete representation of the equation for the space represented by var.
The argument var can represent a distance, or effective distance, for each node in a simulation. Or a time, or in principle any arbitrary `` space . ``var can be a single number, a numpy.ndarray or a ?scipy.sparse_matrix? TODO: think this last one is true, need to check as we need it for LocalConnectivity...
Retrieves an instance to an equation represented as JSON.
| Parameters: | string – the JSON representation of the equation |
|---|---|
| Returns: | a tvb.datatypes.equations_data equation instance |
NOTE: The symbol from the equation which varies should be named: var Returns the series data needed for plotting this equation.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.TemporalApplicableEquation
Equations that decay to zero as the variable moves away from zero. It is necessary to restrict spatial equation evaluated on a surface to this class, are . The main purpose of this class is to facilitate filtering in the UI, for patters on surface (stimuli surface and localConnectivity).
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Bases: tvb.datatypes.equations.HRFKernelEquation
Integral form of the first Volterra kernel of the three used in the Ballon Windekessel model for computing the Bold signal. This function describes a damped Oscillator.
Parameters :
- \(\tau_s\): Dimensionless? exponential decay parameter.
- \(\tau_f\): Dimensionless? oscillatory parameter.
- \(k_1\) : First Volterra kernel coefficient.
- \(V_0\) : Resting blood volume fraction.
References :
[F_2000] Friston, K., Mechelli, A., Turner, R., and Price, C., Nonlinear Responses in fMRI: The Balloon Model, Volterra Kernels, and Other Hemodynamics, NeuroImage, 12, 466 - 477, 2000.
parameters : tvb.datatypes.equations.FirstOrderVolterra.parameters = Attr(field_type=<class ‘dict’>, default=<function FirstOrderVolterra.<lambda> at 0x7f71b3cc6ef0>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.HRFKernelEquation
A Gamma function for the bold monitor. It belongs to the family of Exponential functions.
Parameters:
\(\tau\) : Exponential time constant of the gamma function [seconds].
\(n\) : The phase delay of the gamma function.
math: factorial : (n-1)!. numexpr does not support factorial yet.
math: a : Amplitude factor after normalization. Reference:
[B_1996] Geoffrey M. Boynton, Stephen A. Engel, Gary H. Glover and David J. Heeger (1996). Linear Systems Analysis of Functional Magnetic Resonance Imaging in Human V1. J Neurosci 16: 4207-4221 Note
might be filtered from the equations used in Stimulus and Local Connectivity.
parameters : tvb.datatypes.equations.Gamma.parameters = Attr(field_type=<class ‘dict’>, default=<function Gamma.<lambda> at 0x7f71b3cc6c20>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
Generate a discrete representation of the equation for the space represented by var.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.SpatialApplicableEquation, tvb.datatypes.equations.FiniteSupportEquation
A Gaussian equation. offset: parameter to extend the behaviour of this function when spatializing model parameters.
parameters : tvb.datatypes.equations.Gaussian.parameters = Attr(field_type=<class ‘dict’>, default=<function Gaussian.<lambda> at 0x7f71b3cc6680>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.TemporalApplicableEquation
A General Sigmoid equation.
parameters : tvb.datatypes.equations.GeneralizedSigmoid.parameters = Attr(field_type=<class ‘dict’>, default=<function GeneralizedSigmoid.<lambda> at 0x7f71b3cc6950>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.Equation
Base class for hemodynamic response functions.
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Bases: tvb.datatypes.equations.TemporalApplicableEquation
A linear equation.
parameters : tvb.datatypes.equations.Linear.parameters = Attr(field_type=<class ‘dict’>, default=<function Linear.<lambda> at 0x7f71b3cc65f0>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.HRFKernelEquation
A mixture of two gamma distributions to create a kernel similar to the one used in SPM.
>> import scipy.stats as sp_stats >> import numpy >> t = numpy.linspace(1,20,100) >> a1, a2 = 6., 10. >> lambda = 1. >> c = 0.5 >> hrf = sp_stats.gamma.pdf(t, a1, lambda) - c * sp_stats.gamma.pdf(t, a2, lambda)
gamma.pdf(x, a, theta) = (lambda*x)**(a-1) * exp(-lambda*x) / gamma(a) a : shape parameter theta: 1 / lambda : scale parameter
References:
[G_1999] (1, 2) Glover, G. Deconvolution of Impulse Response in Event-Related BOLD fMRI. NeuroImage 9, 416-429, 1999. Parameters:
- \(a_{1}\) : shape parameter first gamma pdf.
- \(a_{2}\) : shape parameter second gamma pdf.
- \(\lambda\) : scale parameter first gamma pdf.
Default values are based on [G_1999]: * \(a_{1} - 1 = n_{1} = 5.0\) * \(a_{2} - 1 = n_{2} = 12.0\) * \(c \equiv a_{2} = 0.4\)
Alternative values \(a_{2}=10\) and \(c=0.5\)
NOTE: gamma_a_1 and gamma_a_2 are placeholders, the true values are computed before evaluating the expression, because numexpr does not support certain functions.
NOTE: [G_1999] used a different analytical function that can be approximated by this difference of gamma pdfs
parameters : tvb.datatypes.equations.MixtureOfGammas.parameters = Attr(field_type=<class ‘dict’>, default=<function MixtureOfGammas.<lambda> at 0x7f71b3cc6f80>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
Generate a discrete representation of the equation for the space represented by var.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.TemporalApplicableEquation
A pulse train , offset with respect to the time axis.
Parameters:
- \(\tau\) : pulse width or pulse duration
- \(T\) : pulse repetition period
- \(f\) : pulse repetition frequency (1/T)
- duty cycle : :math:\frac{\tau}{T} (for a square wave: 0.5)
- onset time :
parameters : tvb.datatypes.equations.PulseTrain.parameters = Attr(field_type=<class ‘dict’>, default=<function PulseTrain.<lambda> at 0x7f71b3cc6b90>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
Generate a discrete representation of the equation for the space represented by var.
The argument var can represent a distance, or effective distance, for each node in a simulation. Or a time, or in principle any arbitrary `` space . ``var can be a single number, a numpy.ndarray or a ?scipy.sparse_matrix? TODO: think this last one is true, need to check as we need it for LocalConnectivity...
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.SpatialApplicableEquation, tvb.datatypes.equations.FiniteSupportEquation
A Sigmoid equation. offset: parameter to extend the behaviour of this function when spatializing model parameters.
parameters : tvb.datatypes.equations.Sigmoid.parameters = Attr(field_type=<class ‘dict’>, default=<function Sigmoid.<lambda> at 0x7f71b3cc6830>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.TemporalApplicableEquation
A Sinusoid equation.
parameters : tvb.datatypes.equations.Sinusoid.parameters = Attr(field_type=<class ‘dict’>, default=<function Sinusoid.<lambda> at 0x7f71b3cc69e0>, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.equations.Equation
Abstract class introduced just for filtering what equations to be displayed in UI, for setting model parameters on the Surface level.
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Bases: tvb.datatypes.equations.Equation
Abstract class introduced just for filtering what equations to be displayed in UI, for setting the temporal component in Stimulus on region and surface.
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Adapter that uses the traits module to generate interfaces for ... Analyzer.
Bases: tvb.basic.neotraits._core.HasTraits
array_data : tvb.datatypes.fcd.Fcd.array_data = NArray(label=’‘, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
Gather scientifically interesting summary information from an instance of this datatype.
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
The Graph datatypes.
Bases: tvb.basic.neotraits._core.HasTraits
Measurement of based on a connectivity.
array_data : tvb.datatypes.graph.ConnectivityMeasure.array_data = NArray(label=’‘, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
connectivity : tvb.datatypes.graph.ConnectivityMeasure.connectivity = Attr(field_type=<class ‘tvb.datatypes.connectivity.Connectivity’>, default=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.basic.neotraits._core.HasTraits
Correlation coefficients datatype.
array_data : tvb.datatypes.graph.CorrelationCoefficients.array_data = NArray(label=’‘, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.basic.neotraits._core.HasTraits
Covariance datatype.
array_data : tvb.datatypes.graph.Covariance.array_data = NArray(label=’‘, dtype=complex128, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.basic.neotraits._core.HasTraits
A sparse matrix for representing the local connectivity within the Cortex.
surface : tvb.datatypes.local_connectivity.LocalConnectivity.surface = Attr(field_type=<class ‘tvb.datatypes.surfaces.Surface’>, default=None, required=True)
matrix : tvb.datatypes.local_connectivity.LocalConnectivity.matrix = Attr(field_type=<class ‘scipy.sparse.base.spmatrix’>, default=None, required=False)
equation : tvb.datatypes.local_connectivity.LocalConnectivity.equation = Attr(field_type=<class ‘tvb.datatypes.equations.FiniteSupportEquation’>, default=<tvb.datatypes.equations.Gaussian object at 0x7f71b45ee750>, required=False)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
NOTE: Before calling this method, the surface field should already be set on the local connectivity.
Computes the sparse matrix for this local connectivity.
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Retrieve the minimum and maximum values from the metadata. :returns: (minimum_value, maximum_value)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Gather scientifically interesting summary information from an instance of this datatype.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
The LookUpTable datatype.
Bases: tvb.basic.neotraits._core.HasTraits
Lookup Tables for storing pre-computed functions. Specific table subclasses are implemented below.
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Invoke the compute methods for computable attributes that haven’t been set during initialization.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares an integer This is different from Attr(field_type=int). The former enforces int subtypes This allows all integer types, including numpy ones that can be safely cast to the declared type according to numpy rules
Gather scientifically interesting summary information from an instance of this dataType, if any ...
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Bases: tvb.datatypes.lookup_tables.LookUpTable
Look up table containing the values of Nerf integral within the \(\phi\) function that describes how the discharge rate vary as a function of parameters defining the statistical properties of the membrane potential in presence of synaptic inputs.
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Bases: tvb.datatypes.lookup_tables.LookUpTable
Look up table containing the values of a function representing the time-averaged gating variable \(\psi(\nu)\) as a function of the presynaptic rates \(\nu\)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
The Mode Decomposition datatypes.
Bases: tvb.basic.neotraits._core.HasTraits
Result of an Independent Component Analysis.
prewhitening_matrix : tvb.datatypes.mode_decompositions.IndependentComponents.prewhitening_matrix = NArray(label=’Pre-whitening matrix’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
norm_source : tvb.datatypes.mode_decompositions.IndependentComponents.norm_source = NArray(label=’Normalised source time series. Zero centered and whitened.’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
component_time_series : tvb.datatypes.mode_decompositions.IndependentComponents.component_time_series = NArray(label=’Component time series. Unmixed sources.’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
normalised_component_time_series : tvb.datatypes.mode_decompositions.IndependentComponents.normalised_component_time_series = NArray(label=’Normalised component time series’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Compute the linear mixing matrix A, so X = A * S , where X is the observed data and S contain the independent components
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares an integer This is different from Attr(field_type=int). The former enforces int subtypes This allows all integer types, including numpy ones that can be safely cast to the declared type according to numpy rules
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Gather scientifically interesting summary information from an instance of this datatype.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Bases: tvb.basic.neotraits._core.HasTraits
Result of a Principal Component Analysis (PCA).
norm_source : tvb.datatypes.mode_decompositions.PrincipalComponents.norm_source = NArray(label=’Normalised source time series’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
component_time_series : tvb.datatypes.mode_decompositions.PrincipalComponents.component_time_series = NArray(label=’Component time series’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
normalised_component_time_series : tvb.datatypes.mode_decompositions.PrincipalComponents.normalised_component_time_series = NArray(label=’Normalised component time series’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Gather scientifically interesting summary information from an instance of this datatype.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
The Pattern datatypes.
Bases: tvb.basic.neotraits._core.HasTraits
Equation for space variation.
spatial : tvb.datatypes.patterns.SpatialPattern.spatial = Attr(field_type=<class ‘tvb.datatypes.equations.FiniteSupportEquation’>, default=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Stores the distance vector as an attribute of the spatiotemporal pattern and uses it to generate the spatial pattern vector.
Depending on equations used and interpretation distance can be an actual physical distance, on a surface, geodesic distance (along the surface) away for some focal point, or a per node weighting...
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.patterns.SpatialPattern
A spatio-temporal pattern defined in a volume.
volume : tvb.datatypes.patterns.SpatialPatternVolume.volume = Attr(field_type=<class ‘tvb.datatypes.volumes.Volume’>, default=None, required=True)
focal_points_volume : tvb.datatypes.patterns.SpatialPatternVolume.focal_points_volume = NArray(label=’Focal points’, dtype=int64, default=None, dim_names=(), ndim=None, required=True)
spatial : tvb.datatypes.patterns.SpatialPattern.spatial = Attr(field_type=<class ‘tvb.datatypes.equations.FiniteSupportEquation’>, default=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.patterns.SpatialPattern
Combine space and time equations.
temporal : tvb.datatypes.patterns.SpatioTemporalPattern.temporal = Attr(field_type=<class ‘tvb.datatypes.equations.TemporalApplicableEquation’>, default=None, required=True)
spatial : tvb.datatypes.patterns.SpatialPattern.spatial = Attr(field_type=<class ‘tvb.datatypes.equations.FiniteSupportEquation’>, default=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Stores the time vector, physical units (ms), as an attribute of the spatio-temporal pattern and uses it to generate the temporal pattern vector.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.patterns.SpatioTemporalPattern
A class that bundles the temporal profile of the stimulus, together with the list of scaling weights of the regions where it will applied.
connectivity : tvb.datatypes.patterns.StimuliRegion.connectivity = Attr(field_type=<class ‘tvb.datatypes.connectivity.Connectivity’>, default=None, required=True)
spatial : tvb.datatypes.patterns.StimuliRegion.spatial = Attr(field_type=<class ‘tvb.datatypes.equations.DiscreteEquation’>, default=<tvb.datatypes.equations.DiscreteEquation object at 0x7f71b33a6e90>, required=True)
weight : tvb.datatypes.patterns.StimuliRegion.weight = NArray(label=’scaling’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
temporal : tvb.datatypes.patterns.SpatioTemporalPattern.temporal = Attr(field_type=<class ‘tvb.datatypes.equations.TemporalApplicableEquation’>, default=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Do necessary preparations in order to use this stimulus. NOTE: this was previously done in simulator configure_stimuli() method. It no needs to be used in stimulus viewer also.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Returns a list with a number of elements equal to the given number of regions.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Bases: tvb.datatypes.patterns.SpatioTemporalPattern
A spatio-temporal pattern defined in a Surface DataType. It includes the list of focal points.
surface : tvb.datatypes.patterns.StimuliSurface.surface = Attr(field_type=<class ‘tvb.datatypes.surfaces.CorticalSurface’>, default=None, required=True)
focal_points_surface : tvb.datatypes.patterns.StimuliSurface.focal_points_surface = NArray(label=’Focal points’, dtype=int64, default=None, dim_names=(), ndim=None, required=True)
focal_points_triangles : tvb.datatypes.patterns.StimuliSurface.focal_points_triangles = NArray(label=’Focal points triangles’, dtype=int64, default=None, dim_names=(), ndim=None, required=True)
temporal : tvb.datatypes.patterns.SpatioTemporalPattern.temporal = Attr(field_type=<class ‘tvb.datatypes.equations.TemporalApplicableEquation’>, default=None, required=True)
spatial : tvb.datatypes.patterns.SpatialPattern.spatial = Attr(field_type=<class ‘tvb.datatypes.equations.FiniteSupportEquation’>, default=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Do necessary preparations in order to use this stimulus. NOTE: this was previously done in simulator configure_stimuli() method. It no needs to be used in stimulus viewer also.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
The ProjectionMatrices DataTypes.
Bases: tvb.basic.neotraits._core.HasTraits
Base DataType for representing a ProjectionMatrix. The projection is between a source of type CorticalSurface and a set of Sensors.
projection_type : tvb.datatypes.projections.ProjectionMatrix.projection_type = Attr(field_type=<class ‘str’>, default=None, required=True)
sources : tvb.datatypes.projections.ProjectionMatrix.sources = Attr(field_type=<class ‘tvb.datatypes.surfaces.CorticalSurface’>, default=None, required=True)
projection_data : tvb.datatypes.projections.ProjectionMatrix.projection_data = NArray(label=’Projection Matrix Data’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.projections.ProjectionMatrix
Specific projection, from a CorticalSurface to EEG sensors.
projection_type : tvb.datatypes.projections.ProjectionSurfaceEEG.projection_type = Attr(field_type=<class ‘str’>, default=’projEEG’, required=True)
sensors : tvb.datatypes.projections.ProjectionSurfaceEEG.sensors = Attr(field_type=<class ‘tvb.datatypes.sensors.SensorsEEG’>, default=None, required=True)
sources : tvb.datatypes.projections.ProjectionMatrix.sources = Attr(field_type=<class ‘tvb.datatypes.surfaces.CorticalSurface’>, default=None, required=True)
projection_data : tvb.datatypes.projections.ProjectionMatrix.projection_data = NArray(label=’Projection Matrix Data’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.projections.ProjectionMatrix
Specific projection, from a CorticalSurface to MEG sensors.
projection_type : tvb.datatypes.projections.ProjectionSurfaceMEG.projection_type = Attr(field_type=<class ‘str’>, default=’projMEG’, required=True)
sensors : tvb.datatypes.projections.ProjectionSurfaceMEG.sensors = Attr(field_type=<class ‘tvb.datatypes.sensors.SensorsMEG’>, default=None, required=True)
sources : tvb.datatypes.projections.ProjectionMatrix.sources = Attr(field_type=<class ‘tvb.datatypes.surfaces.CorticalSurface’>, default=None, required=True)
projection_data : tvb.datatypes.projections.ProjectionMatrix.projection_data = NArray(label=’Projection Matrix Data’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.projections.ProjectionMatrix
Specific projection, from a CorticalSurface to SEEG sensors.
projection_type : tvb.datatypes.projections.ProjectionSurfaceSEEG.projection_type = Attr(field_type=<class ‘str’>, default=’projSEEG’, required=True)
sensors : tvb.datatypes.projections.ProjectionSurfaceSEEG.sensors = Attr(field_type=<class ‘tvb.datatypes.sensors.SensorsInternal’>, default=None, required=True)
sources : tvb.datatypes.projections.ProjectionMatrix.sources = Attr(field_type=<class ‘tvb.datatypes.surfaces.CorticalSurface’>, default=None, required=True)
projection_data : tvb.datatypes.projections.ProjectionMatrix.projection_data = NArray(label=’Projection Matrix Data’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
DataTypes for mapping some TVB DataTypes to a Connectivity (regions).
In FreeSurfer terms, a RegionMapping is a parcellation and a VolumeMapping is a segmentation.
Bases: tvb.basic.neotraits._core.HasTraits
An array (of length Surface.vertices). Each value is representing the index in Connectivity regions to which the current vertex is mapped.
array_data : tvb.datatypes.region_mapping.RegionMapping.array_data = NArray(label=’‘, dtype=int64, default=None, dim_names=(), ndim=None, required=True)
connectivity : tvb.datatypes.region_mapping.RegionMapping.connectivity = Attr(field_type=<class ‘tvb.datatypes.connectivity.Connectivity’>, default=None, required=True)
surface : tvb.datatypes.region_mapping.RegionMapping.surface = Attr(field_type=<class ‘tvb.datatypes.surfaces.Surface’>, default=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.basic.neotraits._core.HasTraits
Each value is representing the index in Connectivity regions to which the current voxel is mapped.
array_data : tvb.datatypes.region_mapping.RegionVolumeMapping.array_data = NArray(label=’‘, dtype=int64, default=None, dim_names=(), ndim=None, required=True)
connectivity : tvb.datatypes.region_mapping.RegionVolumeMapping.connectivity = Attr(field_type=<class ‘tvb.datatypes.connectivity.Connectivity’>, default=None, required=True)
volume : tvb.datatypes.region_mapping.RegionVolumeMapping.volume = Attr(field_type=<class ‘tvb.datatypes.volumes.Volume’>, default=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
The Sensors dataType.
Bases: tvb.basic.neotraits._core.HasTraits
Base Sensors class. All sensors have locations. Some will have orientations, e.g. MEG.
sensors_type : tvb.datatypes.sensors.Sensors.sensors_type = Attr(field_type=<class ‘str’>, default=None, required=False)
labels : tvb.datatypes.sensors.Sensors.labels = NArray(label=’Sensor labels’, dtype=<U128, default=None, dim_names=(), ndim=None, required=True)
locations : tvb.datatypes.sensors.Sensors.locations = NArray(label=’Sensor locations’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
has_orientation : tvb.datatypes.sensors.Sensors.has_orientation = Attr(field_type=<class ‘bool’>, default=False, required=True)
orientations : tvb.datatypes.sensors.Sensors.orientations = NArray(label=’‘, dtype=float64, default=None, dim_names=(), ndim=None, required=False)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Invoke the compute methods for computable attributes that haven’t been set during initialization.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares an integer This is different from Attr(field_type=int). The former enforces int subtypes This allows all integer types, including numpy ones that can be safely cast to the declared type according to numpy rules
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Map EEG sensors onto the head surface (skin-air).
EEG sensor locations are typically only given on a unit sphere, that is, they are effectively only identified by their orientation with respect to a coordinate system. This method is used to map these unit vector sensor “locations” to a specific location on the surface of the skin.
Assumes coordinate systems are aligned, i.e. common x,y,z and origin.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Gather scientifically interesting summary information from an instance of this datatype.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Bases: tvb.datatypes.sensors.Sensors
EEG sensor locations are represented as unit vectors, these need to be combined with a head(outer-skin) surface to obtain actual sensor locations
position | / \ / \ file columns: labels, x, y, z
sensors_type : tvb.datatypes.sensors.SensorsEEG.sensors_type = Attr(field_type=<class ‘str’>, default=’EEG’, required=True)
has_orientation : tvb.datatypes.sensors.SensorsEEG.has_orientation = Attr(field_type=<class ‘bool’>, default=False, required=True)
labels : tvb.datatypes.sensors.Sensors.labels = NArray(label=’Sensor labels’, dtype=<U128, default=None, dim_names=(), ndim=None, required=True)
locations : tvb.datatypes.sensors.Sensors.locations = NArray(label=’Sensor locations’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
orientations : tvb.datatypes.sensors.Sensors.orientations = NArray(label=’‘, dtype=float64, default=None, dim_names=(), ndim=None, required=False)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.sensors.Sensors
Sensors inside the brain...
sensors_type : tvb.datatypes.sensors.SensorsInternal.sensors_type = Attr(field_type=<class ‘str’>, default=’Internal’, required=True)
labels : tvb.datatypes.sensors.Sensors.labels = NArray(label=’Sensor labels’, dtype=<U128, default=None, dim_names=(), ndim=None, required=True)
locations : tvb.datatypes.sensors.Sensors.locations = NArray(label=’Sensor locations’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
has_orientation : tvb.datatypes.sensors.Sensors.has_orientation = Attr(field_type=<class ‘bool’>, default=False, required=True)
orientations : tvb.datatypes.sensors.Sensors.orientations = NArray(label=’‘, dtype=float64, default=None, dim_names=(), ndim=None, required=False)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.sensors.Sensors
These are actually just SQUIDS. Axial or planar gradiometers are achieved by calculating lead fields for two sets of sensors and then subtracting...
position orientation | | / \ / \ / \ / \ file columns: labels, x, y, z, dx, dy, dz
sensors_type : tvb.datatypes.sensors.SensorsMEG.sensors_type = Attr(field_type=<class ‘str’>, default=’MEG’, required=True)
has_orientation : tvb.datatypes.sensors.SensorsMEG.has_orientation = Attr(field_type=<class ‘bool’>, default=True, required=True)
labels : tvb.datatypes.sensors.Sensors.labels = NArray(label=’Sensor labels’, dtype=<U128, default=None, dim_names=(), ndim=None, required=True)
locations : tvb.datatypes.sensors.Sensors.locations = NArray(label=’Sensor locations’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
The Spectral datatypes.
Bases: tvb.basic.neotraits._core.HasTraits
Result of a NodeCoherence Analysis.
array_data : tvb.datatypes.spectral.CoherenceSpectrum.array_data = NArray(label=’‘, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
frequency : tvb.datatypes.spectral.CoherenceSpectrum.frequency = NArray(label=’Frequency’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares an integer This is different from Attr(field_type=int). The former enforces int subtypes This allows all integer types, including numpy ones that can be safely cast to the declared type according to numpy rules
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.basic.neotraits._core.HasTraits
Result of a NodeComplexCoherence Analysis.
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Gather scientifically interesting summary information from an instance of this datatype.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.basic.neotraits._core.HasTraits
Result of a Fourier Analysis.
array_data : tvb.datatypes.spectral.FourierSpectrum.array_data = NArray(label=’‘, dtype=complex128, default=None, dim_names=(), ndim=None, required=True)
amplitude : tvb.datatypes.spectral.FourierSpectrum.amplitude = NArray(label=’Amplitude’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
phase : tvb.datatypes.spectral.FourierSpectrum.phase = NArray(label=’Phase’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
power : tvb.datatypes.spectral.FourierSpectrum.power = NArray(label=’Power’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
average_power : tvb.datatypes.spectral.FourierSpectrum.average_power = NArray(label=’Average Power’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
normalised_average_power : tvb.datatypes.spectral.FourierSpectrum.normalised_average_power = NArray(label=’Normalised Power’, dtype=float64, default=None, dim_names=(), ndim=None, required=False)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Normalised-average-power of the complex Fourier spectrum.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Gather scientifically interesting summary information from an instance of this datatype.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.basic.neotraits._core.HasTraits
This class bundles all the elements of a Wavelet Analysis into a single object, including the input TimeSeries datatype and the output results as arrays (FloatArray)
array_data : tvb.datatypes.spectral.WaveletCoefficients.array_data = NArray(label=’‘, dtype=complex128, default=None, dim_names=(), ndim=None, required=True)
source : tvb.datatypes.spectral.WaveletCoefficients.source = Attr(field_type=<class ‘tvb.datatypes.time_series.TimeSeries’>, default=None, required=True)
sample_period : tvb.datatypes.spectral.WaveletCoefficients.sample_period = Float(field_type=<class ‘float’>, default=0, required=True)
normalisation : tvb.datatypes.spectral.WaveletCoefficients.normalisation = Attr(field_type=<class ‘str’>, default=None, required=True)
q_ratio : tvb.datatypes.spectral.WaveletCoefficients.q_ratio = Float(field_type=<class ‘float’>, default=5.0, required=True)
amplitude : tvb.datatypes.spectral.WaveletCoefficients.amplitude = NArray(label=’Amplitude’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
phase : tvb.datatypes.spectral.WaveletCoefficients.phase = NArray(label=’Phase’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
power : tvb.datatypes.spectral.WaveletCoefficients.power = NArray(label=’Power’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
The Volume datatypes.
Bases: tvb.basic.neotraits._core.HasTraits
Quantitative volumetric data recorded by means of Magnetic Resonance Imaging.
array_data : tvb.datatypes.structural.StructuralMRI.array_data = NArray(label=’contrast’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
weighting : tvb.datatypes.structural.StructuralMRI.weighting = Attr(field_type=<class ‘str’>, default=None, required=True)
volume : tvb.datatypes.structural.StructuralMRI.volume = Attr(field_type=<class ‘tvb.datatypes.volumes.Volume’>, default=None, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Surface relates DataTypes.
Bases: tvb.datatypes.surfaces.Surface
Brain - inner skull interface surface.
surface_type : tvb.datatypes.surfaces.BrainSkull.surface_type = Final(field_type=<class ‘str’>, default=’Brain Skull’, required=True)
edge_mean_length : tvb.datatypes.surfaces.Surface.edge_mean_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_min_length : tvb.datatypes.surfaces.Surface.edge_min_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_max_length : tvb.datatypes.surfaces.Surface.edge_max_length = Float(field_type=<class ‘float’>, default=0, required=True)
hemisphere_mask : tvb.datatypes.surfaces.Surface.hemisphere_mask = NArray(label=’An array specifying if a vertex belongs to the right hemisphere’, dtype=bool, default=None, dim_names=(), ndim=None, required=False)
zero_based_triangles : tvb.datatypes.surfaces.Surface.zero_based_triangles = Attr(field_type=<class ‘bool’>, default=None, required=True)
bi_hemispheric : tvb.datatypes.surfaces.Surface.bi_hemispheric = Attr(field_type=<class ‘bool’>, default=False, required=True)
valid_for_simulations : tvb.datatypes.surfaces.Surface.valid_for_simulations = Attr(field_type=<class ‘bool’>, default=True, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
Bases: tvb.datatypes.surfaces.Surface
Cortical or pial surface.
surface_type : tvb.datatypes.surfaces.CorticalSurface.surface_type = Attr(field_type=<class ‘str’>, default=’Cortical Surface’, required=True)
edge_mean_length : tvb.datatypes.surfaces.Surface.edge_mean_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_min_length : tvb.datatypes.surfaces.Surface.edge_min_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_max_length : tvb.datatypes.surfaces.Surface.edge_max_length = Float(field_type=<class ‘float’>, default=0, required=True)
hemisphere_mask : tvb.datatypes.surfaces.Surface.hemisphere_mask = NArray(label=’An array specifying if a vertex belongs to the right hemisphere’, dtype=bool, default=None, dim_names=(), ndim=None, required=False)
zero_based_triangles : tvb.datatypes.surfaces.Surface.zero_based_triangles = Attr(field_type=<class ‘bool’>, default=None, required=True)
bi_hemispheric : tvb.datatypes.surfaces.Surface.bi_hemispheric = Attr(field_type=<class ‘bool’>, default=False, required=True)
valid_for_simulations : tvb.datatypes.surfaces.Surface.valid_for_simulations = Attr(field_type=<class ‘bool’>, default=True, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.surfaces.Surface
EEG cap surface.
surface_type : tvb.datatypes.surfaces.EEGCap.surface_type = Final(field_type=<class ‘str’>, default=’EEG Cap’, required=True)
edge_mean_length : tvb.datatypes.surfaces.Surface.edge_mean_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_min_length : tvb.datatypes.surfaces.Surface.edge_min_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_max_length : tvb.datatypes.surfaces.Surface.edge_max_length = Float(field_type=<class ‘float’>, default=0, required=True)
hemisphere_mask : tvb.datatypes.surfaces.Surface.hemisphere_mask = NArray(label=’An array specifying if a vertex belongs to the right hemisphere’, dtype=bool, default=None, dim_names=(), ndim=None, required=False)
zero_based_triangles : tvb.datatypes.surfaces.Surface.zero_based_triangles = Attr(field_type=<class ‘bool’>, default=None, required=True)
bi_hemispheric : tvb.datatypes.surfaces.Surface.bi_hemispheric = Attr(field_type=<class ‘bool’>, default=False, required=True)
valid_for_simulations : tvb.datatypes.surfaces.Surface.valid_for_simulations = Attr(field_type=<class ‘bool’>, default=True, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
Bases: tvb.datatypes.surfaces.Surface
Face surface.
surface_type : tvb.datatypes.surfaces.FaceSurface.surface_type = Final(field_type=<class ‘str’>, default=’Face’, required=True)
edge_mean_length : tvb.datatypes.surfaces.Surface.edge_mean_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_min_length : tvb.datatypes.surfaces.Surface.edge_min_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_max_length : tvb.datatypes.surfaces.Surface.edge_max_length = Float(field_type=<class ‘float’>, default=0, required=True)
hemisphere_mask : tvb.datatypes.surfaces.Surface.hemisphere_mask = NArray(label=’An array specifying if a vertex belongs to the right hemisphere’, dtype=bool, default=None, dim_names=(), ndim=None, required=False)
zero_based_triangles : tvb.datatypes.surfaces.Surface.zero_based_triangles = Attr(field_type=<class ‘bool’>, default=None, required=True)
bi_hemispheric : tvb.datatypes.surfaces.Surface.bi_hemispheric = Attr(field_type=<class ‘bool’>, default=False, required=True)
valid_for_simulations : tvb.datatypes.surfaces.Surface.valid_for_simulations = Attr(field_type=<class ‘bool’>, default=True, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
Bases: tvb.datatypes.surfaces.Surface
Skin - air interface surface.
surface_type : tvb.datatypes.surfaces.SkinAir.surface_type = Final(field_type=<class ‘str’>, default=’Skin Air’, required=True)
edge_mean_length : tvb.datatypes.surfaces.Surface.edge_mean_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_min_length : tvb.datatypes.surfaces.Surface.edge_min_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_max_length : tvb.datatypes.surfaces.Surface.edge_max_length = Float(field_type=<class ‘float’>, default=0, required=True)
hemisphere_mask : tvb.datatypes.surfaces.Surface.hemisphere_mask = NArray(label=’An array specifying if a vertex belongs to the right hemisphere’, dtype=bool, default=None, dim_names=(), ndim=None, required=False)
zero_based_triangles : tvb.datatypes.surfaces.Surface.zero_based_triangles = Attr(field_type=<class ‘bool’>, default=None, required=True)
bi_hemispheric : tvb.datatypes.surfaces.Surface.bi_hemispheric = Attr(field_type=<class ‘bool’>, default=False, required=True)
valid_for_simulations : tvb.datatypes.surfaces.Surface.valid_for_simulations = Attr(field_type=<class ‘bool’>, default=True, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
Bases: tvb.datatypes.surfaces.Surface
Outer-skull - scalp interface surface.
surface_type : tvb.datatypes.surfaces.SkullSkin.surface_type = Final(field_type=<class ‘str’>, default=’Skull Skin’, required=True)
edge_mean_length : tvb.datatypes.surfaces.Surface.edge_mean_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_min_length : tvb.datatypes.surfaces.Surface.edge_min_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_max_length : tvb.datatypes.surfaces.Surface.edge_max_length = Float(field_type=<class ‘float’>, default=0, required=True)
hemisphere_mask : tvb.datatypes.surfaces.Surface.hemisphere_mask = NArray(label=’An array specifying if a vertex belongs to the right hemisphere’, dtype=bool, default=None, dim_names=(), ndim=None, required=False)
zero_based_triangles : tvb.datatypes.surfaces.Surface.zero_based_triangles = Attr(field_type=<class ‘bool’>, default=None, required=True)
bi_hemispheric : tvb.datatypes.surfaces.Surface.bi_hemispheric = Attr(field_type=<class ‘bool’>, default=False, required=True)
valid_for_simulations : tvb.datatypes.surfaces.Surface.valid_for_simulations = Attr(field_type=<class ‘bool’>, default=True, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
Bases: tvb.basic.neotraits._core.HasTraits
A base class for other surfaces.
edge_mean_length : tvb.datatypes.surfaces.Surface.edge_mean_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_min_length : tvb.datatypes.surfaces.Surface.edge_min_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_max_length : tvb.datatypes.surfaces.Surface.edge_max_length = Float(field_type=<class ‘float’>, default=0, required=True)
hemisphere_mask : tvb.datatypes.surfaces.Surface.hemisphere_mask = NArray(label=’An array specifying if a vertex belongs to the right hemisphere’, dtype=bool, default=None, dim_names=(), ndim=None, required=False)
zero_based_triangles : tvb.datatypes.surfaces.Surface.zero_based_triangles = Attr(field_type=<class ‘bool’>, default=None, required=True)
bi_hemispheric : tvb.datatypes.surfaces.Surface.bi_hemispheric = Attr(field_type=<class ‘bool’>, default=False, required=True)
surface_type : tvb.datatypes.surfaces.Surface.surface_type = Attr(field_type=<class ‘str’>, default=None, required=True)
valid_for_simulations : tvb.datatypes.surfaces.Surface.valid_for_simulations = Attr(field_type=<class ‘bool’>, default=True, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Calculate a sparse matrix of the geodesic distance from each vertex to all vertices within max_dist of them on the surface,
max_dist: find the distance to vertices out as far as max_dist.
NOTE: Compute time increases rapidly with max_dist and the memory efficiency of the sparse matrices decreases, so, don’t use too large a value for max_dist...
We call isolated vertices those who do not belong to at least 3 triangles.
Estimates vertex normals, based on triangle normals weighted by the angle they subtend at each vertex...
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
A sorted list of the two element tuples(vertex_0, vertex_1) representing the edges of the mesh.
Construct a Surface from source_file.
Calculate the geodesic distance between vertices of the surface,
max_dist: find the distance to vertices out as far as max_dist. targets: one or more indices into vertices,.
If end_vertex is omitted the distance from the starting vertex to all vertices within max_dist will be returned, if max_dist is also omitted the distance to all vertices on the surface will be returned.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Evaluates the discrete Laplace-Beltrami operator for a given vertex-wise function and geodesic distance matrix. From Belkin 2008:
Let K be a mesh in R^3, with V its set of vertices. For face t in K, the number of vertices in t is #t, and V(t) is the set of vertices in t. For a function f : V -> R, this produces another function L_K^h f : V -> R, and L_K^h is computed for any w in V,
L_K^h f (w) = 1 / (4 pi h^2) sum_{t in K} area(t) / #t sum_{p in V(t)} exp(-||p - w||^2/(4*h)) (f(p) - f(w))
| Parameters: |
|
|---|---|
| Returns: | matrix of evaluated L-B operator |
Return the vertices of the nth ring around a given vertex, defaults to neighbourhood=2. NOTE: if you want neighbourhood=1 then you should directly access the property vertex_neighbours, ie use surf_obj.vertex_neighbours[vertex] setting contains=True returns all vertices from rings 1 to n inclusive.
Declares an integer This is different from Attr(field_type=int). The former enforces int subtypes This allows all integer types, including numpy ones that can be safely cast to the declared type according to numpy rules
Declares an integer This is different from Attr(field_type=int). The former enforces int subtypes This allows all integer types, including numpy ones that can be safely cast to the declared type according to numpy rules
Gather scientifically interesting summary information from an instance of this datatype.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An array containing the inner angles for each triangle, same shape as triangles.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Validates if this surface can be used in simulations. The surface should be topologically equivalent to one or two closed spheres. It should not contain isolated vertices. It should not be pinched or have holes: all edges must belong to 2 triangles. The allowance for one or two closed surfaces is because the skull/etc should be represented by a single closed surface and we typically represent the cortex as one closed surface per hemisphere.
| Returns: | a ValidationResult |
|---|
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: builtins.object
Used by surface validate methods to report non-fatal failed validations
Bases: tvb.datatypes.surfaces.Surface
White matter - gray matter interface surface.
surface_type : tvb.datatypes.surfaces.WhiteMatterSurface.surface_type = Final(field_type=<class ‘str’>, default=’White Matter’, required=True)
edge_mean_length : tvb.datatypes.surfaces.Surface.edge_mean_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_min_length : tvb.datatypes.surfaces.Surface.edge_min_length = Float(field_type=<class ‘float’>, default=0, required=True)
edge_max_length : tvb.datatypes.surfaces.Surface.edge_max_length = Float(field_type=<class ‘float’>, default=0, required=True)
hemisphere_mask : tvb.datatypes.surfaces.Surface.hemisphere_mask = NArray(label=’An array specifying if a vertex belongs to the right hemisphere’, dtype=bool, default=None, dim_names=(), ndim=None, required=False)
zero_based_triangles : tvb.datatypes.surfaces.Surface.zero_based_triangles = Attr(field_type=<class ‘bool’>, default=None, required=True)
bi_hemispheric : tvb.datatypes.surfaces.Surface.bi_hemispheric = Attr(field_type=<class ‘bool’>, default=False, required=True)
valid_for_simulations : tvb.datatypes.surfaces.Surface.valid_for_simulations = Attr(field_type=<class ‘bool’>, default=True, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An attribute that can only be set once. If a default is provided it counts as a set, so it cannot be written to. Note that if the default is a mutable type, the value is shared with all instances of the owning class. We cannot enforce true constancy in python
The Temporal Correlation datatypes.
Bases: tvb.basic.neotraits._core.HasTraits
Result of a CrossCorrelation Analysis.
array_data : tvb.datatypes.temporal_correlations.CrossCorrelation.array_data = NArray(label=’‘, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
time : tvb.datatypes.temporal_correlations.CrossCorrelation.time = NArray(label=’Temporal Offsets’, dtype=float64, default=None, dim_names=(), ndim=None, required=False)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Gather scientifically interesting summary information from an instance of this datatype.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
The TimeSeries datatypes.
Bases: tvb.datatypes.time_series.TimeSeries
title : tvb.datatypes.time_series.TimeSeries.title = Attr(field_type=<class ‘str’>, default=None, required=True)
start_time : tvb.datatypes.time_series.TimeSeries.start_time = Float(field_type=<class ‘float’>, default=0, required=True)
sample_period : tvb.datatypes.time_series.TimeSeries.sample_period = Float(field_type=<class ‘float’>, default=1.0, required=True)
sample_period_unit : tvb.datatypes.time_series.TimeSeries.sample_period_unit = Attr(field_type=<class ‘str’>, default=’ms’, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Bases: tvb.basic.neotraits._core.HasTraits
Base time-series dataType.
title : tvb.datatypes.time_series.TimeSeries.title = Attr(field_type=<class ‘str’>, default=None, required=True)
start_time : tvb.datatypes.time_series.TimeSeries.start_time = Float(field_type=<class ‘float’>, default=0, required=True)
sample_period : tvb.datatypes.time_series.TimeSeries.sample_period = Float(field_type=<class ‘float’>, default=1.0, required=True)
sample_period_unit : tvb.datatypes.time_series.TimeSeries.sample_period_unit = Attr(field_type=<class ‘str’>, default=’ms’, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Declares a float. This is different from Attr(field_type=float). The former enforces float subtypes. This allows any type that can be safely cast to the declared float type according to numpy rules.
Reading and writing this attribute is slower than a plain python attribute. In performance sensitive code you might want to use plain python attributes or even better local variables.
Gather scientifically interesting summary information from an instance of this datatype.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.time_series.SensorsTSBase
A time series associated with a set of EEG sensors.
sensors : tvb.datatypes.time_series.TimeSeriesEEG.sensors = Attr(field_type=<class ‘tvb.datatypes.sensors.SensorsEEG’>, default=None, required=True)
labels_ordering : tvb.datatypes.time_series.TimeSeriesEEG.labels_ordering = List(of=<class ‘str’>, default=(‘Time’, ‘1’, ‘EEG Sensor’, ‘1’), required=True)
title : tvb.datatypes.time_series.TimeSeries.title = Attr(field_type=<class ‘str’>, default=None, required=True)
start_time : tvb.datatypes.time_series.TimeSeries.start_time = Float(field_type=<class ‘float’>, default=0, required=True)
sample_period : tvb.datatypes.time_series.TimeSeries.sample_period = Float(field_type=<class ‘float’>, default=1.0, required=True)
sample_period_unit : tvb.datatypes.time_series.TimeSeries.sample_period_unit = Attr(field_type=<class ‘str’>, default=’ms’, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.time_series.SensorsTSBase
A time series associated with a set of MEG sensors.
sensors : tvb.datatypes.time_series.TimeSeriesMEG.sensors = Attr(field_type=<class ‘tvb.datatypes.sensors.SensorsMEG’>, default=None, required=True)
labels_ordering : tvb.datatypes.time_series.TimeSeriesMEG.labels_ordering = List(of=<class ‘str’>, default=(‘Time’, ‘1’, ‘MEG Sensor’, ‘1’), required=True)
title : tvb.datatypes.time_series.TimeSeries.title = Attr(field_type=<class ‘str’>, default=None, required=True)
start_time : tvb.datatypes.time_series.TimeSeries.start_time = Float(field_type=<class ‘float’>, default=0, required=True)
sample_period : tvb.datatypes.time_series.TimeSeries.sample_period = Float(field_type=<class ‘float’>, default=1.0, required=True)
sample_period_unit : tvb.datatypes.time_series.TimeSeries.sample_period_unit = Attr(field_type=<class ‘str’>, default=’ms’, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.time_series.TimeSeries
A time-series associated with the regions of a connectivity.
connectivity : tvb.datatypes.time_series.TimeSeriesRegion.connectivity = Attr(field_type=<class ‘tvb.datatypes.connectivity.Connectivity’>, default=None, required=True)
region_mapping_volume : tvb.datatypes.time_series.TimeSeriesRegion.region_mapping_volume = Attr(field_type=<class ‘tvb.datatypes.region_mapping.RegionVolumeMapping’>, default=None, required=False)
region_mapping : tvb.datatypes.time_series.TimeSeriesRegion.region_mapping = Attr(field_type=<class ‘tvb.datatypes.region_mapping.RegionMapping’>, default=None, required=False)
labels_ordering : tvb.datatypes.time_series.TimeSeriesRegion.labels_ordering = List(of=<class ‘str’>, default=(‘Time’, ‘State Variable’, ‘Region’, ‘Mode’), required=True)
title : tvb.datatypes.time_series.TimeSeries.title = Attr(field_type=<class ‘str’>, default=None, required=True)
start_time : tvb.datatypes.time_series.TimeSeries.start_time = Float(field_type=<class ‘float’>, default=0, required=True)
sample_period : tvb.datatypes.time_series.TimeSeries.sample_period = Float(field_type=<class ‘float’>, default=1.0, required=True)
sample_period_unit : tvb.datatypes.time_series.TimeSeries.sample_period_unit = Attr(field_type=<class ‘str’>, default=’ms’, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.time_series.SensorsTSBase
A time series associated with a set of Internal sensors.
sensors : tvb.datatypes.time_series.TimeSeriesSEEG.sensors = Attr(field_type=<class ‘tvb.datatypes.sensors.SensorsInternal’>, default=None, required=True)
labels_ordering : tvb.datatypes.time_series.TimeSeriesSEEG.labels_ordering = List(of=<class ‘str’>, default=(‘Time’, ‘1’, ‘sEEG Sensor’, ‘1’), required=True)
title : tvb.datatypes.time_series.TimeSeries.title = Attr(field_type=<class ‘str’>, default=None, required=True)
start_time : tvb.datatypes.time_series.TimeSeries.start_time = Float(field_type=<class ‘float’>, default=0, required=True)
sample_period : tvb.datatypes.time_series.TimeSeries.sample_period = Float(field_type=<class ‘float’>, default=1.0, required=True)
sample_period_unit : tvb.datatypes.time_series.TimeSeries.sample_period_unit = Attr(field_type=<class ‘str’>, default=’ms’, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.time_series.TimeSeries
A time-series associated with a Surface.
surface : tvb.datatypes.time_series.TimeSeriesSurface.surface = Attr(field_type=<class ‘tvb.datatypes.surfaces.CorticalSurface’>, default=None, required=True)
labels_ordering : tvb.datatypes.time_series.TimeSeriesSurface.labels_ordering = List(of=<class ‘str’>, default=(‘Time’, ‘State Variable’, ‘Vertex’, ‘Mode’), required=True)
title : tvb.datatypes.time_series.TimeSeries.title = Attr(field_type=<class ‘str’>, default=None, required=True)
start_time : tvb.datatypes.time_series.TimeSeries.start_time = Float(field_type=<class ‘float’>, default=0, required=True)
sample_period : tvb.datatypes.time_series.TimeSeries.sample_period = Float(field_type=<class ‘float’>, default=1.0, required=True)
sample_period_unit : tvb.datatypes.time_series.TimeSeries.sample_period_unit = Attr(field_type=<class ‘str’>, default=’ms’, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it
Gather scientifically interesting summary information from an instance of this datatype.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Bases: tvb.datatypes.time_series.TimeSeries
A time-series associated with a Volume.
volume : tvb.datatypes.time_series.TimeSeriesVolume.volume = Attr(field_type=<class ‘tvb.datatypes.volumes.Volume’>, default=None, required=True)
labels_ordering : tvb.datatypes.time_series.TimeSeriesVolume.labels_ordering = List(of=<class ‘str’>, default=(‘Time’, ‘X’, ‘Y’, ‘Z’), required=True)
title : tvb.datatypes.time_series.TimeSeries.title = Attr(field_type=<class ‘str’>, default=None, required=True)
start_time : tvb.datatypes.time_series.TimeSeries.start_time = Float(field_type=<class ‘float’>, default=0, required=True)
sample_period : tvb.datatypes.time_series.TimeSeries.sample_period = Float(field_type=<class ‘float’>, default=1.0, required=True)
sample_period_unit : tvb.datatypes.time_series.TimeSeries.sample_period_unit = Attr(field_type=<class ‘str’>, default=’ms’, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
The attribute is a list of values. Choices and type are reinterpreted as applying not to the list but to the elements of it
Gather scientifically interesting summary information from an instance of this datatype.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
module docstring .. moduleauthor:: Mihai Andrei <mihai.andrei@codemart.ro>
Bases: tvb.basic.neotraits._core.HasTraits
Datatype for results of diffusion imaging tractography.
tract_region : tvb.datatypes.tracts.Tracts.tract_region = NArray(label=’Tract region index’, dtype=int64, default=None, dim_names=(), ndim=None, required=False)
An index used to find quickly all tract emerging from a region tract_region[i] is the region of the i’th tract. -1 represents the background
region_volume_map : tvb.datatypes.tracts.Tracts.region_volume_map = Attr(field_type=<class ‘tvb.datatypes.region_mapping.RegionVolumeMapping’>, default=None, required=False)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
The Volume datatypes.
Bases: tvb.basic.neotraits._core.HasTraits
Data defined on a regular grid in three dimensions.
origin : tvb.datatypes.volumes.Volume.origin = NArray(label=’Volume origin coordinates’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
voxel_size : tvb.datatypes.volumes.Volume.voxel_size = NArray(label=’Voxel size’, dtype=float64, default=None, dim_names=(), ndim=None, required=True)
voxel_unit : tvb.datatypes.volumes.Volume.voxel_unit = Attr(field_type=<class ‘str’>, default=’mm’, required=True)
gid : tvb.basic.neotraits._core.HasTraits.gid = Attr(field_type=<class ‘uuid.UUID’>, default=None, required=True)
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
Declares a numpy array. dtype enforces the dtype. The default dtype is float32. An optional symbolic shape can be given, as a tuple of Dim attributes from the owning class. The shape will be enforced, but no broadcasting will be done. domain declares what values are allowed in this array. It can be any object that can be checked for membership Defaults are checked if they are in the declared domain. For performance reasons this does not happen on every attribute set.
An Attr declares the following about the attribute it describes: * the type * a default value shared by all instances * if the value might be missing * documentation It will resolve to attributes on the instance.