diff --git a/neuron/soma.md b/neuron/soma.md
index b46d2ca..2193614 100644
--- a/neuron/soma.md
+++ b/neuron/soma.md
@@ -79,13 +79,13 @@ Qui comprendiamo:
 container: SOMA
 
   expansion: 
-    - VGSC-SOMA-H ( fullness: 50x, active: 20x, emptiness: 10x ) 
+    - VGSC-SOMA-H ( full: 50x, active: 20x, empty: 10x ) 
       # modulated_by: VGSC-SOMA-H-TUN # possible/actual
 
-    - VGSC-SOMA-M ( fullness: 50x, active: 20x, emptiness: 10x ) 
+    - VGSC-SOMA-M ( full: 50x, active: 20x, empty: 10x ) 
       # modulated_by: VGSC-SOMA-M-TUN # possible/actual
 
-    - VGSC-SOMA-L ( fullness: 50x, active: 20x, emptiness: 10x ) 
+    - VGSC-SOMA-L ( full: 50x, active: 20x, empty: 10x ) 
       # modulated_by: VGSC-SOMA-L-TUN # possible/actual
 
 
@@ -101,27 +101,27 @@ container: SOMA
 
 ### ms: SOMA
 
-#### SOMA-Status: check_tpc
+#### SOMA-Status: contextor
 
 As dendrites deliver current (VDB​), the soma acts like a capacitor. It "stores" this charge in the form of membrane potential. This contextualizes VGSC-SOMA to open ion channels that let Na+ ions in.
 
 This only applies if not ApCtx, or in other words, SOMA is not in refractory period.
 
 ```Gen
-check_tpc: SOMA-Status
+SOMA-Status: ( active: 60x )
+  type: contextor
   contained_by: SOMA
 
-  rf: ( active: 60x )
   in_context: any
 
-  condition: ( VDB fullness ) AND NOT ApCtx
-    out_context: VDBMaxCtx
+  condition: ( VDB fullness ) AND NOT AP_ctx
+    out_context: VDBMax_Ctx
 
-  condition: ( VDB mediumness ) AND NOT ApCtx
-    out_context: VDBMediumCtx 
+  condition: ( VDB mediumness ) AND NOT AP_ctx
+    out_context: VDBMedium_ctx 
 
-  condition: ( VDB emptiness ) AND NOT ApCtx
-    out_context: VDBLowCtx
+  condition: ( VDB emptiness ) AND NOT Ap_ctx
+    out_context: VDBLow_ctx
 
   condition: NOT ( Na empty )
     out_context: NaSpill_ctx
@@ -130,7 +130,7 @@ check_tpc: SOMA-Status
     out_context: RefractorySoma_ctx
 ```
 
-#### SomaSpike: check_tpc
+#### SomaSpike: contextor
 
 Il fatto che mettiamo il check di AP separato dal check del Soma-Status, e' perche' vogliamo poter avere un RF specifico per AP, eventualmente tunabile.
 
@@ -139,18 +139,17 @@ Qui siamo nella fase effettiva di spike, non refractory che viene dopo. Fa da co
 La fullness di Na rappresenta il threshold e puo' essere modificato. La fullness di RefractorySoma rappresenta la lunghezza del refractory.
 
 ```Gen
-check_tpc: SomaSpike
+SomaSpike: ( active: 30x )
+  type: contextor
   contained_by: SOMA
 
-  rf: ( active: 30x )
   in_context: any
-
-  condition: ( Na fullness ) AND ( RefractorySoma emptiness )
-    out_context: ApCtx
-    out_context: bApCtx
+    condition: ( Na fullness ) AND ( RefractorySoma emptiness )
+      out_context: AP_ctx
+      out_context: bAp_ctx
 ```
 
-#### ActiveAP: interacting
+#### ActiveAP: accumulator
 
 Durante la fase effettiva di spike:
 
