biocrnpyler.mechanisms.transport

Classes

`Facilitated_Transport_MM`([name, mechanism_type])	Facilitated diffusion mechanism with Michaelis-Menten kinetics.
`Membrane_Protein_Integration`([name, ...])	Membrane protein integration mechanism for protein insertion.
`Primary_Active_Transport_MM`([name, ...])	Primary active transport mechanism with ATP-dependent pumping.
`Simple_Diffusion`([name, mechanism_type])	Passive diffusion mechanism for substrate transport across membranes.
`Simple_Transport`([name, mechanism_type])	Passive transport mechanism through membrane channel proteins.

class biocrnpyler.mechanisms.transport.Facilitated_Transport_MM(name='facilitated_membrane_protein_transport', mechanism_type='transport', **kwargs)[source]

Facilitated diffusion mechanism with Michaelis-Menten kinetics.

A ‘transport’ mechanism that models facilitated diffusion of substrates through membrane carrier proteins. Unlike simple channels, carriers undergo conformational changes to transport substrates across membranes. The mechanism follows Michaelis-Menten kinetics with explicit substrate and product binding steps.

The reaction follows the schema:

Sub + MC <–> Sub:MC –> Prod:MC –> Prod + MC

where MC is the membrane carrier protein.

Parameters:

namestr, default=’facilitated_membrane_protein_transport’: Name identifier for this mechanism instance.
mechanism_typestr, default=’transport’: Type classification of this mechanism.

Attributes:

namestr: Name of the mechanism instance.
mechanism_typestr: Type classification (‘transport’).

See also

Simple_Transport: Passive transport through channels.
Primary_Active_Transport_MM: Energy-dependent active transport.
MichaelisMenten: Enzyme mechanism with similar kinetics.
Mechanism: Base class for all mechanisms.

Notes

This mechanism models facilitated diffusion by carrier proteins that alternate between substrate-bound and product-bound conformations. The carrier binds substrate on one side of the membrane, undergoes a conformational change to transport it across, releases it as product, and returns to the original conformation.

Key characteristics:

Does not require ATP or other energy sources
Transport is driven by concentration gradients
Carrier proteins alternate between conformational states
Follows Michaelis-Menten saturation kinetics

Common examples include:

GLUT transporters for glucose
Amino acid carriers
Nucleoside transporters
Urea transporters

The mechanism uses a GeneralPropensity with a Heaviside function for the initial binding step to enforce directionality based on concentration gradients.

Required parameters for this mechanism:

‘kb_subMC’ : Forward binding rate for substrate to membrane carrier
‘ku_subMC’ : Unbinding rate for substrate from carrier
‘k_trnspMC’ : Conformational change rate (transport step)
‘ku_prodMC’ : Unbinding rate for product from carrier

Examples

Model glucose transport through a GLUT transporter:

>>> glc_in = bcp.Species('glucose', compartment='cytoplasm')
>>> glc_out = bcp.Species('glucose', compartment='external')
>>> carrier = bcp.MembraneChannel(
...     integral_membrane_protein='GlucoseTransporter',
...     substrate=glc_out,
...     external_compartment='external',
...     internal_compartment='cytoplasm',
...     direction='Importer'
... )
>>> mechanism = bcp.Facilitated_Transport_MM()
>>> mixture = bcp.Mixture(
...     components=[carrier],
...     mechanisms={'transport': mechanism},
...     parameters={
...         'kb_subMC': 1.0, 'ku_subMC': 0.5,
...         'k_trnspMC': 0.8, 'ku_prodMC': 0.5
...     }
... )
>>> mixture.compile_crn()

update_reactions(membrane_carrier, substrate, product, complex_dict=None, component=None, part_id=None, **kwargs)[source]

Generate reactions for facilitated transport.

Creates four reactions representing the complete transport cycle: substrate binding, substrate unbinding, conformational change (transport), and product release.

Parameters:

membrane_carrierSpecies: The membrane carrier protein facilitating transport.
substrateSpecies: The substrate species being transported.
productSpecies: The product species after transport.
complex_dictdict, optional: Pre-defined dictionary of complex species. If None, complexes are automatically created using the same logic as in update_species.
componentComponent: Component containing parameter values. Required for parameter lookup.
part_idstr: Identifier for parameter lookup in the component’s parameter database. Required for parameter lookup.
**kwargs: Additional keyword arguments (unused).

Returns:

