diff --git a/neuroml/__version__.py b/neuroml/__version__.py index b22c62b..715286c 100644 --- a/neuroml/__version__.py +++ b/neuroml/__version__.py @@ -18,4 +18,4 @@ __version_info__: tuple = tuple(int(i) for i in __version__.split(".")) -current_neuroml_version: str = "v2.3.1" +current_neuroml_version: str = "v2.3.2" diff --git a/neuroml/nml/NeuroML_v2.3.2.xsd b/neuroml/nml/NeuroML_v2.3.2.xsd new file mode 100644 index 0000000..284683a --- /dev/null +++ b/neuroml/nml/NeuroML_v2.3.2.xsd @@ -0,0 +1,3984 @@ + + + + + + + + An id attribute for elements which need to be identified uniquely (normally just within their parent element). + + + + + + + + A value for a physical quantity in NeuroML 2, e.g. 20, -60.0mV or 5nA + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + An id string for pointing to an entry in an annotation element related to a MIRIAM resource. Based on metaid of SBML + + + + + + + + An id string for pointing to an entry in the NeuroLex ontology. Use of this attribute is a shorthand for a full + RDF based reference to the MIRIAM Resource urn:miriam:neurolex, with an bqbiol:is qualifier + + + + + + + + + A path referring to another component. + + + + + + + + + An attribute useful as id of segments, connections, etc: integer >=0 only! + + + + + + + + + + + Integer >=1 only! + + + + + + + + + + + Double >0 only + + + + + + + + Value which is either 0 or 1 + + + + + + + + + + + + + Textual human readable notes related to the element in question. It's useful to put these into + the NeuroML files instead of XML comments, as the notes can be extracted and repeated in the files to which the NeuroML is mapped. + + + + + + + A property ( a **tag** and **value** pair ), which can be on any **baseStandalone** either as a direct child, or within an **Annotation** . Generally something which helps the visual display or facilitates simulation of a Component, but is not a core physiological property. Common examples include: **numberInternalDivisions,** equivalent of nseg in NEURON; **radius,** for a radius to use in graphical displays for abstract cells ( i. e. without defined morphologies ); **color,** the color to use for a **Population** or **populationList** of cells; **recommended_dt_ms,** the recommended timestep to use for simulating a **Network** , **recommended_duration_ms** the recommended duration to use when running a **Network** + + + + + + + + + + + + A structured annotation containing metadata, specifically RDF or **property** elements + + + + + + + + + + + + + + Contains an extension to NeuroML by creating custom LEMS ComponentType. + + + + + + + + + + + + + + + + + + LEMS ComponentType for Constant. + + + + + + + + + + + + + LEMS Exposure (ComponentType property) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + LEMS DerivedParamter element + + + + + + + + + + + + + + + + + + + + + + + + + + + + LEMS ComponentType for Dynamics + + + + + + + + + + + + + + + LEMS ComponentType for DerivedVariable + + + + + + + + + + + + + + + + + + + LEMS ComponentType for ConditionalDerivedVariable + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Float value restricted to between 1 and 0 + + + + + + + + + + + + The root NeuroML element. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Various types of cells which are defined in NeuroML 2. This list will be expanded... + + + + + + + + + + + + + + + + + + + + + Various types of cells which are defined in NeuroML 2 based on PyNN standard cell models. + + + + + + + + + + + + + + Various types of synapse which are defined in NeuroML 2. This list will be expanded... + + + + + + + + + + + + + + + + + + Various types of synapse which are defined in NeuroML 2 based on PyNN standard cell/synapse models. + + + + + + + + + + + Various types of inputs which are defined in NeuroML2. This list will be expanded... + + + + + + + + + + + + + + + + + + + + + + + + + Various types of input which are defined in NeuroML 2 based on PyNN standard cell/synapse models. + + + + + + + + Various types of concentration model which are defined in NeuroML 2. This list will be expanded... + + + + + + + + + + + + + + + + + + + + + + + A kinetic scheme based ion channel with multiple **gateKS** s, each of which consists of multiple **KSState** s and **KSTransition** s giving the rates of transition between them +\n +:param conductance: +:type conductance: conductance + + + + + + + + + + + + + + + + + Note **ionChannel** and **ionChannelHH** are currently functionally identical. This is needed since many existing examples use ionChannel, some use ionChannelHH. NeuroML v2beta4 should remove one of these, probably ionChannelHH. +\n +:param conductance: +:type conductance: conductance + + + + + + + + + + + + + + + + + + + + + + + + Note **ionChannel** and **ionChannelHH** are currently functionally identical. This is needed since many existing examples use ionChannel, some use ionChannelHH. NeuroML v2beta4 should remove one of these, probably ionChannelHH. +\n +:param conductance: +:type conductance: conductance + + + + + + + + + + Same as **ionChannel** , but with a **vShift** parameter to change voltage activation of gates. The exact usage of **vShift** in expressions for rates is determined by the individual gates. +\n +:param vShift: +:type vShift: voltage +:param conductance: +:type conductance: conductance + + + + + + + + + + + + + + + + + + + A value for the conductance scaling which varies as a standard function of the difference between the current temperature, **temperature,** and the temperature at which the conductance was originally determined, **experimentalTemp** +\n +:param q10Factor: +:type q10Factor: none +:param experimentalTemp: +:type experimentalTemp: temperature + + + + + + + + + + + + + + + + + + + + + + + + + A **KSState** with **relativeConductance** of 0 +\n +:param relativeConductance: +:type relativeConductance: none + + + + + + + + + + + + A **KSState** with **relativeConductance** of 1 +\n +:param relativeConductance: +:type relativeConductance: none + + + + + + + + + + + + A forward only **KSTransition** for a **gateKS** which specifies a **rate** ( type **baseHHRate** ) which follows one of the standard Hodgkin Huxley forms ( e. g. **HHExpRate** , **HHSigmoidRate** , **HHExpLinearRate** + + + + + + + + + + + + + + + + A reverse only **KSTransition** for a **gateKS** which specifies a **rate** ( type **baseHHRate** ) which follows one of the standard Hodgkin Huxley forms ( e. g. **HHExpRate** , **HHSigmoidRate** , **HHExpLinearRate** + + + + + + + + + + + + + + + + + + + + + + KS Transition specified in terms of time constant **tau** and steady state **inf** + + + + + + + + + + + + + + + + A gate which consists of multiple **KSState** s and **KSTransition** s giving the rates of transition between them +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + + + + Note all sub elements for gateHHrates, gateHHratesTau, gateFractional etc. allowed here. Which are valid should be constrained by what type is set + + + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism but is instantaneous, so tau = 0 and gate follows exactly inf value +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + Gate composed of subgates contributing with fractional conductance +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Base for any model of an **ion** concentration which changes with time. Internal ( **concentration** ) and external ( **extConcentration** ) values for the concentration of the ion are given. + + + + + + + + + + + + + + Model of an intracellular buffering mechanism for **ion** ( currently hard Coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** The ion is assumed to occupy a shell inside the membrane of thickness **shellThickness.** +\n +:param restingConc: +:type restingConc: concentration +:param decayConstant: +:type decayConstant: time +:param shellThickness: +:type shellThickness: length + + + + + + + + + + + + + + Model of buffering of concentration of an ion ( currently hard coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** A fixed factor **rho** is used to scale the incoming current *independently of the size of the compartment* to produce a concentration change. +\n +:param restingConc: +:type restingConc: concentration +:param decayConstant: +:type decayConstant: time +:param rho: +:type rho: rho_factor + + + + + + + + + + + + + + + + + Base type for all synapses, i. e. ComponentTypes which produce a current ( dimension current ) and change Dynamics in response to an incoming event. cno_0000009 + + + + + + + + + + + Base type for synapses with a dependence on membrane potential + + + + + + + + + + + Synapse model which produces a synaptic current. + + + + + + + + + + + Synapse model which exposes a conductance **g** in addition to producing a current. Not necessarily ohmic!! cno_0000027 +\n +:param gbase: Baseline conductance, generally the maximum conductance following a single spike +:type gbase: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + Synapse model suited for a sum of two expTwoSynapses which exposes a conductance **g** in addition to producing a current. Not necessarily ohmic!! cno_0000027 +\n +:param gbase1: Baseline conductance 1 +:type gbase1: conductance +:param gbase2: Baseline conductance 2 +:type gbase2: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + + Gap junction/single electrical connection +\n +:param conductance: +:type conductance: conductance + + + + + + + + + + + + Dummy synapse which emits no current. Used as presynaptic endpoint for analog synaptic connection. + + + + + + + + + + + Behaves just like a one way gap junction. +\n +:param conductance: +:type conductance: conductance + + + + + + + + + + + + Graded/analog synapse. Based on synapse in Methods of http://www. nature.com/neuro/journal/v7/n12/abs/nn1352.html +\n +:param conductance: +:type conductance: conductance +:param delta: Slope of the activation curve +:type delta: voltage +:param k: Rate constant for transmitter-receptor dissociation rate +:type k: per_time +:param Vth: The half-activation voltage of the synapse +:type Vth: voltage +:param erev: The reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + + + + Alpha current synapse: rise time and decay time are both **tau.** +\n +:param tau: Time course for rise and decay +:type tau: time +:param ibase: Baseline current increase after receiving a spike +:type ibase: current + + + + + + + + + + + + + Ohmic synapse model where rise time and decay time are both **tau.** Max conductance reached during this time ( assuming zero conductance before ) is **gbase** * **weight.** +\n +:param tau: Time course of rise/decay +:type tau: time +:param gbase: Baseline conductance, generally the maximum conductance following a single spike +:type gbase: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + Ohmic synapse model whose conductance rises instantaneously by ( **gbase** * **weight** ) on receiving an event, and which decays exponentially to zero with time course **tauDecay** +\n +:param tauDecay: Time course of decay +:type tauDecay: time +:param gbase: Baseline conductance, generally the maximum conductance following a single spike +:type gbase: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + Ohmic synapse model whose conductance waveform on receiving an event has a rise time of **tauRise** and a decay time of **tauDecay.** Max conductance reached during this time ( assuming zero conductance before ) is **gbase** * **weight.** +\n +:param tauRise: +:type tauRise: time +:param tauDecay: +:type tauDecay: time +:param gbase: Baseline conductance, generally the maximum conductance following a single spike +:type gbase: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + Ohmic synapse similar to expTwoSynapse but consisting of two components that can differ in decay times and max conductances but share the same rise time. +\n +:param tauRise: +:type tauRise: time +:param tauDecay1: +:type tauDecay1: time +:param tauDecay2: +:type tauDecay2: time +:param gbase1: Baseline conductance 1 +:type gbase1: conductance +:param gbase2: Baseline conductance 2 +:type gbase2: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + + Synapse consisting of two independent synaptic mechanisms ( e. g. AMPA-R and NMDA-R ), which can be easily colocated in connections + + + + + + + + + + + + + + Biexponential synapse that allows for optional block and plasticity mechanisms, which can be expressed as child elements. +\n +:param tauRise: +:type tauRise: time +:param tauDecay: +:type tauDecay: time +:param gbase: Baseline conductance, generally the maximum conductance following a single spike +:type gbase: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Base type of any cell ( e. g. point neuron like **izhikevich2007Cell** , or a morphologically detailed **Cell** with **segment** s ) which can be used in a **population** + + + + + + + + + + + Integrate and fire cell which returns to its leak reversal potential of **leakReversal** with a time constant **tau** +\n +:param leakReversal: +:type leakReversal: voltage +:param tau: +:type tau: time +:param thresh: The membrane potential at which to emit a spiking event and reset voltage +:type thresh: voltage +:param reset: The value the membrane potential is reset to on spiking +:type reset: voltage + + + + + + + + + + + + + + + Integrate and fire cell which returns to its leak reversal potential of **leakReversal** with a time course **tau.** It has a refractory period of **refract** after spiking +\n +:param refract: +:type refract: time +:param leakReversal: +:type leakReversal: voltage +:param tau: +:type tau: time +:param thresh: The membrane potential at which to emit a spiking event and reset voltage +:type thresh: voltage +:param reset: The value the membrane potential is reset to on spiking +:type reset: voltage + + + + + + + + + + + + Integrate and fire cell with capacitance **C,** **leakConductance** and **leakReversal** +\n +:param leakConductance: +:type leakConductance: conductance +:param leakReversal: +:type leakReversal: voltage +:param thresh: +:type thresh: voltage +:param reset: +:type reset: voltage +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + + + + + Integrate and fire cell with capacitance **C,** **leakConductance,** **leakReversal** and refractory period **refract** +\n +:param refract: +:type refract: time +:param leakConductance: +:type leakConductance: conductance +:param leakReversal: +:type leakReversal: voltage +:param thresh: +:type thresh: voltage +:param reset: +:type reset: voltage +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + Cell based on the 2003 model of Izhikevich, see http://izhikevich.org/publications/spikes.htm +\n +:param v0: Initial membrane potential +:type v0: voltage +:param a: Time scale of the recovery variable U +:type a: none +:param b: Sensitivity of U to the subthreshold fluctuations of the membrane potential V +:type b: none +:param c: After-spike reset value of V +:type c: none +:param d: After-spike increase to U +:type d: none +:param thresh: Spike threshold +:type thresh: voltage + + + + + + + + + + + + + + + + + Any cell with a membrane potential **v** with voltage units and a membrane capacitance **C.** Also defines exposed value **iSyn** for current due to external synapses and **iMemb** for total transmembrane current ( usually channel currents plus **iSyn** ) +\n +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + + + + + + + Cell based on the modified Izhikevich model in Izhikevich 2007, Dynamical systems in neuroscience, MIT Press +\n +:param v0: Initial membrane potential +:type v0: voltage +:param k: +:type k: conductance_per_voltage +:param vr: Resting membrane potential +:type vr: voltage +:param vt: Spike threshold +:type vt: voltage +:param vpeak: Peak action potential value +:type vpeak: voltage +:param a: Time scale of recovery variable u +:type a: per_time +:param b: Sensitivity of recovery variable u to subthreshold fluctuations of membrane potential v +:type b: conductance +:param c: After-spike reset value of v +:type c: voltage +:param d: After-spike increase to u +:type d: current +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + + + + + + + + + Model based on Brette R and Gerstner W ( 2005 ) Adaptive Exponential Integrate-and-Fire Model as an Effective Description of Neuronal Activity. J Neurophysiol 94:3637-3642 +\n +:param gL: Leak conductance +:type gL: conductance +:param EL: Leak reversal potential +:type EL: voltage +:param VT: Spike threshold +:type VT: voltage +:param thresh: Spike detection threshold +:type thresh: voltage +:param reset: Reset potential +:type reset: voltage +:param delT: Slope factor +:type delT: voltage +:param tauw: Adaptation time constant +:type tauw: time +:param refract: Refractory period +:type refract: time +:param a: Sub-threshold adaptation variable +:type a: conductance +:param b: Spike-triggered adaptation variable +:type b: current +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + + + + + + + + + + Simple dimensionless model of spiking cell from FitzHugh and Nagumo. Superseded by **fitzHughNagumo1969Cell** ( See https://github.com/NeuroML/NeuroML2/issues/42 ) +\n +:param I: +:type I: none + + + + + + + + + + + + The Fitzhugh Nagumo model is a two-dimensional simplification of the Hodgkin-Huxley model of spike generation in squid giant axons. This system was suggested by FitzHugh ( FitzHugh R. [1961]: Impulses and physiological states in theoretical models of nerve membrane. Biophysical J. 1:445-466 ), who called it " Bonhoeffer-van der Pol model ", and the equivalent circuit by Nagumo et al. ( Nagumo J. , Arimoto S. , and Yoshizawa S. [1962] An active pulse transmission line simulating nerve axon. Proc IRE. 50:2061-2070. 1962 ). This version corresponds to the one described in FitzHugh R. [1969]: Mathematical models of excitation and propagation in nerve. Chapter 1 ( pp. 1-85 in H. P. Schwan, ed. Biological Engineering, McGraw-Hill Book Co. , N. Y. ) +\n +:param a: +:type a: none +:param b: +:type b: none +:param I: plays the role of an external injected current +:type I: none +:param phi: +:type phi: none +:param V0: +:type V0: none +:param W0: +:type W0: none + + + + + + + + + + + + + + + + + Reduced CA3 cell model from Pinsky, P. F. , Rinzel, J. Intrinsic and network rhythmogenesis in a reduced traub model for CA3 neurons. J Comput Neurosci 1, 39-60 ( 1994 ). See https://github.com/OpenSourceBrain/PinskyRinzelModel +\n +:param iSoma: +:type iSoma: currentDensity +:param iDend: +:type iDend: currentDensity +:param gLs: +:type gLs: conductanceDensity +:param gLd: +:type gLd: conductanceDensity +:param gNa: +:type gNa: conductanceDensity +:param gKdr: +:type gKdr: conductanceDensity +:param gCa: +:type gCa: conductanceDensity +:param gKahp: +:type gKahp: conductanceDensity +:param gKC: +:type gKC: conductanceDensity +:param gc: +:type gc: conductanceDensity +:param eNa: +:type eNa: voltage +:param eCa: +:type eCa: voltage +:param eK: +:type eK: voltage +:param eL: +:type eL: voltage +:param pp: +:type pp: none +:param cm: +:type cm: specificCapacitance +:param alphac: +:type alphac: none +:param betac: +:type betac: none +:param gNmda: +:type gNmda: conductanceDensity +:param gAmpa: +:type gAmpa: conductanceDensity +:param qd0: +:type qd0: none + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The Hindmarsh Rose model is a simplified point cell model which captures complex firing patterns of single neurons, such as periodic and chaotic bursting. It has a fast spiking subsystem, which is a generalization of the FitzHugh-Nagumo system, coupled to a slower subsystem which allows the model to fire bursts. The dynamical variables x, y, z correspond to the membrane potential, a recovery variable, and a slower adaptation current, respectively. See Hindmarsh J. L. , and Rose R. M. ( 1984 ) A model of neuronal bursting using three coupled first order differential equations. Proc. R. Soc. London, Ser. B 221:87–102. +\n +:param a: cubic term in x nullcline +:type a: none +:param b: quadratic term in x nullcline +:type b: none +:param c: constant term in y nullcline +:type c: none +:param d: quadratic term in y nullcline +:type d: none +:param r: timescale separation between slow and fast subsystem ( r greater than 0; r much less than 1 ) +:type r: none +:param s: related to adaptation +:type s: none +:param x1: related to the system's resting potential +:type x1: none +:param v_scaling: scaling of x for physiological membrane potential +:type v_scaling: voltage +:param x0: +:type x0: none +:param y0: +:type y0: none +:param z0: +:type z0: none +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + + + + + + + + + + + Cell with **segment** s specified in a **morphology** element along with details on its **biophysicalProperties** . NOTE: this can only be correctly simulated using jLEMS when there is a single segment in the cell, and **v** of this cell represents the membrane potential in that isopotential segment. + + + + + + + + + + + + + + + + + + + + + + Variant of cell with two independent Ca2+ pools. Cell with **segment** s specified in a **morphology** element along with details on its **biophysicalProperties** . NOTE: this can only be correctly simulated using jLEMS when there is a single segment in the cell, and **v** of this cell represents the membrane potential in that isopotential segment. + + + + + + + + + + + + + The collection of **segment** s which specify the 3D structure of the cell, along with a number of **segmentGroup** s + + + + + + + + + + + + + + A segment defines the smallest unit within a possibly branching structure ( **morphology** ), such as a dendrite or axon. Its **id** should be a nonnegative integer ( usually soma/root = 0 ). Its end points are given by the **proximal** and **distal** points. The **proximal** point can be omitted, usually because it is the same as a point on the **parent** segment, see **proximal** for details. **parent** specifies the parent segment. The first segment of a **cell** ( with no **parent** ) usually represents the soma. The shape is normally a cylinder ( radii of the **proximal** and **distal** equal, but positions different ) or a conical frustum ( radii and positions different ). If the x, y, x positions of the **proximal** and **distal** are equal, the segment can be interpreted as a sphere, and in this case the radii of these points must be equal. NOTE: LEMS does not yet support multicompartmental modelling, so the Dynamics here is only appropriate for single compartment modelling. + + + + + + + + + + + + + + + + + + + + + + + + + + Base type for ComponentTypes which specify an ( **x,** **y,** **z** ) coordinate along with a **diameter.** Note: no dimension used in the attributes for these coordinates! These are assumed to have dimension micrometer ( 10^-6 m ). This is due to micrometers being the default option for the majority of neuronal morphology formats, and dimensions are omitted here to facilitate reading and writing of morphologies in NeuroML. +\n +:param x: x coordinate of the point. Note: no dimension used, see description of **point3DWithDiam** for details. +:type x: none +:param y: y coordinate of the ppoint. Note: no dimension used, see description of **point3DWithDiam** for details. +:type y: none +:param z: z coordinate of the ppoint. Note: no dimension used, see description of **point3DWithDiam** for details. +:type z: none +:param diameter: Diameter of the ppoint. Note: no dimension used, see description of **point3DWithDiam** for details. +:type diameter: none + + + + + + + + + + + + + + + A method to describe a group of **segment** s in a **morphology** , e. g. soma_group, dendrite_group, axon_group. While a name is useful to describe the group, the **neuroLexId** attribute can be used to explicitly specify the meaning of the group, e. g. sao1044911821 for 'Neuronal Cell Body', sao1211023249 for 'Dendrite'. The **segment** s in this group can be specified as: a list of individual **member** segments; a **path** , all of the segments along which should be included; a **subTree** of the **cell** to include; other segmentGroups to **include** ( so all segments from those get included here ). An **inhomogeneousParameter** can be defined on the region of the cell specified by this group ( see **variableParameter** for usage ). + + + + + + + + + + + + + + + + + + + + + An inhomogeneous parameter specified across the **segmentGroup** ( see **variableParameter** for usage ). + + + + + + + + + + + + + + + + Allowed metrics for InhomogeneousParam + + + + + + + + What to do at the proximal point when creating an inhomogeneous parameter + + + + + + + + + + + What to do at the distal point when creating an inhomogeneous parameter + + + + + + + + + + + A single identified **segment** which is part of the **segmentGroup** + + + + + + + + + + + Include all members of another **segmentGroup** in this group + + + + + + + + + + + Include all the **segment** s between those specified by **from** and **to** , inclusive + + + + + + + + + + + + + + Include all the **segment** s distal to that specified by **from** in the **segmentGroup** + + + + + + + + + + + + + + + + + + + + + + + + The biophysical properties of the **cell** , including the **membraneProperties** and the **intracellularProperties** + + + + + + + + + + + + + + + The biophysical properties of the **cell** , including the **membraneProperties2CaPools** and the **intracellularProperties2CaPools** for a cell with two Ca pools + + + + + + + + + + + + + + + Properties specific to the membrane, such as the **populations** of channels, **channelDensities,** **specificCapacitance,** etc. + + + + + + + + + + + + + + + + + + + + + + + + + + Variant of membraneProperties with 2 independent Ca pools + + + + + + + + + + + + + + Membrane potential at which to emit a spiking event. Note, usually the spiking event will not be emitted again until the membrane potential has fallen below this value and rises again to cross it in a positive direction +\n +:param value: +:type value: voltage + + + + + + + + + + + + + Capacitance per unit area +\n +:param value: +:type value: specificCapacitance + + + + + + + + + + + + + Explicitly set initial membrane potential for the cell +\n +:param value: +:type value: voltage + + + + + + + + + + + + + The resistivity, or specific axial resistance, of the cytoplasm +\n +:param value: +:type value: resistivity + + + + + + + + + + + + + Population of a **number** of ohmic ion channels. These each produce a conductance **channelg** across a reversal potential **erev,** giving a total current **i.** Note that active membrane currents are more frequently specified as a density over an area of the **cell** using **channelDensity** +\n +:param number: The number of channels present. This will be multiplied by the time varying conductance of the individual ion channel ( which extends **baseIonChannel** ) to produce the total conductance +:type number: none +:param erev: The reversal potential of the current produced +:type erev: voltage + + + + + + + + + + + + + + + + + + + + + + + + Specifies a time varying ohmic conductance density, which is distributed on a region of the **cell.** The conductance density of the channel is not uniform, but is set using the **variableParameter** . Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON +\n +:param erev: The reversal potential of the current produced +:type erev: voltage + + + + + + + + + + + + + + + + + + + + Specifies a time varying conductance density, which is distributed on a region of the **cell,** and whose reversal potential is calculated from the Nernst equation. Hard coded for Ca only!. The conductance density of the channel is not uniform, but is set using the **variableParameter** . Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON + + + + + + + + + + + + + + + + + + Specifies a time varying conductance density, which is distributed on a region of the **cell,** and whose current is calculated from the Goldman-Hodgkin-Katz equation. Hard coded for Ca only!. The conductance density of the channel is not uniform, but is set using the **variableParameter** . Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON + + + + + + + + + + + + + + + + + + Base type for a current of density **iDensity** distributed on an area of a **cell** , flowing through the specified **ionChannel.** Instances of this ( normally **channelDensity** ) are specified in the **membraneProperties** of the **cell** . + + + + + + + + + + + + + Specifies a time varying ohmic conductance density, **gDensity,** which is distributed on an area of the **cell** ( specified in **membraneProperties** ) with fixed reversal potential **erev** producing a current density **iDensity** +\n +:param erev: The reversal potential of the current produced +:type erev: voltage +:param condDensity: +:type condDensity: conductanceDensity + + + + + + + + + + + + + + + + + + + + + + + + Same as **channelDensity** , but with a **vShift** parameter to change voltage activation of gates. The exact usage of **vShift** in expressions for rates is determined by the individual gates. +\n +:param vShift: +:type vShift: voltage +:param erev: The reversal potential of the current produced +:type erev: voltage +:param condDensity: +:type condDensity: conductanceDensity + + + + + + + + + + + + Specifies a time varying conductance density, **gDensity,** which is distributed on an area of the **cell,** producing a current density **iDensity** and whose reversal potential is calculated from the Nernst equation. Hard coded for Ca only! See https://github.com/OpenSourceBrain/ghk-nernst. +\n +:param condDensity: +:type condDensity: conductanceDensity + + + + + + + + + + + + + + + + + + + + + + + This component is similar to the original component type **channelDensityNernst** but it is changed in order to have a reversal potential that depends on a second independent Ca++ pool ( ca2 ). See https://github.com/OpenSourceBrain/ghk-nernst. +\n +:param condDensity: +:type condDensity: conductanceDensity + + + + + + + + + + + + Specifies a time varying conductance density, **gDensity,** which is distributed on an area of the cell, producing a current density **iDensity** and whose reversal potential is calculated from the Goldman Hodgkin Katz equation. Hard coded for Ca only! See https://github.com/OpenSourceBrain/ghk-nernst. +\n +:param permeability: +:type permeability: permeability + + + + + + + + + + + + + + + + + + + + Time varying conductance density, **gDensity,** which is distributed on an area of the cell, producing a current density **iDensity.** Modified version of Jaffe et al. 1994 ( used also in Lawrence et al. 2006 ). See https://github.com/OpenSourceBrain/ghk-nernst. +\n +:param condDensity: +:type condDensity: conductanceDensity + + + + + + + + + + + + + + + + + + + + + Specifies a **parameter** ( e. g. condDensity ) which can vary its value across a **segmentGroup.** The value is calculated from **value** attribute of the **inhomogeneousValue** subelement. This element is normally a child of **channelDensityNonUniform** , **channelDensityNonUniformNernst** or **channelDensityNonUniformGHK** and is used to calculate the value of the conductance, etc. which will vary on different parts of the cell. The **segmentGroup** specified here needs to define an **inhomogeneousParameter** ( referenced from **inhomogeneousParameter** in the **inhomogeneousValue** ), which calculates a **variable** ( e. g. p ) varying across the cell ( e. g. based on the path length from soma ), which is then used in the **value** attribute of the **inhomogeneousValue** ( so for example condDensity = f( p ) ) + + + + + + + + + + + Specifies the **value** of an **inhomogeneousParameter.** For usage see **variableParameter** + + + + + + + + + + + + + Description of a chemical species identified by **ion,** which has internal, **concentration,** and external, **extConcentration** values for its concentration +\n +:param initialConcentration: +:type initialConcentration: concentration +:param initialExtConcentration: +:type initialExtConcentration: concentration + + + + + + + + + + + + + + + + + + + + + + + + + + + Biophysical properties related to the intracellular space within the **cell** , such as the **resistivity** and the list of ionic **species** present. **caConc** and **caConcExt** are explicitly exposed here to facilitate accessing these values from other Components, even though **caConcExt** is clearly not an intracellular property + + + + + + + + + + + + + + Variant of intracellularProperties with 2 independent Ca pools + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Generates a constant current pulse of a certain **amplitude** for a specified **duration** after a **delay.** Scaled by **weight,** if set +\n +:param delay: Delay before change in current. Current is zero prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is zero after delay + duration. +:type duration: time +:param amplitude: Amplitude of current pulse +:type amplitude: current + + + + + + + + + + + + + + Dimensionless equivalent of **pulseGenerator** . Generates a constant current pulse of a certain **amplitude** for a specified **duration** after a **delay.** Scaled by **weight,** if set +\n +:param delay: Delay before change in current. Current is zero prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is zero after delay + duration. +:type duration: time +:param amplitude: Amplitude of current pulse +:type amplitude: none + + + + + + + + + + + + + + Generates a sinusoidally varying current after a time **delay,** for a fixed **duration.** The **period** and maximum **amplitude** of the current can be set as well as the **phase** at which to start. Scaled by **weight,** if set +\n +:param phase: Phase ( between 0 and 2*pi ) at which to start the varying current ( i. e. at time given by delay ) +:type phase: none +:param delay: Delay before change in current. Current is zero prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is zero after delay + duration. +:type duration: time +:param amplitude: Maximum amplitude of current +:type amplitude: current +:param period: Time period of oscillation +:type period: time + + + + + + + + + + + + + + + + Dimensionless equivalent of **sineGenerator** . Generates a sinusoidally varying current after a time **delay,** for a fixed **duration.** The **period** and maximum **amplitude** of the current can be set as well as the **phase** at which to start. Scaled by **weight,** if set +\n +:param phase: Phase ( between 0 and 2*pi ) at which to start the varying current ( i. e. at time given by delay ) +:type phase: none +:param delay: Delay before change in current. Current is zero prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is zero after delay + duration. +:type duration: time +:param amplitude: Maximum amplitude of current +:type amplitude: none +:param period: Time period of oscillation +:type period: time + + + + + + + + + + + + + + + + Generates a ramping current after a time **delay,** for a fixed **duration.** During this time the current steadily changes from **startAmplitude** to **finishAmplitude.** Scaled by **weight,** if set +\n +:param delay: Delay before change in current. Current is baselineAmplitude prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is baselineAmplitude after delay + duration. +:type duration: time +:param startAmplitude: Amplitude of linearly varying current at time delay +:type startAmplitude: current +:param finishAmplitude: Amplitude of linearly varying current at time delay + duration +:type finishAmplitude: current +:param baselineAmplitude: Amplitude of current before time delay, and after time delay + duration +:type baselineAmplitude: current + + + + + + + + + + + + + + + + Dimensionless equivalent of **rampGenerator** . Generates a ramping current after a time **delay,** for a fixed **duration.** During this time the dimensionless current steadily changes from **startAmplitude** to **finishAmplitude.** Scaled by **weight,** if set +\n +:param delay: Delay before change in current. Current is baselineAmplitude prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is baselineAmplitude after delay + duration. +:type duration: time +:param startAmplitude: Amplitude of linearly varying current at time delay +:type startAmplitude: none +:param finishAmplitude: Amplitude of linearly varying current at time delay + duration +:type finishAmplitude: none +:param baselineAmplitude: Amplitude of current before time delay, and after time delay + duration +:type baselineAmplitude: none + + + + + + + + + + + + + + + + Generates a current which is the sum of all its child **basePointCurrent** element, e. g. can be a combination of **pulseGenerator** , **sineGenerator** elements producing a single **i.** Scaled by **weight,** if set + + + + + + + + + + + + + + + Generates a current which is the sum of all its child **basePointCurrentDL** elements, e. g. can be a combination of **pulseGeneratorDL** , **sineGeneratorDL** elements producing a single **i.** Scaled by **weight,** if set + + + + + + + + + + + + + + + Voltage clamp. Applies a variable current **i** to try to keep parent at **targetVoltage.** Not yet fully tested!!! Consider using voltageClampTriple!! +\n +:param delay: Delay before change in current. Current is zero prior to this. +:type delay: time +:param duration: Duration for attempting to keep parent at targetVoltage. Current is zero after delay + duration. +:type duration: time +:param targetVoltage: Current will be applied to try to get parent to this target voltage +:type targetVoltage: voltage +:param simpleSeriesResistance: Current will be calculated by the difference in voltage between the target and parent, divided by this value +:type simpleSeriesResistance: resistance + + + + + + + + + + + + + + + Voltage clamp with 3 clamp levels. Applies a variable current **i** ( through **simpleSeriesResistance** ) to try to keep parent cell at **conditioningVoltage** until time **delay,** **testingVoltage** until **delay** + **duration,** and **returnVoltage** afterwards. Only enabled if **active** = 1. +\n +:param active: Whether the voltage clamp is active ( 1 ) or inactive ( 0 ). +:type active: none +:param delay: Delay before switching from conditioningVoltage to testingVoltage. +:type delay: time +:param duration: Duration to hold at testingVoltage. +:type duration: time +:param conditioningVoltage: Target voltage before time delay +:type conditioningVoltage: voltage +:param testingVoltage: Target voltage between times delay and delay + duration +:type testingVoltage: voltage +:param returnVoltage: Target voltage after time duration +:type returnVoltage: voltage +:param simpleSeriesResistance: Current will be calculated by the difference in voltage between the target and parent, divided by this value +:type simpleSeriesResistance: resistance + + + + + + + + + + + + + + + + + + Emits a single spike at the specified **time** +\n +:param time: Time at which to emit one spike event +:type time: time + + + + + + + + + + + + Set of spike ComponentTypes, each emitting one spike at a certain time. Can be used to feed a predetermined spike train into a cell + + + + + + + + + + + + + Spike array connected to a single **synapse,** producing a current triggered by each **spike** in the array. + + + + + + + + + + + + + + + Simple generator of spikes at a regular interval set by **period** +\n +:param period: Time between spikes. The first spike will be emitted after this time. +:type period: time + + + + + + + + + + + + Generator of spikes with a random interspike interval of at least **minISI** and at most **maxISI** +\n +:param maxISI: Maximum interspike interval +:type maxISI: time +:param minISI: Minimum interspike interval +:type minISI: time + + + + + + + + + + + + + Generator of spikes whose ISI is distributed according to an exponential PDF with scale: 1 / **averageRate** +\n +:param averageRate: The average rate at which spikes are emitted +:type averageRate: per_time + + + + + + + + + + + + Generator of spikes whose ISI distribution is the maximum entropy distribution over [ **minimumISI,** +infinity ) with mean: 1 / **averageRate** +\n +:param minimumISI: The minimum interspike interval +:type minimumISI: time +:param averageRate: The average rate at which spikes are emitted +:type averageRate: per_time + + + + + + + + + + + + Poisson spike generator firing at **averageRate,** which is connected to single **synapse** that is triggered every time a spike is generated, producing an input current. See also **transientPoissonFiringSynapse** . +\n +:param averageRate: The average rate at which spikes are emitted +:type averageRate: per_time + + + + + + + + + + + + + + Poisson spike generator firing at **averageRate** after a **delay** and for a **duration,** connected to single **synapse** that is triggered every time a spike is generated, providing an input current. Similar to ComponentType **poissonFiringSynapse** . +\n +:param averageRate: +:type averageRate: per_time +:param delay: +:type delay: time +:param duration: +:type duration: time + + + + + + + + + + + + + + + + + + + Network containing: **population** s ( potentially of type **populationList** , and so specifying a list of cell **location** s ); **projection** s ( with lists of **connection** s ) and/or **explicitConnection** s; and **inputList** s ( with lists of **input** s ) and/or **explicitInput** s. Note: often in NeuroML this will be of type **networkWithTemperature** if there are temperature dependent elements ( e. g. ion channels ). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Initial attempt to specify 3D region for placing cells. Work in progress. . . + + + + + + + + + + + + + + + A population of components, with just one parameter for the **size,** i. e. number of components to create. Note: quite often this is used with type= **populationList** which means the size is determined by the number of **instance** s ( with **location** s ) in the list. The **size** attribute is still set, and there will be a validation error if this does not match the number in the list. +\n +:param size: Number of instances of this Component to create when the population is instantiated +:type size: none + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Specifies a single instance of a component in a **population** ( placed at **location** ). + + + + + + + + + + + + + + + + + + + + Specifies the ( x, y, z ) location of a single **instance** of a component in a **population** +\n +:param x: +:type x: none +:param y: +:type y: none +:param z: +:type z: none + + + + + + + + + + + + + + + + + + + + + + + + + Explicit event connection between named components, which gets processed via a new instance of a **synapse** component which is created on the target component + + + + + + + + + + + + + + + Base for projection (set of synaptic connections) between two populations + + + + + + + + + + + Projection from one population, **presynapticPopulation** to another, **postsynapticPopulation,** through **synapse.** Contains lists of **connection** or **connectionWD** elements. + + + + + + + + + + + + + + + Base of all synaptic connections (chemical/electrical/analog, etc.) inside projections + + + + + + + + + + + Base of all synaptic connections with preCellId, postSegmentId, etc. + Note: this is not the best name for these attributes, since Id is superfluous, hence BaseConnectionNewFormat + + + + + + + + + + + + + + + Base of all synaptic connections with preCell, postSegment, etc. + See BaseConnectionOldFormat + + + + + + + + + + + + + + + Event connection directly between named components, which gets processed via a new instance of a **synapse** component which is created on the target component. Normally contained inside a **projection** element. + + + + + + + + + + Event connection between named components, which gets processed via a new instance of a synapse component which is created on the target component, includes setting of **weight** and **delay** for the synaptic connection +\n +:param weight: +:type weight: none +:param delay: +:type delay: time + + + + + + + + + + + + + A projection between **presynapticPopulation** to another **postsynapticPopulation** through gap junctions. + + + + + + + + + + + + + + + To enable connections between populations through gap junctions. + + + + + + + + + + + To enable connections between populations through gap junctions. Populations need to be of type **populationList** and contain **instance** and **location** elements. + + + + + + + + + To enable connections between populations through gap junctions. Populations need to be of type **populationList** and contain **instance** and **location** elements. Includes setting of **weight** for the connection +\n +:param weight: +:type weight: none + + + + + + + + + + + + A projection between **presynapticPopulation** and **postsynapticPopulation** through components **preComponent** at the start and **postComponent** at the end of a **continuousConnection** or **continuousConnectionInstance** . Can be used for analog synapses. + + + + + + + + + + + + + + + An instance of a connection in a **continuousProjection** between **presynapticPopulation** to another **postsynapticPopulation** through a **preComponent** at the start and **postComponent** at the end. Can be used for analog synapses. + + + + + + + + + + + + An instance of a connection in a **continuousProjection** between **presynapticPopulation** to another **postsynapticPopulation** through a **preComponent** at the start and **postComponent** at the end. Populations need to be of type **populationList** and contain **instance** and **location** elements. Can be used for analog synapses. + + + + + + + + + An instance of a connection in a **continuousProjection** between **presynapticPopulation** to another **postsynapticPopulation** through a **preComponent** at the start and **postComponent** at the end. Populations need to be of type **populationList** and contain **instance** and **location** elements. Can be used for analog synapses. Includes setting of **weight** for the connection +\n +:param weight: +:type weight: none + + + + + + + + + + + + An explicit input ( anything which extends **basePointCurrent** ) to a target cell in a population + + + + + + + + + + + + + An explicit list of **input** s to a **population.** + + + + + + + + + + + + + + + + Specifies a single input to a **target,** optionally giving the **segmentId** ( default 0 ) and **fractionAlong** the segment ( default 0. 5 ). + + + + + + + + + + + + + + Specifies input lists. Can set **weight** to scale individual inputs. +\n +:param weight: +:type weight: none + + + + + + + + + + + + + + + Base type of any PyNN standard cell model. Note: membrane potential **v** has dimensions voltage, but all other parameters are dimensionless. This is to facilitate translation to and from PyNN scripts in Python, where these parameters have implicit units, see http://neuralensemble.org/trac/PyNN/wiki/StandardModels +\n +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + + + + + + Base type of any PyNN standard integrate and fire model +\n +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + + + + + + Base type of conductance based PyNN IaF cell models +\n +:param e_rev_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_E: none +:param e_rev_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_I: none +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + + + Leaky integrate and fire model with fixed threshold and alpha-function-shaped post-synaptic current +\n +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + Leaky integrate and fire model with fixed threshold and decaying-exponential post-synaptic current +\n +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + Leaky integrate and fire model with fixed threshold and alpha-function-shaped post-synaptic conductance +\n +:param e_rev_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_E: none +:param e_rev_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_I: none +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + Leaky integrate and fire model with fixed threshold and exponentially-decaying post-synaptic conductance +\n +:param e_rev_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_E: none +:param e_rev_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_I: none +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + Adaptive exponential integrate and fire neuron according to Brette R and Gerstner W ( 2005 ) with exponentially-decaying post-synaptic conductance +\n +:param v_spike: +:type v_spike: none +:param delta_T: +:type delta_T: none +:param tau_w: +:type tau_w: none +:param a: +:type a: none +:param b: +:type b: none +:param e_rev_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_E: none +:param e_rev_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_I: none +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + + + + + + Adaptive exponential integrate and fire neuron according to Brette R and Gerstner W ( 2005 ) with alpha-function-shaped post-synaptic conductance +\n +:param v_spike: +:type v_spike: none +:param delta_T: +:type delta_T: none +:param tau_w: +:type tau_w: none +:param a: +:type a: none +:param b: +:type b: none +:param e_rev_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_E: none +:param e_rev_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_I: none +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + Single-compartment Hodgkin-Huxley-type neuron with transient sodium and delayed-rectifier potassium currents using the ion channel models from Traub. +\n +:param gbar_K: +:type gbar_K: none +:param gbar_Na: +:type gbar_Na: none +:param g_leak: +:type g_leak: none +:param e_rev_K: +:type e_rev_K: none +:param e_rev_Na: +:type e_rev_Na: none +:param e_rev_leak: +:type e_rev_leak: none +:param v_offset: +:type v_offset: none +:param e_rev_E: +:type e_rev_E: none +:param e_rev_I: +:type e_rev_I: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + + + + + + + + + + Base type for all PyNN synapses. Note, the current **I** produced is dimensionless, but it requires a membrane potential **v** with dimension voltage +\n +:param tau_syn: +:type tau_syn: none + + + + + + + + + + + + Conductance based synapse with instantaneous rise and single exponential decay ( with time constant tau_syn ) +\n +:param e_rev: +:type e_rev: none +:param tau_syn: +:type tau_syn: none + + + + + + + + + + + + Alpha synapse: rise time and decay time are both tau_syn. Conductance based synapse. +\n +:param e_rev: +:type e_rev: none +:param tau_syn: +:type tau_syn: none + + + + + + + + + + + + Current based synapse with instantaneous rise and single exponential decay ( with time constant tau_syn ) +\n +:param tau_syn: +:type tau_syn: none + + + + + + + + + + + + Alpha synapse: rise time and decay time are both tau_syn. Current based synapse. +\n +:param tau_syn: +:type tau_syn: none + + + + + + + + + + + + Spike source, generating spikes according to a Poisson process. +\n +:param start: +:type start: time +:param duration: +:type duration: time +:param rate: +:type rate: per_time + + + + + + + + + + + + + + + + + + Base element without ID specified *yet*, e.g. for an element with a particular requirement on its id which does not comply with NmlId (e.g. Segment needs nonNegativeInteger). + + + + + Anything which can have a unique (within its parent) id, which must be an integer zero or greater. + + + + + + + + + + Anything which can have a unique (within its parent) id of the form NmlId (spaceless combination of letters, numbers and underscore). + + + + + + + + + + Elements which can stand alone and be referenced by id, e.g. cell, morphology. + + + + + + + + + + + + + + + + diff --git a/neuroml/nml/generatedssupersuper.py b/neuroml/nml/generatedssupersuper.py index 2753ece..0bea3a7 100644 --- a/neuroml/nml/generatedssupersuper.py +++ b/neuroml/nml/generatedssupersuper.py @@ -6,6 +6,7 @@ Copyright 2023 NeuroML contributors """ +import inspect import logging import sys @@ -195,6 +196,50 @@ def component_factory(cls, component_type, validate=True, **kwargs): else: comp_type_class = getattr(module_object, component_type.__name__) + # handle Components that allow "anyAttributes_": these are included in + # the schema to allow use of user-defined Components + comp_type_class_members = inspect.getmembers(comp_type_class, inspect.isroutine) + comp_type_class_init = None + for m in comp_type_class_members: + name, value = m + if name == "__init__": + comp_type_class_init = value + break + + # all component type classes should have a constructor + assert comp_type_class_init is not None + + init_source = inspect.getsource(comp_type_class_init) + comp_type_class_members = comp_type_class._get_members() + + # If we do have an anyattribute, we need to split the kwargs into + # members and other bits that will populate the anyattribute because + # the anyattribute needs to be explicitly populated by us. + + # Unfortunately, there isn't a better way of detecting if a class takes + # anyAttributes than to check its source. We could instantiate objects + # of each class, but that's going to be more expensive. + if "self.anyAttributes_ = {}" in init_source: + new_comp_args = kwargs.copy() + member_args = {} + for m in comp_type_class_members: + try: + member_args[m.get_name()] = new_comp_args.pop(m.get_name()) + except KeyError: + cls.logger.error( + f"Error: {comp_type_class} requires {m.get_name()}" + ) + + # create new class with args that match members + comp = comp_type_class(**member_args) + # populate anyattributes with remaining kwargs + comp.anyAttributes_ = new_comp_args + cls.logger.warning( + "New Component created. Note: This will NOT be validated against the schema." + ) + return comp + + # if it does not have an anyattribute, treat as general comp = comp_type_class(**kwargs) # handle component types that support __ANY__ diff --git a/neuroml/nml/nml.py b/neuroml/nml/nml.py index b19790d..06fbf32 100644 --- a/neuroml/nml/nml.py +++ b/neuroml/nml/nml.py @@ -2,7 +2,7 @@ # -*- coding: utf-8 -*- # -# Generated Wed Oct 16 16:26:54 2024 by generateDS.py version 2.44.1. +# Generated Wed Oct 16 16:30:12 2024 by generateDS.py version 2.44.1. # Python 3.11.10 (main, Sep 9 2024, 00:00:00) [GCC 14.2.1 20240801 (Red Hat 14.2.1-1)] # # Command line options: @@ -13,10 +13,10 @@ # ('--custom-imports-template', 'gds_imports-template.py') # # Command line arguments: -# NeuroML_v2.3.1.xsd +# NeuroML_v2.3.2.xsd # # Command line: -# /home/asinha/.local/share/virtualenvs/neuroml-311-dev/bin/generateDS -o "nml.py" --use-getter-setter="none" --user-methods="helper_methods.py" --export="write validate" --custom-imports-template="gds_imports-template.py" NeuroML_v2.3.1.xsd +# /home/asinha/.local/share/virtualenvs/neuroml-311-dev/bin/generateDS -o "nml.py" --use-getter-setter="none" --user-methods="helper_methods.py" --export="write validate" --custom-imports-template="gds_imports-template.py" NeuroML_v2.3.2.xsd # # Current working directory (os.getcwd()): # nml @@ -21822,6 +21822,317 @@ def _buildChildren( # end class ChannelDensity +class BaseChannelDensity(Base): + """BaseChannelDensity -- Base type for a current of density **iDensity** distributed on an area of a **cell** , flowing through the specified **ionChannel.** Instances of this ( normally **channelDensity** ) are specified in the **membraneProperties** of the **cell** .""" + + __hash__ = GeneratedsSuper.__hash__ + member_data_items_ = [ + MemberSpec_( + "ion_channel", "NmlId", 0, 0, {"use": "required", "name": "ion_channel"} + ), + MemberSpec_("type", "NmlId", 0, 0, {"use": "required", "name": "type"}), + ] + subclass = None + superclass = Base + + def __init__( + self, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + type: "a NmlId (required)" = None, + gds_collector_=None, + **kwargs_, + ): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get("parent_object_") + self.ns_prefix_ = None + super(globals().get("BaseChannelDensity"), self).__init__(id, **kwargs_) + self.ion_channel = _cast(None, ion_channel) + self.ion_channel_nsprefix_ = None + self.type = _cast(None, type) + self.type_nsprefix_ = None + self.anyAttributes_ = {} + + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, BaseChannelDensity + ) + if subclass is not None: + return subclass(*args_, **kwargs_) + if BaseChannelDensity.subclass: + return BaseChannelDensity.subclass(*args_, **kwargs_) + else: + return BaseChannelDensity(*args_, **kwargs_) + + factory = staticmethod(factory) + + def validate_NmlId(self, value): + # Validate type NmlId, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_NmlId_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_NmlId_patterns_, + ) + ) + + validate_NmlId_patterns_ = [["^([a-zA-Z_][a-zA-Z0-9_]*)$"]] + + def has__content(self): + if super(BaseChannelDensity, self).has__content(): + return True + else: + return False + + def export( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="BaseChannelDensity", + pretty_print=True, + ): + imported_ns_def_ = GenerateDSNamespaceDefs_.get("BaseChannelDensity") + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = "\n" + else: + eol_ = "" + if self.original_tagname_ is not None and name_ == "BaseChannelDensity": + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ":" + showIndent(outfile, level, pretty_print) + outfile.write( + "<%s%s%s" + % ( + namespaceprefix_, + name_, + namespacedef_ and " " + namespacedef_ or "", + ) + ) + already_processed = set() + self._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="BaseChannelDensity", + ) + if self.has__content(): + outfile.write(">%s" % (eol_,)) + self._exportChildren( + outfile, + level + 1, + namespaceprefix_, + namespacedef_, + name_="BaseChannelDensity", + pretty_print=pretty_print, + ) + outfile.write("%s" % (namespaceprefix_, name_, eol_)) + else: + outfile.write("/>%s" % (eol_,)) + + def _exportAttributes( + self, + outfile, + level, + already_processed, + namespaceprefix_="", + name_="BaseChannelDensity", + ): + unique_counter = 0 + for name, value in self.anyAttributes_.items(): + xsinamespaceprefix = "xsi" + xsinamespace1 = "http://www.w3.org/2001/XMLSchema-instance" + xsinamespace2 = "{%s}" % (xsinamespace1,) + if name.startswith(xsinamespace2): + name1 = name[len(xsinamespace2) :] + name2 = "%s:%s" % ( + xsinamespaceprefix, + name1, + ) + if name2 not in already_processed: + already_processed.add(name2) + outfile.write( + " %s=%s" + % ( + name2, + quote_attrib(value), + ) + ) + else: + mo = re_.match(Namespace_extract_pat_, name) + if mo is not None: + namespace, name = mo.group(1, 2) + if name not in already_processed: + already_processed.add(name) + if namespace == "http://www.w3.org/XML/1998/namespace": + outfile.write( + " %s=%s" + % ( + name, + quote_attrib(value), + ) + ) + else: + unique_counter += 1 + outfile.write( + ' xmlns:%d="%s"' + % ( + unique_counter, + namespace, + ) + ) + outfile.write( + " %d:%s=%s" + % ( + unique_counter, + name, + quote_attrib(value), + ) + ) + else: + if name not in already_processed: + already_processed.add(name) + outfile.write( + " %s=%s" + % ( + name, + quote_attrib(value), + ) + ) + super(BaseChannelDensity, self)._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="BaseChannelDensity", + ) + if self.ion_channel is not None and "ion_channel" not in already_processed: + already_processed.add("ion_channel") + outfile.write( + " ionChannel=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.ion_channel), input_name="ionChannel" + ) + ), + ) + ) + if self.type is not None and "type" not in already_processed: + already_processed.add("type") + outfile.write( + " type=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.type), input_name="type" + ) + ), + ) + ) + + def _exportChildren( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="BaseChannelDensity", + fromsubclass_=False, + pretty_print=True, + ): + super(BaseChannelDensity, self)._exportChildren( + outfile, + level, + namespaceprefix_, + namespacedef_, + name_, + True, + pretty_print=pretty_print, + ) + pass + + def validate_(self, gds_collector, recursive=False): + self.gds_collector_ = gds_collector + message_count = len(self.gds_collector_.get_messages()) + # validate simple type attributes + self.gds_validate_defined_ST_( + self.validate_NmlId, self.ion_channel, "ion_channel" + ) + self.gds_check_cardinality_(self.ion_channel, "ion_channel", required=True) + self.gds_validate_defined_ST_(self.validate_NmlId, self.type, "type") + self.gds_check_cardinality_(self.type, "type", required=True) + # validate simple type children + # validate complex type children + if recursive: + pass + return message_count == len(self.gds_collector_.get_messages()) + + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self._buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + + def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("ionChannel", node) + if value is not None and "ionChannel" not in already_processed: + already_processed.add("ionChannel") + self.ion_channel = value + self.validate_NmlId(self.ion_channel) # validate type NmlId + value = find_attr_value_("type", node) + if value is not None and "type" not in already_processed: + already_processed.add("type") + self.type = value + self.validate_NmlId(self.type) # validate type NmlId + self.anyAttributes_ = {} + for name, value in attrs.items(): + if name not in already_processed: + self.anyAttributes_[name] = value + super(BaseChannelDensity, self)._buildAttributes(node, attrs, already_processed) + + def _buildChildren( + self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None + ): + super(BaseChannelDensity, self)._buildChildren(child_, node, nodeName_, True) + pass + + +# end class BaseChannelDensity + + class ChannelDensityNonUniformGHK(Base): """ChannelDensityNonUniformGHK -- Specifies a time varying conductance density, which is distributed on a region of the **cell,** and whose current is calculated from the Goldman-Hodgkin-Katz equation. Hard coded for Ca only!. The conductance density of the channel is not uniform, but is set using the **variableParameter** . Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON""" @@ -22433,7 +22744,8 @@ def _buildChildren( class ChannelDensityNonUniform(Base): """ChannelDensityNonUniform -- Specifies a time varying ohmic conductance density, which is distributed on a region of the **cell.** The conductance density of the channel is not uniform, but is set using the **variableParameter** . Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON \n - :param erev: The reversal potential of the current produced + :param erev: The reversal potential + of the current produced :type erev: voltage """ @@ -24435,6 +24747,19 @@ class MembraneProperties(BaseWithoutId): }, None, ), + MemberSpec_( + "baseChannelDensity", + "BaseChannelDensity", + 1, + 1, + { + "maxOccurs": "unbounded", + "minOccurs": "0", + "name": "baseChannelDensity", + "type": "BaseChannelDensity", + }, + None, + ), MemberSpec_( "channel_densities", "ChannelDensity", @@ -24585,6 +24910,7 @@ class MembraneProperties(BaseWithoutId): def __init__( self, channel_populations: "list of ChannelPopulation(s) (optional)" = None, + baseChannelDensity: "list of BaseChannelDensity(s) (optional)" = None, channel_densities: "list of ChannelDensity(s) (optional)" = None, channel_density_v_shifts: "list of ChannelDensityVShift(s) (optional)" = None, channel_density_nernsts: "list of ChannelDensityNernst(s) (optional)" = None, @@ -24613,6 +24939,11 @@ def __init__( else: self.channel_populations = channel_populations self.channel_populations_nsprefix_ = None + if baseChannelDensity is None: + self.baseChannelDensity = [] + else: + self.baseChannelDensity = baseChannelDensity + self.baseChannelDensity_nsprefix_ = None if channel_densities is None: self.channel_densities = [] else: @@ -24689,6 +25020,7 @@ def factory(*args_, **kwargs_): def has__content(self): if ( self.channel_populations + or self.baseChannelDensity or self.channel_densities or self.channel_density_v_shifts or self.channel_density_nernsts @@ -24823,6 +25155,20 @@ def _exportChildren( name_="channelPopulation", pretty_print=pretty_print, ) + for baseChannelDensity_ in self.baseChannelDensity: + namespaceprefix_ = ( + self.baseChannelDensity_nsprefix_ + ":" + if (UseCapturedNS_ and self.baseChannelDensity_nsprefix_) + else "" + ) + baseChannelDensity_.export( + outfile, + level, + namespaceprefix_, + namespacedef_="", + name_="baseChannelDensity", + pretty_print=pretty_print, + ) for channelDensity_ in self.channel_densities: namespaceprefix_ = ( self.channel_densities_nsprefix_ + ":" @@ -24993,6 +25339,12 @@ def validate_(self, gds_collector, recursive=False): min_occurs=0, max_occurs=9999999, ) + self.gds_check_cardinality_( + self.baseChannelDensity, + "baseChannelDensity", + min_occurs=0, + max_occurs=9999999, + ) self.gds_check_cardinality_( self.channel_densities, "channel_densities", @@ -25059,6 +25411,8 @@ def validate_(self, gds_collector, recursive=False): if recursive: for item in self.channel_populations: item.validate_(gds_collector, recursive=True) + for item in self.baseChannelDensity: + item.validate_(gds_collector, recursive=True) for item in self.channel_densities: item.validate_(gds_collector, recursive=True) for item in self.channel_density_v_shifts: @@ -25110,6 +25464,11 @@ def _buildChildren( obj_.build(child_, gds_collector_=gds_collector_) self.channel_populations.append(obj_) obj_.original_tagname_ = "channelPopulation" + elif nodeName_ == "baseChannelDensity": + obj_ = BaseChannelDensity.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.baseChannelDensity.append(obj_) + obj_.original_tagname_ = "baseChannelDensity" elif nodeName_ == "channelDensity": class_obj_ = self.get_class_obj_(child_, ChannelDensity) obj_ = class_obj_.factory(parent_object_=self) @@ -30676,38 +31035,12 @@ def _buildChildren( # end class BaseSynapse -class FixedFactorConcentrationModel(Standalone): - """FixedFactorConcentrationModel -- Model of buffering of concentration of an ion ( currently hard coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** A fixed factor **rho** is used to scale the incoming current *independently of the size of the compartment* to produce a concentration change. - \n - :param restingConc: - :type restingConc: concentration - :param decayConstant: - :type decayConstant: time - :param rho: - :type rho: rho_factor - - """ +class ConcentrationModel(Standalone): + """ConcentrationModel -- Base for any model of an **ion** concentration which changes with time. Internal ( **concentration** ) and external ( **extConcentration** ) values for the concentration of the ion are given.""" __hash__ = GeneratedsSuper.__hash__ member_data_items_ = [ MemberSpec_("ion", "NmlId", 0, 0, {"use": "required", "name": "ion"}), - MemberSpec_( - "resting_conc", - "Nml2Quantity_concentration", - 0, - 0, - {"use": "required", "name": "resting_conc"}, - ), - MemberSpec_( - "decay_constant", - "Nml2Quantity_time", - 0, - 0, - {"use": "required", "name": "decay_constant"}, - ), - MemberSpec_( - "rho", "Nml2Quantity_rhoFactor", 0, 0, {"use": "required", "name": "rho"} - ), ] subclass = None superclass = Standalone @@ -30720,9 +31053,7 @@ def __init__( properties: "list of Property(s) (optional)" = None, annotation: "a Annotation (optional)" = None, ion: "a NmlId (required)" = None, - resting_conc: "a Nml2Quantity_concentration (required)" = None, - decay_constant: "a Nml2Quantity_time (required)" = None, - rho: "a Nml2Quantity_rhoFactor (required)" = None, + extensiontype_=None, gds_collector_=None, **kwargs_, ): @@ -30731,29 +31062,24 @@ def __init__( self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("FixedFactorConcentrationModel"), self).__init__( - id, metaid, notes, properties, annotation, **kwargs_ + super(globals().get("ConcentrationModel"), self).__init__( + id, metaid, notes, properties, annotation, extensiontype_, **kwargs_ ) self.ion = _cast(None, ion) self.ion_nsprefix_ = None - self.resting_conc = _cast(None, resting_conc) - self.resting_conc_nsprefix_ = None - self.decay_constant = _cast(None, decay_constant) - self.decay_constant_nsprefix_ = None - self.rho = _cast(None, rho) - self.rho_nsprefix_ = None + self.extensiontype_ = extensiontype_ def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( - CurrentSubclassModule_, FixedFactorConcentrationModel + CurrentSubclassModule_, ConcentrationModel ) if subclass is not None: return subclass(*args_, **kwargs_) - if FixedFactorConcentrationModel.subclass: - return FixedFactorConcentrationModel.subclass(*args_, **kwargs_) + if ConcentrationModel.subclass: + return ConcentrationModel.subclass(*args_, **kwargs_) else: - return FixedFactorConcentrationModel(*args_, **kwargs_) + return ConcentrationModel(*args_, **kwargs_) factory = staticmethod(factory) @@ -30787,8 +31113,233 @@ def validate_NmlId(self, value): validate_NmlId_patterns_ = [["^([a-zA-Z_][a-zA-Z0-9_]*)$"]] - def validate_Nml2Quantity_concentration(self, value): - # Validate type Nml2Quantity_concentration, a restriction on xs:string. + def has__content(self): + if super(ConcentrationModel, self).has__content(): + return True + else: + return False + + def export( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="ConcentrationModel", + pretty_print=True, + ): + imported_ns_def_ = GenerateDSNamespaceDefs_.get("ConcentrationModel") + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = "\n" + else: + eol_ = "" + if self.original_tagname_ is not None and name_ == "ConcentrationModel": + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ":" + showIndent(outfile, level, pretty_print) + outfile.write( + "<%s%s%s" + % ( + namespaceprefix_, + name_, + namespacedef_ and " " + namespacedef_ or "", + ) + ) + already_processed = set() + self._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="ConcentrationModel", + ) + if self.has__content(): + outfile.write(">%s" % (eol_,)) + self._exportChildren( + outfile, + level + 1, + namespaceprefix_, + namespacedef_, + name_="ConcentrationModel", + pretty_print=pretty_print, + ) + showIndent(outfile, level, pretty_print) + outfile.write("%s" % (namespaceprefix_, name_, eol_)) + else: + outfile.write("/>%s" % (eol_,)) + + def _exportAttributes( + self, + outfile, + level, + already_processed, + namespaceprefix_="", + name_="ConcentrationModel", + ): + super(ConcentrationModel, self)._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="ConcentrationModel", + ) + if self.ion is not None and "ion" not in already_processed: + already_processed.add("ion") + outfile.write( + " ion=%s" + % ( + self.gds_encode( + self.gds_format_string(quote_attrib(self.ion), input_name="ion") + ), + ) + ) + if self.extensiontype_ is not None and "xsi:type" not in already_processed: + already_processed.add("xsi:type") + outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') + if ":" not in self.extensiontype_: + imported_ns_type_prefix_ = GenerateDSNamespaceTypePrefixes_.get( + self.extensiontype_, "" + ) + outfile.write( + ' xsi:type="%s%s"' % (imported_ns_type_prefix_, self.extensiontype_) + ) + else: + outfile.write(' xsi:type="%s"' % self.extensiontype_) + + def _exportChildren( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="ConcentrationModel", + fromsubclass_=False, + pretty_print=True, + ): + super(ConcentrationModel, self)._exportChildren( + outfile, + level, + namespaceprefix_, + namespacedef_, + name_, + True, + pretty_print=pretty_print, + ) + + def validate_(self, gds_collector, recursive=False): + self.gds_collector_ = gds_collector + message_count = len(self.gds_collector_.get_messages()) + # validate simple type attributes + self.gds_validate_defined_ST_(self.validate_NmlId, self.ion, "ion") + self.gds_check_cardinality_(self.ion, "ion", required=True) + # validate simple type children + # validate complex type children + if recursive: + pass + return message_count == len(self.gds_collector_.get_messages()) + + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self._buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + + def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("ion", node) + if value is not None and "ion" not in already_processed: + already_processed.add("ion") + self.ion = value + self.validate_NmlId(self.ion) # validate type NmlId + value = find_attr_value_("xsi:type", node) + if value is not None and "xsi:type" not in already_processed: + already_processed.add("xsi:type") + self.extensiontype_ = value + super(ConcentrationModel, self)._buildAttributes(node, attrs, already_processed) + + def _buildChildren( + self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None + ): + super(ConcentrationModel, self)._buildChildren(child_, node, nodeName_, True) + pass + + +# end class ConcentrationModel + + +class HHTime(BaseWithoutId): + __hash__ = GeneratedsSuper.__hash__ + member_data_items_ = [ + MemberSpec_("type", "NmlId", 0, 0, {"use": "required", "name": "type"}), + MemberSpec_( + "rate", "Nml2Quantity_time", 0, 1, {"use": "optional", "name": "rate"} + ), + MemberSpec_( + "midpoint", + "Nml2Quantity_voltage", + 0, + 1, + {"use": "optional", "name": "midpoint"}, + ), + MemberSpec_( + "scale", "Nml2Quantity_voltage", 0, 1, {"use": "optional", "name": "scale"} + ), + MemberSpec_( + "tau", "Nml2Quantity_time", 0, 1, {"use": "optional", "name": "tau"} + ), + ] + subclass = None + superclass = BaseWithoutId + + def __init__( + self, + type: "a NmlId (required)" = None, + rate: "a Nml2Quantity_time (optional)" = None, + midpoint: "a Nml2Quantity_voltage (optional)" = None, + scale: "a Nml2Quantity_voltage (optional)" = None, + tau: "a Nml2Quantity_time (optional)" = None, + gds_collector_=None, + **kwargs_, + ): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get("parent_object_") + self.ns_prefix_ = None + super(globals().get("HHTime"), self).__init__(**kwargs_) + self.type = _cast(None, type) + self.type_nsprefix_ = None + self.rate = _cast(None, rate) + self.rate_nsprefix_ = None + self.midpoint = _cast(None, midpoint) + self.midpoint_nsprefix_ = None + self.scale = _cast(None, scale) + self.scale_nsprefix_ = None + self.tau = _cast(None, tau) + self.tau_nsprefix_ = None + + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_(CurrentSubclassModule_, HHTime) + if subclass is not None: + return subclass(*args_, **kwargs_) + if HHTime.subclass: + return HHTime.subclass(*args_, **kwargs_) + else: + return HHTime(*args_, **kwargs_) + + factory = staticmethod(factory) + + def validate_NmlId(self, value): + # Validate type NmlId, a restriction on xs:string. if ( value is not None and Validate_simpletypes_ @@ -30805,869 +31356,17 @@ def validate_Nml2Quantity_concentration(self, value): ) return False if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_concentration_patterns_, value + self.validate_NmlId_patterns_, value ): self.gds_collector_.add_message( 'Value "%s" does not match xsd pattern restrictions: %s' % ( encode_str_2_3(value), - self.validate_Nml2Quantity_concentration_patterns_, + self.validate_NmlId_patterns_, ) ) - validate_Nml2Quantity_concentration_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m3|mol_per_cm3|M|mM))$"] - ] - - def validate_Nml2Quantity_time(self, value): - # Validate type Nml2Quantity_time, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_time_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_time_patterns_, - ) - ) - - validate_Nml2Quantity_time_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(s|ms))$"] - ] - - def validate_Nml2Quantity_rhoFactor(self, value): - # Validate type Nml2Quantity_rhoFactor, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_rhoFactor_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_rhoFactor_patterns_, - ) - ) - - validate_Nml2Quantity_rhoFactor_patterns_ = [ - [ - "^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m_per_A_per_s|mol_per_cm_per_uA_per_ms))$" - ] - ] - - def has__content(self): - if super(FixedFactorConcentrationModel, self).has__content(): - return True - else: - return False - - def export( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="FixedFactorConcentrationModel", - pretty_print=True, - ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("FixedFactorConcentrationModel") - if imported_ns_def_ is not None: - namespacedef_ = imported_ns_def_ - if pretty_print: - eol_ = "\n" - else: - eol_ = "" - if ( - self.original_tagname_ is not None - and name_ == "FixedFactorConcentrationModel" - ): - name_ = self.original_tagname_ - if UseCapturedNS_ and self.ns_prefix_: - namespaceprefix_ = self.ns_prefix_ + ":" - showIndent(outfile, level, pretty_print) - outfile.write( - "<%s%s%s" - % ( - namespaceprefix_, - name_, - namespacedef_ and " " + namespacedef_ or "", - ) - ) - already_processed = set() - self._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="FixedFactorConcentrationModel", - ) - if self.has__content(): - outfile.write(">%s" % (eol_,)) - self._exportChildren( - outfile, - level + 1, - namespaceprefix_, - namespacedef_, - name_="FixedFactorConcentrationModel", - pretty_print=pretty_print, - ) - showIndent(outfile, level, pretty_print) - outfile.write("%s" % (namespaceprefix_, name_, eol_)) - else: - outfile.write("/>%s" % (eol_,)) - - def _exportAttributes( - self, - outfile, - level, - already_processed, - namespaceprefix_="", - name_="FixedFactorConcentrationModel", - ): - super(FixedFactorConcentrationModel, self)._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="FixedFactorConcentrationModel", - ) - if self.ion is not None and "ion" not in already_processed: - already_processed.add("ion") - outfile.write( - " ion=%s" - % ( - self.gds_encode( - self.gds_format_string(quote_attrib(self.ion), input_name="ion") - ), - ) - ) - if self.resting_conc is not None and "resting_conc" not in already_processed: - already_processed.add("resting_conc") - outfile.write( - " restingConc=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.resting_conc), input_name="restingConc" - ) - ), - ) - ) - if ( - self.decay_constant is not None - and "decay_constant" not in already_processed - ): - already_processed.add("decay_constant") - outfile.write( - " decayConstant=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.decay_constant), - input_name="decayConstant", - ) - ), - ) - ) - if self.rho is not None and "rho" not in already_processed: - already_processed.add("rho") - outfile.write( - " rho=%s" - % ( - self.gds_encode( - self.gds_format_string(quote_attrib(self.rho), input_name="rho") - ), - ) - ) - - def _exportChildren( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="FixedFactorConcentrationModel", - fromsubclass_=False, - pretty_print=True, - ): - super(FixedFactorConcentrationModel, self)._exportChildren( - outfile, - level, - namespaceprefix_, - namespacedef_, - name_, - True, - pretty_print=pretty_print, - ) - - def validate_(self, gds_collector, recursive=False): - self.gds_collector_ = gds_collector - message_count = len(self.gds_collector_.get_messages()) - # validate simple type attributes - self.gds_validate_defined_ST_(self.validate_NmlId, self.ion, "ion") - self.gds_check_cardinality_(self.ion, "ion", required=True) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_concentration, self.resting_conc, "resting_conc" - ) - self.gds_check_cardinality_(self.resting_conc, "resting_conc", required=True) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_time, self.decay_constant, "decay_constant" - ) - self.gds_check_cardinality_( - self.decay_constant, "decay_constant", required=True - ) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_rhoFactor, self.rho, "rho" - ) - self.gds_check_cardinality_(self.rho, "rho", required=True) - # validate simple type children - # validate complex type children - if recursive: - pass - return message_count == len(self.gds_collector_.get_messages()) - - def build(self, node, gds_collector_=None): - self.gds_collector_ = gds_collector_ - if SaveElementTreeNode: - self.gds_elementtree_node_ = node - already_processed = set() - self.ns_prefix_ = node.prefix - self._buildAttributes(node, node.attrib, already_processed) - for child in node: - nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] - self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) - return self - - def _buildAttributes(self, node, attrs, already_processed): - value = find_attr_value_("ion", node) - if value is not None and "ion" not in already_processed: - already_processed.add("ion") - self.ion = value - self.validate_NmlId(self.ion) # validate type NmlId - value = find_attr_value_("restingConc", node) - if value is not None and "restingConc" not in already_processed: - already_processed.add("restingConc") - self.resting_conc = value - self.validate_Nml2Quantity_concentration( - self.resting_conc - ) # validate type Nml2Quantity_concentration - value = find_attr_value_("decayConstant", node) - if value is not None and "decayConstant" not in already_processed: - already_processed.add("decayConstant") - self.decay_constant = value - self.validate_Nml2Quantity_time( - self.decay_constant - ) # validate type Nml2Quantity_time - value = find_attr_value_("rho", node) - if value is not None and "rho" not in already_processed: - already_processed.add("rho") - self.rho = value - self.validate_Nml2Quantity_rhoFactor( - self.rho - ) # validate type Nml2Quantity_rhoFactor - super(FixedFactorConcentrationModel, self)._buildAttributes( - node, attrs, already_processed - ) - - def _buildChildren( - self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None - ): - super(FixedFactorConcentrationModel, self)._buildChildren( - child_, node, nodeName_, True - ) - pass - - -# end class FixedFactorConcentrationModel - - -class DecayingPoolConcentrationModel(Standalone): - """DecayingPoolConcentrationModel -- Model of an intracellular buffering mechanism for **ion** ( currently hard Coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** The ion is assumed to occupy a shell inside the membrane of thickness **shellThickness.** - \n - :param restingConc: - :type restingConc: concentration - :param decayConstant: - :type decayConstant: time - :param shellThickness: - :type shellThickness: length - - """ - - __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [ - MemberSpec_("ion", "NmlId", 0, 0, {"use": "required", "name": "ion"}), - MemberSpec_( - "resting_conc", - "Nml2Quantity_concentration", - 0, - 0, - {"use": "required", "name": "resting_conc"}, - ), - MemberSpec_( - "decay_constant", - "Nml2Quantity_time", - 0, - 0, - {"use": "required", "name": "decay_constant"}, - ), - MemberSpec_( - "shell_thickness", - "Nml2Quantity_length", - 0, - 0, - {"use": "required", "name": "shell_thickness"}, - ), - ] - subclass = None - superclass = Standalone - - def __init__( - self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - ion: "a NmlId (required)" = None, - resting_conc: "a Nml2Quantity_concentration (required)" = None, - decay_constant: "a Nml2Quantity_time (required)" = None, - shell_thickness: "a Nml2Quantity_length (required)" = None, - extensiontype_=None, - gds_collector_=None, - **kwargs_, - ): - self.gds_collector_ = gds_collector_ - self.gds_elementtree_node_ = None - self.original_tagname_ = None - self.parent_object_ = kwargs_.get("parent_object_") - self.ns_prefix_ = None - super(globals().get("DecayingPoolConcentrationModel"), self).__init__( - id, metaid, notes, properties, annotation, extensiontype_, **kwargs_ - ) - self.ion = _cast(None, ion) - self.ion_nsprefix_ = None - self.resting_conc = _cast(None, resting_conc) - self.resting_conc_nsprefix_ = None - self.decay_constant = _cast(None, decay_constant) - self.decay_constant_nsprefix_ = None - self.shell_thickness = _cast(None, shell_thickness) - self.shell_thickness_nsprefix_ = None - self.extensiontype_ = extensiontype_ - - def factory(*args_, **kwargs_): - if CurrentSubclassModule_ is not None: - subclass = getSubclassFromModule_( - CurrentSubclassModule_, DecayingPoolConcentrationModel - ) - if subclass is not None: - return subclass(*args_, **kwargs_) - if DecayingPoolConcentrationModel.subclass: - return DecayingPoolConcentrationModel.subclass(*args_, **kwargs_) - else: - return DecayingPoolConcentrationModel(*args_, **kwargs_) - - factory = staticmethod(factory) - - def validate_NmlId(self, value): - # Validate type NmlId, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_NmlId_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_NmlId_patterns_, - ) - ) - - validate_NmlId_patterns_ = [["^([a-zA-Z_][a-zA-Z0-9_]*)$"]] - - def validate_Nml2Quantity_concentration(self, value): - # Validate type Nml2Quantity_concentration, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_concentration_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_concentration_patterns_, - ) - ) - - validate_Nml2Quantity_concentration_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m3|mol_per_cm3|M|mM))$"] - ] - - def validate_Nml2Quantity_time(self, value): - # Validate type Nml2Quantity_time, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_time_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_time_patterns_, - ) - ) - - validate_Nml2Quantity_time_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(s|ms))$"] - ] - - def validate_Nml2Quantity_length(self, value): - # Validate type Nml2Quantity_length, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_length_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_length_patterns_, - ) - ) - - validate_Nml2Quantity_length_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(m|cm|um))$"] - ] - - def has__content(self): - if super(DecayingPoolConcentrationModel, self).has__content(): - return True - else: - return False - - def export( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="DecayingPoolConcentrationModel", - pretty_print=True, - ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get( - "DecayingPoolConcentrationModel" - ) - if imported_ns_def_ is not None: - namespacedef_ = imported_ns_def_ - if pretty_print: - eol_ = "\n" - else: - eol_ = "" - if ( - self.original_tagname_ is not None - and name_ == "DecayingPoolConcentrationModel" - ): - name_ = self.original_tagname_ - if UseCapturedNS_ and self.ns_prefix_: - namespaceprefix_ = self.ns_prefix_ + ":" - showIndent(outfile, level, pretty_print) - outfile.write( - "<%s%s%s" - % ( - namespaceprefix_, - name_, - namespacedef_ and " " + namespacedef_ or "", - ) - ) - already_processed = set() - self._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="DecayingPoolConcentrationModel", - ) - if self.has__content(): - outfile.write(">%s" % (eol_,)) - self._exportChildren( - outfile, - level + 1, - namespaceprefix_, - namespacedef_, - name_="DecayingPoolConcentrationModel", - pretty_print=pretty_print, - ) - showIndent(outfile, level, pretty_print) - outfile.write("%s" % (namespaceprefix_, name_, eol_)) - else: - outfile.write("/>%s" % (eol_,)) - - def _exportAttributes( - self, - outfile, - level, - already_processed, - namespaceprefix_="", - name_="DecayingPoolConcentrationModel", - ): - super(DecayingPoolConcentrationModel, self)._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="DecayingPoolConcentrationModel", - ) - if self.ion is not None and "ion" not in already_processed: - already_processed.add("ion") - outfile.write( - " ion=%s" - % ( - self.gds_encode( - self.gds_format_string(quote_attrib(self.ion), input_name="ion") - ), - ) - ) - if self.resting_conc is not None and "resting_conc" not in already_processed: - already_processed.add("resting_conc") - outfile.write( - " restingConc=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.resting_conc), input_name="restingConc" - ) - ), - ) - ) - if ( - self.decay_constant is not None - and "decay_constant" not in already_processed - ): - already_processed.add("decay_constant") - outfile.write( - " decayConstant=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.decay_constant), - input_name="decayConstant", - ) - ), - ) - ) - if ( - self.shell_thickness is not None - and "shell_thickness" not in already_processed - ): - already_processed.add("shell_thickness") - outfile.write( - " shellThickness=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.shell_thickness), - input_name="shellThickness", - ) - ), - ) - ) - if self.extensiontype_ is not None and "xsi:type" not in already_processed: - already_processed.add("xsi:type") - outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') - if ":" not in self.extensiontype_: - imported_ns_type_prefix_ = GenerateDSNamespaceTypePrefixes_.get( - self.extensiontype_, "" - ) - outfile.write( - ' xsi:type="%s%s"' % (imported_ns_type_prefix_, self.extensiontype_) - ) - else: - outfile.write(' xsi:type="%s"' % self.extensiontype_) - - def _exportChildren( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="DecayingPoolConcentrationModel", - fromsubclass_=False, - pretty_print=True, - ): - super(DecayingPoolConcentrationModel, self)._exportChildren( - outfile, - level, - namespaceprefix_, - namespacedef_, - name_, - True, - pretty_print=pretty_print, - ) - - def validate_(self, gds_collector, recursive=False): - self.gds_collector_ = gds_collector - message_count = len(self.gds_collector_.get_messages()) - # validate simple type attributes - self.gds_validate_defined_ST_(self.validate_NmlId, self.ion, "ion") - self.gds_check_cardinality_(self.ion, "ion", required=True) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_concentration, self.resting_conc, "resting_conc" - ) - self.gds_check_cardinality_(self.resting_conc, "resting_conc", required=True) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_time, self.decay_constant, "decay_constant" - ) - self.gds_check_cardinality_( - self.decay_constant, "decay_constant", required=True - ) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_length, self.shell_thickness, "shell_thickness" - ) - self.gds_check_cardinality_( - self.shell_thickness, "shell_thickness", required=True - ) - # validate simple type children - # validate complex type children - if recursive: - pass - return message_count == len(self.gds_collector_.get_messages()) - - def build(self, node, gds_collector_=None): - self.gds_collector_ = gds_collector_ - if SaveElementTreeNode: - self.gds_elementtree_node_ = node - already_processed = set() - self.ns_prefix_ = node.prefix - self._buildAttributes(node, node.attrib, already_processed) - for child in node: - nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] - self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) - return self - - def _buildAttributes(self, node, attrs, already_processed): - value = find_attr_value_("ion", node) - if value is not None and "ion" not in already_processed: - already_processed.add("ion") - self.ion = value - self.validate_NmlId(self.ion) # validate type NmlId - value = find_attr_value_("restingConc", node) - if value is not None and "restingConc" not in already_processed: - already_processed.add("restingConc") - self.resting_conc = value - self.validate_Nml2Quantity_concentration( - self.resting_conc - ) # validate type Nml2Quantity_concentration - value = find_attr_value_("decayConstant", node) - if value is not None and "decayConstant" not in already_processed: - already_processed.add("decayConstant") - self.decay_constant = value - self.validate_Nml2Quantity_time( - self.decay_constant - ) # validate type Nml2Quantity_time - value = find_attr_value_("shellThickness", node) - if value is not None and "shellThickness" not in already_processed: - already_processed.add("shellThickness") - self.shell_thickness = value - self.validate_Nml2Quantity_length( - self.shell_thickness - ) # validate type Nml2Quantity_length - value = find_attr_value_("xsi:type", node) - if value is not None and "xsi:type" not in already_processed: - already_processed.add("xsi:type") - self.extensiontype_ = value - super(DecayingPoolConcentrationModel, self)._buildAttributes( - node, attrs, already_processed - ) - - def _buildChildren( - self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None - ): - super(DecayingPoolConcentrationModel, self)._buildChildren( - child_, node, nodeName_, True - ) - pass - - -# end class DecayingPoolConcentrationModel - - -class HHTime(BaseWithoutId): - __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [ - MemberSpec_("type", "NmlId", 0, 0, {"use": "required", "name": "type"}), - MemberSpec_( - "rate", "Nml2Quantity_time", 0, 1, {"use": "optional", "name": "rate"} - ), - MemberSpec_( - "midpoint", - "Nml2Quantity_voltage", - 0, - 1, - {"use": "optional", "name": "midpoint"}, - ), - MemberSpec_( - "scale", "Nml2Quantity_voltage", 0, 1, {"use": "optional", "name": "scale"} - ), - MemberSpec_( - "tau", "Nml2Quantity_time", 0, 1, {"use": "optional", "name": "tau"} - ), - ] - subclass = None - superclass = BaseWithoutId - - def __init__( - self, - type: "a NmlId (required)" = None, - rate: "a Nml2Quantity_time (optional)" = None, - midpoint: "a Nml2Quantity_voltage (optional)" = None, - scale: "a Nml2Quantity_voltage (optional)" = None, - tau: "a Nml2Quantity_time (optional)" = None, - gds_collector_=None, - **kwargs_, - ): - self.gds_collector_ = gds_collector_ - self.gds_elementtree_node_ = None - self.original_tagname_ = None - self.parent_object_ = kwargs_.get("parent_object_") - self.ns_prefix_ = None - super(globals().get("HHTime"), self).__init__(**kwargs_) - self.type = _cast(None, type) - self.type_nsprefix_ = None - self.rate = _cast(None, rate) - self.rate_nsprefix_ = None - self.midpoint = _cast(None, midpoint) - self.midpoint_nsprefix_ = None - self.scale = _cast(None, scale) - self.scale_nsprefix_ = None - self.tau = _cast(None, tau) - self.tau_nsprefix_ = None - - def factory(*args_, **kwargs_): - if CurrentSubclassModule_ is not None: - subclass = getSubclassFromModule_(CurrentSubclassModule_, HHTime) - if subclass is not None: - return subclass(*args_, **kwargs_) - if HHTime.subclass: - return HHTime.subclass(*args_, **kwargs_) - else: - return HHTime(*args_, **kwargs_) - - factory = staticmethod(factory) - - def validate_NmlId(self, value): - # Validate type NmlId, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_NmlId_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_NmlId_patterns_, - ) - ) - - validate_NmlId_patterns_ = [["^([a-zA-Z_][a-zA-Z0-9_]*)$"]] + validate_NmlId_patterns_ = [["^([a-zA-Z_][a-zA-Z0-9_]*)$"]] def validate_Nml2Quantity_time(self, value): # Validate type Nml2Quantity_time, a restriction on xs:string. @@ -39102,6 +38801,19 @@ class NeuroMLDocument(Standalone): }, None, ), + MemberSpec_( + "concentration_model", + "ConcentrationModel", + 1, + 1, + { + "maxOccurs": "unbounded", + "minOccurs": "0", + "name": "concentrationModel", + "type": "ConcentrationModel", + }, + None, + ), MemberSpec_( "decaying_pool_concentration_models", "DecayingPoolConcentrationModel", @@ -39901,6 +39613,7 @@ def __init__( ion_channel_hhs: "list of IonChannelHH(s) (optional)" = None, ion_channel_v_shifts: "list of IonChannelVShift(s) (optional)" = None, ion_channel_kses: "list of IonChannelKS(s) (optional)" = None, + concentration_model: "list of ConcentrationModel(s) (optional)" = None, decaying_pool_concentration_models: "list of DecayingPoolConcentrationModel(s) (optional)" = None, fixed_factor_concentration_models: "list of FixedFactorConcentrationModel(s) (optional)" = None, alpha_current_synapses: "list of AlphaCurrentSynapse(s) (optional)" = None, @@ -40012,6 +39725,11 @@ def __init__( else: self.ion_channel_kses = ion_channel_kses self.ion_channel_kses_nsprefix_ = None + if concentration_model is None: + self.concentration_model = [] + else: + self.concentration_model = concentration_model + self.concentration_model_nsprefix_ = None if decaying_pool_concentration_models is None: self.decaying_pool_concentration_models = [] else: @@ -40335,6 +40053,7 @@ def has__content(self): or self.ion_channel_hhs or self.ion_channel_v_shifts or self.ion_channel_kses + or self.concentration_model or self.decaying_pool_concentration_models or self.fixed_factor_concentration_models or self.alpha_current_synapses @@ -40596,6 +40315,20 @@ def _exportChildren( name_="ionChannelKS", pretty_print=pretty_print, ) + for concentrationModel_ in self.concentration_model: + namespaceprefix_ = ( + self.concentration_model_nsprefix_ + ":" + if (UseCapturedNS_ and self.concentration_model_nsprefix_) + else "" + ) + concentrationModel_.export( + outfile, + level, + namespaceprefix_, + namespacedef_="", + name_="concentrationModel", + pretty_print=pretty_print, + ) for decayingPoolConcentrationModel_ in self.decaying_pool_concentration_models: namespaceprefix_ = ( self.decaying_pool_concentration_models_nsprefix_ + ":" @@ -41478,6 +41211,12 @@ def validate_(self, gds_collector, recursive=False): self.gds_check_cardinality_( self.ion_channel_kses, "ion_channel_kses", min_occurs=0, max_occurs=9999999 ) + self.gds_check_cardinality_( + self.concentration_model, + "concentration_model", + min_occurs=0, + max_occurs=9999999, + ) self.gds_check_cardinality_( self.decaying_pool_concentration_models, "decaying_pool_concentration_models", @@ -41768,6 +41507,8 @@ def validate_(self, gds_collector, recursive=False): item.validate_(gds_collector, recursive=True) for item in self.ion_channel_kses: item.validate_(gds_collector, recursive=True) + for item in self.concentration_model: + item.validate_(gds_collector, recursive=True) for item in self.decaying_pool_concentration_models: item.validate_(gds_collector, recursive=True) for item in self.fixed_factor_concentration_models: @@ -41950,6 +41691,12 @@ def _buildChildren( obj_.build(child_, gds_collector_=gds_collector_) self.ion_channel_kses.append(obj_) obj_.original_tagname_ = "ionChannelKS" + elif nodeName_ == "concentrationModel": + class_obj_ = self.get_class_obj_(child_, ConcentrationModel) + obj_ = class_obj_.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.concentration_model.append(obj_) + obj_.original_tagname_ = "concentrationModel" elif nodeName_ == "decayingPoolConcentrationModel": class_obj_ = self.get_class_obj_(child_, DecayingPoolConcentrationModel) obj_ = class_obj_.factory(parent_object_=self) @@ -47163,212 +46910,6 @@ def _buildChildren( # end class IntracellularProperties2CaPools -class ConcentrationModel_D(DecayingPoolConcentrationModel): - __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [ - MemberSpec_("type", "xs:string", 0, 0, {"use": "required", "name": "type"}), - ] - subclass = None - superclass = DecayingPoolConcentrationModel - - def __init__( - self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - ion: "a NmlId (required)" = None, - resting_conc: "a Nml2Quantity_concentration (required)" = None, - decay_constant: "a Nml2Quantity_time (required)" = None, - shell_thickness: "a Nml2Quantity_length (required)" = None, - type: "a string (required)" = "decayingPoolConcentrationModel", - gds_collector_=None, - **kwargs_, - ): - self.gds_collector_ = gds_collector_ - self.gds_elementtree_node_ = None - self.original_tagname_ = None - self.parent_object_ = kwargs_.get("parent_object_") - self.ns_prefix_ = None - super(globals().get("ConcentrationModel_D"), self).__init__( - id, - metaid, - notes, - properties, - annotation, - ion, - resting_conc, - decay_constant, - shell_thickness, - **kwargs_, - ) - self.type = _cast(None, type) - self.type_nsprefix_ = None - - def factory(*args_, **kwargs_): - if CurrentSubclassModule_ is not None: - subclass = getSubclassFromModule_( - CurrentSubclassModule_, ConcentrationModel_D - ) - if subclass is not None: - return subclass(*args_, **kwargs_) - if ConcentrationModel_D.subclass: - return ConcentrationModel_D.subclass(*args_, **kwargs_) - else: - return ConcentrationModel_D(*args_, **kwargs_) - - factory = staticmethod(factory) - - def has__content(self): - if super(ConcentrationModel_D, self).has__content(): - return True - else: - return False - - def export( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="ConcentrationModel_D", - pretty_print=True, - ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("ConcentrationModel_D") - if imported_ns_def_ is not None: - namespacedef_ = imported_ns_def_ - if pretty_print: - eol_ = "\n" - else: - eol_ = "" - if self.original_tagname_ is not None and name_ == "ConcentrationModel_D": - name_ = self.original_tagname_ - if UseCapturedNS_ and self.ns_prefix_: - namespaceprefix_ = self.ns_prefix_ + ":" - showIndent(outfile, level, pretty_print) - outfile.write( - "<%s%s%s" - % ( - namespaceprefix_, - name_, - namespacedef_ and " " + namespacedef_ or "", - ) - ) - already_processed = set() - self._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="ConcentrationModel_D", - ) - if self.has__content(): - outfile.write(">%s" % (eol_,)) - self._exportChildren( - outfile, - level + 1, - namespaceprefix_, - namespacedef_, - name_="ConcentrationModel_D", - pretty_print=pretty_print, - ) - showIndent(outfile, level, pretty_print) - outfile.write("%s" % (namespaceprefix_, name_, eol_)) - else: - outfile.write("/>%s" % (eol_,)) - - def _exportAttributes( - self, - outfile, - level, - already_processed, - namespaceprefix_="", - name_="ConcentrationModel_D", - ): - super(ConcentrationModel_D, self)._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="ConcentrationModel_D", - ) - if self.type is not None and "type" not in already_processed: - already_processed.add("type") - outfile.write( - " type=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.type), input_name="type" - ) - ), - ) - ) - - def _exportChildren( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="ConcentrationModel_D", - fromsubclass_=False, - pretty_print=True, - ): - super(ConcentrationModel_D, self)._exportChildren( - outfile, - level, - namespaceprefix_, - namespacedef_, - name_, - True, - pretty_print=pretty_print, - ) - - def validate_(self, gds_collector, recursive=False): - self.gds_collector_ = gds_collector - message_count = len(self.gds_collector_.get_messages()) - # validate simple type attributes - self.gds_validate_builtin_ST_(self.gds_validate_string, self.type, "type") - self.gds_check_cardinality_(self.type, "type", required=True) - # validate simple type children - # validate complex type children - if recursive: - pass - return message_count == len(self.gds_collector_.get_messages()) - - def build(self, node, gds_collector_=None): - self.gds_collector_ = gds_collector_ - if SaveElementTreeNode: - self.gds_elementtree_node_ = node - already_processed = set() - self.ns_prefix_ = node.prefix - self._buildAttributes(node, node.attrib, already_processed) - for child in node: - nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] - self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) - return self - - def _buildAttributes(self, node, attrs, already_processed): - value = find_attr_value_("type", node) - if value is not None and "type" not in already_processed: - already_processed.add("type") - self.type = value - super(ConcentrationModel_D, self)._buildAttributes( - node, attrs, already_processed - ) - - def _buildChildren( - self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None - ): - super(ConcentrationModel_D, self)._buildChildren(child_, node, nodeName_, True) - pass - - -# end class ConcentrationModel_D - - class ChannelDensityNernstCa2(ChannelDensityNernst): """ChannelDensityNernstCa2 -- This component is similar to the original component type **channelDensityNernst** but it is changed in order to have a reversal potential that depends on a second independent Ca++ pool ( ca2 ). See https://github.com/OpenSourceBrain/ghk-nernst. \n @@ -47840,6 +47381,7 @@ class MembraneProperties2CaPools(MembraneProperties): def __init__( self, channel_populations: "list of ChannelPopulation(s) (optional)" = None, + baseChannelDensity: "list of BaseChannelDensity(s) (optional)" = None, channel_densities: "list of ChannelDensity(s) (optional)" = None, channel_density_v_shifts: "list of ChannelDensityVShift(s) (optional)" = None, channel_density_nernsts: "list of ChannelDensityNernst(s) (optional)" = None, @@ -47862,6 +47404,7 @@ def __init__( self.ns_prefix_ = None super(globals().get("MembraneProperties2CaPools"), self).__init__( channel_populations, + baseChannelDensity, channel_densities, channel_density_v_shifts, channel_density_nernsts, @@ -53749,14 +53292,409 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="LinearGradedSynapse", + name_="LinearGradedSynapse", + ): + super(LinearGradedSynapse, self)._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="LinearGradedSynapse", + ) + if self.conductance is not None and "conductance" not in already_processed: + already_processed.add("conductance") + outfile.write( + " conductance=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.conductance), input_name="conductance" + ) + ), + ) + ) + + def _exportChildren( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="LinearGradedSynapse", + fromsubclass_=False, + pretty_print=True, + ): + super(LinearGradedSynapse, self)._exportChildren( + outfile, + level, + namespaceprefix_, + namespacedef_, + name_, + True, + pretty_print=pretty_print, + ) + + def validate_(self, gds_collector, recursive=False): + self.gds_collector_ = gds_collector + message_count = len(self.gds_collector_.get_messages()) + # validate simple type attributes + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_conductance, self.conductance, "conductance" + ) + self.gds_check_cardinality_(self.conductance, "conductance", required=True) + # validate simple type children + # validate complex type children + if recursive: + pass + return message_count == len(self.gds_collector_.get_messages()) + + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self._buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + + def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("conductance", node) + if value is not None and "conductance" not in already_processed: + already_processed.add("conductance") + self.conductance = value + self.validate_Nml2Quantity_conductance( + self.conductance + ) # validate type Nml2Quantity_conductance + super(LinearGradedSynapse, self)._buildAttributes( + node, attrs, already_processed + ) + + def _buildChildren( + self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None + ): + super(LinearGradedSynapse, self)._buildChildren(child_, node, nodeName_, True) + pass + + +# end class LinearGradedSynapse + + +class SilentSynapse(BaseSynapse): + """SilentSynapse -- Dummy synapse which emits no current. Used as presynaptic endpoint for analog synaptic connection.""" + + __hash__ = GeneratedsSuper.__hash__ + member_data_items_ = [] + subclass = None + superclass = BaseSynapse + + def __init__( + self, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + gds_collector_=None, + **kwargs_, + ): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get("parent_object_") + self.ns_prefix_ = None + super(globals().get("SilentSynapse"), self).__init__( + id, metaid, notes, properties, annotation, neuro_lex_id, **kwargs_ + ) + + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_(CurrentSubclassModule_, SilentSynapse) + if subclass is not None: + return subclass(*args_, **kwargs_) + if SilentSynapse.subclass: + return SilentSynapse.subclass(*args_, **kwargs_) + else: + return SilentSynapse(*args_, **kwargs_) + + factory = staticmethod(factory) + + def has__content(self): + if super(SilentSynapse, self).has__content(): + return True + else: + return False + + def export( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="SilentSynapse", + pretty_print=True, + ): + imported_ns_def_ = GenerateDSNamespaceDefs_.get("SilentSynapse") + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = "\n" + else: + eol_ = "" + if self.original_tagname_ is not None and name_ == "SilentSynapse": + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ":" + showIndent(outfile, level, pretty_print) + outfile.write( + "<%s%s%s" + % ( + namespaceprefix_, + name_, + namespacedef_ and " " + namespacedef_ or "", + ) + ) + already_processed = set() + self._exportAttributes( + outfile, level, already_processed, namespaceprefix_, name_="SilentSynapse" + ) + if self.has__content(): + outfile.write(">%s" % (eol_,)) + self._exportChildren( + outfile, + level + 1, + namespaceprefix_, + namespacedef_, + name_="SilentSynapse", + pretty_print=pretty_print, + ) + showIndent(outfile, level, pretty_print) + outfile.write("%s" % (namespaceprefix_, name_, eol_)) + else: + outfile.write("/>%s" % (eol_,)) + + def _exportAttributes( + self, + outfile, + level, + already_processed, + namespaceprefix_="", + name_="SilentSynapse", + ): + super(SilentSynapse, self)._exportAttributes( + outfile, level, already_processed, namespaceprefix_, name_="SilentSynapse" + ) + + def _exportChildren( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="SilentSynapse", + fromsubclass_=False, + pretty_print=True, + ): + super(SilentSynapse, self)._exportChildren( + outfile, + level, + namespaceprefix_, + namespacedef_, + name_, + True, + pretty_print=pretty_print, + ) + + def validate_(self, gds_collector, recursive=False): + self.gds_collector_ = gds_collector + message_count = len(self.gds_collector_.get_messages()) + # validate simple type attributes + # validate simple type children + # validate complex type children + if recursive: + pass + return message_count == len(self.gds_collector_.get_messages()) + + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self._buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + + def _buildAttributes(self, node, attrs, already_processed): + super(SilentSynapse, self)._buildAttributes(node, attrs, already_processed) + + def _buildChildren( + self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None + ): + super(SilentSynapse, self)._buildChildren(child_, node, nodeName_, True) + pass + + +# end class SilentSynapse + + +class GapJunction(BaseSynapse): + """GapJunction -- Gap junction/single electrical connection + \n + :param conductance: + :type conductance: conductance + + """ + + __hash__ = GeneratedsSuper.__hash__ + member_data_items_ = [ + MemberSpec_( + "conductance", + "Nml2Quantity_conductance", + 0, + 0, + {"use": "required", "name": "conductance"}, + ), + ] + subclass = None + superclass = BaseSynapse + + def __init__( + self, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + conductance: "a Nml2Quantity_conductance (required)" = None, + gds_collector_=None, + **kwargs_, + ): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get("parent_object_") + self.ns_prefix_ = None + super(globals().get("GapJunction"), self).__init__( + id, metaid, notes, properties, annotation, neuro_lex_id, **kwargs_ + ) + self.conductance = _cast(None, conductance) + self.conductance_nsprefix_ = None + + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_(CurrentSubclassModule_, GapJunction) + if subclass is not None: + return subclass(*args_, **kwargs_) + if GapJunction.subclass: + return GapJunction.subclass(*args_, **kwargs_) + else: + return GapJunction(*args_, **kwargs_) + + factory = staticmethod(factory) + + def validate_Nml2Quantity_conductance(self, value): + # Validate type Nml2Quantity_conductance, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_conductance_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_conductance_patterns_, + ) + ) + + validate_Nml2Quantity_conductance_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(S|mS|uS|nS|pS))$"] + ] + + def has__content(self): + if super(GapJunction, self).has__content(): + return True + else: + return False + + def export( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="GapJunction", + pretty_print=True, + ): + imported_ns_def_ = GenerateDSNamespaceDefs_.get("GapJunction") + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = "\n" + else: + eol_ = "" + if self.original_tagname_ is not None and name_ == "GapJunction": + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ":" + showIndent(outfile, level, pretty_print) + outfile.write( + "<%s%s%s" + % ( + namespaceprefix_, + name_, + namespacedef_ and " " + namespacedef_ or "", + ) + ) + already_processed = set() + self._exportAttributes( + outfile, level, already_processed, namespaceprefix_, name_="GapJunction" + ) + if self.has__content(): + outfile.write(">%s" % (eol_,)) + self._exportChildren( + outfile, + level + 1, + namespaceprefix_, + namespacedef_, + name_="GapJunction", + pretty_print=pretty_print, + ) + showIndent(outfile, level, pretty_print) + outfile.write("%s" % (namespaceprefix_, name_, eol_)) + else: + outfile.write("/>%s" % (eol_,)) + + def _exportAttributes( + self, + outfile, + level, + already_processed, + namespaceprefix_="", + name_="GapJunction", ): - super(LinearGradedSynapse, self)._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="LinearGradedSynapse", + super(GapJunction, self)._exportAttributes( + outfile, level, already_processed, namespaceprefix_, name_="GapJunction" ) if self.conductance is not None and "conductance" not in already_processed: already_processed.add("conductance") @@ -53777,11 +53715,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="LinearGradedSynapse", + name_="GapJunction", fromsubclass_=False, pretty_print=True, ): - super(LinearGradedSynapse, self)._exportChildren( + super(GapJunction, self)._exportChildren( outfile, level, namespaceprefix_, @@ -53825,22 +53763,20 @@ def _buildAttributes(self, node, attrs, already_processed): self.validate_Nml2Quantity_conductance( self.conductance ) # validate type Nml2Quantity_conductance - super(LinearGradedSynapse, self)._buildAttributes( - node, attrs, already_processed - ) + super(GapJunction, self)._buildAttributes(node, attrs, already_processed) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(LinearGradedSynapse, self)._buildChildren(child_, node, nodeName_, True) + super(GapJunction, self)._buildChildren(child_, node, nodeName_, True) pass -# end class LinearGradedSynapse +# end class GapJunction -class SilentSynapse(BaseSynapse): - """SilentSynapse -- Dummy synapse which emits no current. Used as presynaptic endpoint for analog synaptic connection.""" +class BaseCurrentBasedSynapse(BaseSynapse): + """BaseCurrentBasedSynapse -- Synapse model which produces a synaptic current.""" __hash__ = GeneratedsSuper.__hash__ member_data_items_ = [] @@ -53855,6 +53791,7 @@ def __init__( properties: "list of Property(s) (optional)" = None, annotation: "a Annotation (optional)" = None, neuro_lex_id: "a NeuroLexId (optional)" = None, + extensiontype_=None, gds_collector_=None, **kwargs_, ): @@ -53863,24 +53800,34 @@ def __init__( self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("SilentSynapse"), self).__init__( - id, metaid, notes, properties, annotation, neuro_lex_id, **kwargs_ + super(globals().get("BaseCurrentBasedSynapse"), self).__init__( + id, + metaid, + notes, + properties, + annotation, + neuro_lex_id, + extensiontype_, + **kwargs_, ) + self.extensiontype_ = extensiontype_ def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: - subclass = getSubclassFromModule_(CurrentSubclassModule_, SilentSynapse) + subclass = getSubclassFromModule_( + CurrentSubclassModule_, BaseCurrentBasedSynapse + ) if subclass is not None: return subclass(*args_, **kwargs_) - if SilentSynapse.subclass: - return SilentSynapse.subclass(*args_, **kwargs_) + if BaseCurrentBasedSynapse.subclass: + return BaseCurrentBasedSynapse.subclass(*args_, **kwargs_) else: - return SilentSynapse(*args_, **kwargs_) + return BaseCurrentBasedSynapse(*args_, **kwargs_) factory = staticmethod(factory) def has__content(self): - if super(SilentSynapse, self).has__content(): + if super(BaseCurrentBasedSynapse, self).has__content(): return True else: return False @@ -53891,17 +53838,17 @@ def export( level, namespaceprefix_="", namespacedef_="", - name_="SilentSynapse", + name_="BaseCurrentBasedSynapse", pretty_print=True, ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("SilentSynapse") + imported_ns_def_ = GenerateDSNamespaceDefs_.get("BaseCurrentBasedSynapse") if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = "\n" else: eol_ = "" - if self.original_tagname_ is not None and name_ == "SilentSynapse": + if self.original_tagname_ is not None and name_ == "BaseCurrentBasedSynapse": name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ":" @@ -53916,7 +53863,11 @@ def export( ) already_processed = set() self._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="SilentSynapse" + outfile, + level, + already_processed, + namespaceprefix_, + name_="BaseCurrentBasedSynapse", ) if self.has__content(): outfile.write(">%s" % (eol_,)) @@ -53925,7 +53876,7 @@ def export( level + 1, namespaceprefix_, namespacedef_, - name_="SilentSynapse", + name_="BaseCurrentBasedSynapse", pretty_print=pretty_print, ) showIndent(outfile, level, pretty_print) @@ -53939,11 +53890,27 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="SilentSynapse", + name_="BaseCurrentBasedSynapse", ): - super(SilentSynapse, self)._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="SilentSynapse" + super(BaseCurrentBasedSynapse, self)._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="BaseCurrentBasedSynapse", ) + if self.extensiontype_ is not None and "xsi:type" not in already_processed: + already_processed.add("xsi:type") + outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') + if ":" not in self.extensiontype_: + imported_ns_type_prefix_ = GenerateDSNamespaceTypePrefixes_.get( + self.extensiontype_, "" + ) + outfile.write( + ' xsi:type="%s%s"' % (imported_ns_type_prefix_, self.extensiontype_) + ) + else: + outfile.write(' xsi:type="%s"' % self.extensiontype_) def _exportChildren( self, @@ -53951,11 +53918,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="SilentSynapse", + name_="BaseCurrentBasedSynapse", fromsubclass_=False, pretty_print=True, ): - super(SilentSynapse, self)._exportChildren( + super(BaseCurrentBasedSynapse, self)._exportChildren( outfile, level, namespaceprefix_, @@ -53988,36 +53955,31 @@ def build(self, node, gds_collector_=None): return self def _buildAttributes(self, node, attrs, already_processed): - super(SilentSynapse, self)._buildAttributes(node, attrs, already_processed) + value = find_attr_value_("xsi:type", node) + if value is not None and "xsi:type" not in already_processed: + already_processed.add("xsi:type") + self.extensiontype_ = value + super(BaseCurrentBasedSynapse, self)._buildAttributes( + node, attrs, already_processed + ) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(SilentSynapse, self)._buildChildren(child_, node, nodeName_, True) + super(BaseCurrentBasedSynapse, self)._buildChildren( + child_, node, nodeName_, True + ) pass -# end class SilentSynapse - +# end class BaseCurrentBasedSynapse -class GapJunction(BaseSynapse): - """GapJunction -- Gap junction/single electrical connection - \n - :param conductance: - :type conductance: conductance - """ +class BaseVoltageDepSynapse(BaseSynapse): + """BaseVoltageDepSynapse -- Base type for synapses with a dependence on membrane potential""" __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [ - MemberSpec_( - "conductance", - "Nml2Quantity_conductance", - 0, - 0, - {"use": "required", "name": "conductance"}, - ), - ] + member_data_items_ = [] subclass = None superclass = BaseSynapse @@ -54029,7 +53991,7 @@ def __init__( properties: "list of Property(s) (optional)" = None, annotation: "a Annotation (optional)" = None, neuro_lex_id: "a NeuroLexId (optional)" = None, - conductance: "a Nml2Quantity_conductance (required)" = None, + extensiontype_=None, gds_collector_=None, **kwargs_, ): @@ -54038,58 +54000,34 @@ def __init__( self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("GapJunction"), self).__init__( - id, metaid, notes, properties, annotation, neuro_lex_id, **kwargs_ + super(globals().get("BaseVoltageDepSynapse"), self).__init__( + id, + metaid, + notes, + properties, + annotation, + neuro_lex_id, + extensiontype_, + **kwargs_, ) - self.conductance = _cast(None, conductance) - self.conductance_nsprefix_ = None + self.extensiontype_ = extensiontype_ def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: - subclass = getSubclassFromModule_(CurrentSubclassModule_, GapJunction) + subclass = getSubclassFromModule_( + CurrentSubclassModule_, BaseVoltageDepSynapse + ) if subclass is not None: return subclass(*args_, **kwargs_) - if GapJunction.subclass: - return GapJunction.subclass(*args_, **kwargs_) + if BaseVoltageDepSynapse.subclass: + return BaseVoltageDepSynapse.subclass(*args_, **kwargs_) else: - return GapJunction(*args_, **kwargs_) + return BaseVoltageDepSynapse(*args_, **kwargs_) factory = staticmethod(factory) - def validate_Nml2Quantity_conductance(self, value): - # Validate type Nml2Quantity_conductance, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_conductance_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_conductance_patterns_, - ) - ) - - validate_Nml2Quantity_conductance_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(S|mS|uS|nS|pS))$"] - ] - def has__content(self): - if super(GapJunction, self).has__content(): + if super(BaseVoltageDepSynapse, self).has__content(): return True else: return False @@ -54100,17 +54038,17 @@ def export( level, namespaceprefix_="", namespacedef_="", - name_="GapJunction", + name_="BaseVoltageDepSynapse", pretty_print=True, ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("GapJunction") + imported_ns_def_ = GenerateDSNamespaceDefs_.get("BaseVoltageDepSynapse") if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = "\n" else: eol_ = "" - if self.original_tagname_ is not None and name_ == "GapJunction": + if self.original_tagname_ is not None and name_ == "BaseVoltageDepSynapse": name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ":" @@ -54125,7 +54063,11 @@ def export( ) already_processed = set() self._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="GapJunction" + outfile, + level, + already_processed, + namespaceprefix_, + name_="BaseVoltageDepSynapse", ) if self.has__content(): outfile.write(">%s" % (eol_,)) @@ -54134,7 +54076,7 @@ def export( level + 1, namespaceprefix_, namespacedef_, - name_="GapJunction", + name_="BaseVoltageDepSynapse", pretty_print=pretty_print, ) showIndent(outfile, level, pretty_print) @@ -54148,23 +54090,27 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="GapJunction", + name_="BaseVoltageDepSynapse", ): - super(GapJunction, self)._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="GapJunction" + super(BaseVoltageDepSynapse, self)._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="BaseVoltageDepSynapse", ) - if self.conductance is not None and "conductance" not in already_processed: - already_processed.add("conductance") - outfile.write( - " conductance=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.conductance), input_name="conductance" - ) - ), + if self.extensiontype_ is not None and "xsi:type" not in already_processed: + already_processed.add("xsi:type") + outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') + if ":" not in self.extensiontype_: + imported_ns_type_prefix_ = GenerateDSNamespaceTypePrefixes_.get( + self.extensiontype_, "" ) - ) + outfile.write( + ' xsi:type="%s%s"' % (imported_ns_type_prefix_, self.extensiontype_) + ) + else: + outfile.write(' xsi:type="%s"' % self.extensiontype_) def _exportChildren( self, @@ -54172,11 +54118,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="GapJunction", + name_="BaseVoltageDepSynapse", fromsubclass_=False, pretty_print=True, ): - super(GapJunction, self)._exportChildren( + super(BaseVoltageDepSynapse, self)._exportChildren( outfile, level, namespaceprefix_, @@ -54190,10 +54136,6 @@ def validate_(self, gds_collector, recursive=False): self.gds_collector_ = gds_collector message_count = len(self.gds_collector_.get_messages()) # validate simple type attributes - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_conductance, self.conductance, "conductance" - ) - self.gds_check_cardinality_(self.conductance, "conductance", required=True) # validate simple type children # validate complex type children if recursive: @@ -54213,32 +54155,58 @@ def build(self, node, gds_collector_=None): return self def _buildAttributes(self, node, attrs, already_processed): - value = find_attr_value_("conductance", node) - if value is not None and "conductance" not in already_processed: - already_processed.add("conductance") - self.conductance = value - self.validate_Nml2Quantity_conductance( - self.conductance - ) # validate type Nml2Quantity_conductance - super(GapJunction, self)._buildAttributes(node, attrs, already_processed) + value = find_attr_value_("xsi:type", node) + if value is not None and "xsi:type" not in already_processed: + already_processed.add("xsi:type") + self.extensiontype_ = value + super(BaseVoltageDepSynapse, self)._buildAttributes( + node, attrs, already_processed + ) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(GapJunction, self)._buildChildren(child_, node, nodeName_, True) + super(BaseVoltageDepSynapse, self)._buildChildren(child_, node, nodeName_, True) pass -# end class GapJunction +# end class BaseVoltageDepSynapse -class BaseCurrentBasedSynapse(BaseSynapse): - """BaseCurrentBasedSynapse -- Synapse model which produces a synaptic current.""" +class FixedFactorConcentrationModel(ConcentrationModel): + """FixedFactorConcentrationModel -- Model of buffering of concentration of an ion ( currently hard coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** A fixed factor **rho** is used to scale the incoming current *independently of the size of the compartment* to produce a concentration change. + \n + :param restingConc: + :type restingConc: concentration + :param decayConstant: + :type decayConstant: time + :param rho: + :type rho: rho_factor + + """ __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [] + member_data_items_ = [ + MemberSpec_( + "resting_conc", + "Nml2Quantity_concentration", + 0, + 0, + {"use": "required", "name": "resting_conc"}, + ), + MemberSpec_( + "decay_constant", + "Nml2Quantity_time", + 0, + 0, + {"use": "required", "name": "decay_constant"}, + ), + MemberSpec_( + "rho", "Nml2Quantity_rhoFactor", 0, 0, {"use": "required", "name": "rho"} + ), + ] subclass = None - superclass = BaseSynapse + superclass = ConcentrationModel def __init__( self, @@ -54247,8 +54215,10 @@ def __init__( notes: "a string (optional)" = None, properties: "list of Property(s) (optional)" = None, annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - extensiontype_=None, + ion: "a NmlId (required)" = None, + resting_conc: "a Nml2Quantity_concentration (required)" = None, + decay_constant: "a Nml2Quantity_time (required)" = None, + rho: "a Nml2Quantity_rhoFactor (required)" = None, gds_collector_=None, **kwargs_, ): @@ -54257,34 +54227,130 @@ def __init__( self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("BaseCurrentBasedSynapse"), self).__init__( - id, - metaid, - notes, - properties, - annotation, - neuro_lex_id, - extensiontype_, - **kwargs_, + super(globals().get("FixedFactorConcentrationModel"), self).__init__( + id, metaid, notes, properties, annotation, ion, **kwargs_ ) - self.extensiontype_ = extensiontype_ + self.resting_conc = _cast(None, resting_conc) + self.resting_conc_nsprefix_ = None + self.decay_constant = _cast(None, decay_constant) + self.decay_constant_nsprefix_ = None + self.rho = _cast(None, rho) + self.rho_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( - CurrentSubclassModule_, BaseCurrentBasedSynapse + CurrentSubclassModule_, FixedFactorConcentrationModel ) if subclass is not None: return subclass(*args_, **kwargs_) - if BaseCurrentBasedSynapse.subclass: - return BaseCurrentBasedSynapse.subclass(*args_, **kwargs_) + if FixedFactorConcentrationModel.subclass: + return FixedFactorConcentrationModel.subclass(*args_, **kwargs_) else: - return BaseCurrentBasedSynapse(*args_, **kwargs_) + return FixedFactorConcentrationModel(*args_, **kwargs_) factory = staticmethod(factory) + def validate_Nml2Quantity_concentration(self, value): + # Validate type Nml2Quantity_concentration, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_concentration_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_concentration_patterns_, + ) + ) + + validate_Nml2Quantity_concentration_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m3|mol_per_cm3|M|mM))$"] + ] + + def validate_Nml2Quantity_time(self, value): + # Validate type Nml2Quantity_time, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_time_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_time_patterns_, + ) + ) + + validate_Nml2Quantity_time_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(s|ms))$"] + ] + + def validate_Nml2Quantity_rhoFactor(self, value): + # Validate type Nml2Quantity_rhoFactor, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_rhoFactor_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_rhoFactor_patterns_, + ) + ) + + validate_Nml2Quantity_rhoFactor_patterns_ = [ + [ + "^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m_per_A_per_s|mol_per_cm_per_uA_per_ms))$" + ] + ] + def has__content(self): - if super(BaseCurrentBasedSynapse, self).has__content(): + if super(FixedFactorConcentrationModel, self).has__content(): return True else: return False @@ -54295,17 +54361,20 @@ def export( level, namespaceprefix_="", namespacedef_="", - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", pretty_print=True, ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("BaseCurrentBasedSynapse") + imported_ns_def_ = GenerateDSNamespaceDefs_.get("FixedFactorConcentrationModel") if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = "\n" else: eol_ = "" - if self.original_tagname_ is not None and name_ == "BaseCurrentBasedSynapse": + if ( + self.original_tagname_ is not None + and name_ == "FixedFactorConcentrationModel" + ): name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ":" @@ -54324,7 +54393,7 @@ def export( level, already_processed, namespaceprefix_, - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", ) if self.has__content(): outfile.write(">%s" % (eol_,)) @@ -54333,7 +54402,7 @@ def export( level + 1, namespaceprefix_, namespacedef_, - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", pretty_print=pretty_print, ) showIndent(outfile, level, pretty_print) @@ -54347,27 +54416,53 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", ): - super(BaseCurrentBasedSynapse, self)._exportAttributes( + super(FixedFactorConcentrationModel, self)._exportAttributes( outfile, level, already_processed, namespaceprefix_, - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", ) - if self.extensiontype_ is not None and "xsi:type" not in already_processed: - already_processed.add("xsi:type") - outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') - if ":" not in self.extensiontype_: - imported_ns_type_prefix_ = GenerateDSNamespaceTypePrefixes_.get( - self.extensiontype_, "" + if self.resting_conc is not None and "resting_conc" not in already_processed: + already_processed.add("resting_conc") + outfile.write( + " restingConc=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.resting_conc), input_name="restingConc" + ) + ), ) - outfile.write( - ' xsi:type="%s%s"' % (imported_ns_type_prefix_, self.extensiontype_) + ) + if ( + self.decay_constant is not None + and "decay_constant" not in already_processed + ): + already_processed.add("decay_constant") + outfile.write( + " decayConstant=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.decay_constant), + input_name="decayConstant", + ) + ), ) - else: - outfile.write(' xsi:type="%s"' % self.extensiontype_) + ) + if self.rho is not None and "rho" not in already_processed: + already_processed.add("rho") + outfile.write( + " rho=%s" + % ( + self.gds_encode( + self.gds_format_string(quote_attrib(self.rho), input_name="rho") + ), + ) + ) def _exportChildren( self, @@ -54375,11 +54470,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", fromsubclass_=False, pretty_print=True, ): - super(BaseCurrentBasedSynapse, self)._exportChildren( + super(FixedFactorConcentrationModel, self)._exportChildren( outfile, level, namespaceprefix_, @@ -54393,6 +54488,20 @@ def validate_(self, gds_collector, recursive=False): self.gds_collector_ = gds_collector message_count = len(self.gds_collector_.get_messages()) # validate simple type attributes + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_concentration, self.resting_conc, "resting_conc" + ) + self.gds_check_cardinality_(self.resting_conc, "resting_conc", required=True) + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_time, self.decay_constant, "decay_constant" + ) + self.gds_check_cardinality_( + self.decay_constant, "decay_constant", required=True + ) + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_rhoFactor, self.rho, "rho" + ) + self.gds_check_cardinality_(self.rho, "rho", required=True) # validate simple type children # validate complex type children if recursive: @@ -54410,35 +54519,83 @@ def build(self, node, gds_collector_=None): nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) return self - - def _buildAttributes(self, node, attrs, already_processed): - value = find_attr_value_("xsi:type", node) - if value is not None and "xsi:type" not in already_processed: - already_processed.add("xsi:type") - self.extensiontype_ = value - super(BaseCurrentBasedSynapse, self)._buildAttributes( + + def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("restingConc", node) + if value is not None and "restingConc" not in already_processed: + already_processed.add("restingConc") + self.resting_conc = value + self.validate_Nml2Quantity_concentration( + self.resting_conc + ) # validate type Nml2Quantity_concentration + value = find_attr_value_("decayConstant", node) + if value is not None and "decayConstant" not in already_processed: + already_processed.add("decayConstant") + self.decay_constant = value + self.validate_Nml2Quantity_time( + self.decay_constant + ) # validate type Nml2Quantity_time + value = find_attr_value_("rho", node) + if value is not None and "rho" not in already_processed: + already_processed.add("rho") + self.rho = value + self.validate_Nml2Quantity_rhoFactor( + self.rho + ) # validate type Nml2Quantity_rhoFactor + super(FixedFactorConcentrationModel, self)._buildAttributes( node, attrs, already_processed ) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(BaseCurrentBasedSynapse, self)._buildChildren( + super(FixedFactorConcentrationModel, self)._buildChildren( child_, node, nodeName_, True ) pass -# end class BaseCurrentBasedSynapse +# end class FixedFactorConcentrationModel -class BaseVoltageDepSynapse(BaseSynapse): - """BaseVoltageDepSynapse -- Base type for synapses with a dependence on membrane potential""" +class DecayingPoolConcentrationModel(ConcentrationModel): + """DecayingPoolConcentrationModel -- Model of an intracellular buffering mechanism for **ion** ( currently hard Coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** The ion is assumed to occupy a shell inside the membrane of thickness **shellThickness.** + \n + :param restingConc: + :type restingConc: concentration + :param decayConstant: + :type decayConstant: time + :param shellThickness: + :type shellThickness: length + + """ __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [] + member_data_items_ = [ + MemberSpec_( + "resting_conc", + "Nml2Quantity_concentration", + 0, + 0, + {"use": "required", "name": "resting_conc"}, + ), + MemberSpec_( + "decay_constant", + "Nml2Quantity_time", + 0, + 0, + {"use": "required", "name": "decay_constant"}, + ), + MemberSpec_( + "shell_thickness", + "Nml2Quantity_length", + 0, + 0, + {"use": "required", "name": "shell_thickness"}, + ), + ] subclass = None - superclass = BaseSynapse + superclass = ConcentrationModel def __init__( self, @@ -54447,7 +54604,10 @@ def __init__( notes: "a string (optional)" = None, properties: "list of Property(s) (optional)" = None, annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, + ion: "a NmlId (required)" = None, + resting_conc: "a Nml2Quantity_concentration (required)" = None, + decay_constant: "a Nml2Quantity_time (required)" = None, + shell_thickness: "a Nml2Quantity_length (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -54457,34 +54617,129 @@ def __init__( self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("BaseVoltageDepSynapse"), self).__init__( - id, - metaid, - notes, - properties, - annotation, - neuro_lex_id, - extensiontype_, - **kwargs_, + super(globals().get("DecayingPoolConcentrationModel"), self).__init__( + id, metaid, notes, properties, annotation, ion, extensiontype_, **kwargs_ ) + self.resting_conc = _cast(None, resting_conc) + self.resting_conc_nsprefix_ = None + self.decay_constant = _cast(None, decay_constant) + self.decay_constant_nsprefix_ = None + self.shell_thickness = _cast(None, shell_thickness) + self.shell_thickness_nsprefix_ = None self.extensiontype_ = extensiontype_ def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( - CurrentSubclassModule_, BaseVoltageDepSynapse + CurrentSubclassModule_, DecayingPoolConcentrationModel ) if subclass is not None: return subclass(*args_, **kwargs_) - if BaseVoltageDepSynapse.subclass: - return BaseVoltageDepSynapse.subclass(*args_, **kwargs_) + if DecayingPoolConcentrationModel.subclass: + return DecayingPoolConcentrationModel.subclass(*args_, **kwargs_) else: - return BaseVoltageDepSynapse(*args_, **kwargs_) + return DecayingPoolConcentrationModel(*args_, **kwargs_) factory = staticmethod(factory) + def validate_Nml2Quantity_concentration(self, value): + # Validate type Nml2Quantity_concentration, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_concentration_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_concentration_patterns_, + ) + ) + + validate_Nml2Quantity_concentration_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m3|mol_per_cm3|M|mM))$"] + ] + + def validate_Nml2Quantity_time(self, value): + # Validate type Nml2Quantity_time, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_time_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_time_patterns_, + ) + ) + + validate_Nml2Quantity_time_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(s|ms))$"] + ] + + def validate_Nml2Quantity_length(self, value): + # Validate type Nml2Quantity_length, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_length_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_length_patterns_, + ) + ) + + validate_Nml2Quantity_length_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(m|cm|um))$"] + ] + def has__content(self): - if super(BaseVoltageDepSynapse, self).has__content(): + if super(DecayingPoolConcentrationModel, self).has__content(): return True else: return False @@ -54495,17 +54750,22 @@ def export( level, namespaceprefix_="", namespacedef_="", - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", pretty_print=True, ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("BaseVoltageDepSynapse") + imported_ns_def_ = GenerateDSNamespaceDefs_.get( + "DecayingPoolConcentrationModel" + ) if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = "\n" else: eol_ = "" - if self.original_tagname_ is not None and name_ == "BaseVoltageDepSynapse": + if ( + self.original_tagname_ is not None + and name_ == "DecayingPoolConcentrationModel" + ): name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ":" @@ -54524,7 +54784,7 @@ def export( level, already_processed, namespaceprefix_, - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", ) if self.has__content(): outfile.write(">%s" % (eol_,)) @@ -54533,7 +54793,7 @@ def export( level + 1, namespaceprefix_, namespacedef_, - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", pretty_print=pretty_print, ) showIndent(outfile, level, pretty_print) @@ -54547,15 +54807,59 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", ): - super(BaseVoltageDepSynapse, self)._exportAttributes( + super(DecayingPoolConcentrationModel, self)._exportAttributes( outfile, level, already_processed, namespaceprefix_, - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", ) + if self.resting_conc is not None and "resting_conc" not in already_processed: + already_processed.add("resting_conc") + outfile.write( + " restingConc=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.resting_conc), input_name="restingConc" + ) + ), + ) + ) + if ( + self.decay_constant is not None + and "decay_constant" not in already_processed + ): + already_processed.add("decay_constant") + outfile.write( + " decayConstant=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.decay_constant), + input_name="decayConstant", + ) + ), + ) + ) + if ( + self.shell_thickness is not None + and "shell_thickness" not in already_processed + ): + already_processed.add("shell_thickness") + outfile.write( + " shellThickness=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.shell_thickness), + input_name="shellThickness", + ) + ), + ) + ) if self.extensiontype_ is not None and "xsi:type" not in already_processed: already_processed.add("xsi:type") outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') @@ -54575,11 +54879,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", fromsubclass_=False, pretty_print=True, ): - super(BaseVoltageDepSynapse, self)._exportChildren( + super(DecayingPoolConcentrationModel, self)._exportChildren( outfile, level, namespaceprefix_, @@ -54593,6 +54897,22 @@ def validate_(self, gds_collector, recursive=False): self.gds_collector_ = gds_collector message_count = len(self.gds_collector_.get_messages()) # validate simple type attributes + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_concentration, self.resting_conc, "resting_conc" + ) + self.gds_check_cardinality_(self.resting_conc, "resting_conc", required=True) + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_time, self.decay_constant, "decay_constant" + ) + self.gds_check_cardinality_( + self.decay_constant, "decay_constant", required=True + ) + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_length, self.shell_thickness, "shell_thickness" + ) + self.gds_check_cardinality_( + self.shell_thickness, "shell_thickness", required=True + ) # validate simple type children # validate complex type children if recursive: @@ -54612,22 +54932,45 @@ def build(self, node, gds_collector_=None): return self def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("restingConc", node) + if value is not None and "restingConc" not in already_processed: + already_processed.add("restingConc") + self.resting_conc = value + self.validate_Nml2Quantity_concentration( + self.resting_conc + ) # validate type Nml2Quantity_concentration + value = find_attr_value_("decayConstant", node) + if value is not None and "decayConstant" not in already_processed: + already_processed.add("decayConstant") + self.decay_constant = value + self.validate_Nml2Quantity_time( + self.decay_constant + ) # validate type Nml2Quantity_time + value = find_attr_value_("shellThickness", node) + if value is not None and "shellThickness" not in already_processed: + already_processed.add("shellThickness") + self.shell_thickness = value + self.validate_Nml2Quantity_length( + self.shell_thickness + ) # validate type Nml2Quantity_length value = find_attr_value_("xsi:type", node) if value is not None and "xsi:type" not in already_processed: already_processed.add("xsi:type") self.extensiontype_ = value - super(BaseVoltageDepSynapse, self)._buildAttributes( + super(DecayingPoolConcentrationModel, self)._buildAttributes( node, attrs, already_processed ) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(BaseVoltageDepSynapse, self)._buildChildren(child_, node, nodeName_, True) + super(DecayingPoolConcentrationModel, self)._buildChildren( + child_, node, nodeName_, True + ) pass -# end class BaseVoltageDepSynapse +# end class DecayingPoolConcentrationModel class IonChannel(IonChannelScalable): @@ -59355,6 +59698,212 @@ def __str__(self): # end class Connection +class ConcentrationModel_D(DecayingPoolConcentrationModel): + __hash__ = GeneratedsSuper.__hash__ + member_data_items_ = [ + MemberSpec_("type", "xs:string", 0, 0, {"use": "required", "name": "type"}), + ] + subclass = None + superclass = DecayingPoolConcentrationModel + + def __init__( + self, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + ion: "a NmlId (required)" = None, + resting_conc: "a Nml2Quantity_concentration (required)" = None, + decay_constant: "a Nml2Quantity_time (required)" = None, + shell_thickness: "a Nml2Quantity_length (required)" = None, + type: "a string (required)" = "decayingPoolConcentrationModel", + gds_collector_=None, + **kwargs_, + ): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get("parent_object_") + self.ns_prefix_ = None + super(globals().get("ConcentrationModel_D"), self).__init__( + id, + metaid, + notes, + properties, + annotation, + ion, + resting_conc, + decay_constant, + shell_thickness, + **kwargs_, + ) + self.type = _cast(None, type) + self.type_nsprefix_ = None + + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, ConcentrationModel_D + ) + if subclass is not None: + return subclass(*args_, **kwargs_) + if ConcentrationModel_D.subclass: + return ConcentrationModel_D.subclass(*args_, **kwargs_) + else: + return ConcentrationModel_D(*args_, **kwargs_) + + factory = staticmethod(factory) + + def has__content(self): + if super(ConcentrationModel_D, self).has__content(): + return True + else: + return False + + def export( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="ConcentrationModel_D", + pretty_print=True, + ): + imported_ns_def_ = GenerateDSNamespaceDefs_.get("ConcentrationModel_D") + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = "\n" + else: + eol_ = "" + if self.original_tagname_ is not None and name_ == "ConcentrationModel_D": + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ":" + showIndent(outfile, level, pretty_print) + outfile.write( + "<%s%s%s" + % ( + namespaceprefix_, + name_, + namespacedef_ and " " + namespacedef_ or "", + ) + ) + already_processed = set() + self._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="ConcentrationModel_D", + ) + if self.has__content(): + outfile.write(">%s" % (eol_,)) + self._exportChildren( + outfile, + level + 1, + namespaceprefix_, + namespacedef_, + name_="ConcentrationModel_D", + pretty_print=pretty_print, + ) + showIndent(outfile, level, pretty_print) + outfile.write("%s" % (namespaceprefix_, name_, eol_)) + else: + outfile.write("/>%s" % (eol_,)) + + def _exportAttributes( + self, + outfile, + level, + already_processed, + namespaceprefix_="", + name_="ConcentrationModel_D", + ): + super(ConcentrationModel_D, self)._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="ConcentrationModel_D", + ) + if self.type is not None and "type" not in already_processed: + already_processed.add("type") + outfile.write( + " type=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.type), input_name="type" + ) + ), + ) + ) + + def _exportChildren( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="ConcentrationModel_D", + fromsubclass_=False, + pretty_print=True, + ): + super(ConcentrationModel_D, self)._exportChildren( + outfile, + level, + namespaceprefix_, + namespacedef_, + name_, + True, + pretty_print=pretty_print, + ) + + def validate_(self, gds_collector, recursive=False): + self.gds_collector_ = gds_collector + message_count = len(self.gds_collector_.get_messages()) + # validate simple type attributes + self.gds_validate_builtin_ST_(self.gds_validate_string, self.type, "type") + self.gds_check_cardinality_(self.type, "type", required=True) + # validate simple type children + # validate complex type children + if recursive: + pass + return message_count == len(self.gds_collector_.get_messages()) + + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self._buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + + def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("type", node) + if value is not None and "type" not in already_processed: + already_processed.add("type") + self.type = value + super(ConcentrationModel_D, self)._buildAttributes( + node, attrs, already_processed + ) + + def _buildChildren( + self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None + ): + super(ConcentrationModel_D, self)._buildChildren(child_, node, nodeName_, True) + pass + + +# end class ConcentrationModel_D + + class Cell2CaPools(Cell): """Cell2CaPools -- Variant of cell with two independent Ca2+ pools. Cell with **segment** s specified in a **morphology** element along with details on its **biophysicalProperties** . NOTE: this can only be correctly simulated using jLEMS when there is a single segment in the cell, and **v** of this cell represents the membrane potential in that isopotential segment.""" @@ -67825,243 +68374,245 @@ def main(): # simpleTypes are marked "ST" and complexTypes "CT". NamespaceToDefMappings_ = { "http://www.neuroml.org/schema/neuroml2": [ - ("NmlId", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_none", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_voltage", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_length", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_resistance", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_resistivity", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_conductance", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_conductanceDensity", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_permeability", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_time", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_pertime", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_capacitance", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_specificCapacitance", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_concentration", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_current", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_currentDensity", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_temperature", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_rhoFactor", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_conductancePerVoltage", "NeuroML_v2.3.1.xsd", "ST"), - ("MetaId", "NeuroML_v2.3.1.xsd", "ST"), - ("NeuroLexId", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2PopulationReferencePath", "NeuroML_v2.3.1.xsd", "ST"), - ("NonNegativeInteger", "NeuroML_v2.3.1.xsd", "ST"), - ("PositiveInteger", "NeuroML_v2.3.1.xsd", "ST"), - ("DoubleGreaterThanZero", "NeuroML_v2.3.1.xsd", "ST"), - ("ZeroOrOne", "NeuroML_v2.3.1.xsd", "ST"), - ("Notes", "NeuroML_v2.3.1.xsd", "ST"), - ("TrueOrFalse", "NeuroML_v2.3.1.xsd", "ST"), - ("ZeroToOne", "NeuroML_v2.3.1.xsd", "ST"), - ("channelTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("gateTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("BlockTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("PlasticityTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("Metric", "NeuroML_v2.3.1.xsd", "ST"), - ("networkTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("allowedSpaces", "NeuroML_v2.3.1.xsd", "ST"), - ("populationTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("Property", "NeuroML_v2.3.1.xsd", "CT"), - ("Annotation", "NeuroML_v2.3.1.xsd", "CT"), - ("ComponentType", "NeuroML_v2.3.1.xsd", "CT"), - ("Constant", "NeuroML_v2.3.1.xsd", "CT"), - ("Exposure", "NeuroML_v2.3.1.xsd", "CT"), - ("NamedDimensionalType", "NeuroML_v2.3.1.xsd", "CT"), - ("NamedDimensionalVariable", "NeuroML_v2.3.1.xsd", "CT"), - ("Parameter", "NeuroML_v2.3.1.xsd", "CT"), - ("DerivedParameter", "NeuroML_v2.3.1.xsd", "CT"), - ("LEMS_Property", "NeuroML_v2.3.1.xsd", "CT"), - ("Requirement", "NeuroML_v2.3.1.xsd", "CT"), - ("InstanceRequirement", "NeuroML_v2.3.1.xsd", "CT"), - ("Dynamics", "NeuroML_v2.3.1.xsd", "CT"), - ("DerivedVariable", "NeuroML_v2.3.1.xsd", "CT"), - ("StateVariable", "NeuroML_v2.3.1.xsd", "CT"), - ("ConditionalDerivedVariable", "NeuroML_v2.3.1.xsd", "CT"), - ("Case", "NeuroML_v2.3.1.xsd", "CT"), - ("TimeDerivative", "NeuroML_v2.3.1.xsd", "CT"), - ("OnStart", "NeuroML_v2.3.1.xsd", "CT"), - ("StateAssignment", "NeuroML_v2.3.1.xsd", "CT"), - ("OnEvent", "NeuroML_v2.3.1.xsd", "CT"), - ("EventOut", "NeuroML_v2.3.1.xsd", "CT"), - ("OnCondition", "NeuroML_v2.3.1.xsd", "CT"), - ("Transition", "NeuroML_v2.3.1.xsd", "CT"), - ("Regime", "NeuroML_v2.3.1.xsd", "CT"), - ("OnEntry", "NeuroML_v2.3.1.xsd", "CT"), - ("NeuroMLDocument", "NeuroML_v2.3.1.xsd", "CT"), - ("IncludeType", "NeuroML_v2.3.1.xsd", "CT"), - ("IonChannelScalable", "NeuroML_v2.3.1.xsd", "CT"), - ("IonChannelKS", "NeuroML_v2.3.1.xsd", "CT"), - ("IonChannel", "NeuroML_v2.3.1.xsd", "CT"), - ("IonChannelHH", "NeuroML_v2.3.1.xsd", "CT"), - ("IonChannelVShift", "NeuroML_v2.3.1.xsd", "CT"), - ("Q10ConductanceScaling", "NeuroML_v2.3.1.xsd", "CT"), - ("ClosedState", "NeuroML_v2.3.1.xsd", "CT"), - ("OpenState", "NeuroML_v2.3.1.xsd", "CT"), - ("ForwardTransition", "NeuroML_v2.3.1.xsd", "CT"), - ("ReverseTransition", "NeuroML_v2.3.1.xsd", "CT"), - ("TauInfTransition", "NeuroML_v2.3.1.xsd", "CT"), - ("GateKS", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHUndetermined", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHRates", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHTauInf", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHRatesTauInf", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHRatesTau", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHRatesInf", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHInstantaneous", "NeuroML_v2.3.1.xsd", "CT"), - ("GateFractional", "NeuroML_v2.3.1.xsd", "CT"), - ("GateFractionalSubgate", "NeuroML_v2.3.1.xsd", "CT"), - ("Q10Settings", "NeuroML_v2.3.1.xsd", "CT"), - ("HHRate", "NeuroML_v2.3.1.xsd", "CT"), - ("HHVariable", "NeuroML_v2.3.1.xsd", "CT"), - ("HHTime", "NeuroML_v2.3.1.xsd", "CT"), - ("DecayingPoolConcentrationModel", "NeuroML_v2.3.1.xsd", "CT"), - ("FixedFactorConcentrationModel", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseVoltageDepSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseCurrentBasedSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseConductanceBasedSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseConductanceBasedSynapseTwo", "NeuroML_v2.3.1.xsd", "CT"), - ("GapJunction", "NeuroML_v2.3.1.xsd", "CT"), - ("SilentSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("LinearGradedSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("GradedSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("AlphaCurrentSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("AlphaSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("ExpOneSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("ExpTwoSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("ExpThreeSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("DoubleSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BlockingPlasticSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BlockMechanism", "NeuroML_v2.3.1.xsd", "CT"), - ("PlasticityMechanism", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IafTauCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IafTauRefCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IafCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IafRefCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IzhikevichCell", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseCellMembPotCap", "NeuroML_v2.3.1.xsd", "CT"), - ("Izhikevich2007Cell", "NeuroML_v2.3.1.xsd", "CT"), - ("AdExIaFCell", "NeuroML_v2.3.1.xsd", "CT"), - ("FitzHughNagumoCell", "NeuroML_v2.3.1.xsd", "CT"), - ("FitzHughNagumo1969Cell", "NeuroML_v2.3.1.xsd", "CT"), - ("PinskyRinzelCA3Cell", "NeuroML_v2.3.1.xsd", "CT"), - ("HindmarshRose1984Cell", "NeuroML_v2.3.1.xsd", "CT"), - ("Cell", "NeuroML_v2.3.1.xsd", "CT"), - ("Cell2CaPools", "NeuroML_v2.3.1.xsd", "CT"), - ("Morphology", "NeuroML_v2.3.1.xsd", "CT"), - ("Segment", "NeuroML_v2.3.1.xsd", "CT"), - ("SegmentParent", "NeuroML_v2.3.1.xsd", "CT"), - ("Point3DWithDiam", "NeuroML_v2.3.1.xsd", "CT"), - ("SegmentGroup", "NeuroML_v2.3.1.xsd", "CT"), - ("InhomogeneousParameter", "NeuroML_v2.3.1.xsd", "CT"), - ("ProximalDetails", "NeuroML_v2.3.1.xsd", "CT"), - ("DistalDetails", "NeuroML_v2.3.1.xsd", "CT"), - ("Member", "NeuroML_v2.3.1.xsd", "CT"), - ("Include", "NeuroML_v2.3.1.xsd", "CT"), - ("Path", "NeuroML_v2.3.1.xsd", "CT"), - ("SubTree", "NeuroML_v2.3.1.xsd", "CT"), - ("SegmentEndPoint", "NeuroML_v2.3.1.xsd", "CT"), - ("BiophysicalProperties", "NeuroML_v2.3.1.xsd", "CT"), - ("BiophysicalProperties2CaPools", "NeuroML_v2.3.1.xsd", "CT"), - ("MembraneProperties", "NeuroML_v2.3.1.xsd", "CT"), - ("MembraneProperties2CaPools", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeThresh", "NeuroML_v2.3.1.xsd", "CT"), - ("SpecificCapacitance", "NeuroML_v2.3.1.xsd", "CT"), - ("InitMembPotential", "NeuroML_v2.3.1.xsd", "CT"), - ("Resistivity", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelPopulation", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityNonUniform", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityNonUniformNernst", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityNonUniformGHK", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensity", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityVShift", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityNernst", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityNernstCa2", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityGHK", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityGHK2", "NeuroML_v2.3.1.xsd", "CT"), - ("VariableParameter", "NeuroML_v2.3.1.xsd", "CT"), - ("InhomogeneousValue", "NeuroML_v2.3.1.xsd", "CT"), - ("Species", "NeuroML_v2.3.1.xsd", "CT"), - ("ConcentrationModel_D", "NeuroML_v2.3.1.xsd", "CT"), - ("IntracellularProperties", "NeuroML_v2.3.1.xsd", "CT"), - ("IntracellularProperties2CaPools", "NeuroML_v2.3.1.xsd", "CT"), - ("ExtracellularProperties", "NeuroML_v2.3.1.xsd", "CT"), - ("ExtracellularPropertiesLocal", "NeuroML_v2.3.1.xsd", "CT"), - ("ReactionScheme", "NeuroML_v2.3.1.xsd", "CT"), - ("PulseGenerator", "NeuroML_v2.3.1.xsd", "CT"), - ("PulseGeneratorDL", "NeuroML_v2.3.1.xsd", "CT"), - ("SineGenerator", "NeuroML_v2.3.1.xsd", "CT"), - ("SineGeneratorDL", "NeuroML_v2.3.1.xsd", "CT"), - ("RampGenerator", "NeuroML_v2.3.1.xsd", "CT"), - ("RampGeneratorDL", "NeuroML_v2.3.1.xsd", "CT"), - ("CompoundInput", "NeuroML_v2.3.1.xsd", "CT"), - ("CompoundInputDL", "NeuroML_v2.3.1.xsd", "CT"), - ("VoltageClamp", "NeuroML_v2.3.1.xsd", "CT"), - ("VoltageClampTriple", "NeuroML_v2.3.1.xsd", "CT"), - ("Spike", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeArray", "NeuroML_v2.3.1.xsd", "CT"), - ("TimedSynapticInput", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeGenerator", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeGeneratorRandom", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeGeneratorPoisson", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeGeneratorRefPoisson", "NeuroML_v2.3.1.xsd", "CT"), - ("PoissonFiringSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("TransientPoissonFiringSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("Network", "NeuroML_v2.3.1.xsd", "CT"), - ("Space", "NeuroML_v2.3.1.xsd", "CT"), - ("SpaceStructure", "NeuroML_v2.3.1.xsd", "CT"), - ("Region", "NeuroML_v2.3.1.xsd", "CT"), - ("Population", "NeuroML_v2.3.1.xsd", "CT"), - ("Layout", "NeuroML_v2.3.1.xsd", "CT"), - ("UnstructuredLayout", "NeuroML_v2.3.1.xsd", "CT"), - ("RandomLayout", "NeuroML_v2.3.1.xsd", "CT"), - ("GridLayout", "NeuroML_v2.3.1.xsd", "CT"), - ("Instance", "NeuroML_v2.3.1.xsd", "CT"), - ("Location", "NeuroML_v2.3.1.xsd", "CT"), - ("CellSet", "NeuroML_v2.3.1.xsd", "CT"), - ("SynapticConnection", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseProjection", "NeuroML_v2.3.1.xsd", "CT"), - ("Projection", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseConnection", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseConnectionOldFormat", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseConnectionNewFormat", "NeuroML_v2.3.1.xsd", "CT"), - ("Connection", "NeuroML_v2.3.1.xsd", "CT"), - ("ConnectionWD", "NeuroML_v2.3.1.xsd", "CT"), - ("ElectricalProjection", "NeuroML_v2.3.1.xsd", "CT"), - ("ElectricalConnection", "NeuroML_v2.3.1.xsd", "CT"), - ("ElectricalConnectionInstance", "NeuroML_v2.3.1.xsd", "CT"), - ("ElectricalConnectionInstanceW", "NeuroML_v2.3.1.xsd", "CT"), - ("ContinuousProjection", "NeuroML_v2.3.1.xsd", "CT"), - ("ContinuousConnection", "NeuroML_v2.3.1.xsd", "CT"), - ("ContinuousConnectionInstance", "NeuroML_v2.3.1.xsd", "CT"), - ("ContinuousConnectionInstanceW", "NeuroML_v2.3.1.xsd", "CT"), - ("ExplicitInput", "NeuroML_v2.3.1.xsd", "CT"), - ("InputList", "NeuroML_v2.3.1.xsd", "CT"), - ("Input", "NeuroML_v2.3.1.xsd", "CT"), - ("InputW", "NeuroML_v2.3.1.xsd", "CT"), - ("basePyNNCell", "NeuroML_v2.3.1.xsd", "CT"), - ("basePyNNIaFCell", "NeuroML_v2.3.1.xsd", "CT"), - ("basePyNNIaFCondCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IF_curr_alpha", "NeuroML_v2.3.1.xsd", "CT"), - ("IF_curr_exp", "NeuroML_v2.3.1.xsd", "CT"), - ("IF_cond_alpha", "NeuroML_v2.3.1.xsd", "CT"), - ("IF_cond_exp", "NeuroML_v2.3.1.xsd", "CT"), - ("EIF_cond_exp_isfa_ista", "NeuroML_v2.3.1.xsd", "CT"), - ("EIF_cond_alpha_isfa_ista", "NeuroML_v2.3.1.xsd", "CT"), - ("HH_cond_exp", "NeuroML_v2.3.1.xsd", "CT"), - ("BasePynnSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("ExpCondSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("AlphaCondSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("ExpCurrSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("AlphaCurrSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeSourcePoisson", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseWithoutId", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseNonNegativeIntegerId", "NeuroML_v2.3.1.xsd", "CT"), - ("Base", "NeuroML_v2.3.1.xsd", "CT"), - ("Standalone", "NeuroML_v2.3.1.xsd", "CT"), + ("NmlId", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_none", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_voltage", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_length", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_resistance", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_resistivity", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_conductance", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_conductanceDensity", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_permeability", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_time", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_pertime", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_capacitance", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_specificCapacitance", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_concentration", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_current", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_currentDensity", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_temperature", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_rhoFactor", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_conductancePerVoltage", "NeuroML_v2.3.2.xsd", "ST"), + ("MetaId", "NeuroML_v2.3.2.xsd", "ST"), + ("NeuroLexId", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2PopulationReferencePath", "NeuroML_v2.3.2.xsd", "ST"), + ("NonNegativeInteger", "NeuroML_v2.3.2.xsd", "ST"), + ("PositiveInteger", "NeuroML_v2.3.2.xsd", "ST"), + ("DoubleGreaterThanZero", "NeuroML_v2.3.2.xsd", "ST"), + ("ZeroOrOne", "NeuroML_v2.3.2.xsd", "ST"), + ("Notes", "NeuroML_v2.3.2.xsd", "ST"), + ("TrueOrFalse", "NeuroML_v2.3.2.xsd", "ST"), + ("ZeroToOne", "NeuroML_v2.3.2.xsd", "ST"), + ("channelTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("gateTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("BlockTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("PlasticityTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("Metric", "NeuroML_v2.3.2.xsd", "ST"), + ("networkTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("allowedSpaces", "NeuroML_v2.3.2.xsd", "ST"), + ("populationTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("Property", "NeuroML_v2.3.2.xsd", "CT"), + ("Annotation", "NeuroML_v2.3.2.xsd", "CT"), + ("ComponentType", "NeuroML_v2.3.2.xsd", "CT"), + ("Constant", "NeuroML_v2.3.2.xsd", "CT"), + ("Exposure", "NeuroML_v2.3.2.xsd", "CT"), + ("NamedDimensionalType", "NeuroML_v2.3.2.xsd", "CT"), + ("NamedDimensionalVariable", "NeuroML_v2.3.2.xsd", "CT"), + ("Parameter", "NeuroML_v2.3.2.xsd", "CT"), + ("DerivedParameter", "NeuroML_v2.3.2.xsd", "CT"), + ("LEMS_Property", "NeuroML_v2.3.2.xsd", "CT"), + ("Requirement", "NeuroML_v2.3.2.xsd", "CT"), + ("InstanceRequirement", "NeuroML_v2.3.2.xsd", "CT"), + ("Dynamics", "NeuroML_v2.3.2.xsd", "CT"), + ("DerivedVariable", "NeuroML_v2.3.2.xsd", "CT"), + ("StateVariable", "NeuroML_v2.3.2.xsd", "CT"), + ("ConditionalDerivedVariable", "NeuroML_v2.3.2.xsd", "CT"), + ("Case", "NeuroML_v2.3.2.xsd", "CT"), + ("TimeDerivative", "NeuroML_v2.3.2.xsd", "CT"), + ("OnStart", "NeuroML_v2.3.2.xsd", "CT"), + ("StateAssignment", "NeuroML_v2.3.2.xsd", "CT"), + ("OnEvent", "NeuroML_v2.3.2.xsd", "CT"), + ("EventOut", "NeuroML_v2.3.2.xsd", "CT"), + ("OnCondition", "NeuroML_v2.3.2.xsd", "CT"), + ("Transition", "NeuroML_v2.3.2.xsd", "CT"), + ("Regime", "NeuroML_v2.3.2.xsd", "CT"), + ("OnEntry", "NeuroML_v2.3.2.xsd", "CT"), + ("NeuroMLDocument", "NeuroML_v2.3.2.xsd", "CT"), + ("IncludeType", "NeuroML_v2.3.2.xsd", "CT"), + ("IonChannelScalable", "NeuroML_v2.3.2.xsd", "CT"), + ("IonChannelKS", "NeuroML_v2.3.2.xsd", "CT"), + ("IonChannel", "NeuroML_v2.3.2.xsd", "CT"), + ("IonChannelHH", "NeuroML_v2.3.2.xsd", "CT"), + ("IonChannelVShift", "NeuroML_v2.3.2.xsd", "CT"), + ("Q10ConductanceScaling", "NeuroML_v2.3.2.xsd", "CT"), + ("ClosedState", "NeuroML_v2.3.2.xsd", "CT"), + ("OpenState", "NeuroML_v2.3.2.xsd", "CT"), + ("ForwardTransition", "NeuroML_v2.3.2.xsd", "CT"), + ("ReverseTransition", "NeuroML_v2.3.2.xsd", "CT"), + ("TauInfTransition", "NeuroML_v2.3.2.xsd", "CT"), + ("GateKS", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHUndetermined", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHRates", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHTauInf", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHRatesTauInf", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHRatesTau", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHRatesInf", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHInstantaneous", "NeuroML_v2.3.2.xsd", "CT"), + ("GateFractional", "NeuroML_v2.3.2.xsd", "CT"), + ("GateFractionalSubgate", "NeuroML_v2.3.2.xsd", "CT"), + ("Q10Settings", "NeuroML_v2.3.2.xsd", "CT"), + ("HHRate", "NeuroML_v2.3.2.xsd", "CT"), + ("HHVariable", "NeuroML_v2.3.2.xsd", "CT"), + ("HHTime", "NeuroML_v2.3.2.xsd", "CT"), + ("ConcentrationModel", "NeuroML_v2.3.2.xsd", "CT"), + ("DecayingPoolConcentrationModel", "NeuroML_v2.3.2.xsd", "CT"), + ("FixedFactorConcentrationModel", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseVoltageDepSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseCurrentBasedSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseConductanceBasedSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseConductanceBasedSynapseTwo", "NeuroML_v2.3.2.xsd", "CT"), + ("GapJunction", "NeuroML_v2.3.2.xsd", "CT"), + ("SilentSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("LinearGradedSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("GradedSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("AlphaCurrentSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("AlphaSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("ExpOneSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("ExpTwoSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("ExpThreeSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("DoubleSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BlockingPlasticSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BlockMechanism", "NeuroML_v2.3.2.xsd", "CT"), + ("PlasticityMechanism", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IafTauCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IafTauRefCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IafCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IafRefCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IzhikevichCell", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseCellMembPotCap", "NeuroML_v2.3.2.xsd", "CT"), + ("Izhikevich2007Cell", "NeuroML_v2.3.2.xsd", "CT"), + ("AdExIaFCell", "NeuroML_v2.3.2.xsd", "CT"), + ("FitzHughNagumoCell", "NeuroML_v2.3.2.xsd", "CT"), + ("FitzHughNagumo1969Cell", "NeuroML_v2.3.2.xsd", "CT"), + ("PinskyRinzelCA3Cell", "NeuroML_v2.3.2.xsd", "CT"), + ("HindmarshRose1984Cell", "NeuroML_v2.3.2.xsd", "CT"), + ("Cell", "NeuroML_v2.3.2.xsd", "CT"), + ("Cell2CaPools", "NeuroML_v2.3.2.xsd", "CT"), + ("Morphology", "NeuroML_v2.3.2.xsd", "CT"), + ("Segment", "NeuroML_v2.3.2.xsd", "CT"), + ("SegmentParent", "NeuroML_v2.3.2.xsd", "CT"), + ("Point3DWithDiam", "NeuroML_v2.3.2.xsd", "CT"), + ("SegmentGroup", "NeuroML_v2.3.2.xsd", "CT"), + ("InhomogeneousParameter", "NeuroML_v2.3.2.xsd", "CT"), + ("ProximalDetails", "NeuroML_v2.3.2.xsd", "CT"), + ("DistalDetails", "NeuroML_v2.3.2.xsd", "CT"), + ("Member", "NeuroML_v2.3.2.xsd", "CT"), + ("Include", "NeuroML_v2.3.2.xsd", "CT"), + ("Path", "NeuroML_v2.3.2.xsd", "CT"), + ("SubTree", "NeuroML_v2.3.2.xsd", "CT"), + ("SegmentEndPoint", "NeuroML_v2.3.2.xsd", "CT"), + ("BiophysicalProperties", "NeuroML_v2.3.2.xsd", "CT"), + ("BiophysicalProperties2CaPools", "NeuroML_v2.3.2.xsd", "CT"), + ("MembraneProperties", "NeuroML_v2.3.2.xsd", "CT"), + ("MembraneProperties2CaPools", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeThresh", "NeuroML_v2.3.2.xsd", "CT"), + ("SpecificCapacitance", "NeuroML_v2.3.2.xsd", "CT"), + ("InitMembPotential", "NeuroML_v2.3.2.xsd", "CT"), + ("Resistivity", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelPopulation", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityNonUniform", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityNonUniformNernst", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityNonUniformGHK", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseChannelDensity", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensity", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityVShift", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityNernst", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityNernstCa2", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityGHK", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityGHK2", "NeuroML_v2.3.2.xsd", "CT"), + ("VariableParameter", "NeuroML_v2.3.2.xsd", "CT"), + ("InhomogeneousValue", "NeuroML_v2.3.2.xsd", "CT"), + ("Species", "NeuroML_v2.3.2.xsd", "CT"), + ("ConcentrationModel_D", "NeuroML_v2.3.2.xsd", "CT"), + ("IntracellularProperties", "NeuroML_v2.3.2.xsd", "CT"), + ("IntracellularProperties2CaPools", "NeuroML_v2.3.2.xsd", "CT"), + ("ExtracellularProperties", "NeuroML_v2.3.2.xsd", "CT"), + ("ExtracellularPropertiesLocal", "NeuroML_v2.3.2.xsd", "CT"), + ("ReactionScheme", "NeuroML_v2.3.2.xsd", "CT"), + ("PulseGenerator", "NeuroML_v2.3.2.xsd", "CT"), + ("PulseGeneratorDL", "NeuroML_v2.3.2.xsd", "CT"), + ("SineGenerator", "NeuroML_v2.3.2.xsd", "CT"), + ("SineGeneratorDL", "NeuroML_v2.3.2.xsd", "CT"), + ("RampGenerator", "NeuroML_v2.3.2.xsd", "CT"), + ("RampGeneratorDL", "NeuroML_v2.3.2.xsd", "CT"), + ("CompoundInput", "NeuroML_v2.3.2.xsd", "CT"), + ("CompoundInputDL", "NeuroML_v2.3.2.xsd", "CT"), + ("VoltageClamp", "NeuroML_v2.3.2.xsd", "CT"), + ("VoltageClampTriple", "NeuroML_v2.3.2.xsd", "CT"), + ("Spike", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeArray", "NeuroML_v2.3.2.xsd", "CT"), + ("TimedSynapticInput", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeGenerator", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeGeneratorRandom", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeGeneratorPoisson", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeGeneratorRefPoisson", "NeuroML_v2.3.2.xsd", "CT"), + ("PoissonFiringSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("TransientPoissonFiringSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("Network", "NeuroML_v2.3.2.xsd", "CT"), + ("Space", "NeuroML_v2.3.2.xsd", "CT"), + ("SpaceStructure", "NeuroML_v2.3.2.xsd", "CT"), + ("Region", "NeuroML_v2.3.2.xsd", "CT"), + ("Population", "NeuroML_v2.3.2.xsd", "CT"), + ("Layout", "NeuroML_v2.3.2.xsd", "CT"), + ("UnstructuredLayout", "NeuroML_v2.3.2.xsd", "CT"), + ("RandomLayout", "NeuroML_v2.3.2.xsd", "CT"), + ("GridLayout", "NeuroML_v2.3.2.xsd", "CT"), + ("Instance", "NeuroML_v2.3.2.xsd", "CT"), + ("Location", "NeuroML_v2.3.2.xsd", "CT"), + ("CellSet", "NeuroML_v2.3.2.xsd", "CT"), + ("SynapticConnection", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseProjection", "NeuroML_v2.3.2.xsd", "CT"), + ("Projection", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseConnection", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseConnectionOldFormat", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseConnectionNewFormat", "NeuroML_v2.3.2.xsd", "CT"), + ("Connection", "NeuroML_v2.3.2.xsd", "CT"), + ("ConnectionWD", "NeuroML_v2.3.2.xsd", "CT"), + ("ElectricalProjection", "NeuroML_v2.3.2.xsd", "CT"), + ("ElectricalConnection", "NeuroML_v2.3.2.xsd", "CT"), + ("ElectricalConnectionInstance", "NeuroML_v2.3.2.xsd", "CT"), + ("ElectricalConnectionInstanceW", "NeuroML_v2.3.2.xsd", "CT"), + ("ContinuousProjection", "NeuroML_v2.3.2.xsd", "CT"), + ("ContinuousConnection", "NeuroML_v2.3.2.xsd", "CT"), + ("ContinuousConnectionInstance", "NeuroML_v2.3.2.xsd", "CT"), + ("ContinuousConnectionInstanceW", "NeuroML_v2.3.2.xsd", "CT"), + ("ExplicitInput", "NeuroML_v2.3.2.xsd", "CT"), + ("InputList", "NeuroML_v2.3.2.xsd", "CT"), + ("Input", "NeuroML_v2.3.2.xsd", "CT"), + ("InputW", "NeuroML_v2.3.2.xsd", "CT"), + ("basePyNNCell", "NeuroML_v2.3.2.xsd", "CT"), + ("basePyNNIaFCell", "NeuroML_v2.3.2.xsd", "CT"), + ("basePyNNIaFCondCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IF_curr_alpha", "NeuroML_v2.3.2.xsd", "CT"), + ("IF_curr_exp", "NeuroML_v2.3.2.xsd", "CT"), + ("IF_cond_alpha", "NeuroML_v2.3.2.xsd", "CT"), + ("IF_cond_exp", "NeuroML_v2.3.2.xsd", "CT"), + ("EIF_cond_exp_isfa_ista", "NeuroML_v2.3.2.xsd", "CT"), + ("EIF_cond_alpha_isfa_ista", "NeuroML_v2.3.2.xsd", "CT"), + ("HH_cond_exp", "NeuroML_v2.3.2.xsd", "CT"), + ("BasePynnSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("ExpCondSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("AlphaCondSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("ExpCurrSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("AlphaCurrSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeSourcePoisson", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseWithoutId", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseNonNegativeIntegerId", "NeuroML_v2.3.2.xsd", "CT"), + ("Base", "NeuroML_v2.3.2.xsd", "CT"), + ("Standalone", "NeuroML_v2.3.2.xsd", "CT"), ] } @@ -68075,6 +68626,7 @@ def main(): "Base", "BaseCell", "BaseCellMembPotCap", + "BaseChannelDensity", "BaseConductanceBasedSynapse", "BaseConductanceBasedSynapseTwo", "BaseConnection", @@ -68109,6 +68661,7 @@ def main(): "ComponentType", "CompoundInput", "CompoundInputDL", + "ConcentrationModel", "ConcentrationModel_D", "ConditionalDerivedVariable", "Connection",