@@ -159,61 +158,266 @@ Durante la fase effettiva di spike:
 - riempiamo Ca2+ per le tracce medio termine di potenziamento/depotenziamento.
 
 ```Gen
-interacting: ActiveAP
+ActiveAP: ( active: 8x )
+  type: accumulator
   contained_by: SOMA
 
-  rf: ( active: 8x )
-  in_context: ApCtx
+  in_context: Ap_ctx
+    hypothesis: NOT Na empty
+      action: [ decrease Na ]
+      trace: 
 
-  hypothesis: NOT Na empty
-    action: [ decrease Na ]
-    trace: 
+    hypothesis: NOT RefractorySoma full
+      action: [ increase RefractorySoma ]
+      trace: 
 
-  hypothesis: NOT RefractorySoma full
-    action: [ increase RefractorySoma ]
-    trace: 
-
-  hypothesis: NOT Ca2+ full
-    action: [ increase Ca2+ ]
-    trace: 
+    hypothesis: NOT Ca2+ full
+      action: [ increase Ca2+ ]
+      trace: 
 ```
 
-#### NaSpill: interacting
+#### NaSpill: accumulator
 
 Questo potrebbe non servire se eliminiamo tutti Na durante ActiveAP.
 
 ```Gen
-interacting: NaSpill
+NaSpill: ( active: 8x )
+  type: accumulator
   contained_by: SOMA
 
-  rf: ( active: 8x )
   in_context: NaSpill_ctx
-
-  hypothesis: NOT ( Na emptiness )
-    action: [ decrease Na ]
-    trace:
+    hypothesis: NOT ( Na emptiness )
+      action: [ decrease Na ]
+      trace:
 ```
 
-#### RefractorySomaSpill: interacting
+#### RefractorySomaSpill: accumulator
 
 Lo spill deve essere piu' lento dell'increase che avviene in ActiveAP
 
 ```Gen
-interacting: RefractorySomaSpill
+RefractorySomaSpill: ( active: 16x )
+  type: accumulator
   contained_by: SOMA
 
-  rf: ( active: 16x )
   in_context: RefractorySoma_ctx
-
-  hypothesis: NOT ( RefractorySoma empty )
-    action: [ decrease RefractorySoma ]
-    trace: 
+    hypothesis: NOT ( RefractorySoma empty )
+      action: [ decrease RefractorySoma ]
+      trace: 
 ```
 
 ### sec: SOMA
 
 ### min: SOMA
 