list of Reaction: List of four reactions: [substrate_binding, substrate_unbinding, transport_step, product_release].

Raises:

AttributeError: If component or part_id is None (required for parameter lookup).

Notes

The reaction scheme follows this pathway:

MC + Sub <–> MC:Sub (GeneralPropensity with Heaviside function using ‘kb_subMC’)
MC:Sub –> MC + Sub (irreversible, rate: ‘ku_subMC’)
MC:Sub –> MC:Prod (conformational change, rate: ‘k_trnspMC’)
MC:Prod –> MC + Prod (irreversible, rate: ‘ku_prodMC’)

The initial binding step uses a GeneralPropensity with a Heaviside function to enforce concentration gradient-driven directionality. The Heaviside function ensures transport only occurs when substrate concentration exceeds product concentration.

update_species(membrane_carrier, substrate, product, complex_dict=None, **kwargs)[source]

Generate species for facilitated transport.

Creates species for the membrane carrier, substrate, product, and the two intermediate complexes formed during the transport cycle.

Parameters:

membrane_carrierSpecies: The membrane carrier protein that facilitates transport.
substrateSpecies: The substrate species being transported (typically intracellular side).
productSpecies: The product species after transport (typically extracellular side). Usually the same molecular species as substrate but in a different compartment.
complex_dictdict, optional: Pre-defined dictionary of complex species with keys ‘sub:MC’ and ‘prod:MC’. If None, complexes are automatically created.
**kwargs: Additional keyword arguments (unused).

Returns:

list: List containing [membrane_carrier, substrate, product, complex_array] where complex_array is a list of two Complex species: [substrate:carrier, product:carrier].

Notes

The method creates two complex species representing intermediates in the transport cycle:

sub:MC : substrate:membrane_carrier complex
prod:MC : product:membrane_carrier complex

class biocrnpyler.mechanisms.transport.Membrane_Protein_Integration(name='membrane_protein_integration', mechanism_type='membrane_insertion', **kwargs)[source]

Membrane protein integration mechanism for protein insertion.

A ‘membrane_insertion’ mechanism that models the integration of newly synthesized proteins into cellular membranes. Supports both monomeric and oligomeric membrane proteins, handling oligomerization before membrane insertion when required.

The reaction schema depends on protein oligomeric state:

For monomers (size = 1):: monomer –> integral membrane protein
For oligomers (size > 1):: monomer * size <–> oligomer –> integral membrane protein

Parameters:

namestr, default=’membrane_protein_integration’: Name identifier for this mechanism instance.
mechanism_typestr, default=’membrane_insertion’: Type classification of this mechanism.

Attributes:

namestr: Name of the mechanism instance.
mechanism_typestr: Type classification (‘membrane_insertion’).

See also

Mechanism: Base class for all mechanisms.

Notes

This mechanism models the process by which proteins become embedded in cellular membranes. For oligomeric proteins, multiple monomers must first associate into a complex before integration can occur. The integration step uses a ProportionalHillNegative propensity function to model saturation kinetics and product inhibition.

The mechanism requires the integral membrane protein to have a size attribute (integral_membrane_protein.size) that specifies the number of monomers in the functional unit.

Common examples include:

Integration of ion channels (often oligomeric)
Insertion of receptor proteins (can be monomeric or oligomeric)
Assembly and insertion of transporter complexes

Required parameters for this mechanism:

‘kb_oligomer’ : Forward oligomerization rate constant (for size > 1)
‘ku_oligomer’ : Reverse oligomerization rate constant (for size > 1)
‘kex’ : Maximum integration rate constant
‘kcat’ : Michaelis constant for integration

Examples

Model integration of a tetrameric channel:

>>> channel = bcp.IntegralMembraneProtein(
...     membrane_protein='Aquaporin',
...     product='Aquaporin_channel',
...     size=2,
...     direction='Passive'
... )
>>> mechanism = bcp.Membrane_Protein_Integration()
>>> mixture = bcp.Mixture(
...     components=[channel],
...     mechanisms={'membrane_insertion': mechanism},
...     parameters={
...         'kb_oligomer': 1.0, 'ku_oligomer': 0.1,
...         'kex': 0.5, 'kcat': 10.0
...     }
... )
>>> mixture.compile_crn()

update_reactions(integral_membrane_protein, product, complex=None, component=None, part_id=None, **kwargs)[source]

Generate reactions for membrane protein integration.

