                         ::core/phase-space [
                                             {::core/domain-start    -1.0
                                              ::core/domain-end      1.0
-                                             ::core/domain-interval 0.2}
+                                             ::core/domain-interval 0.1}
                                             {::core/domain-start    -1.0
                                              ::core/domain-end      1.0
-                                             ::core/domain-interval 0.2}]
+                                             ::core/domain-interval 0.1}]
                         ::core/gap-time    500}
-        time-intervals 50000
+        time-intervals 10000
         samples        (map (fn [t]
-                              (hash-map
-                                ::core/raw-datum
-                                {::core/position-value
-                                              (vec
-                                                (take
-                                                  (::core/dimensions test-props)
-                                                  (repeatedly
-                                                    (fn []
-                                                      (let [r (rand)]
-                                                        (cond (< t (int (/ time-intervals 2))) (+ 0.1
-                                                                                                  (* 0.15
-                                                                                                     (first
-                                                                                                       (random/sample-normal 1))))
-                                                              :else (-
-                                                                      (* 0.15
-                                                                         (first
-                                                                           (random/sample-normal 1)))
-                                                                      0.3)))))))
-                                 ::core/value 1.0})
+                              (sample-at-time t time-intervals test-props)
                               ) (range time-intervals))
 
         test-state     {::core/state {::core/grid-cells           {}

  )





(deftest stuff
  (let [test-props     {::core/c_m         3.0

                            (if (and (not (= nil cluster))
                                     (not (= "NO_CLASS" cluster)))
                              (do
                                (::core/density-at-last-update (get grid-cells [r c])))
                              (/ (rand) 10000))))
                        (::core/density-at-last-update (get grid-cells [r c]))
                        (/ (rand) 10000))]
              num))]
      {:matrix (->>
                 vecs
                 (viz/matrix-2d rows cols))
       :rows   rows
       :cols   cols})))

(defn heatmap-spec
  [id the-matrix]
  {:matrix        the-matrix
   :value-domain  (viz/value-domain-bounds the-matrix)
   :palette       (->> id (grad/cosine-schemes) (apply grad/cosine-gradient 100))