+## VGSC-SOMA-H: container
+
+Voltage Gated Sodium Channel: difficult to open (High)
+
+```Gen
+container: VGSC-SOMA-H
+
+  tub_local:
+    RefractoryH ( full: 60x, active: 30x, empty: 0x )
+
+  tub_intricated:
+    Na ( contained_in: SOMA)
+
+   context_intricated:
+    VDBMaxCtx ( contained_by: SOMA )
+```
+
+### sec: VGSC-SOMA-H
+
+#### VGSC-H_Status: contextor
+
+Il check su refractory deve essere fatto ad un RF maggiore della eliminazione di Refractory. Questo perche' e' un era nella quale avviene l'episodio.
+
+```Gen
+VGSC-H_Status: ( active: 60x )
+  type: contextor
+  contained_by: VGSC-SOMA-H
+
+  in_context: any
+    condition: VDBMaxCtx AND ( RefractoryH emptiness ) 
+      out_context: NaEnterH_Ctx
+
+    condition: ( RefractoryH mediumness ) OR ( RefractoryH fullness )
+      out_context: RefractoryHSpill_ctx
+```
+
+#### NaEnterH: accumulator
+
+Se metto il controllo sulla (NOT Ready fullness) il VGSC puo' far entrare un numero di Na non superiore ad un massimo.
+Questo sopra è il commmento della versione precedente, ora la quantità di NA increase dipende dal rf di VGSC-H_TPC dato che li c'è la condition sulla presenza delle traccie di refractory
+
+```Gen
+NaEnterH: ( active: 1x )
+  type: accumulator
+  contained_by: VGSC-SOMA-H
+
+  in_context: NaEnterH_ctx
+    hypothesis: ( NOT Na full )
+      action: [ Na increase]
+      trace: None
+
+    hypothesis: ( NOT RefractoryH full )
+      action: [ RefractoryH increase ]
+      trace: None
+```
+
+#### RefractoryHSpill: accumulator
+
+Lo Spill deve avere un rf maggiore dell'interacting che incrementa RefractoryH (interactor precedente)
+
+```Gen
+RefractoryHSpill: ( active: 1x )
+  type: accumulator
+  contained_by: VGSC-SOMA-H
+
+  in_context: RefractoryHSpill_ctx
+    hypothesis: NOT ( RefractoryH empty )  
+      action: [ RefractoryH decrease ]
+      trace: None
+```
+
+## VGSC-SOMA-M: container
+
+Voltage Gated Sodium Channel: less difficult to open (Medium)
+
+```Gen
+container: VGSC-SOMA-M
+
+  tub_local:
+    RefractoryM ( full: 60x, active: 30x, empty: 0x )
+
+  tub_intricated:
+    Na ( contained_in: SOMA)
+
+  context_intricated:
+    VDBMedCtx ( contained_by: SOMA ) 
+```
+
+### sec: VGSC-SOMA-M
+
+#### VGSC-M_TPC: contextor
+
+Il check su refractory deve essere fatto ad un RF maggiore della eliminazione di Refractory. Questo perche' e' un era nella quale avviene l'episodio.
+
+```Gen
+VGSC-M_Status: ( active: 60x )
+  type: contextor
+  contained_by: VGSC-SOMA-M
+
+  in_context: VDBMediumCtx OR VDBMaxCtx
+    condition: ( RefractoryH emptiness ) 
+      out_context: NaEnterM_Ctx
+```
+
+#### NaEnterM: accumulator
+
+Se metto il controllo sulla (NOT Ready fullness) il VGSC puo' far entrare un numero di Na non superiore ad un massimo.
+Questo sopra è il commmento della versione precedente, ora la quantità di NA increase dipende dal rf di VGSC-H_TPC dato che li c'è la condition sulla presenza delle traccie di refractory
+
+```Gen
+NaEnterM: ( active: 1x )
+  type: accumulator
+  contained_by: VGSC-SOMA-M
+
+  in_context: NaEnterM_ctx
+    hypothesis: ( NOT Na full )
+      action: [ Na increase]
+      trace: None
+
+    hypothesis: ( NOT RefractoryM full )
+      action: [ RefractoryH increase ]
+      trace: None
+```
+
+#### RefractoryMSpill: accumulator
+
+Lo Spill deve avere un rf maggiore dell'interacting che incrementa RefractoryH (interactor precedente)
+
+```Gen
+RefractoryMSpill: ( active: 1x )
+  type: accumulator
+  contained_by: VGSC-SOMA-M
+
+  in_context: any
+    hypothesis: NOT ( RefractoryM empty )  
+      action: [ RefractoryM decrease ]
+      trace: None
+```
+
+## VGSC-SOMA-L: container
+
+Voltage Gated Sodium Channel: easy to open (Low)
+
+```Gen
+container: VGSC-SOMA-L
+
+  tub_local:
+    RefractoryL ( full: 60x, active: 30x, empty: 0x )
+
+  tub_intricated:
+    Na ( contained_in: SOMA)
+
+  context_intricated:
+    VDBLowCtx ( contained_by: SOMA ) 
+```
+
+### sec: VGSC-SOMA-L
+
+#### VGSC-L_TPC: contextor
+
+Il check su refractory deve essere fatto ad un RF maggiore della eliminazione di Refractory. Questo perche' e' un era nella qualle avviene l'episodio.
+
+```Gen
+VGSC-L_Status: ( active: 60x )
+  type: contextor
+  contained_by: VGSC-SOMA-L
+
+  in_context: VDBLowCtx OR VDBMediumCtx OR VDBMaxCtx
+    condition: ( RefractoryH emptiness ) 
+      out_context: NaEnterL_ctx
+```
+
+#### NaEnterL: accumulator
+
+Se metto il controllo sulla (NOT Ready fullness) il VGSC puo' far entrare un numero di Na non superiore ad un massimo.
+Questo sopra è il commmento della versione precedente, ora la quantità di NA increase dipende dal rf di VGSC-H_TPC dato che li c'è la condition sulla presenza delle traccie di refractory
+
+```Gen
+NaEnterL: ( active: 1x )
+  type: accumulator
+  contained_by: VGSC-SOMA-L
+
+  in_context: NaEnterL_ctx
+    hypothesis: ( NOT Na full )
+      action: [ Na increase]
+      trace: None
+
+    hypothesis: ( NOT RefractoryL full )
+      action: [ RefractoryL increase ]
+      trace: None
+```
+
+#### RefractoryLSpill: accumulator
+
+Lo Spill deve avere un rf maggiore dell'interacting che incrementa RefractoryH (interactor precedente)
+
+```Gen
+RefractoryLSpill: ( active: 1x )
+  type: accumulator
+  contained_by: VGSC-L-SOMA
+
+  in_context: any
+    hypothesis: NOT ( RefractoryL empty )  
+      action: [ RefractoryL decrease ]
+      trace: None
+```
+
+
 #### VGSC-SOMA-TUN: Tuner
 
 ```Gen
@@ -257,220 +461,3 @@ interacting: ?
   action: 
   trace: 
 ```