Creates reactions for oligomerization (if needed) and membrane integration. For oligomeric proteins, generates both oligomerization and integration reactions. For monomers, generates only the integration reaction.

Parameters:

integral_membrane_proteinSpecies: The membrane protein monomer. Must have a size attribute.
productSpecies: The integrated membrane protein product.
complexSpecies, optional: Pre-specified oligomeric complex. If None and size > 1, automatically created.
componentComponent: Component containing parameter values. Required for parameter lookup.
part_idstr: Identifier for parameter lookup in the component’s parameter database. Required for parameter lookup.
**kwargs: Additional keyword arguments (unused).

Returns:

list of Reaction: For oligomers (size > 1): List of two reactions [oligomerization, integration]. For monomers (size = 1): List of one reaction [integration].

Raises:

AttributeError: If component or part_id is None (required for parameter lookup).

Notes

The reaction scheme depends on oligomeric state:

For oligomers (size > 1):

size * monomer <–> oligomer (rates: ‘kb_oligomer’, ‘ku_oligomer’)
oligomer –> product (ProportionalHillNegative with ‘kex’, ‘kcat’)

For monomers (size = 1):

monomer –> product (ProportionalHillNegative with ‘kex’, ‘kcat’)

The integration reaction uses ProportionalHillNegative kinetics with Hill coefficient n=4 to model saturation and product inhibition.

update_species(integral_membrane_protein, product, complex=None, **kwargs)[source]

Generate species for membrane protein integration.

Creates species for monomers, oligomeric complexes (if needed), and the integrated membrane protein product.

Parameters:

integral_membrane_proteinSpecies: The membrane protein monomer that will be integrated. Must have a size attribute specifying oligomeric state.
productSpecies: The integrated membrane protein product after insertion.
complexSpecies, optional: Pre-specified oligomeric complex. If None and size > 1, automatically creates a Complex of size monomers. Ignored for monomeric proteins (size = 1).
**kwargs: Additional keyword arguments (unused).

Returns:

list: List containing [integral_membrane_protein, product, complex] where complex is None for monomers or a Complex species for oligomers.

Notes

For monomeric proteins (size = 1), no oligomeric complex is formed and the complex element in the return list is None.

For oligomeric proteins (size > 1), a complex containing ‘size’ copies of the monomer is created or used if provided.

class biocrnpyler.mechanisms.transport.Primary_Active_Transport_MM(name='active_membrane_protein_transport', mechanism_type='transport', **kwargs)[source]

Primary active transport mechanism with ATP-dependent pumping.

A ‘transport’ mechanism that models primary active transport where substrates are moved against their concentration gradients using energy from ATP hydrolysis. The mechanism follows Michaelis-Menten kinetics with explicit binding, ATP hydrolysis, conformational change, and product release steps.

The reaction follows the schema:

Sub + MP <–> Sub:MP + E –> Sub:MP:E –> MP:Prod:E –> Prod + MP:W –> Prod + MP + W

where MP is the membrane pump, E is ATP (energy), and W is ADP (waste).

Parameters:

namestr, default=’active_membrane_protein_transport’: Name identifier for this mechanism instance.
mechanism_typestr, default=’transport’: Type classification of this mechanism.

Attributes:

namestr: Name of the mechanism instance.
mechanism_typestr: Type classification (‘transport’).

See also

Facilitated_Transport_MM: Passive facilitated diffusion.
Simple_Transport: Passive channel transport.
Mechanism: Base class for all mechanisms.

Notes

This mechanism models primary active transporters such as P-type ATPases (e.g., Na+/K+-ATPase, Ca2+-ATPase), ABC transporters, and other pumps that directly couple ATP hydrolysis to substrate transport. The pump undergoes conformational changes driven by ATP binding and hydrolysis to move substrates against concentration gradients.

Key characteristics:

Requires ATP or other energy source
Can transport substrates against concentration gradients
Undergoes ATP-dependent conformational changes
Follows Michaelis-Menten saturation kinetics

Common examples include:

Na+/K+-ATPase (maintains ion gradients in animal cells)
Ca2+-ATPase (SERCA pump in muscle cells)
H+-ATPases (proton pumps in various organisms)
ABC transporters (drug efflux pumps)

The mechanism requires the membrane pump to have an ATP attribute (membrane_pump.ATP) that specifies the number of ATP molecules required per transport cycle.

The binding steps use GeneralPropensity with Heaviside functions to ensure proper directionality based on species concentrations.

Required parameters for this mechanism:

‘kb_subMP’ : Forward binding rate for substrate to membrane pump
‘ku_subMP’ : Unbinding rate for substrate from pump
‘kb_subMPnATP’ : Forward binding rate for ATP to substrate:pump complex
‘ku_subMPnATP’ : Unbinding rate for ATP from substrate:pump complex
‘k_trnspMP’ : Conformational change rate (transport step)
‘ku_prodMP’ : Unbinding rate for product from pump
‘ku_MP’ : Unbinding rate for ADP from pump

Examples

Model active sodium transport by Na+/K+-ATPase:

>>> pump = bcp.MembranePump(
...     membrane_pump='NaK_ATPase',
...     substrate='Na',
...     direction='Exporter',
...     ATP=1
... )
>>> mechanism = bcp.Primary_Active_Transport_MM()
>>> mixture = bcp.Mixture(
...     components=[pump],
...     mechanisms={'transport': mechanism},
...     parameters={
...         'kb_subMP': 1.0, 'ku_subMP': 0.1,
...         'kb_subMPnATP': 1.0, 'ku_subMPnATP': 0.1,
...         'k_trnspMP': 0.5, 'ku_prodMP': 1.0,
...         'ku_MP': 1.0
...     }
... )
>>> mixture.compile_crn()

update_reactions(membrane_pump, substrate, product, energy, waste, complex_dict=None, component=None, part_id=None, **kwargs)[source]

Generate reactions for primary active transport.

Creates seven reactions representing the complete ATP-driven transport cycle: substrate binding/unbinding, ATP binding/unbinding, conformational change (transport), product release, and ADP release.

Parameters:

membrane_pumpSpecies: The membrane pump protein. Must have an ATP attribute.
substrateSpecies: The substrate species being transported.
productSpecies: The product species after transport.
energySpecies: ATP species used for active transport.
wasteSpecies: ADP species produced after ATP hydrolysis.
complex_dictdict, optional: Pre-defined dictionary of complex species. If None, complexes are automatically created using the same logic as in update_species.
componentComponent: Component containing parameter values. Required for parameter lookup.
part_idstr: Identifier for parameter lookup in the component’s parameter database. Required for parameter lookup.
**kwargs: Additional keyword arguments (unused).

Returns:

list of Reaction: List of seven reactions: [substrate_binding, substrate_unbinding, ATP_binding, ATP_unbinding, transport_step, product_release, ADP_release].

Raises:

AttributeError: If component or part_id is None (required for parameter lookup).

Notes

The reaction scheme follows this pathway:

MP + Sub <–> MP:Sub (GeneralPropensity with Heaviside using ‘kb_subMP’, reverse rate: ‘ku_subMP’)
MP:Sub + nATP <–> MP:Sub:nATP (GeneralPropensity with Heaviside using ‘kb_subMPnATP’, reverse rate: ‘ku_subMPnATP’)
MP:Sub:nATP –> MP:Prod:nATP (conformational change, rate: ‘k_trnspMP’)
MP:Prod:nATP –> MP:nADP + Prod (product release, rate: ‘ku_prodMP’)
MP:nADP –> MP + nADP (ADP release, rate: ‘ku_MP’)

The binding steps use GeneralPropensity with Heaviside functions to enforce proper directionality. The Heaviside functions ensure that reactions only proceed when the required species are present.

The number of ATP/ADP molecules (nATP) is determined by membrane_pump.ATP attribute.

update_species(membrane_pump, substrate, product, energy, waste, complex_dict=None, **kwargs)[source]

Generate species for primary active transport.

Creates species for the membrane pump, substrate, product, ATP/ADP energy species, and all intermediate complexes formed during the ATP-driven transport cycle.

Parameters:

membrane_pumpSpecies: The membrane pump protein that transports substrates using ATP. Must have an ATP attribute specifying the number of ATP molecules required per transport cycle.
substrateSpecies: The substrate species being transported (typically intracellular side).
productSpecies: The product species after transport (typically extracellular side). Usually the same molecular species as substrate but in a different compartment.
energySpecies: ATP species used to drive active transport.
wasteSpecies: ADP species produced after ATP hydrolysis.
complex_dictdict, optional: Pre-defined dictionary of complex species with keys ‘Pump:Sub’, ‘Pump:Sub:ATP’, ‘Pump:Prod:ATP’, and ‘Pump:ADP’. If None, complexes are automatically created.
**kwargs: Additional keyword arguments (unused).