-
-## VGSC-SOMA-H: container
-
-Voltage Gated Sodium Channel: difficult to open (High)
-
-```Gen
-container: VGSC-SOMA-H
-
-  tub_local:
-    RefractoryH ( full: 60x, active: 30x, empty: 0x )
-
-  tub_intricated:
-    Na ( contained_in: SOMA)
-
-   context_intricated:
-    VDBMaxCtx ( contained_by: SOMA )
-```
-
-### sec: VGSC-SOMA-H
-
-#### VGSC-H_Status: check_tpc
-
-Il check su refractory deve essere fatto ad un RF maggiore della eliminazione di Refractory. Questo perche' e' un era nella quale avviene l'episodio.
-
-```Gen
-check_tpc: VGSC-H_Status
-
-  contained_by: VGSC-SOMA-H
-
-  rf: ( active: 60x )
-  in_context: any
-
-  condition: VDBMaxCtx AND ( RefractoryH emptiness ) 
-    out_context: NaEnterH_Ctx
-
-  condition: ( RefractoryH mediumness ) OR ( RefractoryH fullness )
-    out_context: RefractoryHSpill_ctx
-```
-
-#### NaEnterH: interacting
-
-Se metto il controllo sulla (NOT Ready fullness) il VGSC puo' far entrare un numero di Na non superiore ad un massimo.
-Questo sopra è il commmento della versione precedente, ora la quantità di NA increase dipende dal rf di VGSC-H_TPC dato che li c'è la condition sulla presenza delle traccie di refractory
-
-```Gen
-interacting: NaEnterH
-  contained_by: VGSC-SOMA-H
-
-  in_context: NaEnterH_Ctx
-  rf: ( active: 1x )
-
-  hypothesis: ( NOT Na full )
-    action: [ Na increase]
-    trace: None
-
-  hypothesis: ( NOT RefractoryH full )
-    action: [ RefractoryH increase ]
-    trace: None
-```
-
-#### RefractoryHSpill: interacting
-
-Lo Spill deve avere un rf maggiore dell'interacting che incrementa RefractoryH (interactor precedente)
-
-```Gen
-interacting: RefractoryHSpill
-  contained_by: VGSC-SOMA-H
-
-  rf: ( active: 1x )
-  in_context: RefractoryHSpill_ctx
-
-  hypothesis: NOT ( RefractoryH empty )  
-    action: [ RefractoryH decrease ]
-    trace: None
-```
-
-## VGSC-SOMA-M: container
-
-Voltage Gated Sodium Channel: less difficult to open (Medium)
-
-```Gen
-container: VGSC-SOMA-M
-
-  tub_local:
-    RefractoryM ( full: 60x, active: 30x, empty: 0x )
-
-  tub_intricated:
-    Na ( contained_in: SOMA)
-
-  context_intricated:
-    VDBMedCtx ( contained_by: SOMA ) 
-```
-
-### sec: VGSC-SOMA-M
-
-#### VGSC-M_TPC: check_Status
-
-Il check su refractory deve essere fatto ad un RF maggiore della eliminazione di Refractory. Questo perche' e' un era nella quale avviene l'episodio.
-
-```Gen
-check_tpc: VGSC-M_Status
-  contained_by: VGSC-SOMA-M
-
-  rf: ( active: 60x )
-  in_context: VDBMediumCtx OR VDBMaxCtx
-
-  condition: ( RefractoryH emptiness ) 
-    out_context: NaEnterM_Ctx
-```
-
-#### NaEnterM: interacting
-
-Se metto il controllo sulla (NOT Ready fullness) il VGSC puo' far entrare un numero di Na non superiore ad un massimo.
-Questo sopra è il commmento della versione precedente, ora la quantità di NA increase dipende dal rf di VGSC-H_TPC dato che li c'è la condition sulla presenza delle traccie di refractory
-
-```Gen
-interacting: NaEnterM
-  contained_by: VGSC-SOMA-M
-
-  rf: ( active: 1x )
-  in_context: NaEnterM_Ctx
-
-  hypothesis: ( NOT Na full )
-    action: [ Na increase]
-    trace: None
-
-  hypothesis: ( NOT RefractoryM full )
-    action: [ RefractoryH increase ]
-    trace: None
-```
-
-#### RefractoryMSpill: interacting
-
-Lo Spill deve avere un rf maggiore dell'interacting che incrementa RefractoryH (interactor precedente)
-
-```Gen
-interacting: RefractoryMSpill
-  contained_by: VGSC-SOMA-M
-
-  rf: ( active: 1x )
-  in_context: any
-
-  hypothesis: NOT ( RefractoryM empty )  
-    action: [ RefractoryM decrease ]
-    trace: None
-```
-
-## VGSC-SOMA-L: container
-
-Voltage Gated Sodium Channel: easy to open (Low)
-
-```Gen
-container: VGSC-SOMA-L
-
-  tub_local:
-    RefractoryL ( full: 60x, active: 30x, empty: 0x )
-
-  tub_intricated:
-    Na ( contained_in: SOMA)
-
-  context_intricated:
-    VDBLowCtx ( contained_by: SOMA ) 
-```
-
-### sec: VGSC-SOMA-L
-
-#### VGSC-L_TPC: check_Status
-
-Il check su refractory deve essere fatto ad un RF maggiore della eliminazione di Refractory. Questo perche' e' un era nella qualle avviene l'episodio.
-
-```Gen
-check_tpc: VGSC-L_Status
-  contained_by: VGSC-SOMA-L
-
-  rf: ( active: 60x )
-  in_context: VDBLowCtx OR VDBMediumCtx OR VDBMaxCtx
-
-  condition: ( RefractoryH emptiness ) 
-    out_context: NaEnterL_Ctx
-```
-
-#### NaEnterL: interacting
-
-Se metto il controllo sulla (NOT Ready fullness) il VGSC puo' far entrare un numero di Na non superiore ad un massimo.
-Questo sopra è il commmento della versione precedente, ora la quantità di NA increase dipende dal rf di VGSC-H_TPC dato che li c'è la condition sulla presenza delle traccie di refractory
-
-```Gen
-interacting: NaEnterL
-  contained_by: VGSC-SOMA-L
-
-  rf: ( active: 1x )
-  in_context: NaEnterL_Ctx
-
-  hypothesis: ( NOT Na full )
-    action: [ Na increase]
-    trace: None
-
-  hypothesis: ( NOT RefractoryL full )
-    action: [ RefractoryL increase ]
-    trace: None
-```
-
-#### RefractoryLSpill: interacting
-
-Lo Spill deve avere un rf maggiore dell'interacting che incrementa RefractoryH (interactor precedente)
-
-```Gen
-interacting: RefractoryLSpill
-  contained_by: VGSC-L-SOMA
-
-  rf: ( active: 1x )
-  in_context: any
-
-  hypothesis: NOT ( RefractoryL empty )  
-    action: [ RefractoryL decrease ]
-    trace: None
-```