Returns:

list: List containing [membrane_pump, substrate, product, energy, waste, complex_array] where complex_array is a list of four Complex species generated.

Notes

The method creates four complex species representing intermediates in the active transport cycle:

Pump:Sub : membrane_pump:substrate complex
Pump:Sub:ATP : membrane_pump:substrate:nATP complex
Pump:Prod:ATP : membrane_pump:product:nATP complex
Pump:ADP : membrane_pump:nADP complex

The number of ATP/ADP molecules (nATP) is determined by the membrane_pump.ATP attribute.

class biocrnpyler.mechanisms.transport.Simple_Diffusion(name='simple_diffusion', mechanism_type='diffusion', **kwargs)[source]

Passive diffusion mechanism for substrate transport across membranes.

A ‘diffusion’ mechanism that models simple passive diffusion of substrates through a membrane without requiring membrane proteins or energy. The transport is bidirectional and follows Fick’s law of diffusion with equal forward and reverse rate constants.

The reaction follows the schema:

substrate <–> product

where substrate and product represent the same species on opposite sides of the membrane.

Parameters:

namestr, default=’simple_diffusion’: Name identifier for this mechanism instance.
mechanism_typestr, default=’diffusion’: Type classification of this mechanism.

Attributes:

namestr: Name of the mechanism instance.
mechanism_typestr: Type classification (‘diffusion’).

See also

Simple_Transport: Passive transport through membrane channels.
Facilitated_Transport_MM: Facilitated diffusion with carriers.
Mechanism: Base class for all mechanisms.

Notes

Simple diffusion models the movement of small, lipophilic molecules across lipid bilayers without the assistance of membrane proteins. This process is driven purely by concentration gradients and does not require cellular energy.

Common examples include:

Diffusion of gases (O2, CO2) across cell membranes
Transport of small nonpolar molecules
Movement of lipid-soluble substances

The mechanism generates a single reversible mass-action reaction with equal forward and reverse rate constants, reflecting the thermodynamic equilibrium of passive diffusion.

Required parameters for this mechanism:

‘k_diff’ : Diffusion rate constant (same for both directions)

Examples

Model oxygen diffusion across a membrane:

>>> O2 = bcp.DiffusibleMolecule('O2')
>>> mechanism = bcp.Simple_Diffusion()
>>> mixture = bcp.Mixture(
...     components=[O2],
...     mechanisms={'diffusion': mechanism},
...     parameters={'k_diff': 0.1}
... )
>>> mixture.compile_crn()

update_reactions(substrate, product, component=None, part_id=None, k_diff=None, **kwargs)[source]

Generate reactions for simple diffusion.

Creates a single reversible mass-action reaction representing passive diffusion across a membrane with equal forward and reverse rate constants.

Parameters:

substrateSpecies: The substrate species on one side of the membrane.
productSpecies: The product species on the other side of the membrane.
componentComponent, optional: Component containing parameter values. Required if k_diff is not provided directly.
part_idstr, optional: Identifier for parameter lookup. If None and component is provided, defaults to component.name.
k_diffParameter or float, optional: Diffusion rate constant. If None, retrieved from component parameters. Used as both forward and reverse rate constant.
**kwargs: Additional keyword arguments (unused).

Returns:

list of Reaction: List containing a single reversible mass-action reaction for diffusion.

Raises:

ValueError: If component is None and k_diff is not provided.

Notes

The reaction has equal forward and reverse rate constants, reflecting the thermodynamic equilibrium of passive diffusion:

substrate <–> product (rates: ‘k_diff’, ‘k_diff’)

update_species(substrate, product, **kwargs)[source]

Generate species for simple diffusion.

Returns the substrate and product species involved in the diffusion reaction.

Parameters:

substrateSpecies: The substrate species on one side of the membrane (typically the intracellular side).
productSpecies: The product species on the other side of the membrane (typically the extracellular side). Usually the same molecular species as substrate but in a different compartment.
**kwargs: Additional keyword arguments (unused).

Returns:

list of Species: List containing [substrate, product].

class biocrnpyler.mechanisms.transport.Simple_Transport(name='simple_membrane_protein_transport', mechanism_type='transport', **kwargs)[source]

Passive transport mechanism through membrane channel proteins.

A ‘transport’ mechanism that models passive, bidirectional transport of substrates through membrane channel proteins. Unlike simple diffusion, this mechanism requires a membrane channel protein but does not consume energy. The channel acts catalytically, binding substrate and product but not being consumed.

The reaction follows the schema:

membrane_channel + substrate <–> membrane_channel + product

Parameters:

namestr, default=’simple_membrane_protein_transport’: Name identifier for this mechanism instance.
mechanism_typestr, default=’transport’: Type classification of this mechanism.

Attributes:

namestr: Name of the mechanism instance.
mechanism_typestr: Type classification (‘transport’).

See also

Simple_Diffusion: Passive diffusion without proteins.
Facilitated_Transport_MM: Transport with MM kinetics.
Primary_Active_Transport_MM: Energy-dependent active transport.
Mechanism: Base class for all mechanisms.

Notes

This mechanism models passive transport through channel proteins such as ion channels, aquaporins, and other pore-forming proteins. The channel facilitates movement down concentration gradients without conformational changes or energy expenditure.

The mechanism requires the membrane channel to have the ‘Passive’ attribute, distinguishing it from active transporters and carriers that require different mechanisms.

Common examples include:

Ion channels (K+, Na+, Ca2+ channels)
Aquaporins for water transport
Gap junctions between cells
Porins in bacterial outer membranes

The transport is bidirectional with equal forward and reverse rate constants, reflecting passive equilibration across the membrane.

Required parameters for this mechanism:

‘k_trnsp’ : Transport rate constant (same for both directions)

Examples

Model potassium transport through an ion channel:

>>> protein = bcp.IntegralMembraneProtein(
...     membrane_protein='Knck1',
...     product='K_channel',
...     direction='Passive',
...     compartment='cytoplasm',
...     membrane_compartment='membrane',
...     attributes=['Passive']
... )
>>> channel = bcp.MembraneChannel(
...     integral_membrane_protein=protein.membrane_protein,
...     substrate='K',
...     direction='Passive',
...     internal_compartment='cytoplasm',
...     external_compartment='external'
... )
>>> mixture = bcp.Mixture(
...     components=[protein, channel],
...     mechanisms={
...         'membrane_insertion': bcp.Membrane_Protein_Integration(),
...         'transport': bcp.Simple_Transport(),
...     },
...     parameters={'k_trnsp': 1.0},
...     parameter_file='mechanisms/transport_parameters.tsv',
... )
>>> mixture.compile_crn()

update_reactions(membrane_channel, substrate, product, component=None, part_id=None, k_trnsp=None, **kwargs)[source]

Generate reactions for simple membrane protein transport.

Creates a single reversible mass-action reaction representing passive transport through a membrane channel with equal forward and reverse rate constants. The channel acts catalytically and is not consumed.

Parameters:

membrane_channelSpecies: The membrane channel protein facilitating transport.
substrateSpecies: The substrate species being transported.
productSpecies: The product species after transport.
componentComponent, optional: Component containing parameter values. Required if k_trnsp is not provided directly.
part_idstr, optional: Identifier for parameter lookup. If None and component is provided, defaults to component.name.
k_trnspParameter or float, optional: Transport rate constant. If None, retrieved from component parameters. Used as both forward and reverse rate constant.
**kwargs: Additional keyword arguments (unused).

Returns:

list of Reaction: List containing a single reversible mass-action reaction for transport.

Raises:

ValueError: If component is None and k_trnsp is not provided.

Notes

The reaction has equal forward and reverse rate constants:

membrane_channel + substrate <–> membrane_channel + product (rates: ‘k_trnsp’, ‘k_trnsp’)

The membrane channel appears on both sides of the reaction, indicating it acts catalytically and is recycled.

update_species(membrane_channel, substrate, product, **kwargs)[source]

Generate species for simple transport.

Returns the membrane channel, substrate, and product species involved in the transport reaction. Validates that the channel has the ‘Passive’ attribute.

Parameters:

membrane_channelSpecies: The membrane channel protein through which transport occurs. Must have ‘Passive’ as its first attribute.
substrateSpecies: The substrate species being transported (typically intracellular side).
productSpecies: The product species after transport (typically extracellular side).
**kwargs: Additional keyword arguments (unused).

Returns:

list of Species: List containing [membrane_channel, substrate, product].

Raises:

ValueError: If membrane_channel does not have ‘Passive’ as its first attribute, indicating it should use Facilitated_Transport_MM instead.