From c9e06ba4606ed60608905348a47915b38561de34 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Fri, 30 Jun 2023 15:50:57 -0400
Subject: [PATCH 01/27] basic implementation of generic sim_one_period. see
 #1295

---
 HARK/simulation/__init__.py         |   0
 HARK/simulation/monte_carlo.py      |  33 ++++++++
 HARK/simulation/test_monte_carlo.py | 113 ++++++++++++++++++++++++++++
 3 files changed, 146 insertions(+)
 create mode 100644 HARK/simulation/__init__.py
 create mode 100644 HARK/simulation/monte_carlo.py
 create mode 100644 HARK/simulation/test_monte_carlo.py

diff --git a/HARK/simulation/__init__.py b/HARK/simulation/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
new file mode 100644
index 000000000..2e17e1fac
--- /dev/null
+++ b/HARK/simulation/monte_carlo.py
@@ -0,0 +1,33 @@
+from inspect import signature
+from typing import Callable, Mapping
+
+
+class Control:
+    """
+    Should go in HARK.model
+    """
+
+    def __init__(self, args):
+        pass
+
+def sim_one_period(
+        dynamics : Mapping[str, Callable],
+        pre : Mapping,
+        dr : Mapping[str, Callable]
+):
+    vals = pre.copy()
+
+    for varn in dynamics:
+        # Using the fact that Python dictionaries are ordered
+
+        feq = dynamics[varn]
+
+        if isinstance(feq, Control):
+            vals[varn] = dr[varn](*[
+                vals[var]
+                for var 
+                in signature(dr[varn]).parameters]) # TODO: test for signature match with Control
+        else:
+            vals[varn] = feq(*[vals[var] for var in signature(feq).parameters])
+
+    return vals
\ No newline at end of file
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
new file mode 100644
index 000000000..f8211348e
--- /dev/null
+++ b/HARK/simulation/test_monte_carlo.py
@@ -0,0 +1,113 @@
+"""
+This file implements unit tests for the Monte Carlo simulation module
+"""
+import unittest
+
+from HARK.simulation.monte_carlo import *
+
+
+pre = {
+    'R' : 1.05,
+    'aNrm' : 1,
+    'gamma' : 1.1,
+    'psi' : 1.1, # TODO: draw this from a shock,
+    'theta' : 1.1 # TODO: draw this from a shock
+}
+
+dynamics = {
+    'G' : lambda gamma, psi : gamma * psi,
+    'Rnrm' : lambda R, G : R / G,
+    'bNrm' : lambda Rnrm, aNrm : Rnrm * aNrm,
+    'mNrm' : lambda bNrm, theta : bNrm + theta,
+    'cNrm' : Control(['mNrm']),
+    'aNrm' : lambda mNrm, cNrm : mNrm - cNrm
+}
+
+dr = {
+    'cNrm' : lambda mNrm : mNrm / 2
+}
+
+
+class test_sim_one_period(unittest.TestCase):
+    def test_sim_one_period(self):
+
+        post = sim_one_period(dynamics, pre, dr)
+
+        self.assertAlmostEqual(post['cNrm'], 0.98388429)
+
+
+
+
+
+
+
+
+
+
+###############################################################3
+
+'''
+init_parameters = {}
+init_parameters["PermGroFac"] = 1.05
+init_parameters["PermShkStd"] = 1.5
+init_parameters["PermShkCount"] = 5
+init_parameters["TranShkStd"] = 3.0
+init_parameters["TranShkCount"] = 5
+init_parameters["RiskyAvg"] = 1.05
+init_parameters["RiskyStd"] = 1.5
+init_parameters["RiskyCount"] = 5
+init_parameters["Rfree"] = 1.03
+
+frames_A = [
+    Frame(("bNrm",), ("aNrm",), transition=lambda Rfree, aNrm: Rfree * aNrm),
+    Frame(("mNrm",), ("bNrm", "TranShk"), transition=lambda bNrm: mNrm),
+    Frame(("cNrm"), ("mNrm",), control=True),
+    Frame(
+        ("U"),
+        ("cNrm", "CRRA"),  # Note CRRA here is a parameter not a state var
+        transition=lambda cNrm, CRRA: (CRRAutility(cNrm, CRRA),),
+        reward=True,
+        context={"CRRA": 2.0},
+    ),
+    Frame(("aNrm"), ("mNrm", "cNrm"), transition=lambda mNrm, cNrm: (mNrm - cNrm,)),
+]
+
+
+class test_FrameModel(unittest.TestCase):
+    def setUp(self):
+        self.model = FrameModel(frames_A, init_parameters)
+
+    def test_init(self):
+        self.model.frames.var("aNrm")
+
+        self.assertTrue(
+            isinstance(
+                list(self.model.frames.var("bNrm").parents.values())[0],
+                BackwardFrameReference,
+            )
+        )
+
+        self.assertTrue(
+            isinstance(
+                list(self.model.frames.var("aNrm").children.values())[0],
+                ForwardFrameReference,
+            )
+        )
+
+    def test_make_terminal(self):
+        terminal_model = self.model.make_terminal()
+
+        self.assertEqual(len(self.model.make_terminal().frames.var("aNrm").children), 0)
+
+    def test_prepend(self):
+        double_model = self.model.prepend(self.model)
+
+        self.assertEqual(len(double_model.frames), 10)
+
+    def test_repeat(self):
+        repeat_model = self.model.repeat({"bNrm": {"Rfree": [1.01, 1.03, 1.02]}})
+
+        self.assertEqual(len(repeat_model.frames), 15)
+
+        self.assertEqual(repeat_model.frames.var("bNrm_1").context["Rfree"], 1.03)
+'''
\ No newline at end of file

From 74382c34f8422bdd7a2934d1fbbb3f67edde361b Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Thu, 20 Jul 2023 14:05:16 -0400
Subject: [PATCH 02/27] draw_shocks and docs

---
 HARK/simulation/monte_carlo.py | 46 +++++++++++++++++++++++++++++++---
 1 file changed, 43 insertions(+), 3 deletions(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 2e17e1fac..10643e329 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -1,5 +1,10 @@
+"""
+Functions to support Monte Carlo simulation of models.
+"""
+
+from distribution import Distribution
 from inspect import signature
-from typing import Callable, Mapping
+from typing import Any, Callable, Mapping, Union
 
 
 class Control:
@@ -10,11 +15,46 @@ class Control:
     def __init__(self, args):
         pass
 
+def draw_shocks(shocks: Mapping[str, Distribution], N: int):
+    """
+
+    Parameters
+    ------------
+    shocks Mapping[str, Distribution]
+        A dictionary-like mapping from shock names to distributions from which to draw
+
+    N: int
+        Number of draws from each shock
+    """
+    return {
+        shock : shocks[shock].draw(N)
+        for shock in shocks
+    }
+
+
 def sim_one_period(
-        dynamics : Mapping[str, Callable],
-        pre : Mapping,
+        dynamics : Mapping[str, Union[Callable, Control]],
+        pre : Mapping[str, Any],
         dr : Mapping[str, Callable]
 ):
+    """
+
+    Parameters
+    ------------
+
+    dynamics: Mapping[str, Callable]
+        Maps variable names to functions from variables to values.
+        Can include Controls
+        ## TODO: Make collection of equations into a named type
+
+
+    pre : Mapping[str, Any]
+        Bound values for all variables that must be known before beginning the period's dynamics.
+
+
+    dr : Mapping[str, Callable]
+        Decision rules for all the Control variables in the dynamics.
+    """
     vals = pre.copy()
 
     for varn in dynamics:

From f6a672df703b1e4d10648e3db385427a58f605d1 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Thu, 20 Jul 2023 14:18:23 -0400
Subject: [PATCH 03/27] automated test for draw_shock

---
 HARK/simulation/monte_carlo.py      |  2 +-
 HARK/simulation/test_monte_carlo.py | 12 ++++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 10643e329..557a9dd45 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -2,7 +2,7 @@
 Functions to support Monte Carlo simulation of models.
 """
 
-from distribution import Distribution
+from HARK.distribution import Distribution
 from inspect import signature
 from typing import Any, Callable, Mapping, Union
 
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
index f8211348e..b0e3d75e3 100644
--- a/HARK/simulation/test_monte_carlo.py
+++ b/HARK/simulation/test_monte_carlo.py
@@ -3,8 +3,14 @@
 """
 import unittest
 
+from HARK.distribution import MeanOneLogNormal
 from HARK.simulation.monte_carlo import *
 
+shocks = {
+    'psi' : MeanOneLogNormal(1),
+    'theta' : MeanOneLogNormal(1)
+
+}
 
 pre = {
     'R' : 1.05,
@@ -27,6 +33,12 @@
     'cNrm' : lambda mNrm : mNrm / 2
 }
 
+class test_draw_shocks(unittest.TestCase):
+    def test_draw_shocks(self):
+
+        drawn = draw_shocks(shocks, 2)
+
+        self.assertEqual(len(drawn['psi']), 2)
 
 class test_sim_one_period(unittest.TestCase):
     def test_sim_one_period(self):

From 0041d2cb763d2e4e1f4a72f457ac61bd495368ec Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Fri, 21 Jul 2023 12:25:55 -0400
Subject: [PATCH 04/27] AgentTypeMonteCarloSimulator class draft

---
 HARK/simulation/monte_carlo.py      | 472 +++++++++++++++++++++++++++-
 HARK/simulation/test_monte_carlo.py |   6 +-
 2 files changed, 473 insertions(+), 5 deletions(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 557a9dd45..8e3895287 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -4,6 +4,7 @@
 
 from HARK.distribution import Distribution
 from inspect import signature
+import numpy as np
 from typing import Any, Callable, Mapping, Union
 
 
@@ -30,9 +31,10 @@ def draw_shocks(shocks: Mapping[str, Distribution], N: int):
         shock : shocks[shock].draw(N)
         for shock in shocks
     }
+    ## TODO: Use time-varying distributions properly with conditions.
 
 
-def sim_one_period(
+def simulate_dynamics(
         dynamics : Mapping[str, Union[Callable, Control]],
         pre : Mapping[str, Any],
         dr : Mapping[str, Callable]
@@ -70,4 +72,470 @@ def sim_one_period(
         else:
             vals[varn] = feq(*[vals[var] for var in signature(feq).parameters])
 
-    return vals
\ No newline at end of file
+    return vals
+
+class Simulator():
+    pass
+
+class AgentTypeMonteCarloSimulator(Simulator):
+    """
+    A Monte Carlo simulation engine based on the HARK.core.AgentType framework.
+    Unlike HARK.core.AgentType, this class:
+      * does not do any model solving
+      * depends on dynamic equations, shocks, and decision rules paased into it
+
+    The purpose of this class is to provide a way to simulate models without
+    relying on inheritance from the AgentType class.
+
+    This simulator makes assumptions about population birth and mortality which
+    are not generic. They are: TODO.
+    
+    Parameters
+    ----------
+    seed : int
+        A seed for this instance's random number generator.
+
+    Attributes
+    ----------
+    AgentCount : int
+        The number of agents of this type to use in simulation.
+
+    state_vars : list of string
+        The string labels for this AgentType's model state variables.
+    """
+
+    state_vars = []
+
+    def __init__(
+        self,
+        parameters,
+        shocks,
+        dynamics,
+        dr,
+        seed=0,
+        agent_count = 1,
+        T_sim = 10
+    ):
+        super().__init__()
+
+        self.parameters = parameters
+        self.shocks = shocks
+        self.dynamics = dynamics
+        self.dr = dr
+
+        self.seed = seed  # NOQA
+        self.agent_count = agent_count
+        self.T_sim = T_sim
+
+        # changes here from HARK.core.AgentType
+        self.vars = list(shocks.keys()) + list(dynamics.keys())
+
+        self.vars_now = {v: None for v in self.vars}
+        self.vars_prev = self.state_now.copy()
+
+        self.read_shocks = False  # NOQA
+        self.shock_history = {}
+        self.newborn_init_history = {}
+        self.history = {}
+
+        self.reset_rng()  # NOQA
+
+    def reset_rng(self):
+        """
+        Reset the random number generator for this type.
+
+        Parameters
+        ----------
+        none
+
+        Returns
+        -------
+        none
+        """
+        self.RNG = np.random.default_rng(self.seed)
+
+    def initialize_sim(self):
+        """
+        Prepares for a new simulation.  Resets the internal random number generator,
+        makes initial states for all agents (using sim_birth), clears histories of tracked variables.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+        """
+        if not hasattr(self, "T_sim"):
+            raise Exception(
+                "To initialize simulation variables it is necessary to first "
+                + "set the attribute T_sim to the largest number of observations "
+                + "you plan to simulate for each agent including re-births."
+            )
+        elif self.T_sim <= 0:
+            raise Exception(
+                "T_sim represents the largest number of observations "
+                + "that can be simulated for an agent, and must be a positive number."
+            )
+
+        self.reset_rng()
+        self.t_sim = 0
+        all_agents = np.ones(self.agent_count, dtype=bool)
+        blank_array = np.empty(self.agent_count)
+        blank_array[:] = np.nan
+        for var in self.vars:
+            if self.vars_now[var] is None:
+                self.vars_now[var] = copy(blank_array)
+
+            # elif self.state_prev[var] is None:
+            #    self.state_prev[var] = copy(blank_array)
+        self.t_age = np.zeros(
+            self.agent_count, dtype=int
+        )  # Number of periods since agent entry
+        self.t_cycle = np.zeros(
+            self.agent_count, dtype=int
+        )  # Which cycle period each agent is on
+        self.sim_birth(all_agents)
+
+        # If we are asked to use existing shocks and a set of initial conditions
+        # exist, use them
+        ### TODO what to do with this?
+        if self.read_shocks and bool(self.newborn_init_history):
+            for var_name in self.state_now:
+                # Check that we are actually given a value for the variable
+                if var_name in self.newborn_init_history.keys():
+                    # Copy only array-like idiosyncratic states. Aggregates should
+                    # not be set by newborns
+                    idio = (
+                        isinstance(self.state_now[var_name], np.ndarray)
+                        and len(self.state_now[var_name]) == self.AgentCount
+                    )
+                    if idio:
+                        self.state_now[var_name] = self.newborn_init_history[var_name][
+                            0
+                        ]
+
+                else:
+                    warn(
+                        "The option for reading shocks was activated but "
+                        + "the model requires state "
+                        + var_name
+                        + ", not contained in "
+                        + "newborn_init_history."
+                    )
+
+        self.clear_history()
+        return None
+
+    def sim_one_period(self):
+        """
+        Simulates one period for this type.  Calls the methods get_mortality(), get_shocks() or
+        read_shocks, get_states(), get_controls(), and get_poststates().  These should be defined for
+        AgentType subclasses, except get_mortality (define its components sim_death and sim_birth
+        instead) and read_shocks.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+        """
+        if not hasattr(self, "solution"):
+            raise Exception(
+                "Model instance does not have a solution stored. To simulate, it is necessary"
+                " to run the `solve()` method of the class first."
+            )
+
+        # Mortality adjusts the agent population
+        self.get_mortality()  # Replace some agents with "newborns"
+
+        # state_{t-1}
+        for var in self.vars:
+            self.vars_prev[var] = self.vars_now[var]
+
+            if isinstance(self.vars_now[var], np.ndarray):
+                self.vars_now[var] = np.empty(self.AgentCount)
+            else:
+                # Probably an aggregate variable. It may be getting set by the Market.
+                pass
+
+        shocks_now = {}
+
+        if self.read_shocks:  # If shock histories have been pre-specified, use those
+            for var_name in self.shocks:
+                shocks_now[var_name] = self.shock_history[var_name][self.t_sim, :]
+        else:  # Otherwise, draw shocks as usual according to subclass-specific method
+            ### BIG CHANGES HERE from HARK.core.AgentType
+            shocks_now = draw_shocks(self.shocks)
+
+        # maybe need to time index the parameters here somehow?
+        pre = self.parameters + shocks_now + self.vars_prev
+        
+        post = simulate_dynamics(self.dynamics, pre, self.dr)
+        
+        self.vars_now = post
+        ### BIG CHANGES HERE
+
+        # Advance time for all agents
+        self.t_age = self.t_age + 1  # Age all consumers by one period
+        self.t_cycle = self.t_cycle + 1  # Age all consumers within their cycle
+        self.t_cycle[
+            self.t_cycle == self.T_cycle
+        ] = 0  # Resetting to zero for those who have reached the end
+
+    def make_shock_history(self):
+        """
+        Makes a pre-specified history of shocks for the simulation.  Shock variables should be named
+        in self.shock_vars, a list of strings that is subclass-specific.  This method runs a subset
+        of the standard simulation loop by simulating only mortality and shocks; each variable named
+        in shock_vars is stored in a T_sim x AgentCount array in history dictionary self.history[X].
+        Automatically sets self.read_shocks to True so that these pre-specified shocks are used for
+        all subsequent calls to simulate().
+
+        ### TODO: Rethink this for when shocks are passed in.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+        """
+        # Re-initialize the simulation
+        self.initialize_sim()
+
+        # Make blank history arrays for each shock variable (and mortality)
+        for var_name in self.shock_vars:
+            self.shock_history[var_name] = (
+                np.zeros((self.T_sim, self.agent_count)) + np.nan
+            )
+        self.shock_history["who_dies"] = np.zeros(
+            (self.T_sim, self.agent_count), dtype=bool
+        )
+
+        # Also make blank arrays for the draws of newborns' initial conditions
+        for var_name in self.state_vars:
+            self.newborn_init_history[var_name] = (
+                np.zeros((self.T_sim, self.agent_count)) + np.nan
+            )
+
+        # Record the initial condition of the newborns created by
+        # initialize_sim -> sim_births
+        for var_name in self.state_vars:
+            # Check whether the state is idiosyncratic or an aggregate
+            idio = (
+                isinstance(self.state_now[var_name], np.ndarray)
+                and len(self.state_now[var_name]) == self.agent_count
+            )
+            if idio:
+                self.newborn_init_history[var_name][self.t_sim] = self.state_now[
+                    var_name
+                ]
+            else:
+                # Aggregate state is a scalar. Assign it to every agent.
+                self.newborn_init_history[var_name][self.t_sim, :] = self.state_now[
+                    var_name
+                ]
+
+        # Make and store the history of shocks for each period
+        for t in range(self.T_sim):
+            # Deaths
+            self.get_mortality()
+            self.shock_history["who_dies"][t, :] = self.who_dies
+
+            # Initial conditions of newborns
+            if np.sum(self.who_dies) > 0:
+                for var_name in self.state_vars:
+                    # Check whether the state is idiosyncratic or an aggregate
+                    idio = (
+                        isinstance(self.state_now[var_name], np.ndarray)
+                        and len(self.state_now[var_name]) == self.agent_count
+                    )
+                    if idio:
+                        self.newborn_init_history[var_name][
+                            t, self.who_dies
+                        ] = self.state_now[var_name][self.who_dies]
+                    else:
+                        self.newborn_init_history[var_name][
+                            t, self.who_dies
+                        ] = self.state_now[var_name]
+
+            # Other Shocks
+            self.get_shocks()
+            for var_name in self.shock_vars:
+                self.shock_history[var_name][t, :] = self.shocks[var_name]
+
+            self.t_sim += 1
+            self.t_age = self.t_age + 1  # Age all consumers by one period
+            self.t_cycle = self.t_cycle + 1  # Age all consumers within their cycle
+            self.t_cycle[
+                self.t_cycle == self.T_cycle
+            ] = 0  # Resetting to zero for those who have reached the end
+
+        # Flag that shocks can be read rather than simulated
+        self.read_shocks = True
+
+    def get_mortality(self):
+        """
+        Simulates mortality or agent turnover according to some model-specific rules named sim_death
+        and sim_birth (methods of an AgentType subclass).  sim_death takes no arguments and returns
+        a Boolean array of size AgentCount, indicating which agents of this type have "died" and
+        must be replaced.  sim_birth takes such a Boolean array as an argument and generates initial
+        post-decision states for those agent indices.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+        """
+        if self.read_shocks:
+            who_dies = self.shock_history["who_dies"][self.t_sim, :]
+            # Instead of simulating births, assign the saved newborn initial conditions
+            if np.sum(who_dies) > 0:
+                for var_name in self.state_now:
+                    if var_name in self.newborn_init_history.keys():
+                        # Copy only array-like idiosyncratic states. Aggregates should
+                        # not be set by newborns
+                        idio = (
+                            isinstance(self.state_now[var_name], np.ndarray)
+                            and len(self.state_now[var_name]) == self.AgentCount
+                        )
+                        if idio:
+                            self.state_now[var_name][
+                                who_dies
+                            ] = self.newborn_init_history[var_name][
+                                self.t_sim, who_dies
+                            ]
+
+                    else:
+                        warn(
+                            "The option for reading shocks was activated but "
+                            + "the model requires state "
+                            + var_name
+                            + ", not contained in "
+                            + "newborn_init_history."
+                        )
+
+                # Reset ages of newborns
+                self.t_age[who_dies] = 0
+                self.t_cycle[who_dies] = 0
+        else:
+            who_dies = self.sim_death()
+            self.sim_birth(who_dies)
+        self.who_dies = who_dies
+        return None
+
+    def sim_death(self):
+        """
+        Determines which agents in the current population "die" or should be replaced.  Takes no
+        inputs, returns a Boolean array of size self.AgentCount, which has True for agents who die
+        and False for those that survive. Returns all False by default, must be overwritten by a
+        subclass to have replacement events.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        who_dies : np.array
+            Boolean array of size self.AgentCount indicating which agents die and are replaced.
+        """
+        who_dies = np.zeros(self.agent_count, dtype=bool)
+        return who_dies
+
+    def sim_birth(self, which_agents):
+        """
+        Makes new agents for the simulation.  Takes a boolean array as an input, indicating which
+        agent indices are to be "born".  Does nothing by default, must be overwritten by a subclass.
+
+        Parameters
+        ----------
+        which_agents : np.array(Bool)
+            Boolean array of size self.AgentCount indicating which agents should be "born".
+
+        Returns
+        -------
+        None
+        """
+        print("AgentType subclass must define method sim_birth!")
+        return None      
+
+    def simulate(self, sim_periods=None):
+        """
+        Simulates this agent type for a given number of periods. Defaults to
+        self.T_sim if no input.
+        Records histories of attributes named in self.track_vars in
+        self.history[varname].
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        history : dict
+            The history tracked during the simulation.
+        """
+        if not hasattr(self, "t_sim"):
+            raise Exception(
+                "It seems that the simulation variables were not initialize before calling "
+                + "simulate(). Call initialize_sim() to initialize the variables before calling simulate() again."
+            )
+
+        if not hasattr(self, "T_sim"):
+            raise Exception(
+                "This agent type instance must have the attribute T_sim set to a positive integer."
+                + "Set T_sim to match the largest dataset you might simulate, and run this agent's"
+                + "initalizeSim() method before running simulate() again."
+            )
+
+        if sim_periods is not None and self.T_sim < sim_periods:
+            raise Exception(
+                "To simulate, sim_periods has to be larger than the maximum data set size "
+                + "T_sim. Either increase the attribute T_sim of this agent type instance "
+                + "and call the initialize_sim() method again, or set sim_periods <= T_sim."
+            )
+
+        # Ignore floating point "errors". Numpy calls it "errors", but really it's excep-
+        # tions with well-defined answers such as 1.0/0.0 that is np.inf, -1.0/0.0 that is
+        # -np.inf, np.inf/np.inf is np.nan and so on.
+        with np.errstate(
+            divide="ignore", over="ignore", under="ignore", invalid="ignore"
+        ):
+            if sim_periods is None:
+                sim_periods = self.T_sim
+
+            for t in range(sim_periods):
+                self.sim_one_period()
+
+                # track all the vars -- shocks and dynamics
+                for var_name in self.vars:
+                    self.history[var_name][self.t_sim, :] = self.vars_now[var_name]
+                    
+                self.t_sim += 1
+
+            return self.history
+
+    def clear_history(self):
+        """
+        Clears the histories.
+
+        Parameters
+        ----------
+        None
+
+        Returns
+        -------
+        None
+        """
+        for var_name in self.vars:
+            self.history[var_name] = np.empty((self.T_sim, self.AgentCount))
+            self.history[var_name].fill(np.nan)
\ No newline at end of file
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
index b0e3d75e3..b276ba0fe 100644
--- a/HARK/simulation/test_monte_carlo.py
+++ b/HARK/simulation/test_monte_carlo.py
@@ -40,10 +40,10 @@ def test_draw_shocks(self):
 
         self.assertEqual(len(drawn['psi']), 2)
 
-class test_sim_one_period(unittest.TestCase):
-    def test_sim_one_period(self):
+class test_simulate_dynamics(unittest.TestCase):
+    def test_simulate_dynamics(self):
 
-        post = sim_one_period(dynamics, pre, dr)
+        post = simulate_dynamics(dynamics, pre, dr)
 
         self.assertAlmostEqual(post['cNrm'], 0.98388429)
 

From 3004643958d5aba008adbff70145408bcbd491ba Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 24 Jul 2023 15:51:15 -0400
Subject: [PATCH 05/27] generic draw_shocks distinguishes between time-varying,
 non-time varying, and Aggregate shocks.

---
 HARK/simulation/monte_carlo.py      | 39 +++++++++++++++++++++--------
 HARK/simulation/test_monte_carlo.py | 24 +++++++++++-------
 2 files changed, 44 insertions(+), 19 deletions(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 8e3895287..2abc1fceb 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -2,11 +2,19 @@
 Functions to support Monte Carlo simulation of models.
 """
 
-from HARK.distribution import Distribution
+from HARK.distribution import Distribution, IndexDistribution, TimeVaryingDiscreteDistribution
 from inspect import signature
 import numpy as np
-from typing import Any, Callable, Mapping, Union
+from typing import Any, Callable, Mapping, Sequence, Union
 
+class Aggregate:
+    """
+    Used to designate a shock as an aggregate shock.
+    If so designated, draws from the shock will be scalar rather
+    than array valued.
+    """
+    def __init__(self, dist: Distribution):
+        self.dist = dist
 
 class Control:
     """
@@ -16,7 +24,10 @@ class Control:
     def __init__(self, args):
         pass
 
-def draw_shocks(shocks: Mapping[str, Distribution], N: int):
+def draw_shocks(
+        shocks: Mapping[str, Distribution],
+        conditions: Sequence[int]
+        ):
     """
 
     Parameters
@@ -24,15 +35,23 @@ def draw_shocks(shocks: Mapping[str, Distribution], N: int):
     shocks Mapping[str, Distribution]
         A dictionary-like mapping from shock names to distributions from which to draw
 
-    N: int
-        Number of draws from each shock
+    conditions: Sequence[int]
+        An array of conditions, one for each agent.
+        Typically these will be agent ages.
     """
-    return {
-        shock : shocks[shock].draw(N)
-        for shock in shocks
-    }
-    ## TODO: Use time-varying distributions properly with conditions.
+    draws = {}
+
+    for shock_var in shocks:
+        shock = shocks[shock_var]
+        if isinstance(shock, Aggregate):
+            draws[shock_var] = shock.dist.draw(1)[0]
+        elif isinstance(shock, IndexDistribution) \
+            or isinstance(shock, TimeVaryingDiscreteDistribution):
+            draws[shock_var] = shock.draw(conditions)
+        else:
+            draws[shock_var] = shock.draw(len(conditions))
 
+    return draws
 
 def simulate_dynamics(
         dynamics : Mapping[str, Union[Callable, Control]],
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
index b276ba0fe..3533f88fd 100644
--- a/HARK/simulation/test_monte_carlo.py
+++ b/HARK/simulation/test_monte_carlo.py
@@ -3,16 +3,20 @@
 """
 import unittest
 
-from HARK.distribution import MeanOneLogNormal
+from HARK.distribution import MeanOneLogNormal, IndexDistribution
 from HARK.simulation.monte_carlo import *
 
-shocks = {
-    'psi' : MeanOneLogNormal(1),
+cons_shocks = {
+    'agg_gro' : Aggregate(MeanOneLogNormal(1)),
+    'psi' : IndexDistribution(
+        MeanOneLogNormal,
+        {
+            'sigma' : [1.0, 1.1]
+        }),
     'theta' : MeanOneLogNormal(1)
-
 }
 
-pre = {
+cons_pre = {
     'R' : 1.05,
     'aNrm' : 1,
     'gamma' : 1.1,
@@ -20,7 +24,7 @@
     'theta' : 1.1 # TODO: draw this from a shock
 }
 
-dynamics = {
+cons_dynamics = {
     'G' : lambda gamma, psi : gamma * psi,
     'Rnrm' : lambda R, G : R / G,
     'bNrm' : lambda Rnrm, aNrm : Rnrm * aNrm,
@@ -29,21 +33,23 @@
     'aNrm' : lambda mNrm, cNrm : mNrm - cNrm
 }
 
-dr = {
+cons_dr = {
     'cNrm' : lambda mNrm : mNrm / 2
 }
 
 class test_draw_shocks(unittest.TestCase):
     def test_draw_shocks(self):
 
-        drawn = draw_shocks(shocks, 2)
+        drawn = draw_shocks(cons_shocks, np.array([0,1]))
 
+        self.assertEqual(len(drawn['theta']), 2)
         self.assertEqual(len(drawn['psi']), 2)
+        self.assertTrue(isinstance(drawn['agg_gro'], float))
 
 class test_simulate_dynamics(unittest.TestCase):
     def test_simulate_dynamics(self):
 
-        post = simulate_dynamics(dynamics, pre, dr)
+        post = simulate_dynamics(cons_dynamics, cons_pre, cons_dr)
 
         self.assertAlmostEqual(post['cNrm'], 0.98388429)
 

From 53a7f651f6bf97ceca077c73b9061f3301026043 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 24 Jul 2023 16:42:16 -0400
Subject: [PATCH 06/27] Working test for AgentTypeMonteCarloSimulator.

---
 HARK/simulation/monte_carlo.py      | 61 ++++++++++++----------
 HARK/simulation/test_monte_carlo.py | 81 +++++++++++++++--------------
 2 files changed, 75 insertions(+), 67 deletions(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 2abc1fceb..623d50b4a 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -1,7 +1,7 @@
 """
 Functions to support Monte Carlo simulation of models.
 """
-
+from copy import copy
 from HARK.distribution import Distribution, IndexDistribution, TimeVaryingDiscreteDistribution
 from inspect import signature
 import numpy as np
@@ -47,6 +47,7 @@ def draw_shocks(
             draws[shock_var] = shock.dist.draw(1)[0]
         elif isinstance(shock, IndexDistribution) \
             or isinstance(shock, TimeVaryingDiscreteDistribution):
+            ## TODO  his type test is awkward. They should share a superclass.
             draws[shock_var] = shock.draw(conditions)
         else:
             draws[shock_var] = shock.draw(len(conditions))
@@ -111,16 +112,16 @@ class AgentTypeMonteCarloSimulator(Simulator):
     
     Parameters
     ----------
+    TODO
+
     seed : int
         A seed for this instance's random number generator.
 
     Attributes
     ----------
-    AgentCount : int
+    agent_count : int
         The number of agents of this type to use in simulation.
 
-    state_vars : list of string
-        The string labels for this AgentType's model state variables.
     """
 
     state_vars = []
@@ -131,6 +132,7 @@ def __init__(
         shocks,
         dynamics,
         dr,
+        initial,
         seed=0,
         agent_count = 1,
         T_sim = 10
@@ -141,6 +143,7 @@ def __init__(
         self.shocks = shocks
         self.dynamics = dynamics
         self.dr = dr
+        self.initial = initial
 
         self.seed = seed  # NOQA
         self.agent_count = agent_count
@@ -150,7 +153,7 @@ def __init__(
         self.vars = list(shocks.keys()) + list(dynamics.keys())
 
         self.vars_now = {v: None for v in self.vars}
-        self.vars_prev = self.state_now.copy()
+        self.vars_prev = self.vars_now.copy()
 
         self.read_shocks = False  # NOQA
         self.shock_history = {}
@@ -228,7 +231,7 @@ def initialize_sim(self):
                     # not be set by newborns
                     idio = (
                         isinstance(self.state_now[var_name], np.ndarray)
-                        and len(self.state_now[var_name]) == self.AgentCount
+                        and len(self.state_now[var_name]) == self.agent_count
                     )
                     if idio:
                         self.state_now[var_name] = self.newborn_init_history[var_name][
@@ -262,12 +265,6 @@ def sim_one_period(self):
         -------
         None
         """
-        if not hasattr(self, "solution"):
-            raise Exception(
-                "Model instance does not have a solution stored. To simulate, it is necessary"
-                " to run the `solve()` method of the class first."
-            )
-
         # Mortality adjusts the agent population
         self.get_mortality()  # Replace some agents with "newborns"
 
@@ -276,7 +273,7 @@ def sim_one_period(self):
             self.vars_prev[var] = self.vars_now[var]
 
             if isinstance(self.vars_now[var], np.ndarray):
-                self.vars_now[var] = np.empty(self.AgentCount)
+                self.vars_now[var] = np.empty(self.agent_count)
             else:
                 # Probably an aggregate variable. It may be getting set by the Market.
                 pass
@@ -288,10 +285,10 @@ def sim_one_period(self):
                 shocks_now[var_name] = self.shock_history[var_name][self.t_sim, :]
         else:  # Otherwise, draw shocks as usual according to subclass-specific method
             ### BIG CHANGES HERE from HARK.core.AgentType
-            shocks_now = draw_shocks(self.shocks)
+            shocks_now = draw_shocks(self.shocks, self.t_age)
 
         # maybe need to time index the parameters here somehow?
-        pre = self.parameters + shocks_now + self.vars_prev
+        pre = self.parameters | self.vars_prev | shocks_now
         
         post = simulate_dynamics(self.dynamics, pre, self.dr)
         
@@ -300,17 +297,19 @@ def sim_one_period(self):
 
         # Advance time for all agents
         self.t_age = self.t_age + 1  # Age all consumers by one period
-        self.t_cycle = self.t_cycle + 1  # Age all consumers within their cycle
-        self.t_cycle[
-            self.t_cycle == self.T_cycle
-        ] = 0  # Resetting to zero for those who have reached the end
+
+        # What will we do with cycles?
+        #self.t_cycle = self.t_cycle + 1  # Age all consumers within their cycle
+        #self.t_cycle[
+        #    self.t_cycle == self.T_cycle
+        #] = 0  # Resetting to zero for those who have reached the end
 
     def make_shock_history(self):
         """
         Makes a pre-specified history of shocks for the simulation.  Shock variables should be named
         in self.shock_vars, a list of strings that is subclass-specific.  This method runs a subset
         of the standard simulation loop by simulating only mortality and shocks; each variable named
-        in shock_vars is stored in a T_sim x AgentCount array in history dictionary self.history[X].
+        in shock_vars is stored in a T_sim x agent_count array in history dictionary self.history[X].
         Automatically sets self.read_shocks to True so that these pre-specified shocks are used for
         all subsequent calls to simulate().
 
@@ -402,7 +401,7 @@ def get_mortality(self):
         """
         Simulates mortality or agent turnover according to some model-specific rules named sim_death
         and sim_birth (methods of an AgentType subclass).  sim_death takes no arguments and returns
-        a Boolean array of size AgentCount, indicating which agents of this type have "died" and
+        a Boolean array of size agent_count, indicating which agents of this type have "died" and
         must be replaced.  sim_birth takes such a Boolean array as an argument and generates initial
         post-decision states for those agent indices.
 
@@ -424,7 +423,7 @@ def get_mortality(self):
                         # not be set by newborns
                         idio = (
                             isinstance(self.state_now[var_name], np.ndarray)
-                            and len(self.state_now[var_name]) == self.AgentCount
+                            and len(self.state_now[var_name]) == self.agent_count
                         )
                         if idio:
                             self.state_now[var_name][
@@ -454,7 +453,7 @@ def get_mortality(self):
     def sim_death(self):
         """
         Determines which agents in the current population "die" or should be replaced.  Takes no
-        inputs, returns a Boolean array of size self.AgentCount, which has True for agents who die
+        inputs, returns a Boolean array of size self.agent_count, which has True for agents who die
         and False for those that survive. Returns all False by default, must be overwritten by a
         subclass to have replacement events.
 
@@ -465,7 +464,7 @@ def sim_death(self):
         Returns
         -------
         who_dies : np.array
-            Boolean array of size self.AgentCount indicating which agents die and are replaced.
+            Boolean array of size self.agent_count indicating which agents die and are replaced.
         """
         who_dies = np.zeros(self.agent_count, dtype=bool)
         return who_dies
@@ -478,14 +477,20 @@ def sim_birth(self, which_agents):
         Parameters
         ----------
         which_agents : np.array(Bool)
-            Boolean array of size self.AgentCount indicating which agents should be "born".
+            Boolean array of size self.agent_count indicating which agents should be "born".
 
         Returns
         -------
         None
         """
-        print("AgentType subclass must define method sim_birth!")
-        return None      
+
+        initial_vals = draw_shocks(
+            self.initial,
+            np.zeros(which_agents.sum())
+        )
+
+        for varn in initial_vals:
+            self.vars_now[varn][which_agents] = initial_vals[varn]
 
     def simulate(self, sim_periods=None):
         """
@@ -556,5 +561,5 @@ def clear_history(self):
         None
         """
         for var_name in self.vars:
-            self.history[var_name] = np.empty((self.T_sim, self.AgentCount))
+            self.history[var_name] = np.empty((self.T_sim, self.agent_count))
             self.history[var_name].fill(np.nan)
\ No newline at end of file
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
index 3533f88fd..83d0b3b24 100644
--- a/HARK/simulation/test_monte_carlo.py
+++ b/HARK/simulation/test_monte_carlo.py
@@ -54,10 +54,52 @@ def test_simulate_dynamics(self):
         self.assertAlmostEqual(post['cNrm'], 0.98388429)
 
 
+class test_AgentTypeMonteCarloSimulator(unittest.TestCase):
+    def setUp(self):
 
+        self.shocks = {
+            ## TODO: Add an aggregate shock
+            ## TODO: Add a time varying shock.
+            'theta' : MeanOneLogNormal(1),
+            'agg_R' : Aggregate(MeanOneLogNormal(1))
+        }
+
+        self.initial = {
+            'a' : MeanOneLogNormal(1)
+        }
+
+        self.parameters = { # TODO
+            'G' : 1.05,
+        }
+
+        self.dynamics = {
+            'b' : lambda agg_R, G, a : agg_R * G * a,
+            'm' : lambda b, theta : b + theta,
+            'c' : Control(['m']),
+            'a' : lambda m, c : m - c
+        }
+
+        self.dr = {
+            'c' : lambda m : m / 2
+        }
+
+    def test_AgentTypeMonteCarloSimulator(self):
+        self.simulator = AgentTypeMonteCarloSimulator(
+            self.parameters,
+            self.shocks,
+            self.dynamics,
+            self.dr,
+            self.initial,
+            agent_count = 3
+        )
 
+        self.simulator.initialize_sim()
+        history = self.simulator.simulate()
 
+        a1 = history['a'][5]
+        b1 = history['a'][4] * history['agg_R'][5] * self.parameters['G'] + history['theta'][5]  - history['c'][5]
 
+        self.assertTrue((a1 == b1).all())
 
 
 
@@ -89,43 +131,4 @@ def test_simulate_dynamics(self):
     ),
     Frame(("aNrm"), ("mNrm", "cNrm"), transition=lambda mNrm, cNrm: (mNrm - cNrm,)),
 ]
-
-
-class test_FrameModel(unittest.TestCase):
-    def setUp(self):
-        self.model = FrameModel(frames_A, init_parameters)
-
-    def test_init(self):
-        self.model.frames.var("aNrm")
-
-        self.assertTrue(
-            isinstance(
-                list(self.model.frames.var("bNrm").parents.values())[0],
-                BackwardFrameReference,
-            )
-        )
-
-        self.assertTrue(
-            isinstance(
-                list(self.model.frames.var("aNrm").children.values())[0],
-                ForwardFrameReference,
-            )
-        )
-
-    def test_make_terminal(self):
-        terminal_model = self.model.make_terminal()
-
-        self.assertEqual(len(self.model.make_terminal().frames.var("aNrm").children), 0)
-
-    def test_prepend(self):
-        double_model = self.model.prepend(self.model)
-
-        self.assertEqual(len(double_model.frames), 10)
-
-    def test_repeat(self):
-        repeat_model = self.model.repeat({"bNrm": {"Rfree": [1.01, 1.03, 1.02]}})
-
-        self.assertEqual(len(repeat_model.frames), 15)
-
-        self.assertEqual(repeat_model.frames.var("bNrm_1").context["Rfree"], 1.03)
 '''
\ No newline at end of file

From e8799dae38920ec9068ed9acf7ca09c6130ef456 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 24 Jul 2023 17:07:58 -0400
Subject: [PATCH 07/27] var value updates working for Python 3.8 now

---
 HARK/simulation/monte_carlo.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 623d50b4a..a1e3e735b 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -288,7 +288,10 @@ def sim_one_period(self):
             shocks_now = draw_shocks(self.shocks, self.t_age)
 
         # maybe need to time index the parameters here somehow?
-        pre = self.parameters | self.vars_prev | shocks_now
+        pre = copy(self.parameters)
+        pre.update(self.vars_prev)
+        pre.update(shocks_now)
+        #Won't work for 3.8: self.parameters | self.vars_prev | shocks_now
         
         post = simulate_dynamics(self.dynamics, pre, self.dr)
         

From 98ca16f8d546df3a85a11258dcfcad77bb534c20 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Wed, 26 Jul 2023 10:00:38 -0400
Subject: [PATCH 08/27] tighter make_shock_history, with test

---
 HARK/simulation/monte_carlo.py      | 76 +++--------------------------
 HARK/simulation/test_monte_carlo.py | 12 ++++-
 2 files changed, 19 insertions(+), 69 deletions(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index a1e3e735b..1b139569a 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -324,81 +324,21 @@ def make_shock_history(self):
 
         Returns
         -------
-        None
+        shock_history: dict
+            The subset of simulation history that are the shocks for each agent and time.
         """
         # Re-initialize the simulation
         self.initialize_sim()
+        self.simulate()
 
-        # Make blank history arrays for each shock variable (and mortality)
-        for var_name in self.shock_vars:
-            self.shock_history[var_name] = (
-                np.zeros((self.T_sim, self.agent_count)) + np.nan
-            )
-        self.shock_history["who_dies"] = np.zeros(
-            (self.T_sim, self.agent_count), dtype=bool
-        )
-
-        # Also make blank arrays for the draws of newborns' initial conditions
-        for var_name in self.state_vars:
-            self.newborn_init_history[var_name] = (
-                np.zeros((self.T_sim, self.agent_count)) + np.nan
-            )
-
-        # Record the initial condition of the newborns created by
-        # initialize_sim -> sim_births
-        for var_name in self.state_vars:
-            # Check whether the state is idiosyncratic or an aggregate
-            idio = (
-                isinstance(self.state_now[var_name], np.ndarray)
-                and len(self.state_now[var_name]) == self.agent_count
-            )
-            if idio:
-                self.newborn_init_history[var_name][self.t_sim] = self.state_now[
-                    var_name
-                ]
-            else:
-                # Aggregate state is a scalar. Assign it to every agent.
-                self.newborn_init_history[var_name][self.t_sim, :] = self.state_now[
-                    var_name
-                ]
-
-        # Make and store the history of shocks for each period
-        for t in range(self.T_sim):
-            # Deaths
-            self.get_mortality()
-            self.shock_history["who_dies"][t, :] = self.who_dies
-
-            # Initial conditions of newborns
-            if np.sum(self.who_dies) > 0:
-                for var_name in self.state_vars:
-                    # Check whether the state is idiosyncratic or an aggregate
-                    idio = (
-                        isinstance(self.state_now[var_name], np.ndarray)
-                        and len(self.state_now[var_name]) == self.agent_count
-                    )
-                    if idio:
-                        self.newborn_init_history[var_name][
-                            t, self.who_dies
-                        ] = self.state_now[var_name][self.who_dies]
-                    else:
-                        self.newborn_init_history[var_name][
-                            t, self.who_dies
-                        ] = self.state_now[var_name]
-
-            # Other Shocks
-            self.get_shocks()
-            for var_name in self.shock_vars:
-                self.shock_history[var_name][t, :] = self.shocks[var_name]
-
-            self.t_sim += 1
-            self.t_age = self.t_age + 1  # Age all consumers by one period
-            self.t_cycle = self.t_cycle + 1  # Age all consumers within their cycle
-            self.t_cycle[
-                self.t_cycle == self.T_cycle
-            ] = 0  # Resetting to zero for those who have reached the end
+        for shock_name in self.shocks:
+            self.shock_history[shock_name] = self.history[shock_name]
 
         # Flag that shocks can be read rather than simulated
         self.read_shocks = True
+        self.clear_history()
+
+        return self.shock_history
 
     def get_mortality(self):
         """
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
index 83d0b3b24..7276bea58 100644
--- a/HARK/simulation/test_monte_carlo.py
+++ b/HARK/simulation/test_monte_carlo.py
@@ -83,7 +83,7 @@ def setUp(self):
             'c' : lambda m : m / 2
         }
 
-    def test_AgentTypeMonteCarloSimulator(self):
+    def test_simulate(self):
         self.simulator = AgentTypeMonteCarloSimulator(
             self.parameters,
             self.shocks,
@@ -101,7 +101,17 @@ def test_AgentTypeMonteCarloSimulator(self):
 
         self.assertTrue((a1 == b1).all())
 
+    def test_make_shock_history(self):
+        self.simulator = AgentTypeMonteCarloSimulator(
+            self.parameters,
+            self.shocks,
+            self.dynamics,
+            self.dr,
+            self.initial,
+            agent_count = 3
+        )
 
+        self.simulator.make_shock_history()
 
 
 ###############################################################3

From ddaf18589e46f90a292acc50f3dc0db90cfa44dd Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Wed, 26 Jul 2023 11:01:55 -0400
Subject: [PATCH 09/27] fixing handling of saved newborn inits

---
 HARK/simulation/monte_carlo.py      | 95 ++++++++++++-----------------
 HARK/simulation/test_monte_carlo.py | 11 ++++
 2 files changed, 49 insertions(+), 57 deletions(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 1b139569a..63f719b0f 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -218,34 +218,18 @@ def initialize_sim(self):
         self.t_cycle = np.zeros(
             self.agent_count, dtype=int
         )  # Which cycle period each agent is on
-        self.sim_birth(all_agents)
 
-        # If we are asked to use existing shocks and a set of initial conditions
-        # exist, use them
-        ### TODO what to do with this?
+        # Get recorded newborn conditions or initialize blank history.
         if self.read_shocks and bool(self.newborn_init_history):
-            for var_name in self.state_now:
-                # Check that we are actually given a value for the variable
-                if var_name in self.newborn_init_history.keys():
-                    # Copy only array-like idiosyncratic states. Aggregates should
-                    # not be set by newborns
-                    idio = (
-                        isinstance(self.state_now[var_name], np.ndarray)
-                        and len(self.state_now[var_name]) == self.agent_count
-                    )
-                    if idio:
-                        self.state_now[var_name] = self.newborn_init_history[var_name][
-                            0
-                        ]
-
-                else:
-                    warn(
-                        "The option for reading shocks was activated but "
-                        + "the model requires state "
-                        + var_name
-                        + ", not contained in "
-                        + "newborn_init_history."
-                    )
+            for init_var_name in self.initial:
+                self.vars_now[init_var_name] = self.newborn_init_history[init_var_name][self.t_sim, :]
+        else:
+            for var_name in self.initial:
+                self.newborn_init_history[var_name] = (
+                    np.zeros((self.T_sim, self.agent_count)) + np.nan
+                )
+
+        self.sim_birth(all_agents)
 
         self.clear_history()
         return None
@@ -283,7 +267,7 @@ def sim_one_period(self):
         if self.read_shocks:  # If shock histories have been pre-specified, use those
             for var_name in self.shocks:
                 shocks_now[var_name] = self.shock_history[var_name][self.t_sim, :]
-        else:  # Otherwise, draw shocks as usual according to subclass-specific method
+        else:
             ### BIG CHANGES HERE from HARK.core.AgentType
             shocks_now = draw_shocks(self.shocks, self.t_age)
 
@@ -356,45 +340,31 @@ def get_mortality(self):
         -------
         None
         """
+        who_dies = self.sim_death()
+
         if self.read_shocks:
-            who_dies = self.shock_history["who_dies"][self.t_sim, :]
             # Instead of simulating births, assign the saved newborn initial conditions
             if np.sum(who_dies) > 0:
-                for var_name in self.state_now:
-                    if var_name in self.newborn_init_history.keys():
-                        # Copy only array-like idiosyncratic states. Aggregates should
-                        # not be set by newborns
-                        idio = (
-                            isinstance(self.state_now[var_name], np.ndarray)
-                            and len(self.state_now[var_name]) == self.agent_count
-                        )
-                        if idio:
-                            self.state_now[var_name][
-                                who_dies
-                            ] = self.newborn_init_history[var_name][
-                                self.t_sim, who_dies
-                            ]
-
-                    else:
-                        warn(
-                            "The option for reading shocks was activated but "
-                            + "the model requires state "
-                            + var_name
-                            + ", not contained in "
-                            + "newborn_init_history."
-                        )
+                for var_name in self.initial:
+                    self.state_now[var_name][
+                        who_dies
+                    ] = self.newborn_init_history[var_name][
+                        self.t_sim, who_dies
+                    ]
 
                 # Reset ages of newborns
                 self.t_age[who_dies] = 0
                 self.t_cycle[who_dies] = 0
         else:
-            who_dies = self.sim_death()
             self.sim_birth(who_dies)
+
         self.who_dies = who_dies
         return None
 
     def sim_death(self):
         """
+        # TODO: This should mainly just track the 'who_dies' var, which can be a shock or endogenous.
+
         Determines which agents in the current population "die" or should be replaced.  Takes no
         inputs, returns a Boolean array of size self.agent_count, which has True for agents who die
         and False for those that survive. Returns all False by default, must be overwritten by a
@@ -409,6 +379,10 @@ def sim_death(self):
         who_dies : np.array
             Boolean array of size self.agent_count indicating which agents die and are replaced.
         """
+
+        #if self.read_shocks:
+        #    who_dies = self.shock_history["who_dies"][self.t_sim, :]
+
         who_dies = np.zeros(self.agent_count, dtype=bool)
         return who_dies
 
@@ -426,14 +400,21 @@ def sim_birth(self, which_agents):
         -------
         None
         """
-
-        initial_vals = draw_shocks(
-            self.initial,
-            np.zeros(which_agents.sum())
-        )
+        if self.read_shocks:
+            initial_vals = {
+                init_var: self.newborn_init_history[init_var][self.t_sim, :]
+                for init_var
+                in self.initial
+                }
+        else:
+            initial_vals = draw_shocks(
+                self.initial,
+                np.zeros(which_agents.sum())
+            )
 
         for varn in initial_vals:
             self.vars_now[varn][which_agents] = initial_vals[varn]
+            self.newborn_init_history[varn][self.t_sim, which_agents] = initial_vals[varn]
 
     def simulate(self, sim_periods=None):
         """
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
index 7276bea58..4cc05f032 100644
--- a/HARK/simulation/test_monte_carlo.py
+++ b/HARK/simulation/test_monte_carlo.py
@@ -113,6 +113,17 @@ def test_make_shock_history(self):
 
         self.simulator.make_shock_history()
 
+        newborn_init_1 = self.simulator.newborn_init_history.copy()
+        shocks_1 = self.simulator.shock_history.copy()
+
+        self.simulator.initialize_sim()
+        self.simulator.simulate()
+
+        self.assertEqual(newborn_init_1, self.simulator.newborn_init_history)
+        self.assertTrue(
+            np.all(self.simulator.history['theta'] == shocks_1['theta'])
+            )
+
 
 ###############################################################3
 

From dde1e88237ef7a54a920158fbcb5d3c45aab3422 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Wed, 26 Jul 2023 11:09:43 -0400
Subject: [PATCH 10/27] removing warning for very unlikely scenario (T_sim set
 by default)

---
 HARK/simulation/monte_carlo.py | 16 +---------------
 1 file changed, 1 insertion(+), 15 deletions(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 63f719b0f..cd84c5523 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -189,13 +189,7 @@ def initialize_sim(self):
         -------
         None
         """
-        if not hasattr(self, "T_sim"):
-            raise Exception(
-                "To initialize simulation variables it is necessary to first "
-                + "set the attribute T_sim to the largest number of observations "
-                + "you plan to simulate for each agent including re-births."
-            )
-        elif self.T_sim <= 0:
+        if self.T_sim <= 0:
             raise Exception(
                 "T_sim represents the largest number of observations "
                 + "that can be simulated for an agent, and must be a positive number."
@@ -437,14 +431,6 @@ def simulate(self, sim_periods=None):
                 "It seems that the simulation variables were not initialize before calling "
                 + "simulate(). Call initialize_sim() to initialize the variables before calling simulate() again."
             )
-
-        if not hasattr(self, "T_sim"):
-            raise Exception(
-                "This agent type instance must have the attribute T_sim set to a positive integer."
-                + "Set T_sim to match the largest dataset you might simulate, and run this agent's"
-                + "initalizeSim() method before running simulate() again."
-            )
-
         if sim_periods is not None and self.T_sim < sim_periods:
             raise Exception(
                 "To simulate, sim_periods has to be larger than the maximum data set size "

From 4ea021aa3a15aede18efd82fe7258d77f378dab4 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Thu, 27 Jul 2023 10:10:19 -0400
Subject: [PATCH 11/27] remove sim_death from MonteCarloSimulator, just use
 'live' state

---
 HARK/simulation/monte_carlo.py      | 45 +++++++++--------------------
 HARK/simulation/test_monte_carlo.py | 11 ++++---
 2 files changed, 21 insertions(+), 35 deletions(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index cd84c5523..41d202db9 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -43,7 +43,10 @@ def draw_shocks(
 
     for shock_var in shocks:
         shock = shocks[shock_var]
-        if isinstance(shock, Aggregate):
+
+        if isinstance(shock, (int, float)):
+            draws[shock_var] = np.ones(len(conditions)) * shock
+        elif isinstance(shock, Aggregate):
             draws[shock_var] = shock.dist.draw(1)[0]
         elif isinstance(shock, IndexDistribution) \
             or isinstance(shock, TimeVaryingDiscreteDistribution):
@@ -321,10 +324,15 @@ def make_shock_history(self):
     def get_mortality(self):
         """
         Simulates mortality or agent turnover according to some model-specific rules named sim_death
-        and sim_birth (methods of an AgentType subclass).  sim_death takes no arguments and returns
+        and sim_birth (methods of an AgentType subclass).
+
+        Agents die when their states `live` is less than or equal to zero.
+
         a Boolean array of size agent_count, indicating which agents of this type have "died" and
-        must be replaced.  sim_birth takes such a Boolean array as an argument and generates initial
-        post-decision states for those agent indices.
+        must be replaced.
+
+        sim_birth takes such a Boolean array as an argument and generates initial
+        states for those agent indices.
 
         Parameters
         ----------
@@ -334,13 +342,13 @@ def get_mortality(self):
         -------
         None
         """
-        who_dies = self.sim_death()
+        who_dies = self.vars_now['live'] <= 0
 
         if self.read_shocks:
             # Instead of simulating births, assign the saved newborn initial conditions
             if np.sum(who_dies) > 0:
                 for var_name in self.initial:
-                    self.state_now[var_name][
+                    self.vars_now[var_name][
                         who_dies
                     ] = self.newborn_init_history[var_name][
                         self.t_sim, who_dies
@@ -355,31 +363,6 @@ def get_mortality(self):
         self.who_dies = who_dies
         return None
 
-    def sim_death(self):
-        """
-        # TODO: This should mainly just track the 'who_dies' var, which can be a shock or endogenous.
-
-        Determines which agents in the current population "die" or should be replaced.  Takes no
-        inputs, returns a Boolean array of size self.agent_count, which has True for agents who die
-        and False for those that survive. Returns all False by default, must be overwritten by a
-        subclass to have replacement events.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        who_dies : np.array
-            Boolean array of size self.agent_count indicating which agents die and are replaced.
-        """
-
-        #if self.read_shocks:
-        #    who_dies = self.shock_history["who_dies"][self.t_sim, :]
-
-        who_dies = np.zeros(self.agent_count, dtype=bool)
-        return who_dies
-
     def sim_birth(self, which_agents):
         """
         Makes new agents for the simulation.  Takes a boolean array as an input, indicating which
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
index 4cc05f032..12ab20cbb 100644
--- a/HARK/simulation/test_monte_carlo.py
+++ b/HARK/simulation/test_monte_carlo.py
@@ -3,7 +3,7 @@
 """
 import unittest
 
-from HARK.distribution import MeanOneLogNormal, IndexDistribution
+from HARK.distribution import Bernoulli, MeanOneLogNormal, IndexDistribution
 from HARK.simulation.monte_carlo import *
 
 cons_shocks = {
@@ -13,7 +13,8 @@
         {
             'sigma' : [1.0, 1.1]
         }),
-    'theta' : MeanOneLogNormal(1)
+    'theta' : MeanOneLogNormal(1),
+    'live' : Bernoulli(p=0.98)
 }
 
 cons_pre = {
@@ -61,11 +62,13 @@ def setUp(self):
             ## TODO: Add an aggregate shock
             ## TODO: Add a time varying shock.
             'theta' : MeanOneLogNormal(1),
-            'agg_R' : Aggregate(MeanOneLogNormal(1))
+            'agg_R' : Aggregate(MeanOneLogNormal(1)),
+            'live' : Bernoulli(p=0.98)
         }
 
         self.initial = {
-            'a' : MeanOneLogNormal(1)
+            'a' : MeanOneLogNormal(1),
+            'live' : 1
         }
 
         self.parameters = { # TODO

From 411703ab73ed8ca15f715ff4c95ac87969bb705c Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Thu, 10 Aug 2023 10:09:07 -0400
Subject: [PATCH 12/27] use age-varying parameters in MonteCarloSimulator

---
 HARK/simulation/monte_carlo.py | 45 +++++++++++++++++++++++++++++++---
 1 file changed, 41 insertions(+), 4 deletions(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 41d202db9..43288a401 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -97,6 +97,45 @@ def simulate_dynamics(
 
     return vals
 
+def parameters_by_age(ages, parameters):
+    """
+    Returns parameters for this model, but with vectorized
+    values which map age-varying values to agent ages.
+
+    Parameters
+    ----------
+    ages: np.array
+        An array of agent ages.
+
+    parameters: dict
+        A parameters dictionary
+
+    Returns
+    --------
+    aged_parameters: dict
+        A dictionary of parameter values.
+        If a parameter is age-varying, the value is a vector
+        corresponding to the values for each input age.
+    """
+    def aged_param(ages, p_value):
+        if isinstance(p_value, float) or isinstance(p_value, int):
+            return p_value
+        elif isinstance(p_value, list) and len(p_value) > 1:
+            pv_array = np.array(p_value)
+            return np.apply_along_axis(
+                lambda a: pv_array[a],
+                0,
+                ages
+            )
+        else:
+            return np.empty(ages.size)
+
+    return {
+        p : aged_param(ages, parameters[p])
+        for p
+        in parameters
+    }
+
 class Simulator():
     pass
 
@@ -207,8 +246,6 @@ def initialize_sim(self):
             if self.vars_now[var] is None:
                 self.vars_now[var] = copy(blank_array)
 
-            # elif self.state_prev[var] is None:
-            #    self.state_prev[var] = copy(blank_array)
         self.t_age = np.zeros(
             self.agent_count, dtype=int
         )  # Number of periods since agent entry
@@ -268,8 +305,8 @@ def sim_one_period(self):
             ### BIG CHANGES HERE from HARK.core.AgentType
             shocks_now = draw_shocks(self.shocks, self.t_age)
 
-        # maybe need to time index the parameters here somehow?
-        pre = copy(self.parameters)
+        pre = parameters_by_age(self.t_age, self.parameters)
+
         pre.update(self.vars_prev)
         pre.update(shocks_now)
         #Won't work for 3.8: self.parameters | self.vars_prev | shocks_now

From ea3e7b18cf349a74c7e122ddb909749992ba80d0 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 28 Aug 2023 17:00:09 -0400
Subject: [PATCH 13/27] age-varying decision rules in generic monte carlo

---
 HARK/simulation/monte_carlo.py      | 30 ++++++++---
 HARK/simulation/test_monte_carlo.py | 81 ++++++++++++++++++-----------
 2 files changed, 75 insertions(+), 36 deletions(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 43288a401..16634547a 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -88,10 +88,24 @@ def simulate_dynamics(
         feq = dynamics[varn]
 
         if isinstance(feq, Control):
-            vals[varn] = dr[varn](*[
-                vals[var]
-                for var 
-                in signature(dr[varn]).parameters]) # TODO: test for signature match with Control
+            # This tests if the decision rule is age varying.
+            # If it is, this will be a vector with the decision rule for each agent.
+            if isinstance(dr[varn], np.ndarray):
+                ## Now we have to loop through each agent, and apply the decision rule.
+                ## This is quite slow.
+                for i in range(dr[varn].size):
+                    vals_i = {var : vals[var][i] if isinstance(vals[var], np.ndarray) else vals[var]
+                              for var in vals
+                              }
+                    vals[varn][i] = dr[varn][i](*[
+                        vals_i[var]
+                        for var
+                        in signature(dr[varn][i]).parameters])
+            else:
+                vals[varn] = dr[varn](*[
+                    vals[var]
+                    for var
+                    in signature(dr[varn]).parameters]) # TODO: test for signature match with Control
         else:
             vals[varn] = feq(*[vals[var] for var in signature(feq).parameters])
 
@@ -118,10 +132,11 @@ def parameters_by_age(ages, parameters):
         corresponding to the values for each input age.
     """
     def aged_param(ages, p_value):
-        if isinstance(p_value, float) or isinstance(p_value, int):
+        if isinstance(p_value, (float, int)) or callable(p_value):
             return p_value
         elif isinstance(p_value, list) and len(p_value) > 1:
             pv_array = np.array(p_value)
+
             return np.apply_along_axis(
                 lambda a: pv_array[a],
                 0,
@@ -310,8 +325,11 @@ def sim_one_period(self):
         pre.update(self.vars_prev)
         pre.update(shocks_now)
         #Won't work for 3.8: self.parameters | self.vars_prev | shocks_now
+
+        # Age-varying decision rules captured here
+        dr = parameters_by_age(self.t_age, self.dr)
         
-        post = simulate_dynamics(self.dynamics, pre, self.dr)
+        post = simulate_dynamics(self.dynamics, pre, dr)
         
         self.vars_now = post
         ### BIG CHANGES HERE
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
index 12ab20cbb..f0df92a3f 100644
--- a/HARK/simulation/test_monte_carlo.py
+++ b/HARK/simulation/test_monte_carlo.py
@@ -59,8 +59,6 @@ class test_AgentTypeMonteCarloSimulator(unittest.TestCase):
     def setUp(self):
 
         self.shocks = {
-            ## TODO: Add an aggregate shock
-            ## TODO: Add a time varying shock.
             'theta' : MeanOneLogNormal(1),
             'agg_R' : Aggregate(MeanOneLogNormal(1)),
             'live' : Bernoulli(p=0.98)
@@ -126,33 +124,56 @@ def test_make_shock_history(self):
         self.assertTrue(
             np.all(self.simulator.history['theta'] == shocks_1['theta'])
             )
+        
 
+class test_AgentTypeMonteCarloSimulatorAgeVariance(unittest.TestCase):
+    def setUp(self):
+
+        self.shocks = {
+            'theta' : MeanOneLogNormal(1),
+            'agg_R' : Aggregate(MeanOneLogNormal(1)),
+            'live' : Bernoulli(p=0.98),
+            'psi' : IndexDistribution(
+                MeanOneLogNormal,
+                {
+                'sigma' : [1.0, 1.1]
+                })
+        }
+
+        self.initial = {
+            'a' : MeanOneLogNormal(1),
+            'live' : 1
+        }
+
+        self.parameters = { # TODO
+            'G' : 1.05,
+        }
+
+        self.dynamics = {
+            'b' : lambda agg_R, G, a : agg_R * G * a,
+            'm' : lambda b, theta : b + theta,
+            'c' : Control(['m']),
+            'a' : lambda m, c : m - c
+        }
+
+        self.dr = {
+            'c' : [lambda m : m * 0.5, lambda m : m * 0.9]
+        }
+
+    def test_simulate(self):
+        self.simulator = AgentTypeMonteCarloSimulator(
+            self.parameters,
+            self.shocks,
+            self.dynamics,
+            self.dr,
+            self.initial,
+            agent_count = 3
+        )
+
+        self.simulator.initialize_sim()
+        history = self.simulator.simulate(sim_periods=2)
+
+        a1 = history['a'][1]
+        b1 = history['m'][1] - self.dr['c'][1](history['m'][1])
 
-###############################################################3
-
-'''
-init_parameters = {}
-init_parameters["PermGroFac"] = 1.05
-init_parameters["PermShkStd"] = 1.5
-init_parameters["PermShkCount"] = 5
-init_parameters["TranShkStd"] = 3.0
-init_parameters["TranShkCount"] = 5
-init_parameters["RiskyAvg"] = 1.05
-init_parameters["RiskyStd"] = 1.5
-init_parameters["RiskyCount"] = 5
-init_parameters["Rfree"] = 1.03
-
-frames_A = [
-    Frame(("bNrm",), ("aNrm",), transition=lambda Rfree, aNrm: Rfree * aNrm),
-    Frame(("mNrm",), ("bNrm", "TranShk"), transition=lambda bNrm: mNrm),
-    Frame(("cNrm"), ("mNrm",), control=True),
-    Frame(
-        ("U"),
-        ("cNrm", "CRRA"),  # Note CRRA here is a parameter not a state var
-        transition=lambda cNrm, CRRA: (CRRAutility(cNrm, CRRA),),
-        reward=True,
-        context={"CRRA": 2.0},
-    ),
-    Frame(("aNrm"), ("mNrm", "cNrm"), transition=lambda mNrm, cNrm: (mNrm - cNrm,)),
-]
-'''
\ No newline at end of file
+        self.assertTrue((a1 == b1).all())
\ No newline at end of file

From ce1fe319de80f83b6cb3263a9da46523d8f1a197 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 9 Oct 2023 18:18:43 -0400
Subject: [PATCH 14/27] updating CHANGELOG

---
 Documentation/CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Documentation/CHANGELOG.md b/Documentation/CHANGELOG.md
index 9ec54333c..79b0a3eb8 100644
--- a/Documentation/CHANGELOG.md
+++ b/Documentation/CHANGELOG.md
@@ -16,6 +16,7 @@ Release Date: TBD
 
 - Adds `HARK.core.AgentPopulation` class to represent a population of agents with ex-ante heterogeneous parametrizations as distributions. [#1237](https://github.com/econ-ark/HARK/pull/1237)
 - Adds `HARK.core.Parameters` class to represent a collection of time varying and time invariant parameters in a model. [#1240](https://github.com/econ-ark/HARK/pull/1240)
+- Adds `HARK.simulation.monte_carlo` module for generic Monte Carlo simulation functions using Python model configurations. [1296](https://github.com/econ-ark/HARK/pull/1296)
 
 ### Minor Changes
 

From 4c0850c3e29b89e8f5a33348d9b40149d7345ccc Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 9 Oct 2023 18:19:56 -0400
Subject: [PATCH 15/27] use HARK.model classes in HARK.simulate functions

---
 HARK/model.py                       | 21 ++++++++++++++++++++-
 HARK/simulation/monte_carlo.py      | 18 +-----------------
 HARK/simulation/test_monte_carlo.py |  1 +
 3 files changed, 22 insertions(+), 18 deletions(-)

diff --git a/HARK/model.py b/HARK/model.py
index 2ea919ea6..63b20d19f 100644
--- a/HARK/model.py
+++ b/HARK/model.py
@@ -2,9 +2,28 @@
 Tools for crafting models.
 """
 
+from HARK.distribution import Distribution
+
+
+class Aggregate:
+    """
+    Used to designate a shock as an aggregate shock.
+    If so designated, draws from the shock will be scalar rather
+    than array valued.
+    """
+    def __init__(self, dist: Distribution):
+        self.dist = dist
+
+
+
 class Control:
     """
-    Should go in different model support module.
+    Used to designate a variabel that is a control variable.
+
+    Parameters
+    ----------
+    args : list of str
+        The labels of the variables that are in the information set of this control.
     """
 
     def __init__(self, args):
diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 16634547a..3636a90b4 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -3,27 +3,11 @@
 """
 from copy import copy
 from HARK.distribution import Distribution, IndexDistribution, TimeVaryingDiscreteDistribution
+from HARK.model import Aggregate, Control
 from inspect import signature
 import numpy as np
 from typing import Any, Callable, Mapping, Sequence, Union
 
-class Aggregate:
-    """
-    Used to designate a shock as an aggregate shock.
-    If so designated, draws from the shock will be scalar rather
-    than array valued.
-    """
-    def __init__(self, dist: Distribution):
-        self.dist = dist
-
-class Control:
-    """
-    Should go in HARK.model
-    """
-
-    def __init__(self, args):
-        pass
-
 def draw_shocks(
         shocks: Mapping[str, Distribution],
         conditions: Sequence[int]
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
index f0df92a3f..bf999b008 100644
--- a/HARK/simulation/test_monte_carlo.py
+++ b/HARK/simulation/test_monte_carlo.py
@@ -4,6 +4,7 @@
 import unittest
 
 from HARK.distribution import Bernoulli, MeanOneLogNormal, IndexDistribution
+from HARK.model import Aggregate, Control
 from HARK.simulation.monte_carlo import *
 
 cons_shocks = {

From 5ef3a19186ea74033aeac01e536eeaf355b3e1a0 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 9 Oct 2023 18:21:05 -0400
Subject: [PATCH 16/27] adjust PF python model so you only need to initialize
 p, not y

---
 HARK/models/perfect_foresight.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/HARK/models/perfect_foresight.py b/HARK/models/perfect_foresight.py
index cca33e2ed..6ae8b55af 100644
--- a/HARK/models/perfect_foresight.py
+++ b/HARK/models/perfect_foresight.py
@@ -20,9 +20,9 @@
         'BoroCnstArt' : None,
     },
     'dynamics' : {
+        'y' : lambda p : p,
         'm' : lambda Rfree, a, y : Rfree * a + y,
         'c' : Control(['m']),
-        'y' : lambda p : p,
         'p' : lambda PermGroFac, p: PermGroFac * p,
         'a' : lambda m, c : m - c
     },

From 2cc60bf9f6ef1b919f526cde47bcac6999535558 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 9 Oct 2023 18:22:15 -0400
Subject: [PATCH 17/27] when creating new data arrays for variables NOW in
 generic monte carlo, set to nan to avoid confusion

---
 HARK/simulation/monte_carlo.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 3636a90b4..acfa93578 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -291,6 +291,7 @@ def sim_one_period(self):
 
             if isinstance(self.vars_now[var], np.ndarray):
                 self.vars_now[var] = np.empty(self.agent_count)
+                self.vars_now[var][:] = np.nan
             else:
                 # Probably an aggregate variable. It may be getting set by the Market.
                 pass

From b95b0f4a20092651481413cf400203040d055137 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 9 Oct 2023 18:23:31 -0400
Subject: [PATCH 18/27] adding example notebook for comparing HARK PF and
 Generic Monte Carlo

---
 ...eneric Monte Carlo Perfect Foresight.ipynb | 414 ++++++++++++++++++
 1 file changed, 414 insertions(+)
 create mode 100644 examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb

diff --git a/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb b/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb
new file mode 100644
index 000000000..8a547fca3
--- /dev/null
+++ b/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb	
@@ -0,0 +1,414 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "be704ca8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d0698156",
+   "metadata": {},
+   "source": [
+    "## Original Perfect Foresight Example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "e0f219ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "PFexample = PerfForesightConsumerType()\n",
+    "PFexample.cycles = 0\n",
+    "PFexample.solve()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "83e6f76e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SimulationParams = {\n",
+    "    \"AgentCount\": 10000,  # Number of agents of this type\n",
+    "    \"T_sim\": 120,  # Number of periods to simulate\n",
+    "    \"aNrmInitMean\": -6.0,  # Mean of log initial assets\n",
+    "    \"aNrmInitStd\": 1.0,  # Standard deviation of log initial assets\n",
+    "    \"pLvlInitMean\": 0.0,  # Mean of log initial permanent income\n",
+    "    \"pLvlInitStd\": 0.0,  # Standard deviation of log initial permanent income\n",
+    "    \"PermGroFacAgg\": 1.0,  # Aggregate permanent income growth factor\n",
+    "    \"T_age\": None,  # Age after which simulated agents are automatically killed\n",
+    "}\n",
+    "\n",
+    "PFexample.assign_parameters(**SimulationParams)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "66cc08fb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'mNrm': array([[  1.00095989,   1.00282396,   1.00111932, ...,   1.00185921,\n",
+       "           1.00044451,   1.00448108],\n",
+       "        [ -0.30491013,  -0.30309332,  -0.30475474, ...,  -0.30403362,\n",
+       "          -0.30541244,  -0.30147822],\n",
+       "        [ -1.57766816,  -1.57589742,  -1.57751671, ...,  -1.57681387,\n",
+       "          -1.57815773,  -1.57432327],\n",
+       "        ...,\n",
+       "        [-21.97118426,  -9.62717581, -36.59971086, ...,   1.00376132,\n",
+       "          -2.81712554, -46.01045686],\n",
+       "        [-22.69456637, -10.66355594,   1.00072865, ...,  -0.30217974,\n",
+       "          -4.02618315, -46.12429267],\n",
+       "        [-23.39960622, -11.67365734,  -0.30513551, ...,  -1.575007  ,\n",
+       "          -5.20458357, -46.23524203]])}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "PFexample.track_vars = [\"mNrm\"]\n",
+    "PFexample.initialize_sim()\n",
+    "PFexample.simulate()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3b126cc4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(np.mean(PFexample.history[\"mNrm\"], axis=1))\n",
+    "plt.xlabel(\"Time\")\n",
+    "plt.ylabel(\"Mean normalized market resources\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0ead3ec8",
+   "metadata": {},
+   "source": [
+    "## Using the Generic Monte Carlo Simulator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "adfbe431",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from HARK.distribution import Lognormal\n",
+    "import HARK.models.perfect_foresight as pf\n",
+    "from HARK.simulation.monte_carlo import AgentTypeMonteCarloSimulator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "5a0c394b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'shocks': {'live': <HARK.distribution.Bernoulli at 0x7f86ff5f3cd0>},\n",
+       " 'parameters': {'DiscFac': 0.96,\n",
+       "  'CRRA': (2.0,),\n",
+       "  'Rfree': 1.03,\n",
+       "  'LivPrb': 0.98,\n",
+       "  'PermGroFac': 1.01,\n",
+       "  'BoroCnstArt': None},\n",
+       " 'dynamics': {'y': <function HARK.models.perfect_foresight.<lambda>(p)>,\n",
+       "  'm': <function HARK.models.perfect_foresight.<lambda>(Rfree, a, y)>,\n",
+       "  'c': <HARK.model.Control at 0x7f86ff4d25f0>,\n",
+       "  'p': <function HARK.models.perfect_foresight.<lambda>(PermGroFac, p)>,\n",
+       "  'a': <function HARK.models.perfect_foresight.<lambda>(m, c)>},\n",
+       " 'reward': {'u': <function HARK.models.perfect_foresight.<lambda>(c)>}}"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "pf.model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e8201f3e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.6790219804335322"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "PFexample.solution[0].cFunc(10).tolist()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "7c65d4cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array(2.67902198)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "## getting the decision rule from the original Perfect Foresight model\n",
+    "PFexample.solution[0].cFunc(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e9d068bd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pf_simulator = AgentTypeMonteCarloSimulator(\n",
+    "    pf.model['parameters'],\n",
+    "    pf.model['shocks'],\n",
+    "    pf.model['dynamics'],\n",
+    "    {\n",
+    "        'c' : lambda m: PFexample.solution[0].cFunc(m)\n",
+    "    },\n",
+    "    { # initial states\n",
+    "        'a' : Lognormal(-6, 1),\n",
+    "        'live' : 1,\n",
+    "        'p' : 1.0\n",
+    "    },\n",
+    "    agent_count = 10000,\n",
+    "    T_sim = 120\n",
+    ")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "65df3a7f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'live': array([[1., 1., 1., ..., 1., 1., 1.],\n",
+       "        [1., 1., 1., ..., 1., 1., 1.],\n",
+       "        [1., 1., 1., ..., 1., 1., 1.],\n",
+       "        ...,\n",
+       "        [1., 1., 1., ..., 1., 1., 1.],\n",
+       "        [1., 1., 1., ..., 1., 1., 1.],\n",
+       "        [1., 1., 1., ..., 1., 1., 1.]]),\n",
+       " 'y': array([[1.        , 1.        , 1.        , ..., 1.        , 1.        ,\n",
+       "         1.        ],\n",
+       "        [1.01      , 1.01      , 1.01      , ..., 1.01      , 1.01      ,\n",
+       "         1.01      ],\n",
+       "        [1.0201    , 1.0201    , 1.0201    , ..., 1.0201    , 1.0201    ,\n",
+       "         1.0201    ],\n",
+       "        ...,\n",
+       "        [1.08285671, 1.34784892, 1.69446581, ..., 3.203323  , 2.10912847,\n",
+       "         3.203323  ],\n",
+       "        [1.09368527, 1.3613274 , 1.71141047, ..., 3.23535623, 2.13021975,\n",
+       "         3.23535623],\n",
+       "        [1.10462213, 1.37494068, 1.72852457, ..., 3.2677098 , 2.15152195,\n",
+       "         3.2677098 ]]),\n",
+       " 'm': array([[  1.00289517,   1.00223716,   1.00484398, ...,   1.00168362,\n",
+       "           1.00071965,   1.00716025],\n",
+       "        [ -0.30605416,  -0.3067019 ,  -0.30413577, ...,  -0.3072468 ,\n",
+       "          -0.30819572,  -0.30185566],\n",
+       "        [ -1.58447101,  -1.58510864,  -1.58258257, ...,  -1.58564503,\n",
+       "          -1.58657914,  -1.58033805],\n",
+       "        ...,\n",
+       "        [ -8.63499874, -26.33490532, -33.32979358, ...,  -3.90476234,\n",
+       "         -30.84337272,  -3.90389321],\n",
+       "        [ -9.70981688, -26.86578873, -33.40140489, ...,  -2.91174772,\n",
+       "         -30.53498736,  -2.91089216],\n",
+       "        [-10.75692043, -27.37477187, -33.45478426, ...,  -1.90188034,\n",
+       "         -30.21011365,  -1.90103813]]),\n",
+       " 'c': array([[2.28061766, 2.28058852, 2.28070395, ..., 2.28056401, 2.28052132,\n",
+       "         2.28080652],\n",
+       "        [2.22265556, 2.22262688, 2.22274051, ..., 2.22260275, 2.22256073,\n",
+       "         2.22284147],\n",
+       "        [2.16604548, 2.16601725, 2.1661291 , ..., 2.16599349, 2.16595213,\n",
+       "         2.1662285 ],\n",
+       "        ...,\n",
+       "        [1.8538383 , 1.07006181, 0.76031842, ..., 2.06329975, 0.87042059,\n",
+       "         2.06333824],\n",
+       "        [1.80624386, 1.04655355, 0.75714737, ..., 2.10727182, 0.88407633,\n",
+       "         2.10730971],\n",
+       "        [1.75987666, 1.02401507, 0.75478366, ..., 2.15199016, 0.89846219,\n",
+       "         2.15202745]]),\n",
+       " 'p': array([[1.01      , 1.01      , 1.01      , ..., 1.01      , 1.01      ,\n",
+       "         1.01      ],\n",
+       "        [1.0201    , 1.0201    , 1.0201    , ..., 1.0201    , 1.0201    ,\n",
+       "         1.0201    ],\n",
+       "        [1.030301  , 1.030301  , 1.030301  , ..., 1.030301  , 1.030301  ,\n",
+       "         1.030301  ],\n",
+       "        ...,\n",
+       "        [1.09368527, 1.3613274 , 1.71141047, ..., 3.23535623, 2.13021975,\n",
+       "         3.23535623],\n",
+       "        [1.10462213, 1.37494068, 1.72852457, ..., 3.2677098 , 2.15152195,\n",
+       "         3.2677098 ],\n",
+       "        [1.11566835, 1.38869009, 1.74580982, ..., 3.30038689, 2.17303717,\n",
+       "         3.30038689]]),\n",
+       " 'a': array([[ -1.27772249,  -1.27835136,  -1.27585997, ...,  -1.27888039,\n",
+       "          -1.27980167,  -1.27364627],\n",
+       "        [ -2.52870972,  -2.52932877,  -2.52687628, ...,  -2.52984955,\n",
+       "          -2.53075645,  -2.52469714],\n",
+       "        [ -3.75051649,  -3.75112588,  -3.74871167, ...,  -3.75163853,\n",
+       "          -3.75253127,  -3.74656654],\n",
+       "        ...,\n",
+       "        [-10.48883704, -27.40496712, -34.090112  , ...,  -5.96806209,\n",
+       "         -31.71379332,  -5.96723145],\n",
+       "        [-11.51606074, -27.91234228, -34.15855226, ...,  -5.01901955,\n",
+       "         -31.41906369,  -5.01820187],\n",
+       "        [-12.51679709, -28.39878694, -34.20956791, ...,  -4.05387049,\n",
+       "         -31.10857584,  -4.05306558]])}"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#pf_simulator.track_vars = [\"mNrm\"]\n",
+    "pf_simulator.initialize_sim()\n",
+    "pf_simulator.simulate(sim_periods=120)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "9e2c7ad0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(np.mean(pf_simulator.history['m'], axis=1))\n",
+    "plt.xlabel(\"Time\")\n",
+    "plt.ylabel(\"Mean normalized market resources\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "464f19e7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f86f968eb60>]"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(pf_simulator.history['live'].sum(axis=1))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "hark-env",
+   "language": "python",
+   "name": "hark-env"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 0c5296370af638e82f199e80d24ad3abfbc288b5 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Wed, 11 Oct 2023 11:25:59 -0400
Subject: [PATCH 19/27] adding python model configuration for normalized
 perfect foresight; generic monte carlo example shows exact match

---
 HARK/models/__init__.py                       |   0
 HARK/models/perfect_foresight_normalized.py   |  33 ++
 ...eneric Monte Carlo Perfect Foresight.ipynb | 505 ++++++++++++------
 3 files changed, 384 insertions(+), 154 deletions(-)
 create mode 100644 HARK/models/__init__.py
 create mode 100644 HARK/models/perfect_foresight_normalized.py

diff --git a/HARK/models/__init__.py b/HARK/models/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/HARK/models/perfect_foresight_normalized.py b/HARK/models/perfect_foresight_normalized.py
new file mode 100644
index 000000000..22211db45
--- /dev/null
+++ b/HARK/models/perfect_foresight_normalized.py
@@ -0,0 +1,33 @@
+from HARK.distribution import Bernoulli
+from HARK.model import Control
+
+# This way of distributing parameters across the scope is clunky
+# Can be handled better if parsed from a YAML file, probably
+# But it would be better to have a more graceful Python version as well.
+CRRA = 2.0,
+LivPrb = 0.98
+
+model = {
+    'shocks' : {
+        'live' : Bernoulli(p=LivPrb),
+    },
+    'parameters' : {
+        'DiscFac' : 0.96,
+        'CRRA' : CRRA,
+        'Rfree' : 1.03,
+        'LivPrb' : LivPrb,
+        'PermGroFac' : 1.01,
+        'BoroCnstArt' : None,
+    },
+    'dynamics' : {
+        'p' : lambda PermGroFac, p: PermGroFac * p,
+        'r_eff' : lambda Rfree, PermGroFac : Rfree / PermGroFac,
+        'b_nrm' : lambda r_eff, a_nrm: r_eff * a_nrm,
+        'm_nrm' : lambda b_nrm: b_nrm + 1,
+        'c_nrm' : Control(['m_nrm']),
+        'a_nrm' : lambda m_nrm, c_nrm : m_nrm - c_nrm
+    },
+    'reward' : {
+        'u' : lambda c : c ** (1 - CRRA) / (1 - CRRA)
+    }
+}
\ No newline at end of file
diff --git a/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb b/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb
index 8a547fca3..5583edc51 100644
--- a/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb	
+++ b/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb	
@@ -2,12 +2,13 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 50,
    "id": "be704ca8",
    "metadata": {},
    "outputs": [],
    "source": [
     "from HARK.ConsumptionSaving.ConsIndShockModel import PerfForesightConsumerType\n",
+    "from HARK.distribution import Bernoulli\n",
     "\n",
     "import matplotlib.pyplot as plt\n",
     "import numpy as np"
@@ -23,32 +24,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "id": "e0f219ec",
+   "execution_count": 13,
+   "id": "83e6f76e",
    "metadata": {},
    "outputs": [],
    "source": [
     "PFexample = PerfForesightConsumerType()\n",
     "PFexample.cycles = 0\n",
-    "PFexample.solve()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "83e6f76e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "\n",
     "SimulationParams = {\n",
     "    \"AgentCount\": 10000,  # Number of agents of this type\n",
     "    \"T_sim\": 120,  # Number of periods to simulate\n",
     "    \"aNrmInitMean\": -6.0,  # Mean of log initial assets\n",
-    "    \"aNrmInitStd\": 1.0,  # Standard deviation of log initial assets\n",
+    "    \"aNrmInitStd\": 0, #1.0,  # Standard deviation of log initial assets\n",
     "    \"pLvlInitMean\": 0.0,  # Mean of log initial permanent income\n",
     "    \"pLvlInitStd\": 0.0,  # Standard deviation of log initial permanent income\n",
     "    \"PermGroFacAgg\": 1.0,  # Aggregate permanent income growth factor\n",
-    "    \"T_age\": None,  # Age after which simulated agents are automatically killed\n",
+    "    \"T_age\": None,  # Age after which simulated agents are automatically killed,\n",
+    "    \"LivPrb\": [1.0] # [0.98]\n",
     "}\n",
     "\n",
     "PFexample.assign_parameters(**SimulationParams)"
@@ -56,48 +49,112 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 14,
+   "id": "e0f219ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "PFexample.solve()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "312a516e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<HARK.ConsumptionSaving.ConsIndShockModel.PerfForesightConsumerType object at 0x7fa6f7367220.\n",
+       "Parameters:\n",
+       "cycles: 1\n",
+       "CRRA: 2.0\n",
+       "Rfree: 1.03\n",
+       "DiscFac: 0.96\n",
+       "LivPrb: [1.0]\n",
+       "PermGroFac: [1.01]\n",
+       "BoroCnstArt: None\n",
+       "MaxKinks: 400\n",
+       "AgentCount: 10000\n",
+       "aNrmInitMean: -6.0\n",
+       "aNrmInitStd: 0\n",
+       "pLvlInitMean: 0.0\n",
+       "pLvlInitStd: 0.0\n",
+       "PermGroFacAgg: 1.0\n",
+       "T_age: None\n",
+       "T_cycle: 1\n",
+       "PerfMITShk: False\n",
+       "T_sim: 120>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "PFexample"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
    "id": "66cc08fb",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'mNrm': array([[  1.00095989,   1.00282396,   1.00111932, ...,   1.00185921,\n",
-       "           1.00044451,   1.00448108],\n",
-       "        [ -0.30491013,  -0.30309332,  -0.30475474, ...,  -0.30403362,\n",
-       "          -0.30541244,  -0.30147822],\n",
-       "        [ -1.57766816,  -1.57589742,  -1.57751671, ...,  -1.57681387,\n",
-       "          -1.57815773,  -1.57432327],\n",
+       "{'mNrm': array([[  1.00252784,   1.00252784,   1.00252784, ...,   1.00252784,\n",
+       "           1.00252784,   1.00252784],\n",
+       "        [  0.20624094,   0.20624094,   0.20624094, ...,   0.20624094,\n",
+       "           0.20624094,   0.20624094],\n",
+       "        [ -0.57773444,  -0.57773444,  -0.57773444, ...,  -0.57773444,\n",
+       "          -0.57773444,  -0.57773444],\n",
+       "        ...,\n",
+       "        [-42.18087615, -42.18087615, -42.18087615, ..., -42.18087615,\n",
+       "         -42.18087615, -42.18087615],\n",
+       "        [-42.30949766, -42.30949766, -42.30949766, ..., -42.30949766,\n",
+       "         -42.30949766, -42.30949766],\n",
+       "        [-42.43613053, -42.43613053, -42.43613053, ..., -42.43613053,\n",
+       "         -42.43613053, -42.43613053]]),\n",
+       " 'pLvl': array([[1.01      , 1.01      , 1.01      , ..., 1.01      , 1.01      ,\n",
+       "         1.01      ],\n",
+       "        [1.0201    , 1.0201    , 1.0201    , ..., 1.0201    , 1.0201    ,\n",
+       "         1.0201    ],\n",
+       "        [1.030301  , 1.030301  , 1.030301  , ..., 1.030301  , 1.030301  ,\n",
+       "         1.030301  ],\n",
        "        ...,\n",
-       "        [-21.97118426,  -9.62717581, -36.59971086, ...,   1.00376132,\n",
-       "          -2.81712554, -46.01045686],\n",
-       "        [-22.69456637, -10.66355594,   1.00072865, ...,  -0.30217974,\n",
-       "          -4.02618315, -46.12429267],\n",
-       "        [-23.39960622, -11.67365734,  -0.30513551, ...,  -1.575007  ,\n",
-       "          -5.20458357, -46.23524203]])}"
+       "        [3.23535623, 3.23535623, 3.23535623, ..., 3.23535623, 3.23535623,\n",
+       "         3.23535623],\n",
+       "        [3.2677098 , 3.2677098 , 3.2677098 , ..., 3.2677098 , 3.2677098 ,\n",
+       "         3.2677098 ],\n",
+       "        [3.30038689, 3.30038689, 3.30038689, ..., 3.30038689, 3.30038689,\n",
+       "         3.30038689]])}"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 62,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "PFexample.track_vars = [\"mNrm\"]\n",
+    "PFexample.track_vars = [\"mNrm\",\"pLvl\"]\n",
     "PFexample.initialize_sim()\n",
     "PFexample.simulate()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 63,
    "id": "3b126cc4",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -115,6 +172,66 @@
     "plt.show()"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "e0e3ac8d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(np.mean(PFexample.history[\"mNrm\"] * PFexample.history[\"pLvl\"], axis=1))\n",
+    "plt.xlabel(\"Time\")\n",
+    "plt.ylabel(\"Mean normalized market resources\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "d4a181a8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_11254/947589964.py:1: RuntimeWarning: divide by zero encountered in log\n",
+      "  plt.plot(np.log(np.mean(PFexample.history[\"mNrm\"], axis=1) - np.min(np.mean(PFexample.history[\"mNrm\"], axis=1))))\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(np.log(np.mean(PFexample.history[\"mNrm\"], axis=1) - np.min(np.mean(PFexample.history[\"mNrm\"], axis=1))))\n",
+    "plt.xlabel(\"Time\")\n",
+    "plt.ylabel(\"Mean normalized market resources\")\n",
+    "plt.show()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "0ead3ec8",
@@ -125,108 +242,77 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 70,
    "id": "adfbe431",
    "metadata": {},
    "outputs": [],
    "source": [
     "from HARK.distribution import Lognormal\n",
-    "import HARK.models.perfect_foresight as pf\n",
+    "import HARK.models.perfect_foresight_normalized as pfn\n",
     "from HARK.simulation.monte_carlo import AgentTypeMonteCarloSimulator"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 72,
    "id": "5a0c394b",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'shocks': {'live': <HARK.distribution.Bernoulli at 0x7f86ff5f3cd0>},\n",
+       "{'shocks': {'live': <HARK.distribution.Bernoulli at 0x7fa6f5a29030>},\n",
        " 'parameters': {'DiscFac': 0.96,\n",
        "  'CRRA': (2.0,),\n",
        "  'Rfree': 1.03,\n",
        "  'LivPrb': 0.98,\n",
        "  'PermGroFac': 1.01,\n",
        "  'BoroCnstArt': None},\n",
-       " 'dynamics': {'y': <function HARK.models.perfect_foresight.<lambda>(p)>,\n",
-       "  'm': <function HARK.models.perfect_foresight.<lambda>(Rfree, a, y)>,\n",
-       "  'c': <HARK.model.Control at 0x7f86ff4d25f0>,\n",
-       "  'p': <function HARK.models.perfect_foresight.<lambda>(PermGroFac, p)>,\n",
-       "  'a': <function HARK.models.perfect_foresight.<lambda>(m, c)>},\n",
-       " 'reward': {'u': <function HARK.models.perfect_foresight.<lambda>(c)>}}"
+       " 'dynamics': {'p': <function HARK.models.perfect_foresight_normalized.<lambda>(PermGroFac, p)>,\n",
+       "  'r_eff': <function HARK.models.perfect_foresight_normalized.<lambda>(Rfree, PermGroFac)>,\n",
+       "  'b_nrm': <function HARK.models.perfect_foresight_normalized.<lambda>(r_eff, a_nrm)>,\n",
+       "  'm_nrm': <function HARK.models.perfect_foresight_normalized.<lambda>(b_nrm)>,\n",
+       "  'c_nrm': <HARK.model.Control at 0x7fa6f6902380>,\n",
+       "  'a_nrm': <function HARK.models.perfect_foresight_normalized.<lambda>(m_nrm, c_nrm)>},\n",
+       " 'reward': {'u': <function HARK.models.perfect_foresight_normalized.<lambda>(c)>}}"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 72,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "pf.model"
+    "pfn.model"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "id": "e8201f3e",
+   "execution_count": 73,
+   "id": "08164ab2",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "2.6790219804335322"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "PFexample.solution[0].cFunc(10).tolist()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "7c65d4cc",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array(2.67902198)"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "## getting the decision rule from the original Perfect Foresight model\n",
-    "PFexample.solution[0].cFunc(10)"
+    "pfn.model['parameters']['LivPrb'] = 1.0\n",
+    "pfn.model['shocks'] = {'live' : Bernoulli(1.0)}"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 85,
    "id": "e9d068bd",
    "metadata": {},
    "outputs": [],
    "source": [
-    "pf_simulator = AgentTypeMonteCarloSimulator(\n",
-    "    pf.model['parameters'],\n",
-    "    pf.model['shocks'],\n",
-    "    pf.model['dynamics'],\n",
+    "pfn_simulator = AgentTypeMonteCarloSimulator(\n",
+    "    pfn.model['parameters'],\n",
+    "    pfn.model['shocks'],\n",
+    "    pfn.model['dynamics'],\n",
     "    {\n",
-    "        'c' : lambda m: PFexample.solution[0].cFunc(m)\n",
+    "        'c_nrm' : lambda m_nrm: PFexample.solution[0].cFunc(m_nrm)\n",
     "    },\n",
     "    { # initial states\n",
-    "        'a' : Lognormal(-6, 1),\n",
+    "        'a_nrm' : Lognormal(-6, 0),\n",
     "        'live' : 1,\n",
     "        'p' : 1.0\n",
     "    },\n",
@@ -238,7 +324,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 86,
    "id": "65df3a7f",
    "metadata": {},
    "outputs": [
@@ -252,45 +338,6 @@
        "        [1., 1., 1., ..., 1., 1., 1.],\n",
        "        [1., 1., 1., ..., 1., 1., 1.],\n",
        "        [1., 1., 1., ..., 1., 1., 1.]]),\n",
-       " 'y': array([[1.        , 1.        , 1.        , ..., 1.        , 1.        ,\n",
-       "         1.        ],\n",
-       "        [1.01      , 1.01      , 1.01      , ..., 1.01      , 1.01      ,\n",
-       "         1.01      ],\n",
-       "        [1.0201    , 1.0201    , 1.0201    , ..., 1.0201    , 1.0201    ,\n",
-       "         1.0201    ],\n",
-       "        ...,\n",
-       "        [1.08285671, 1.34784892, 1.69446581, ..., 3.203323  , 2.10912847,\n",
-       "         3.203323  ],\n",
-       "        [1.09368527, 1.3613274 , 1.71141047, ..., 3.23535623, 2.13021975,\n",
-       "         3.23535623],\n",
-       "        [1.10462213, 1.37494068, 1.72852457, ..., 3.2677098 , 2.15152195,\n",
-       "         3.2677098 ]]),\n",
-       " 'm': array([[  1.00289517,   1.00223716,   1.00484398, ...,   1.00168362,\n",
-       "           1.00071965,   1.00716025],\n",
-       "        [ -0.30605416,  -0.3067019 ,  -0.30413577, ...,  -0.3072468 ,\n",
-       "          -0.30819572,  -0.30185566],\n",
-       "        [ -1.58447101,  -1.58510864,  -1.58258257, ...,  -1.58564503,\n",
-       "          -1.58657914,  -1.58033805],\n",
-       "        ...,\n",
-       "        [ -8.63499874, -26.33490532, -33.32979358, ...,  -3.90476234,\n",
-       "         -30.84337272,  -3.90389321],\n",
-       "        [ -9.70981688, -26.86578873, -33.40140489, ...,  -2.91174772,\n",
-       "         -30.53498736,  -2.91089216],\n",
-       "        [-10.75692043, -27.37477187, -33.45478426, ...,  -1.90188034,\n",
-       "         -30.21011365,  -1.90103813]]),\n",
-       " 'c': array([[2.28061766, 2.28058852, 2.28070395, ..., 2.28056401, 2.28052132,\n",
-       "         2.28080652],\n",
-       "        [2.22265556, 2.22262688, 2.22274051, ..., 2.22260275, 2.22256073,\n",
-       "         2.22284147],\n",
-       "        [2.16604548, 2.16601725, 2.1661291 , ..., 2.16599349, 2.16595213,\n",
-       "         2.1662285 ],\n",
-       "        ...,\n",
-       "        [1.8538383 , 1.07006181, 0.76031842, ..., 2.06329975, 0.87042059,\n",
-       "         2.06333824],\n",
-       "        [1.80624386, 1.04655355, 0.75714737, ..., 2.10727182, 0.88407633,\n",
-       "         2.10730971],\n",
-       "        [1.75987666, 1.02401507, 0.75478366, ..., 2.15199016, 0.89846219,\n",
-       "         2.15202745]]),\n",
        " 'p': array([[1.01      , 1.01      , 1.01      , ..., 1.01      , 1.01      ,\n",
        "         1.01      ],\n",
        "        [1.0201    , 1.0201    , 1.0201    , ..., 1.0201    , 1.0201    ,\n",
@@ -298,47 +345,99 @@
        "        [1.030301  , 1.030301  , 1.030301  , ..., 1.030301  , 1.030301  ,\n",
        "         1.030301  ],\n",
        "        ...,\n",
-       "        [1.09368527, 1.3613274 , 1.71141047, ..., 3.23535623, 2.13021975,\n",
+       "        [3.23535623, 3.23535623, 3.23535623, ..., 3.23535623, 3.23535623,\n",
        "         3.23535623],\n",
-       "        [1.10462213, 1.37494068, 1.72852457, ..., 3.2677098 , 2.15152195,\n",
+       "        [3.2677098 , 3.2677098 , 3.2677098 , ..., 3.2677098 , 3.2677098 ,\n",
        "         3.2677098 ],\n",
-       "        [1.11566835, 1.38869009, 1.74580982, ..., 3.30038689, 2.17303717,\n",
+       "        [3.30038689, 3.30038689, 3.30038689, ..., 3.30038689, 3.30038689,\n",
        "         3.30038689]]),\n",
-       " 'a': array([[ -1.27772249,  -1.27835136,  -1.27585997, ...,  -1.27888039,\n",
-       "          -1.27980167,  -1.27364627],\n",
-       "        [ -2.52870972,  -2.52932877,  -2.52687628, ...,  -2.52984955,\n",
-       "          -2.53075645,  -2.52469714],\n",
-       "        [ -3.75051649,  -3.75112588,  -3.74871167, ...,  -3.75163853,\n",
-       "          -3.75253127,  -3.74656654],\n",
+       " 'r_eff': array([[1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
+       "         1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
+       "         1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
+       "         1.01980198],\n",
+       "        ...,\n",
+       "        [1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
+       "         1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
+       "         1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
+       "         1.01980198]]),\n",
+       " 'b_nrm': array([[ 2.52783638e-03,  2.52783638e-03,  2.52783638e-03, ...,\n",
+       "          2.52783638e-03,  2.52783638e-03,  2.52783638e-03],\n",
+       "        [-7.93759059e-01, -7.93759059e-01, -7.93759059e-01, ...,\n",
+       "         -7.93759059e-01, -7.93759059e-01, -7.93759059e-01],\n",
+       "        [-1.57773444e+00, -1.57773444e+00, -1.57773444e+00, ...,\n",
+       "         -1.57773444e+00, -1.57773444e+00, -1.57773444e+00],\n",
+       "        ...,\n",
+       "        [-4.31808761e+01, -4.31808761e+01, -4.31808761e+01, ...,\n",
+       "         -4.31808761e+01, -4.31808761e+01, -4.31808761e+01],\n",
+       "        [-4.33094977e+01, -4.33094977e+01, -4.33094977e+01, ...,\n",
+       "         -4.33094977e+01, -4.33094977e+01, -4.33094977e+01],\n",
+       "        [-4.34361305e+01, -4.34361305e+01, -4.34361305e+01, ...,\n",
+       "         -4.34361305e+01, -4.34361305e+01, -4.34361305e+01]]),\n",
+       " 'm_nrm': array([[  1.00252784,   1.00252784,   1.00252784, ...,   1.00252784,\n",
+       "           1.00252784,   1.00252784],\n",
+       "        [  0.20624094,   0.20624094,   0.20624094, ...,   0.20624094,\n",
+       "           0.20624094,   0.20624094],\n",
+       "        [ -0.57773444,  -0.57773444,  -0.57773444, ...,  -0.57773444,\n",
+       "          -0.57773444,  -0.57773444],\n",
        "        ...,\n",
-       "        [-10.48883704, -27.40496712, -34.090112  , ...,  -5.96806209,\n",
-       "         -31.71379332,  -5.96723145],\n",
-       "        [-11.51606074, -27.91234228, -34.15855226, ...,  -5.01901955,\n",
-       "         -31.41906369,  -5.01820187],\n",
-       "        [-12.51679709, -28.39878694, -34.20956791, ...,  -4.05387049,\n",
-       "         -31.10857584,  -4.05306558]])}"
+       "        [-42.18087615, -42.18087615, -42.18087615, ..., -42.18087615,\n",
+       "         -42.18087615, -42.18087615],\n",
+       "        [-42.30949766, -42.30949766, -42.30949766, ..., -42.30949766,\n",
+       "         -42.30949766, -42.30949766],\n",
+       "        [-42.43613053, -42.43613053, -42.43613053, ..., -42.43613053,\n",
+       "         -42.43613053, -42.43613053]]),\n",
+       " 'c_nrm': array([[1.7808741 , 1.7808741 , 1.7808741 , ..., 1.7808741 , 1.7808741 ,\n",
+       "         1.7808741 ],\n",
+       "        [1.75333976, 1.75333976, 1.75333976, ..., 1.75333976, 1.75333976,\n",
+       "         1.75333976],\n",
+       "        [1.72623113, 1.72623113, 1.72623113, ..., 1.72623113, 1.72623113,\n",
+       "         1.72623113],\n",
+       "        ...,\n",
+       "        [0.28766039, 0.28766039, 0.28766039, ..., 0.28766039, 0.28766039,\n",
+       "         0.28766039],\n",
+       "        [0.28321287, 0.28321287, 0.28321287, ..., 0.28321287, 0.28321287,\n",
+       "         0.28321287],\n",
+       "        [0.2788341 , 0.2788341 , 0.2788341 , ..., 0.2788341 , 0.2788341 ,\n",
+       "         0.2788341 ]]),\n",
+       " 'a_nrm': array([[ -0.77834626,  -0.77834626,  -0.77834626, ...,  -0.77834626,\n",
+       "          -0.77834626,  -0.77834626],\n",
+       "        [ -1.54709882,  -1.54709882,  -1.54709882, ...,  -1.54709882,\n",
+       "          -1.54709882,  -1.54709882],\n",
+       "        [ -2.30396557,  -2.30396557,  -2.30396557, ...,  -2.30396557,\n",
+       "          -2.30396557,  -2.30396557],\n",
+       "        ...,\n",
+       "        [-42.46853654, -42.46853654, -42.46853654, ..., -42.46853654,\n",
+       "         -42.46853654, -42.46853654],\n",
+       "        [-42.59271052, -42.59271052, -42.59271052, ..., -42.59271052,\n",
+       "         -42.59271052, -42.59271052],\n",
+       "        [-42.71496463, -42.71496463, -42.71496463, ..., -42.71496463,\n",
+       "         -42.71496463, -42.71496463]])}"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 86,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "#pf_simulator.track_vars = [\"mNrm\"]\n",
-    "pf_simulator.initialize_sim()\n",
-    "pf_simulator.simulate(sim_periods=120)"
+    "pfn_simulator.initialize_sim()\n",
+    "pfn_simulator.simulate(sim_periods=120)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 87,
    "id": "9e2c7ad0",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -350,7 +449,7 @@
     }
    ],
    "source": [
-    "plt.plot(np.mean(pf_simulator.history['m'], axis=1))\n",
+    "plt.plot(np.mean(pfn_simulator.history['m_nrm'], axis=1))\n",
     "plt.xlabel(\"Time\")\n",
     "plt.ylabel(\"Mean normalized market resources\")\n",
     "plt.show()"
@@ -358,23 +457,57 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 88,
+   "id": "6b3b4811",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_11254/2889722531.py:1: RuntimeWarning: divide by zero encountered in log\n",
+      "  plt.plot(np.log(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1) - np.min(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1))))\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(np.log(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1) - np.min(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1))))\n",
+    "plt.xlabel(\"Time\")\n",
+    "plt.ylabel(\"Mean normalized market resources\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
    "id": "464f19e7",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f86f968eb60>]"
+       "[<matplotlib.lines.Line2D at 0x7fa6f68e2410>]"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 89,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -386,8 +519,72 @@
     }
    ],
    "source": [
-    "plt.plot(pf_simulator.history['live'].sum(axis=1))"
+    "plt.plot(pfn_simulator.history['live'].sum(axis=1))"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "id": "3c721410",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(np.mean(pfn_simulator.history['m_nrm'], axis=1), label = 'Generic monte carlo')\n",
+    "plt.plot(np.mean(PFexample.history[\"mNrm\"], axis=1), label = 'HARK 0.13 PerfForesightConsumerType')\n",
+    "plt.xlabel(\"Time\")\n",
+    "plt.ylabel(\"Mean normalized market resources\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 93,
+   "id": "38bce0b9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0.])"
+      ]
+     },
+     "execution_count": 93,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.mean(pfn_simulator.history['m_nrm'], axis=1) - np.mean(PFexample.history[\"mNrm\"], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c0e622a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

From 799de9a3462c9d00f39d66af4040bf89c20aab7a Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Tue, 17 Oct 2023 18:10:05 -0400
Subject: [PATCH 20/27] put loading initial values to newborns with read_shocks
 into sim_birth

---
 HARK/simulation/monte_carlo.py                |  32 +-
 ...eneric Monte Carlo Perfect Foresight.ipynb | 382 +++++++++++-------
 2 files changed, 256 insertions(+), 158 deletions(-)

diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index acfa93578..93b4605cd 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -384,21 +384,7 @@ def get_mortality(self):
         """
         who_dies = self.vars_now['live'] <= 0
 
-        if self.read_shocks:
-            # Instead of simulating births, assign the saved newborn initial conditions
-            if np.sum(who_dies) > 0:
-                for var_name in self.initial:
-                    self.vars_now[var_name][
-                        who_dies
-                    ] = self.newborn_init_history[var_name][
-                        self.t_sim, who_dies
-                    ]
-
-                # Reset ages of newborns
-                self.t_age[who_dies] = 0
-                self.t_cycle[who_dies] = 0
-        else:
-            self.sim_birth(who_dies)
+        self.sim_birth(who_dies)
 
         self.who_dies = who_dies
         return None
@@ -418,20 +404,26 @@ def sim_birth(self, which_agents):
         None
         """
         if self.read_shocks:
+            t = self.t_sim - 1 if self.t_sim > 0 else 0
             initial_vals = {
-                init_var: self.newborn_init_history[init_var][self.t_sim, :]
+                init_var: self.newborn_init_history[init_var][t, which_agents]
                 for init_var
                 in self.initial
-                }
+            }
+
         else:
             initial_vals = draw_shocks(
                 self.initial,
                 np.zeros(which_agents.sum())
             )
 
-        for varn in initial_vals:
-            self.vars_now[varn][which_agents] = initial_vals[varn]
-            self.newborn_init_history[varn][self.t_sim, which_agents] = initial_vals[varn]
+        if np.sum(which_agents) > 0:
+            for varn in initial_vals:
+                self.vars_now[varn][which_agents] = initial_vals[varn]
+                self.newborn_init_history[varn][self.t_sim, which_agents] = initial_vals[varn]
+
+        self.t_age[which_agents] = 0
+        self.t_cycle[which_agents] = 0
 
     def simulate(self, sim_periods=None):
         """
diff --git a/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb b/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb
index 5583edc51..3894c3da5 100644
--- a/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb	
+++ b/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb	
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 1,
    "id": "be704ca8",
    "metadata": {},
    "outputs": [],
@@ -24,7 +24,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 2,
    "id": "83e6f76e",
    "metadata": {},
    "outputs": [],
@@ -41,7 +41,7 @@
     "    \"pLvlInitStd\": 0.0,  # Standard deviation of log initial permanent income\n",
     "    \"PermGroFacAgg\": 1.0,  # Aggregate permanent income growth factor\n",
     "    \"T_age\": None,  # Age after which simulated agents are automatically killed,\n",
-    "    \"LivPrb\": [1.0] # [0.98]\n",
+    "    \"LivPrb\": [0.98]\n",
     "}\n",
     "\n",
     "PFexample.assign_parameters(**SimulationParams)"
@@ -49,31 +49,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 3,
    "id": "e0f219ec",
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "PFexample.solve()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "id": "312a516e",
+   "execution_count": 4,
+   "id": "c3981c6d",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<HARK.ConsumptionSaving.ConsIndShockModel.PerfForesightConsumerType object at 0x7fa6f7367220.\n",
+       "<HARK.ConsumptionSaving.ConsIndShockModel.PerfForesightConsumerType object at 0x7f81cd8bae60.\n",
        "Parameters:\n",
        "cycles: 1\n",
        "CRRA: 2.0\n",
        "Rfree: 1.03\n",
        "DiscFac: 0.96\n",
-       "LivPrb: [1.0]\n",
+       "LivPrb: [0.98]\n",
        "PermGroFac: [1.01]\n",
        "BoroCnstArt: None\n",
        "MaxKinks: 400\n",
@@ -89,7 +88,7 @@
        "T_sim: 120>"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -100,26 +99,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 62,
+   "execution_count": 5,
    "id": "66cc08fb",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'mNrm': array([[  1.00252784,   1.00252784,   1.00252784, ...,   1.00252784,\n",
+       "{'who_dies': array([[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        ...,\n",
+       "        [0., 0., 0., ..., 1., 0., 0.],\n",
+       "        [0., 0., 1., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]]),\n",
+       " 'mNrm': array([[  1.00252784,   1.00252784,   1.00252784, ...,   1.00252784,\n",
        "           1.00252784,   1.00252784],\n",
-       "        [  0.20624094,   0.20624094,   0.20624094, ...,   0.20624094,\n",
-       "           0.20624094,   0.20624094],\n",
-       "        [ -0.57773444,  -0.57773444,  -0.57773444, ...,  -0.57773444,\n",
-       "          -0.57773444,  -0.57773444],\n",
+       "        [ -0.30338194,  -0.30338194,  -0.30338194, ...,  -0.30338194,\n",
+       "          -0.30338194,  -0.30338194],\n",
+       "        [ -1.57617872,  -1.57617872,  -1.57617872, ...,  -1.57617872,\n",
+       "          -1.57617872,  -1.57617872],\n",
        "        ...,\n",
-       "        [-42.18087615, -42.18087615, -42.18087615, ..., -42.18087615,\n",
-       "         -42.18087615, -42.18087615],\n",
-       "        [-42.30949766, -42.30949766, -42.30949766, ..., -42.30949766,\n",
-       "         -42.30949766, -42.30949766],\n",
-       "        [-42.43613053, -42.43613053, -42.43613053, ..., -42.43613053,\n",
-       "         -42.43613053, -42.43613053]]),\n",
+       "        [-21.97112221,  -9.62650475, -36.60139796, ...,   1.00252784,\n",
+       "          -2.81670212, -46.01051785],\n",
+       "        [-22.6945059 , -10.6629019 ,   1.00252784, ...,  -0.30338194,\n",
+       "          -4.02577047, -46.12435211],\n",
+       "        [-23.39954727, -11.67301988,  -0.30338194, ...,  -1.57617872,\n",
+       "          -5.20418135, -46.23529996]]),\n",
        " 'pLvl': array([[1.01      , 1.01      , 1.01      , ..., 1.01      , 1.01      ,\n",
        "         1.01      ],\n",
        "        [1.0201    , 1.0201    , 1.0201    , ..., 1.0201    , 1.0201    ,\n",
@@ -127,34 +133,36 @@
        "        [1.030301  , 1.030301  , 1.030301  , ..., 1.030301  , 1.030301  ,\n",
        "         1.030301  ],\n",
        "        ...,\n",
-       "        [3.23535623, 3.23535623, 3.23535623, ..., 3.23535623, 3.23535623,\n",
-       "         3.23535623],\n",
-       "        [3.2677098 , 3.2677098 , 3.2677098 , ..., 3.2677098 , 3.2677098 ,\n",
-       "         3.2677098 ],\n",
-       "        [3.30038689, 3.30038689, 3.30038689, ..., 3.30038689, 3.30038689,\n",
-       "         3.30038689]])}"
+       "        [1.26973465, 1.10462213, 1.67768892, ..., 1.01      , 1.04060401,\n",
+       "         2.59927293],\n",
+       "        [1.282432  , 1.11566835, 1.01      , ..., 1.0201    , 1.05101005,\n",
+       "         2.62526565],\n",
+       "        [1.29525631, 1.12682503, 1.0201    , ..., 1.030301  , 1.06152015,\n",
+       "         2.65151831]])}"
       ]
      },
-     "execution_count": 62,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "PFexample.track_vars = [\"mNrm\",\"pLvl\"]\n",
+    "PFexample.track_vars = [\"who_dies\",\"mNrm\",\"pLvl\"]\n",
+    "PFexample.make_shock_history()\n",
+    "\n",
     "PFexample.initialize_sim()\n",
     "PFexample.simulate()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": 6,
    "id": "3b126cc4",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -174,13 +182,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 64,
-   "id": "e0e3ac8d",
+   "execution_count": 7,
+   "id": "633034d3",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -200,21 +208,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 65,
-   "id": "d4a181a8",
+   "execution_count": 8,
+   "id": "bb741c54",
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/tmp/ipykernel_11254/947589964.py:1: RuntimeWarning: divide by zero encountered in log\n",
+      "/tmp/ipykernel_82097/947589964.py:1: RuntimeWarning: divide by zero encountered in log\n",
       "  plt.plot(np.log(np.mean(PFexample.history[\"mNrm\"], axis=1) - np.min(np.mean(PFexample.history[\"mNrm\"], axis=1))))\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -232,6 +240,69 @@
     "plt.show()"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "31ec9e16",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0., 0., 0., ..., 0., 0., 0.])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "PFexample.history[\"who_dies\"][0,:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "603ae6e5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(203,)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "PFexample.newborn_init_history['pLvl'][1,PFexample.history[\"who_dies\"][1,:] > 0].shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "567440dd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(181,)"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "PFexample.newborn_init_history['aNrm'][2, PFexample.history[\"who_dies\"][2,:] > 0].shape"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "0ead3ec8",
@@ -242,7 +313,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 12,
    "id": "adfbe431",
    "metadata": {},
    "outputs": [],
@@ -254,14 +325,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 72,
+   "execution_count": 13,
    "id": "5a0c394b",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'shocks': {'live': <HARK.distribution.Bernoulli at 0x7fa6f5a29030>},\n",
+       "{'shocks': {'live': <HARK.distribution.Bernoulli at 0x7f81cd6c33d0>},\n",
        " 'parameters': {'DiscFac': 0.96,\n",
        "  'CRRA': (2.0,),\n",
        "  'Rfree': 1.03,\n",
@@ -272,12 +343,12 @@
        "  'r_eff': <function HARK.models.perfect_foresight_normalized.<lambda>(Rfree, PermGroFac)>,\n",
        "  'b_nrm': <function HARK.models.perfect_foresight_normalized.<lambda>(r_eff, a_nrm)>,\n",
        "  'm_nrm': <function HARK.models.perfect_foresight_normalized.<lambda>(b_nrm)>,\n",
-       "  'c_nrm': <HARK.model.Control at 0x7fa6f6902380>,\n",
+       "  'c_nrm': <HARK.model.Control at 0x7f81cd53bfa0>,\n",
        "  'a_nrm': <function HARK.models.perfect_foresight_normalized.<lambda>(m_nrm, c_nrm)>},\n",
        " 'reward': {'u': <function HARK.models.perfect_foresight_normalized.<lambda>(c)>}}"
       ]
      },
-     "execution_count": 72,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -288,18 +359,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 73,
-   "id": "08164ab2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pfn.model['parameters']['LivPrb'] = 1.0\n",
-    "pfn.model['shocks'] = {'live' : Bernoulli(1.0)}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 85,
+   "execution_count": 14,
    "id": "e9d068bd",
    "metadata": {},
    "outputs": [],
@@ -313,18 +373,40 @@
     "    },\n",
     "    { # initial states\n",
     "        'a_nrm' : Lognormal(-6, 0),\n",
-    "        'live' : 1,\n",
+    "        #'live' : 1,\n",
     "        'p' : 1.0\n",
     "    },\n",
     "    agent_count = 10000,\n",
     "    T_sim = 120\n",
-    ")\n",
-    "\n"
+    ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 86,
+   "execution_count": 15,
+   "id": "36ba1dda",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pfn_simulator.read_shocks = True\n",
+    "pfn_simulator.shock_history['live'] = 1 - PFexample.history[\"who_dies\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "bc84d3e5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pfn_simulator.newborn_init_history['a_nrm'] = PFexample.newborn_init_history['aNrm']\n",
+    "pfn_simulator.newborn_init_history['p'] = PFexample.newborn_init_history['pLvl']\n",
+    "#pfn_simulator.newborn_init_history['live'] = np.ones(PFexample.newborn_init_history['pLvl'].shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
    "id": "65df3a7f",
    "metadata": {},
    "outputs": [
@@ -335,8 +417,8 @@
        "        [1., 1., 1., ..., 1., 1., 1.],\n",
        "        [1., 1., 1., ..., 1., 1., 1.],\n",
        "        ...,\n",
-       "        [1., 1., 1., ..., 1., 1., 1.],\n",
-       "        [1., 1., 1., ..., 1., 1., 1.],\n",
+       "        [1., 1., 1., ..., 0., 1., 1.],\n",
+       "        [1., 1., 0., ..., 1., 1., 1.],\n",
        "        [1., 1., 1., ..., 1., 1., 1.]]),\n",
        " 'p': array([[1.01      , 1.01      , 1.01      , ..., 1.01      , 1.01      ,\n",
        "         1.01      ],\n",
@@ -345,12 +427,12 @@
        "        [1.030301  , 1.030301  , 1.030301  , ..., 1.030301  , 1.030301  ,\n",
        "         1.030301  ],\n",
        "        ...,\n",
-       "        [3.23535623, 3.23535623, 3.23535623, ..., 3.23535623, 3.23535623,\n",
-       "         3.23535623],\n",
-       "        [3.2677098 , 3.2677098 , 3.2677098 , ..., 3.2677098 , 3.2677098 ,\n",
-       "         3.2677098 ],\n",
-       "        [3.30038689, 3.30038689, 3.30038689, ..., 3.30038689, 3.30038689,\n",
-       "         3.30038689]]),\n",
+       "        [1.25716302, 1.09368527, 1.66107814, ..., 2.54805698, 1.030301  ,\n",
+       "         2.57353755],\n",
+       "        [1.26973465, 1.10462213, 1.67768892, ..., 1.01      , 1.04060401,\n",
+       "         2.59927293],\n",
+       "        [1.282432  , 1.11566835, 1.01      , ..., 1.0201    , 1.05101005,\n",
+       "         2.62526565]]),\n",
        " 'r_eff': array([[1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
        "         1.01980198],\n",
        "        [1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
@@ -366,59 +448,59 @@
        "         1.01980198]]),\n",
        " 'b_nrm': array([[ 2.52783638e-03,  2.52783638e-03,  2.52783638e-03, ...,\n",
        "          2.52783638e-03,  2.52783638e-03,  2.52783638e-03],\n",
-       "        [-7.93759059e-01, -7.93759059e-01, -7.93759059e-01, ...,\n",
-       "         -7.93759059e-01, -7.93759059e-01, -7.93759059e-01],\n",
-       "        [-1.57773444e+00, -1.57773444e+00, -1.57773444e+00, ...,\n",
-       "         -1.57773444e+00, -1.57773444e+00, -1.57773444e+00],\n",
+       "        [-1.30338194e+00, -1.30338194e+00, -1.30338194e+00, ...,\n",
+       "         -1.30338194e+00, -1.30338194e+00, -1.30338194e+00],\n",
+       "        [-2.57617872e+00, -2.57617872e+00, -2.57617872e+00, ...,\n",
+       "         -2.57617872e+00, -2.57617872e+00, -2.57617872e+00],\n",
        "        ...,\n",
-       "        [-4.31808761e+01, -4.31808761e+01, -4.31808761e+01, ...,\n",
-       "         -4.31808761e+01, -4.31808761e+01, -4.31808761e+01],\n",
-       "        [-4.33094977e+01, -4.33094977e+01, -4.33094977e+01, ...,\n",
-       "         -4.33094977e+01, -4.33094977e+01, -4.33094977e+01],\n",
-       "        [-4.34361305e+01, -4.34361305e+01, -4.34361305e+01, ...,\n",
-       "         -4.34361305e+01, -4.34361305e+01, -4.34361305e+01]]),\n",
+       "        [-2.22289190e+01, -9.56314476e+00, -3.72398151e+01, ...,\n",
+       "         -4.67738878e+01, -2.57617872e+00, -4.68937221e+01],\n",
+       "        [-2.29711222e+01, -1.06265047e+01, -3.76013980e+01, ...,\n",
+       "          2.52783638e-03, -3.81670212e+00, -4.70105178e+01],\n",
+       "        [-2.36945059e+01, -1.16629019e+01,  2.52783638e-03, ...,\n",
+       "         -1.30338194e+00, -5.02577047e+00, -4.71243521e+01]]),\n",
        " 'm_nrm': array([[  1.00252784,   1.00252784,   1.00252784, ...,   1.00252784,\n",
        "           1.00252784,   1.00252784],\n",
-       "        [  0.20624094,   0.20624094,   0.20624094, ...,   0.20624094,\n",
-       "           0.20624094,   0.20624094],\n",
-       "        [ -0.57773444,  -0.57773444,  -0.57773444, ...,  -0.57773444,\n",
-       "          -0.57773444,  -0.57773444],\n",
+       "        [ -0.30338194,  -0.30338194,  -0.30338194, ...,  -0.30338194,\n",
+       "          -0.30338194,  -0.30338194],\n",
+       "        [ -1.57617872,  -1.57617872,  -1.57617872, ...,  -1.57617872,\n",
+       "          -1.57617872,  -1.57617872],\n",
        "        ...,\n",
-       "        [-42.18087615, -42.18087615, -42.18087615, ..., -42.18087615,\n",
-       "         -42.18087615, -42.18087615],\n",
-       "        [-42.30949766, -42.30949766, -42.30949766, ..., -42.30949766,\n",
-       "         -42.30949766, -42.30949766],\n",
-       "        [-42.43613053, -42.43613053, -42.43613053, ..., -42.43613053,\n",
-       "         -42.43613053, -42.43613053]]),\n",
-       " 'c_nrm': array([[1.7808741 , 1.7808741 , 1.7808741 , ..., 1.7808741 , 1.7808741 ,\n",
-       "         1.7808741 ],\n",
-       "        [1.75333976, 1.75333976, 1.75333976, ..., 1.75333976, 1.75333976,\n",
-       "         1.75333976],\n",
-       "        [1.72623113, 1.72623113, 1.72623113, ..., 1.72623113, 1.72623113,\n",
-       "         1.72623113],\n",
+       "        [-21.22891902,  -8.56314476, -36.23981511, ..., -45.77388776,\n",
+       "          -1.57617872, -45.89372208],\n",
+       "        [-21.97112221,  -9.62650475, -36.60139796, ...,   1.00252784,\n",
+       "          -2.81670212, -46.01051785],\n",
+       "        [-22.6945059 , -10.6629019 ,   1.00252784, ...,  -0.30338194,\n",
+       "          -4.02577047, -46.12435211]]),\n",
+       " 'c_nrm': array([[2.28060139, 2.28060139, 2.28060139, ..., 2.28060139, 2.28060139,\n",
+       "         2.28060139],\n",
+       "        [2.22277389, 2.22277389, 2.22277389, ..., 2.22277389, 2.22277389,\n",
+       "         2.22277389],\n",
+       "        [2.16641268, 2.16641268, 2.16641268, ..., 2.16641268, 2.16641268,\n",
+       "         2.16641268],\n",
        "        ...,\n",
-       "        [0.28766039, 0.28766039, 0.28766039, ..., 0.28766039, 0.28766039,\n",
-       "         0.28766039],\n",
-       "        [0.28321287, 0.28321287, 0.28321287, ..., 0.28321287, 0.28321287,\n",
-       "         0.28321287],\n",
-       "        [0.2788341 , 0.2788341 , 0.2788341 , ..., 0.2788341 , 0.2788341 ,\n",
-       "         0.2788341 ]]),\n",
-       " 'a_nrm': array([[ -0.77834626,  -0.77834626,  -0.77834626, ...,  -0.77834626,\n",
-       "          -0.77834626,  -0.77834626],\n",
-       "        [ -1.54709882,  -1.54709882,  -1.54709882, ...,  -1.54709882,\n",
-       "          -1.54709882,  -1.54709882],\n",
-       "        [ -2.30396557,  -2.30396557,  -2.30396557, ...,  -2.30396557,\n",
-       "          -2.30396557,  -2.30396557],\n",
+       "        [1.29616199, 1.8570201 , 0.63145862, ..., 0.20927661, 2.16641268,\n",
+       "         0.20397018],\n",
+       "        [1.26329619, 1.80993304, 0.61544722, ..., 2.28060139, 2.11148057,\n",
+       "         0.1987983 ],\n",
+       "        [1.23126376, 1.76403993, 2.28060139, ..., 2.22277389, 2.05794134,\n",
+       "         0.19375756]]),\n",
+       " 'a_nrm': array([[ -1.27807355,  -1.27807355,  -1.27807355, ...,  -1.27807355,\n",
+       "          -1.27807355,  -1.27807355],\n",
+       "        [ -2.52615583,  -2.52615583,  -2.52615583, ...,  -2.52615583,\n",
+       "          -2.52615583,  -2.52615583],\n",
+       "        [ -3.74259139,  -3.74259139,  -3.74259139, ...,  -3.74259139,\n",
+       "          -3.74259139,  -3.74259139],\n",
        "        ...,\n",
-       "        [-42.46853654, -42.46853654, -42.46853654, ..., -42.46853654,\n",
-       "         -42.46853654, -42.46853654],\n",
-       "        [-42.59271052, -42.59271052, -42.59271052, ..., -42.59271052,\n",
-       "         -42.59271052, -42.59271052],\n",
-       "        [-42.71496463, -42.71496463, -42.71496463, ..., -42.71496463,\n",
-       "         -42.71496463, -42.71496463]])}"
+       "        [-22.525081  , -10.42016485, -36.87127373, ..., -45.98316437,\n",
+       "          -3.74259139, -46.09769226],\n",
+       "        [-23.2344184 , -11.43643779, -37.21684518, ...,  -1.27807355,\n",
+       "          -4.92818269, -46.20931615],\n",
+       "        [-23.92576966, -12.42694183,  -1.27807355, ...,  -2.52615583,\n",
+       "          -6.08371181, -46.31810967]])}"
       ]
      },
-     "execution_count": 86,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -431,13 +513,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 87,
+   "execution_count": 21,
    "id": "9e2c7ad0",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEGCAYAAACO8lkDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAre0lEQVR4nO3dd3wc9Z3/8ddHqy5Zkossucu9G4MFNt1U41AcCCQQkstRQvnljiTkcglHSLvk7hIScnfJESBAAqGFUEIJzRBaKDY2GFuuuGIbF7nKkmy1/fz+2DUIy2VkaTW70vv5eMzDO7OrnfcwRh/Pd77z/Zq7IyIi0lxa2AFERCT5qDiIiEgLKg4iItKCioOIiLSg4iAiIi2khx2gPfTq1cvLysrCjiEiklLmzp27xd2L9/depygOZWVlzJkzJ+wYIiIpxczWHOg9NSuJiEgLKg4iItKCioOIiLSg4iAiIi2oOIiISAsqDiIi0oKKg4iItNCli8P6Hbv52XNL2LhzT9hRRESSSpcuDjV1jfz2lRW8vHRz2FFERJJKly4Ow3vn068oh5eXqDiIiDTXpYuDmTF1ZDFvLN9CXWNT2HFERJJGly4OAKeM7E1NfRNzVm8PO4qISNJI2uJgZmeZ2VIzW25m303Ufo4b1pPMSJqalkREmknK4mBmEeD/gOnAGOASMxuTiH3lZqYzeUgP3ZQWEWkmKYsDcAyw3N1Xuns98BAwI1E7O2Vkb1ZU1vDh1tpE7UJEJKUka3HoB6xttr4uvu1jZnaVmc0xszmVlZVt2tkpo3oD8MoyXT2IiEDyFodDcvc73L3c3cuLi/c7kVFgg3vlUdYzl7/pvoOICJC8xWE9MKDZev/4toQ5ZVRv3lqxldr6xkTuRkQkJSRrcXgHGG5mg80sE7gYeDKROzx9dAl1jVH+/sGWRO5GRCQlJGVxcPdG4J+A54HFwMPuvjCR+zy6rAfdstJ5abGalkRE0sMOcCDu/gzwTEftLzM9jZNGFvPSks1Eo05amnXUrkVEkk6rrhzMrLuZTUhUmLCdMbqELdV1zF+/M+woIiKhOmRxMLNXzKzAzHoA7wK/M7NbEh+t400dWUwkzXhx0aawo4iIhCrIlUOhu1cBFwD3uvtk4PTExgpHUW4mkwZ158XFKg4i0rUFKQ7pZtYH+DzwdILzhO6M0SUs2biLddv1tLSIdF1BisOPifUaWuHu75jZEOCDxMYKz2mjY09Lq2lJRLqyQxYHd/+zu09w92vj6yvd/XOJjxaOIcX5DC3OY6aalkSkCwtyQ3qEmb1kZhXx9Qlm9r3ERwvPtLGlvL1yGztq68OOIiISiiDNSr8DbgAaANx9PrEnljutM8eW0hR1jbUkIl1WkOKQ6+6z99nWqQcgmtCvkNKCbF5YqKYlEemaghSHLWY2FHAAM7sQ2JDQVCFLSzPOGFPCq8sq2dOguaVFpOsJUhy+BtwOjDKz9cA3gGsTGSoZTBtbyu6GJl7XQHwi0gUF6a200t1PB4qBUe5+gruvTniykE0e0oNu2ek8v3Bj2FFERDpckN5K/2FmRe5e4+674uMr/aQjwoUpI5LGaaN689LiTTQ2RcOOIyLSoYI0K0139x17V9x9O/CZhCVKImeN68P22gbeXrkt7CgiIh0qSHGImFnW3hUzywGyDvL5TmPqyGJyMyM8U9Gp77+LiLQQpDjcD7xkZleY2RXATOCexMZKDtkZEU4d1ZvnKzaqaUlEupSDFgczM+AB4CfA6Pjy7+7+8w7IlhTOHt+HrTX1zF6lpiUR6ToOOhOcu7uZPePu44HnOihTUpk6sjc5GbGmpeOG9Qo7johIhwjSrPSumR2d8CRJKicz1rT0XMUmmqIedhwRkQ4RpDhMBt4ysxVmNt/MFpjZ/EQHSybTx5eypbqOd1araUlEuoaDNivFTUt4iiR36qjeZGek8fT8j5gypGfYcUREEi7IlYMfYOkycjPTOW1UCc8uUK8lEekaghSHvxKbHvSvwEvASuDZRIZKRuceEeu19NbKrWFHERFJuCBjK42PzwQ33t2HA8cAbyU+WnKZOrI3+VnpPPX+R2FHERFJuCBXDp/i7u8Su0ndpWRnRDhzbAnPVWykrlHDeItI53bIG9Jmdn2z1TTgKKBL/vP53CP68ti763l92RZOH1MSdhwRkYQJcuXQrdmSRezew4xEBTKzH5rZejObF1+SZpC/E4b1oig3g6fmd8naKCJdyCGvHNz9RwBmlh9fr050KOBX7v6LDthPq2RE0pg+rg9PzFvP7vomcjIjYUcSEUmIIPM5jDOz94CFwEIzm2tm4xIfLTmdd0RfauubmLlY80uLSOcVpFnpDuB6dx/k7oOAb8W3JdI/xZ/GvtvMuu/vA2Z2lZnNMbM5lZWVCY7zicmDe9CnMJvH313XYfsUEeloQYpDnru/vHfF3V8B8tqyUzN70cwq9rPMAH4LDAUmAhuAX+7vO9z9Dncvd/fy4uLitsRplbQ0Y8bEfrz2wRa2VNd12H5FRDpSkOKw0sxuMrOy+PI9Yg/CHTZ3P93dx+1necLdN7l7k7tHgd8Re64iqZx/ZD+aos7TeuZBRDqpIMXhcqAYeCy+9IpvSwgz69Ns9XygIlH7OlwjS7sxpk8Bj89TcRCRzilIb6XtwHUAZhYh1sxUlcBMPzezicTGb1oNXJ3AfR2284/sx0+fWczKymqGFOeHHUdEpF0F6a30gJkVmFkesABYZGbfTlQgd/9ysyE7znP3pJzA+byJfTGDv7y3PuwoIiLtLkiz0pj4lcJniQ24Nxj4ciJDpYKSgmyOH9qLx95bT1STAIlIJxOkOGSYWQax4vCkuzfQxYbsPpALJ/Vn3fbdzNL80iLSyQQpDrcTa/vPA14zs0FAIu85pIxpY0vJz0rnUT3zICKdTJAhu//X3fu5+2c8Zg1wSgdkS3o5mRHOHt+HZxZsoKauMew4IiLtJsgN6RIzu8vMno2vjwG+kvBkKeLC8v7U1jfxXMXGsKOIiLSbIM1KfwCeB/rG15cB30hQnpRTPqg7g3rm8shcNS2JSOcRpDj0cveHgSiAuzcCmu0mzsz43FH9eWvlVtZuqw07johIuwhSHGrMrCfxHkpmNgXYmdBUKebCSf1JM3jonQ/DjiIi0i6CFIfrgSeBoWb2BnAv8M8JTZVi+hblcOqo3vzpnXXUN0bDjiMi0mYHLQ7x4TJOji/HERvKYqy7z++AbCnl0smD2FJdx8xFmudBRFLfQYuDuzcBl7h7o7svdPeK+ENwso+TRhTTryiH+2etCTuKiEibBWlWesPMfmNmJ5rZUXuXhCdLMZE044uTB/Lmiq2sqOyImVRFRBInSHGYCIwFfkxs4p1fAkk3v3MyuKi8P+lpxgOzdGNaRFJbkCG79TR0QL27ZTNtbCmPzF3Ht6eNJDsjEnYkEZHDEuTKQVrh0ikD2bm7gafnJ+VI4yIigag4tLNjh/RkaHEef3xbN6ZFJHUFGVspK8g2iTEzvjRlEO+v3cGCdXpWUERSU5Arh7cCbpO4C47qT05GhPt09SAiKeqAxcHMSs1sEpBjZkc268Y6FcjtqICpqDAngxkT+/LE++vZuVuPhYhI6jnYlcM0Yl1W+wO38Ek31m8C/5b4aKntS1MGsachyp/nrA07iohIqx2wK6u73wPcY2afc/dHOzBTpzCuXyFHl3XnD2+u5rLjBxNJs7AjiYgEFvQJ6U9N9mNmVyQ4V6dw+fGDWbd9t8ZbEpGUE6Q4/B5N9nNYzhhTQr+iHO5+Y1XYUUREWkWT/SRQeiSNfzyujNmrtlGxXt1aRSR1aLKfBPv80QPIzYzo6kFEUkook/2Y2UVmttDMomZWvs97N5jZcjNbambT2rKfZFCYk8FFk/rz1PsfsblqT9hxREQCCVIctrPPZD9AW5+QrgAuAF5rvtHMxgAXx/dxFnBrfMKhlHbZ8YNpjDr3vLU67CgiIoEEKQ6PACV7J/sBjgXubstO3X2xuy/dz1szgIfcvc7dVwHLgWPasq9kUNYrjzPHlHD/rA+prW8MO46IyCEFKQ7XAH+JPzH9GeDXwGcSlKcf0PypsXXxbSnvqycOYUdtA4/OXRd2FBGRQwoyn8M7ZnYd8AKwBzjd3SsP9XNm9iJQup+3bnT3J1qdtOX3XwVcBTBw4MC2fl3CTRrUnSMGFHHX31fxxcmD9FCciCS1AxYHM3uKeA+luFxivZTuMjPc/byDfbG7n34YedYDA5qt949v29/33wHcAVBeXu77+0wyMTO+euJg/umB93hx8Samjd1f3RQRSQ4Hu3IIYyrQJ4EHzOwWYg/dDQdmh5AjIc4aW8qAHjnc9uoKzhxTgpmuHkQkOR1sbKVX4z2FXmzvqULN7Hxi9y6Kgb+a2Tx3n+buC83sYWAR0Ah8zd07zQN36ZE0rjpxCDc9sZDZq7YxeUjPsCOJiOzXQW9Ix38xR82ssD136u6Pu3t/d89y9xJ3n9bsvZ+6+1B3H+nuz7bnfpPBReUD6JmXyW2vrgg7iojIAR3yhjRQDSwws5lAzd6N7n5dwlJ1YtkZES47voxfvLCMxRuqGN2nIOxIIiItBOnK+hhwE7EH1uY2W+QwfXlKGXmZEV09iEjSCtKV9Z6OCNKVFOZmcOmUQdz191Vcf8YIBvXMCzuSiMinHPLKwcyGm9kjZrbIzFbuXToiXGd25QmDSU8zbn1ZVw8iknyCzufwW2K9h04hNvDefYkM1RX0LsjmkmMG8ui761i7rTbsOCIinxKkOOS4+0uAufsad/8hcHZiY3UNV588hDQzfqt7DyKSZIIUhzozSwM+MLN/ij+jkJ/gXF1Cn8IcPn90f/48Zy0f7dgddhwRkY8FKQ5fJzZ0xnXAJODLwFcSGaoruXbqMABufWV5yElERD5xyOLg7u+4e7W7r3P3y9z9And/uyPCdQX9inL4wtEDeGj2WtZsrTn0D4iIdIAgvZXKzexxM3vXzObvXToiXFdx3anDSY8Y//3iB2FHEREBgj0hfT/wbWABEE1snK6pd0E2XzmujDteW8nVJw9hVKmemhaRcAW551Dp7k+6+6p4b6U17r4m4cm6mGtPHkp+Vjq/eH5Z2FFERAIVhx+Y2Z1mdomZXbB3SXiyLqYoN5OrTxrCi4s3MXfNtrDjiEgXF6Q4XAZMBM4Czo0v5yQwU5d1+QmDKe6WxX89uwT3pJ+/SEQ6sSD3HI5295EJTyLkZqbzjdOHc+PjFby0eDOnjykJO5KIdFFBrhzeNLMxCU8iAHy+fABDeuXxs+eW0BTV1YOIhCNIcZgCzDOzpfFurAvUlTVxMiJpfHvaSD7YXM2jc9eFHUdEuqggzUpnJTyFfMpZ40qZOKCIX85cyjlH9CE3M8hpEhFpP0GekF6zv6UjwnVVZsb3zh7Npqo67nx9VdhxRKQLCtKsJCEoL+vB9HGl3PbqCjZX7Qk7joh0MSoOSew7Z42ioSnKr17Ug3Ei0rFUHJJYWa88vjyljD+9s5aFH+0MO46IdCEHLA5mtsvMqg60dGTIruzrpw2nR14m//bYAnVtFZEOc8Di4O7d3L0A+B/gu0A/oD/wHeC/OySdUJibwffPHcv763Zy71urw44jIl1EkGal89z9Vnff5e5V7v5bYEaig8knzp3Qh5NHFHPz80tZrxnjRKQDBCkONWZ2qZlFzCzNzC4FNCtNBzIzfvLZcbjDTX+p0LhLIpJwQYrDF4HPA5viy0XxbYfNzC4ys4VmFjWz8mbby8xst5nNiy+3tWU/ncmAHrl868wR/G3JZp58/6Ow44hIJ3fIR2/dfTXt34xUAVwA3L6f91a4+8R23l+ncNnxg3l6/gZ++ORCThjWi575WWFHEpFOKsg0oSPM7CUzq4ivTzCz77Vlp+6+2N2XtuU7uqJImvHzCydQXdfID59aFHYcEenEgjQr/Q64AWgAcPf5wMUJzDTYzN4zs1fN7MQDfcjMrjKzOWY2p7KyMoFxksuIkm7886nDeer9j3hp8aaw44hIJxWkOOS6++x9tjUe6ofM7EUzq9jPcrAmqg3AQHc/ErgeeMDM9juhsrvf4e7l7l5eXFwc4DA6j2tOHsqIkny+/8RCausPeSpERFotSHHYYmZDAQcwswuJ/RI/KHc/3d3H7Wd54iA/U+fuW+Ov5wIrgBGBjqQLyUxP46fnj2f9jt38z0sfhB1HRDqhIMXha8RuHI8ys/XAN4BrExHGzIrNLBJ/PQQYDqxMxL5S3dFlPfhC+QDuen0VSzbqgXURaV9Bhuxe6e6nA8XAKHc/Id6D6bCZ2flmtg44FvirmT0ff+skYL6ZzQMeAa5x921t2Vdn9t3poyjIydDQGiLS7oL0Vmoys/8Cat19V3zbu23Zqbs/7u793T3L3UvcfVp8+6PuPtbdJ7r7Ue7+VFv209l1z8vkpnNG8+6HO/jDm6vDjiMinUiQZqWF8c+9YGY94tsscZGkNT47sR+njerNzc8vYdUWPbguIu0jSHFodPd/Be4EXjezScRvTkv4zIyfnj+ejEga33lkPlE1L4lIOwhSHAzA3f8EfAH4PTAkkaGkdUoLs/n+OWOYvXqbmpdEpF0EKQ5X7n3h7hXAicB1CUskh+XCSf05dVRvfvbcElZUVocdR0RS3MEm+zk1/nKQmV2wdwFOA/TbJ8mYGf91wXhyMiNc//D7NDZFw44kIinsYFcOJ8f/PHc/yzkJziWHoXdBNv8+Yxzvr93B7a/p8RAROXwHHJXV3X8Q//OyjosjbXXuEX15buFGfjVzGccM7sHRZT0O/UMiIvs4YHEws+sP9oPufkv7x5H28B/nj2fRR1Vce9+7PP3PJ1BamB12JBFJMQdrVup2iEWSVGFOBrd/eRK19Y1cc99c6hqbwo4kIinmYM1KP+rIINK+RpR045cXHcG197/Lvz+9iJ98dnzYkUQkhRxyJjgzywauAMYCH7dPuPvlCcwl7WD6+D589cTB/O71VZw4vJhpY0vDjiQiKSLIcw5/BEqBacCrQH9gVyJDSfv59rRRjO9XyHcenc+GnbvDjiMiKSJIcRjm7jcBNe5+D3A2MDmxsaS9ZKan8b+XHEl9Y5RvPDRPzz+ISCBBikND/M8dZjYOKAR6Jy6StLfBvfL4yWfHMWvVNv7jmSVhxxGRFHDIew7AHWbWHbgJeBLIB76f0FTS7i44qj8V66u4+41VjCjJ5+JjBoYdSUSS2CGLg7vfGX/5KhpwL6X922dGsbyympueqKCsVx5ThvQMO5KIJKkgk/0Umdl1ZnaLmf3v3qUjwkn7So+k8etLjmRgj1y+eu8cKtbvDDuSiCSpIPccngHKgAXA3GaLpKDCnAzuvWIyBdkZ/MPds1m+WR3PRKSlIMUh292vd/ffu/s9e5eEJ5OE6VeUw31XTibNjEvvnMVqzSAnIvsI9JyDmX3VzPqYWY+9S8KTSUIN7pXH/VdOpr4xysV3vK0CISKfEqQ41AM3A2/xSZPSnESGko4xsrQbD3x1CvVNUb5wx1uag1pEPhakOHyL2INwZe4+OL6o11InMbpPAQ9+dQqNTc5Ft73Fko1VYUcSkSQQpDgsB2oTHUTCM7K0G3+6egqRNPjC7W/z7ofbw44kIiELUhxqgHlmdru6snZew3p345FrjqMoN4Mv3TmLWSu3hh1JREIUpDj8Bfgp8CbqytqpDeiRy5+vPpY+hdlccc8c5q/bEXYkEQmJufuB3zSLAC+6+ykdF6n1ysvLfc4c3SNvLxt37uHC296kuq6Rh68+lhElmttJpDMys7nuXr6/9w565eDuTUDUzArbOdDNZrbEzOab2eNmVtTsvRvMbLmZLTWzae25XwmmtDCb+6+cTGYkjS/dOYs1W9WLSaSrCdKsVA0sMLO72vGew0xgnLtPAJYBNwCY2RjgYmITC50F3Bq/epEONqhnHvddOZmGpihf/N0sPtqhuSBEupIgxeExYiOyvkY73XNw9xfcvTG++jaxCYQAZgAPuXudu68i1lPqmLbsSw7fiJJu/PGKyVTtbuDSO2exedeesCOJSAc5ZHGID5XxIJ8UhQfaefiMy4Fn46/7AWubvbcuvq0FM7vKzOaY2ZzKysp2jCPNjetXyO8vO5qNO/dw8e1v6wpCpIsIMirrVOAD4P+AW4FlZnZSgJ970cwq9rPMaPaZG4FG4P7WBnf3O9y93N3Li4uLW/vj0grlZT344xXHULmrjotue0tDbYh0AUGalX4JnOnuJ7v7ScTmkv7VoX7I3U9393H7WZ4AMLN/BM4BLvVPukytBwY0+5r+8W0SsvKyHjx41RR2NzRx0e1vsegjPUkt0pkFKQ4Z7r5074q7LwMy2rJTMzsL+FfgPHdv/vT1k8DFZpZlZoOB4cDstuxL2s+4foU8fPUU0tOML9z+Fm+t0INyIp1VkOIwx8zuNLOp8eV3tH3gvd8A3YCZZjbPzG4DcPeFwMPAIuA54Gvx7rSSJIb17saj1x5HaWE2X7l7Ns9VbAg7kogkwEEfggMwsyzga8AJ8U2vA7e6e12CswWmh+A63o7aei7/wzvMW7uDn31uAheVDzj0D4lIUjnYQ3BB5pCuA26JLyIAFOVmct+Vk7n6j3P59iPz2bWnkcuOL8PMwo4mIu0gSG+l481sppktM7OVe5eOCCfJLTcznTu/Us5ZY0v58dOLuPa+d/UshEgnEeSew13ErhpOAI5utoiQlR7hN188ku9OH8Xflm7mjFte4/H31nGo5koRSW5BisNOd3/W3Te7+9a9S8KTScpIj6RxzclDefbrJzKsdz7f/NP7XHPfXLZUJ81tKRFppSDF4eX4QHnHmtlRe5eEJ5OUM7Q4n4evPpYbpo/i5SWVnPmr13h0rq4iRFJRkN5KL+9ns7v7qYmJ1HrqrZR8lm7cxb8+Op/31+7g6LLu/HjGOEb3KQg7log0c7DeSocsDqlAxSE5RaPOn+eu5b+eXcLO3Q18cfJArj9jJD3yMsOOJiK0YT4HkbZISzO+cPRAXv6XqfzDsWU8OHstU29+mXvfWk1TNPX/USLSmak4SMIV5Wbyw/PG8tzXT2RC/yK+/8RCZvzf35m3dkfY0UTkAFQcpMMML+nGH684hl9fciSbq+o4/9Y3uOkvFezc3RB2NBHZxyGfkAYws+OAsuafd/d7E5RJOjEz49wj+jJ1ZDG3zFzGPW+u5tmKjXzzjOFcNGkAmen694pIMgjSW+mPwFBgHrB3EDx39+sSGy043ZBOXRXrd/KDJxcyd812+hZm8/9OGcYlxwwkkqZhOEQSrU29lcxsMTDGk7hbk4pDanN3Xv9gC//z0gfMXbOd8f0K+c8LxjOuX2HY0UQ6tbb2VqoASts3ksgnzIyTRhTzyDXH8utLjmTDzj2c95u/85/PLmZPg0ZsFwlDkHsOvYBFZjYb+Hg8BHc/L2GppEvaez/ipOHF/Oezi7n91ZW8vGQzt3x+oq4iRDpYkGalk/e33d1fTUiiw6Bmpc7plaWb+c6j86ncVceMif342ilDGda7W9ixRDoNPSEtKWtnbQO/efkD7nv7Q/Y0NnHqyN5cOKk/p47uTVZ6JOx4IimtrTekpwC/BkYDmUAEqHH3pBkoR8Wh89tWU8/v31jFw3PWsqmqjqLcDL51xggunTyINPVsEjksbS0Oc4CLgT8D5cA/ACPc/Yb2Dnq4VBy6jqao8/flW7j91RW8uWIrR5d156fnj2dEiZqbRFqrzWMruftyIOLuTe7+e+Cs9gwoElQkzTh5RDH3XzmZmy+cwLJN1Zz5q9f40p2zeK5ig8ZsEmknQXor1ZpZJjDPzH4ObEDDbkjIzIyLygdw6qjePDj7Qx6Y9SHX3Pcuw3rn8y9njmDa2FLNZy3SBkGalQYBm4jdb/gmUAjcGr+aSApqVpLGpijPL9zELTOXsqKyhrF9C7j4mIGcd0RfCnMywo4nkpTa3FvJzHKAge6+tL3DtQcVB9mrsSnKY++t5+6/r2LJxl1kpafxuUn9ufbkoQzokRt2PJGk0tYb0ucCvwAy3X2wmU0EfpxMD8GpOMi+3J2K9VU8MHsNj8xdhzucN7Ev507oy7FDe5KdoW6wIm0tDnOBU4FX3P3I+LYF7j6+3ZMeJhUHOZgNO3dz2ysreGTuOmrqm8jNjPC5o/pz/Rkj6K5Z6aQLa2tvpQZ337nPtjZ1CTGzm81siZnNN7PHzawovr3MzHab2bz4cltb9iMC0Kcwhx/NGMe73z+Dey4/hnMm9OGB2R8y9Rev8Ic3VlFd1xh2RJGkE+TK4S7gJeC7wOeA64AMd7/msHdqdibwN3dvNLOfAbj7d8ysDHja3ce15vt05SCttXTjLn701ELeXLGV7Iw0Th9dwrSxpUwZ0pPibllhxxPpEAe7cgjSlfWfgRuJDbr3IPA88O9tCeTuLzRbfRu4sC3fJ9JaI0u7cf+Vk5m7ZjtPzPuIvy7YwNPzNwAwvHc+Z4wp4TPj+zC2b4G6xEqXFPrYSmb2FPAnd78vfuWwEFgGVAHfc/fXD/UdunKQtmpsilLxURVvr9zK6x9U8vbKbTRFnYE9cpk+vpSzx/dhfL9CFQrpVA7rhrSZPXmwLz1UbyUze5H9zwNxo7s/Ef/MjcSG5LjA3d3MsoB8d99qZpOAvwBj3b1qP99/FXAVwMCBAyetWbPmYHFEWmVbTT0vLNzIsxUbeWP5FhqjTr+iHKaNLWX6+FImDeyuMZ0k5R1ucagE1hJrSpoFfOr/hLYO2W1m/whcDZzm7rUH+MwrwL+4+0EvC3TlIIm0o7aemYs28VzFRl7/YAv1TVFKCrKYPq4PZ4wpYdKg7uoaKynpcItDBDgDuASYAPwVeNDdF7ZDoLOAW4CT3b2y2fZiYJu7N5nZEOB1YLy7bzvY96k4SEfZtaeBvy3ZzF/nb+CVZZXUN0bJzkjj2CE9OW9iX6aNLSU3M8itPJHwtccT0lnEisTNwI/c/TdtDLQcyAK2xje97e7XmNnngB8DDUAU+IG7P3Wo71NxkDDU1DXG71FsYeaiTazfsZvczAjnTujL5ScMZmSpRoqV5HbYxSFeFM4mVhjKgCeBu919fQJyHjYVBwlbNOrMWbOdR+eu44n317OnIcrxw3py3hF9OW10Cb3y1T1Wks/hNivdC4wDngEecveKxEVsGxUHSSbba+p5YPaHPDj7Q9Zt340ZjOtbyMQBRUzoX8jI0m4MKc4nP0vNTxKuwy0OUaAmvtr8Qwa4ZoITOTh3Z/GGXbywaCOzVm5jwfqdn3oau7QgmyHFeQzulUdhTgbZGRG652Ywuk8Bo/sUkKfiIQl2WA/BubvmbBBpAzNjTN8CxvSN/TuqKeqs2lLD8s27WFFZw4rN1azYUsPT8zdQU9dI4z4TFWVG0nCcSJrRtyiHAd1zGdO3gClDelI+qLuKhyRU6A/BtQddOUhn0NgUpbK6joXrq1i0oYra+ibSDOobo6zfsZsPt9WydOMuGqNORsQ4ZnAPThtVwvHDejG0OI/0iP49J63T1uEzRKQDpEfS6FOYQ5/CHE4fU7Lfz9TUNTJ3zXb+vnwLf1uymR8/vQiAzPQ0hvTKoynqVO1pIC8znZNHFnPqqN5M6F+kCY+k1XTlIJLC1myt4b0Pd7BoQxXLN1eTGUmjMCeDTbv28NaKrdQ1RgHolZ/FyNJ8pgzuyXHDejG+XyGZ6brS6Ora/JxDslNxEGlpd30Ts1ZtZdmmXazYXMP89TtZvCE2Ek1mJI3Rfboxuk8BhTkZ5Gam0y07ne55GRTmZJCVHiE9zUhLM6JRj1+RNFK1p4Hd9U1E3XGHYb3zOWpQd/W8SlFqVhLpgnIyI0wd2ZupI3t/vG1bTT2zVm5l3todvL9uBy8u3kR1XSN7GqKHvZ80gyHF+RRkp5OXlU5BTgYF2bEiU5CTTkF2Bn2LshlR0o1+RTm4Q3V9I1npaWSlBx92ZGt1HenxKyNJPBUHkS6kR14m08f3Yfr4Pp/a3tgUpbquke21Dezc3UB9Y5TGpihN7kTMMDO6ZafHrzIiRNKMpqizaEMV76zaxpKNu6ipb6RqTyPrd+ymancDO2obWvbASk+joSmKe+z10WXdOXZITwpyMnCH3Q1NbKraw+ZddWRG0ijKzaC+McqsVdtYvrkagOJuWQzplUfvgmx65WdSWpDNgB65DOieS8/8THrkZWqsq3agZiURSQh3Z09DlKo9DazdVsvSTbtYs7WW7IwIBdnpbNi5hzeWb2HJxl2f+rn8rHR6d8uivinKjtoG3J3ysh5MGdITM1i+uZrVW2rYUl3Hlur6/c7k1zMvkwn9C5nQv4jhJfmU9cxjQPdcCnLSk2rYdXfno517yEgz8rPTiaQZu+ubqI0vu+ubMIPBvfL223U5GnUaotFWXYE1p2YlEelwZkZOZoSczAglBdmUl/XY7+eq9sSuVAzIzoi0+vmNnbtjxWf9jt1sr6lna009q7fU8P66HbyyrJLm//5NTzOKcjMZUZL/8RPrQ4vzGdgz9+NfsPWNUT7asZu122vZURvLVt8Upb4xSl1jE5ur6li6aRcrK2sYUpzHlCE9OWpgd0oLY1cymelpuEOa2cc3/esboyzZWMXiDVXs3N3Arj2NfLCpmndWb2NrTX2g4ywtyCY3KxIrCE2xXmnVdY3MOKIv/33xka36bxaEioOIhKogu233EApzMijsV8i4foUt3qutb2TN1lrWbK1h3fbdbK+tZ8uuehZtqOKO11Z+3OxlFrtJ3xT1Fk1h+8pKT2NESTeOHFjEsk27uPn5pQf8bF5mhKLcTCqr66hv/OS+jhn0K8rh5JHFHDmwOwZU1zXSFHVyMiLkxotqbmY6DU1RVm2pYUVlNXWNUSJmpEeMguwMCrLTGdO35XG3BxUHEem0cjPTPx6OZF97GppYunEXq7fWsLKyhj2NTaSnGZmRCH2LYvcxeubFrgQy4zfPs9LTyMmIfGqipy3VdSzeUMWW6joqd9XR0OSkmdEUjbK9toFtNfX0zMvkyIHdGd+vkB75meTu8x3JSMVBRLqk7IwIRwwo4ogBRW36nl75WZw4vLh9QiURPQUjIiItqDiIiEgLKg4iItKCioOIiLSg4iAiIi2oOIiISAsqDiIi0oKKg4iItNApBt4zs0pgTRu+ohewpZ3ihE3Hkpx0LMmpqx/LIHff7xN8naI4tJWZzTnQyISpRseSnHQsyUnHcmBqVhIRkRZUHEREpAUVh5g7wg7QjnQsyUnHkpx0LAegew4iItKCrhxERKQFFQcREWmhSxcHMzvLzJaa2XIz+27YeVrDzAaY2ctmtsjMFprZ1+Pbe5jZTDP7IP5n97CzBmVmETN7z8yejq8PNrNZ8fPzJzPLDDtjEGZWZGaPmNkSM1tsZsem+Hn5ZvzvWIWZPWhm2alybszsbjPbbGYVzbbt91xYzP/Gj2m+mR0VXvKWDnAsN8f/ns03s8fNrKjZezfEj2WpmU1r7f66bHEwswjwf8B0YAxwiZmNCTdVqzQC33L3McAU4Gvx/N8FXnL34cBL8fVU8XVgcbP1nwG/cvdhwHbgilBStd7/AM+5+yjgCGLHlJLnxcz6AdcB5e4+DogAF5M65+YPwFn7bDvQuZgODI8vVwG/7aCMQf2BlscyExjn7hOAZcANAPHfBRcDY+M/c2v8d15gXbY4AMcAy919pbvXAw8BM0LOFJi7b3D3d+OvdxH7BdSP2DHcE//YPcBnQwnYSmbWHzgbuDO+bsCpwCPxj6TEsZhZIXAScBeAu9e7+w5S9LzEpQM5ZpYO5AIbSJFz4+6vAdv22XygczEDuNdj3gaKzKxPhwQNYH/H4u4vuHtjfPVtoH/89QzgIXevc/dVwHJiv/MC68rFoR+wttn6uvi2lGNmZcCRwCygxN03xN/aCJSElauV/hv4VyAaX+8J7Gj2Fz9Vzs9goBL4fbyJ7E4zyyNFz4u7rwd+AXxIrCjsBOaSmudmrwOdi1T/nXA58Gz8dZuPpSsXh07BzPKBR4FvuHtV8/c81k856fsqm9k5wGZ3nxt2lnaQDhwF/NbdjwRq2KcJKVXOC0C8PX4GsaLXF8ijZdNGykqlc3EwZnYjsabm+9vrO7tycVgPDGi23j++LWWYWQaxwnC/uz8W37xp76Vw/M/NYeVrheOB88xsNbHmvVOJtdsXxZsyIHXOzzpgnbvPiq8/QqxYpOJ5ATgdWOXule7eADxG7Hyl4rnZ60DnIiV/J5jZPwLnAJf6Jw+utflYunJxeAcYHu91kUns5s2TIWcKLN4mfxew2N1vafbWk8BX4q+/AjzR0dlay91vcPf+7l5G7Dz8zd0vBV4GLox/LFWOZSOw1sxGxjedBiwiBc9L3IfAFDPLjf+d23s8KXdumjnQuXgS+Id4r6UpwM5mzU9JyczOItYce5671zZ760ngYjPLMrPBxG6yz27Vl7t7l12AzxC7w78CuDHsPK3MfgKxy+H5wLz48hlibfUvAR8ALwI9ws7ayuOaCjwdfz0k/hd6OfBnICvsfAGPYSIwJ35u/gJ0T+XzAvwIWAJUAH8EslLl3AAPErtX0kDsqu6KA50LwIj1YFwBLCDWQyv0YzjEsSwndm9h7++A25p9/sb4sSwFprd2fxo+Q0REWujKzUoiInIAKg4iItKCioOIiLSg4iAiIi2oOIiISAsqDiKtYGY9zWxefNloZuvjr6vN7Naw84m0F3VlFTlMZvZDoNrdfxF2FpH2pisHkXZgZlObzUPxQzO7x8xeN7M1ZnaBmf3czBaY2XPxYU8ws0lm9qqZzTWz55NpBFARFQeRxBhKbIyo84D7gJfdfTywGzg7XiB+DVzo7pOAu4GfhhVWZF/ph/6IiByGZ929wcwWEJsg57n49gVAGTASGAfMjA1ZRITY0AgiSUHFQSQx6gDcPWpmDf7Jzb0osf/vDFjo7seGFVDkYNSsJBKOpUCxmR0LseHXzWxsyJlEPqbiIBICj01NeyHwMzN7n9iImseFGkqkGXVlFRGRFnTlICIiLag4iIhICyoOIiLSgoqDiIi0oOIgIiItqDiIiEgLKg4iItLC/wfIDcOJ5IqKSAAAAABJRU5ErkJggg==\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -457,21 +539,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 88,
-   "id": "6b3b4811",
+   "execution_count": 22,
+   "id": "2b471cf1",
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/tmp/ipykernel_11254/2889722531.py:1: RuntimeWarning: divide by zero encountered in log\n",
+      "/tmp/ipykernel_82097/2889722531.py:1: RuntimeWarning: divide by zero encountered in log\n",
       "  plt.plot(np.log(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1) - np.min(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1))))\n"
      ]
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEICAYAAABWJCMKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAqTElEQVR4nO3deXxU9b3/8dcnISSBkEAWkhCWsG8BBYKyFRX3DS3aXlvbapefbS+16722Xu+91bv0cW8X215rba1L1VZta7Vaal1QFgWRTWRfwg4GsrAvCVk+vz9mwJSSZCAzOUnm/Xw85kHmZGbO+zwOzIfv93zP92vujoiIxJ+EoAOIiEgwVABEROKUCoCISJxSARARiVMqACIicUoFQEQkTgVeAMws0czeM7NZQWcREYknnYIOAHwNWAekN/fC7OxsLywsjHkgEZGOZNmyZRXunnP69kALgJn1Bq4F/hv4ZnOvLywsZOnSpTHPJSLSkZjZ9jNtD7oL6CfAXUB9wDlEROJOYAXAzK4Dytx9WTOvu8PMlprZ0vLy8lZKJyLS8QXZApgMTDezbcCzwDQz+83pL3L3h9292N2Lc3L+rgtLRETOUWAFwN3vdvfe7l4I3AK86e6fCiqPiEi8CfoagIiIBKQtDAPF3ecCcwOOISISV9QCEBGJU22iBRBrb67fS0nZES7sn8XIXul0SlTdExGJiwIwd0M5T74Tug+ia+dExvbrwYQBWVzQP5PRvTNI7pQYcEIRkdZn7WlJyOLiYj/XO4HLDlWxeNs+3t2yj8Vb97Fh72EAkjslMKZvdy7on8WE/pmM6duD1M4qCCLScZjZMncv/rvt8VIATrf/6AkWbwsVg3e3VrL2g0PUOyQlGuf17s6FAzK5sH8W4/r1oGtyXDSURKSDUgFoxqGqGpZt28+irZW8u2Ufq3YfpK7e6ZRgjOqdwYX9s7hwQCbF/XrQLSUpJhlERGJBBeAsHamuZfn2/by7tZJFW/axctcBauqcxASjqFc6Fw7IYsKATIoLM0lXQRCRNkwFoIWOn6hj+Y79LNoSaiG8t3M/NXVOgsHIXhlMGJDJhAFZjO+vgiAibYsKQJQdP1HHezv2s2jrPhZtrmTFzgOcqKsnwaCoIIMJ4RbC+MJMdRmJSKBUAGKsquZkC2Efi7ZUsmLHhwVhVEEGEwZmhVoIhZmk6aKyiLQiFYBWdrKF8M6WylBB2PnhNYTRvTOYOCCLSQOzGddPw05FJLZUAAJ2/EQdy7bv550tFbyzuZL3d4VGGSUlGmP69GDiwCwmDsxiTN/uujFNRKJKBaCNOVJdy5JtoesH72ypZPXug9R76Ma04sIeTBqYzcSBWYwuyNDUFSLSIioAbdzB4zW8uyVUDN7ZXMn6PaE7ldOSO3FB/0wmhVsIw/PSSUiwgNOKSHvSWAHQ1cg2IiM1iStG5nHFyDwAKo9Us2jLPhZuDnUZvbm+DIAeXZLC3UXZTBmUTWFWF8xUEETk7J1VC8DMegB93H1l7CI1riO3AJpTevA4C0sqWbi5koWbKyg9WAVAr4wUJg7MZvKgLCYPyiY3PSXgpCLS1pxzF5CZzQWmE2otLAPKgAXu/s0Y5GxSPBeAhtydbZXHWFBSwcLNFSzcXMmBYzUADMzpypRB2UwelM2EgVm6KU1EWlQA3nP3MWb2BUL/+/+uma1099GxCtsYFYAzq6931pYeYuHmCt4uqWTx1kqqakL3IIzu3f1UQRjbTyOMROJRSwrAKuAK4AngHndfogLQtlXX1vHejgMsKKlgQUnFqSGnKUkJXNA/iymDspgyKIdhed10QVkkDrSkAHwM+DdC3T5fNrMBwA/c/abYRG2cCsC5OVxVw6It+1hQUsHbJRWUlB0BIDutM5MGZjNlcDYfGZxNfkZqwElFJBY0DFROKT14nAUllby9qZy3SyqpOFINwKCeaUwZlM3UIdlc2D9L6yCIdBAtaQEMAR4Cct29yMxGA9Pd/b9iE7VxKgDR5+6s33OYtzdV8FZJxanrB0mJxpi+PZg6OJuPDM6hqCCDRHUXibRLLSkA84B/Bn7p7mPC21a7e1FMkjZBBSD2qmrqWL59P/M3VTB/YzlrSw8BofsPJg/KZuqQHKYOziEvQ8NNRdqLltwI1sXdF592s1Ft1JJJm5KSlMikQdlMGpTNd64eRsWRahaUVDB/YwVvbSpn1spSAIbkpvGRwTlMHZLDhf0zSUnS6CKR9iaSAlBhZgMBBzCzm4HSmKaSNiM7LZkbzi/ghvMLTnUXvbWpnLc2VfDUou08+vZWkjslcOGALKYOzubioTkMzEnT3cki7UAkXUADgIeBScB+YCvwKXff1qIdm6UA84FkQoXoOXf/blPvURdQ23L8RB2LtlYyb0M58zeVs6X8KAAF3VOZOiSHi4bkMHlQlhbEEQlYi0cBmVlXIMHdD0cpkAFd3f2ImSUBbwNfc/dFjb1HBaBt27X/GPM2ljN/YzkLSio5Ul1LpwRjXL8eXDQ0h4uH9GR4fje1DkRaWUsuAn8P+L67Hwg/7wF8y93/NYrhuhAqAF9293cbe50KQPtRU1fPsu37mbexnLkbylkXvpicm57MRUNyuGRoTyYPztZUFSKtoMVTQZy2bbm7j41CqERC8wsNAh5092+f4TV3AHcA9O3bd9z27dtbulsJwN5DVczbWH6qu+hw1Yetg0uG9eSSoT0ZkqtrByKx0JICsBIY7+7V4eepwFJ3HxnFcN2BF4A73X11Y69TC6BjqK2rZ/mOA8zdUMacBq2Dgu6pXDw01DqYNCiLLp11I5pINLSkAHwbuB54PLzps8BL7v79KAf8d+CYu/+wsdeoAHRMew5WMXdDGW+uL2NBSQVHT9TRuVMCEwZkMW1oDpcOz6VPZpegY4q0W+dUAMIXansDI4HLwptfd/dXoxAoB6hx9wPhVsVrwP+6+6zG3qMC0PFV19axZOt+3lxfxpwNZWytCI0sGtwzjWnDe3LpsFzG9u2uZTJFzkKLZgN191ExCDSa0AyjiUAC8Ht3/4+m3qMCEH+2lB85VQze3bKP2nqne5ckLh6Sw7ThuVw0JIeMVF1IFmlKSwrAE8DP3H1JrMJFSgUgvh2uquGtTRW8sS5UEPYdPUGnBGN8YSaXDu/JZcNzKczuGnRMkTanJQVgPaFROtuBo4ABrvUAJEh19c6KnQd4Y91e3lhXxoa9odtTBvdM47IRuVw2PJcxfbprvQMRWlYA+p1pu7u3+nhMFQBpzI7KY8xet5c31u891VWUndaZS4flcvmIXKYMztZ8RRK3WlIA+p5pu7vviFK2iKkASCQOHq9h7oYyZq8rY+76Mg5X15KalMjUIdlcMSKPacN60qNr56BjirSali4J6YS6flKA/sCGaN4HECkVADlbJ2rreXdrJa+v3cvra/dSerCKxATjgsJMrhgZah307qEhptKxRW1FMDMbC/yju38hWuEipQIgLeHurN59iFfX7OG1tXvYuDe0NGZRQTpXjsjjqqI8BvXU3cjS8UR1SchYDQ1tjgqARNPWiqO8umYPr67Zw3s7DgAwIKcrV47M4+qiPEYVZKgYSIfQki6gbzZ4mgCMBbLc/croRmyeCoDEyt5DVby2Zg+vrtnLO1sqqat3CrqncuXIPK4ZlcfYvj00okjarZYUgIZz9NcC24A/untVVBNGQAVAWsP+oyeYvW4vr6zew1ubKjhRV0/PbslcXZTH1aPyGV+YqfWRpV2JxnoAaQDufiTK2SKmAiCt7XBVDW+uL+PlVaXM21hOVU092WmduXJkHteOyufCAVkqBtLmtaQFUAQ8BWSGN1UAtzU1a2esqABIkI6dqGXO+nJeXl3Km+vKOF5TR3ZaZ64qyuPaUb24oL9aBtI2taQALATucfc54ecXA99z90kxyNkkFQBpK46fqGPuhjL+sqqUN04Vg2SuGZXHdaN7UdxP1wyk7WhJAXjf3c9rbltrUAGQtuhky2DWyg94c30Z1bX15KWncO3ofK4/rxfn9dZoIglWSwrAC8ByQt1AAJ8Cxrn7R6OeshkqANLWHamu5Y11e/nz+6XM31jOibp6+mV14frRvbjh/F4Mzu0WdESJQy0pAD2A+4Ap4U3zgfvcfX/UUzZDBUDak4PHa3h1zR7+/P4HLCipoN5hWF43bji/gOnn96Kge2rQESVOROVGsPAavl3d/VA0w0VKBUDaq/LD1by8qpQ/rdh96qazCwozuXFMAdeMyqN7F81NJLHTkhbA08CXgDpgCZAO/NTdfxCLoE1RAZCOYEflMV5csZsX3/+AkrIjJCUalwztyYyxBVwyrCfJnTRrqURXSwrACnc/38xuJXQX8HeAZVoPQKRl3J01Hxzihfd289L7H1B+uJr0lE5cd14vbhpbwNi+PXTxWKKisQLQKYL3JplZEnAjoZXBaszs7CcQEpG/YWYUFWRQVJDBv1wznAUlFTy/fBcvLN/N0+/uoF9WF2aM6c2MsQX0ydSMpRJ9kRSAXxKa/uF9YH54gZhArgGIdFSJCcbUITlMHZLDkepaXlm9h+eX7+Inb2zkx7M3MmFAJjeP68PVRXl0TY7kn61I8851NtBO7l4bgzxNUheQxJvdB47z/LJd/HH5LrZVHqNL50SuG53Px4r7UNxPXUQSmZZcA8gFvgf0cverzWwEMNHdH41N1MapAEi8cneWbt/Pc0t3MWvlBxw9UceA7K58rLgPN40roGe3lKAjShvWkgLwV+BxQtNBnGdmnYD3tB6ASDCOVtfy8qpS/rB0F4u37SMxwZg2rCe3jO/DRUNy6JSYEHREaWNachE4291/b2Z3A7h7rZnVRT2hiESka3InPlbch48V92FL+RF+v3QXzy3bxetr95Kbnsw/FPfh4+P7aKlLaVYkBeComWURWhcYM5sAHIxpKhGJyICcNL5z9TC+dcUQ3lhXxrNLdvDAnBIemFPCxUNy+MQFfZk2rKdaBXJGkXQBjQUeAIqA1UAOcLO7r4x9vL+lLiCR5u3af4zfL9nJs0t2Una4mrz0FG65oA+3jO9LXoauFcSjc7oGEJ764auECsBQwIAN7l4ThUB9gCeBXEKti4fd/adNvUcFQCRytXX1zF5XxtOLdzB/YzmJCcYVI3L59IR+TByYpRFEcaQlF4EXu/sFMQiUD+S7+3Iz6wYsA25097WNvUcFQOTcbK88ytPv7uB3S3dy4FgNg3qm8ZmJ/Zgxtjdpuq+gw2tJAfgxkAT8Djh6cru7L49ywBcJ3Wn8emOvUQEQaZmqmjpmrSzlqXe28f6ug6Qld+Lmcb25bVIh/bO7Bh1PYqQlBWDOGTa7u0+LYrhCQtNMF50+06iZ3QHcAdC3b99x27dvj9ZuReLaip0HeGLhNmat/ICaOufioTl8bnJ/PjI4W91DHUxUpoOOhfBi8/OA/3b355t6rVoAItFXdriKZ97dyVOLtlNxpJrBPdP47OT+zBhbQEqSZibtCNpkAQhPMjcLeNXd72/u9SoAIrFTXVvHX1aW8ujbW1nzwSEyu3bmUxf25dMTC8nplhx0PGmBNlcALNTGfALY5+5fj+Q9KgAisefuLN66j0fe3srsdXtJSkxgxpgCvvCRAQzqmRZ0PDkHLbkGkOzu1c1tO4dAU4C3gFVAfXjzv7j7y429RwVApHVtrTjKo29v4Q9Ld1FdW8/lI3L50kUDGNcvM+hochZaUgCWu/vY5ra1BhUAkWBUHqnmyXe288Q72zhwrIbxhT34x4sHcfHQHF0wbgfOei4gM8sDCoBUMxtD6CYwCC0JqUlGROJIVloy37h8CF+8aAC/W7KTX83fwmd/vYTh+enMvGQgVxflk5igQtDeNNoCMLPbgNuBYqDhf7sPAU80N2InFtQCEGkbTtTW8+KK3Tw0bzNbyo8yIKcrMy8exA3n99K8Q21QS7qAbnL3P8Ys2VlQARBpW+rqnVdW7+Fnc0pYV3qIvpldmHnJQGaM7U2SCkGb0VgBiOQMLTCzR8PrAmBmI8zs81FPKCLtTmKCce3ofF7+6hR+9ZliMlKT+PYfVzHtR3P5/ZKd1NTVN/8hEphICsDjwKtAr/DzjcDXYxVIRNofM+PyEbm89JXJPHZ7Md1TO3PXH1dy2f3zeOG9XdTVB3vDqZxZJAUg291/T3ioZngtYC0IIyJ/x8yYNixUCB75TDFdO3fiG797nyt/Mp+/riol6JkH5G9FUgC0IIyInBUz47IRucy6cwo/v3Us7s6Xf7ucGx5cwNubKoKOJ2FaEEZEYq6u3nl++S5+MnsTuw8c5yODs/n2VcMoKsgIOlpcaMkooP7AThosCAOc7+5LYhG0KSoAIu1bdW0dv1m0g5+9uYn9x2q48fxe/NOVQ7V+cYy1pAAsA6a7++7w86nAg+4+KiZJm6ACINIxHKqq4RdzN/Po21tx4HOT+zPzkoF0S0kKOlqH1JJhoF8C/mRmeWZ2DaHuoGuiHVBE4kd6ShJ3XTWMOf90MdeNyucX8zZzyQ/n8uziHRox1Ioimg3UzCYCvwSqgGvdvTzWwc5ELQCRjmnlrgP8x5/XsnT7fkbkp3PfDSMZX6gJ56LlrLuAzOzPhEf+hI0ASoH9AO4+PQY5m6QCINJxuTuzVpbyvZfXUXqwihvP78W/XDOcnukpQUdr9856MjjghzHMIyLyN8yM68/rxaXDe/KLuZv5xfwtzF5XxtcvG8ztkwo1x1AMNNkFZGaJwGx3v6T1IjVOLQCR+LG98ij3vrSGORvKGZbXje/NGMXYvj2CjtUundNFYHevA+rNTIN1RaRV9cvqymO3j+eXnx7HweM13PTQQv71T6s4VFUTdLQOo6kuoJOOAKvM7HXg6MmN7v7VmKUSESHULXTlyDwmD8rm/tc28uuFW3l97V7+84YirhiZF3S8di+S+wBuO9N2d38iJomaoC4gkfi2ctcB7npuJev3HObaUfncd8NIstO0YH1z2tyi8OdCBUBEaurqeXj+Fn46exNpKZ34zxuKuHZ0ftCx2rRzvhHMzAab2XNmttbMtpx8xCamiEjTkhITmHnJIGZ9dQq9e6Qy8+nlzHx6OQeOnQg6WrsT6XoADwG1wCXAk8BvYhlKRKQ5Q3K78fyXJ/FPVwzh1dV7uPIn85m3MZB7VNutSApAqru/Qai7aLu73wtcG9tYIiLN65SYwFemDeZPMyeTnpLEbY8t5r4/r6GqRkuWRCKSAlBtZgnAJjP7ipl9FEiLcS4RkYgVFWTw5zuncPukQh5fsI0bH1zApr2Hg47V5kVSAL4GdAG+CowDPg2ccWSQiEhQUpISuXf6SB67vZjyw9VM/9kC/rB0Z9Cx2jSNAhKRDqfsUBVfe3YF72ypZMbYAv7rxiK6dI7ktqeOqSWjgIrN7AUzW25mK08+ohTqMTMrM7PV0fg8ERGAnukp/OYLF/K1Swfzwnu7mfHzhWyrONr8G+NMJF1AvyU0Eugm4PoGj2j4NXBVlD5LROSUxATjG5cP4YnPXsCeQ1Vc/7O3mb12b9Cx2pRICkC5u7/k7lvDo4C2u/v2aOzc3ecD+6LxWSIiZzJ1SA6z7pxCYVZXvvDkUh54YxPtqes7liIpAN81s0fM7BNmNuPkI+bJwszsDjNbamZLy8s1xldEzl7vHl34w5cm8tExBfzo9Y185en3OHaiNuhYgYvkqshngWFAElAf3ubA87EK1ZC7Pww8DKGLwK2xTxHpeFKSErn/4+cxPL8b//PX9ezYd4xHbismN44XnImkAIx396ExTyIiEmNmxh1TBzIwJ407n3mPjz64gEdvH8/w/PSgowUiki6ghWY2IuZJRERayaXDc/n9FydS587HfvEOC0sqgo4UiEgKwARghZltCA8BXRXFYaDPAO8AQ81sl5l9PhqfKyLSnKKCDP40czK9uqdw2+OLmbXyg6AjtbpIuoBiNkzT3T8Rq88WEWlOfkYqf/jiJL7w5BLufOY99h09wWcmFgYdq9U0WwCiNeRTRKQtyuiSxFOfv5A7n3mPf39xDUer6/jyxQODjtUqIukCEhHp0FKSEvn5rWOZfl4v/veV9fzotQ1xca9A/E6OISLSQFJiAj/+h/Pp0jmRB94sobbeuevKoZhZ0NFiRgVARCQsMcH43kdHYWY8NHcziWZ864ohHbYINFoAzOwwoRu+zsjd43PgrIh0aAkJxn/fWIS787M5JafmFOqIGi0A7t4NwMz+EygFngIMuBXQCswi0mElhFsCtfXOT9/YREZqEp+b0j/oWFEXSRfQdHc/r8Hzh8zsfeDfY5RJRCRwCQnG/8wYxeGqGv5j1loyUpO4aVzvoGNFVSSjgI6a2a1mlmhmCWZ2K6CJtUWkw+uUmMBPbxnDpIFZ3PXHlcxZXxZ0pKiKpAB8Evg4sDf8+Fh4m4hIh5eSlMjDnylmWF43Zj69nNW7DwYdKWqaLQDuvs3db3D3bHfPcfcb3X1bK2QTEWkT0pI78djt4+memsTnn1hC6cHjQUeKikiWhBxiZm+cXLbRzEab2b/GPpqISNuRm57CY58dz9HqOj77+JIOsZ5AJF1AvwLuBmoA3H0lcEssQ4mItEXD8tJ58NaxbNx7mH9+bmW7v1s4kgLQxd0Xn7at/Zc+EZFzcNGQHO66ahh/WVnKL+dvCTpOi0RSACrMbCDhm8LM7GZC9wWIiMSlL04dwHWj8/n+K+t5a1P7Xao2kgIwE/glMMzMdgNfB74cy1AiIm2ZmfH9m0czuGc3vv7sCsoOVQUd6ZxEMgpoi7tfBuQAw9x9ikYBiUi869K5Ez/75BiOnqjlG79fQV19+7seEMkooDoz+x/gmLsfDm9bHvNkIiJt3ODcbtw3fSQLSip5aG5J0HHOWiRdQGvCr3vNzDLD2zrm1HgiImfp48V9mH5eL348exMrdh4IOs5ZiaQA1Lr7XcAjwFtmNo4mZgkVEYknZsZ/3lhEz27J/NMf3qeqpi7oSBGLpAAYgLv/DvgH4HFgQCxDiYi0JxmpSfzPTaMpKTvCj2dvDDpOxCIpAF84+YO7rwY+Anw1ZolERNqhi4bk8IkL+vKr+VtYtn1/0HEi0mgBMLNp4R/7mdmMkw/gUuBIq6QTEWlH7rl2OPkZqdz9/Epq6uqDjtOsploAF4X/vP4Mj+tinEtEpN1JS+7EvdNHsnHvER5fsDXoOM1qakWw74b//GzrxRERad8uH5HLpcN68pPZm7j+vF7kZ6QGHalRTa0J/M2m3uju90c/johI+3fv9JFcdv88/mvWOh68dWzQcRrVVBdQt2YeLWZmV5nZBjMrMbPvROMzRUSC1iezCzMvGcRfVpWycHNF0HEaZUFNZ2pmicBG4HJgF7AE+IS7r23sPcXFxb506dJWSigicu6qauqY9sO5ZHdL5sWZkzEL7v5ZM1vm7sWnb49kKogUM5tpZj83s8dOPqKQ6QKgJDzX0AngWeCGKHyuiEjgUpIS+cblQ1i56yAvr9oTdJwziuQ+gKeAPOBKYB7QGzgchX0XADsbPN8V3vY3zOwOM1tqZkvLy9vvtKsiEn9mjO3NkNw0fvjahjY5LDSSAjDI3f8NOOruTwDXAhfGNtaH3P1hdy929+KcnJzW2q2ISIslJhjfvmoYWyuO8rslO5t/QyuLpADUhP88YGZFQAbQMwr73g30afC8d3ibiEiHMW1YTy4ozOSBNzdRXdu25gmKpAA8bGY9gH8DXgLWAt+Pwr6XAIPNrL+ZdSa0zvBLUfhcEZE2w8y489JB7D1UzZ/ea1v/x230PoCT3P2R8I/ziOIkcO5ea2ZfAV4FEoHH3H1NtD5fRKStmDIom6KCdH4xbws3j+tDYkLbmFG/2QJgZt2BzwCFDV/v7i2eEM7dXwZebunniIi0ZWbGly8axMynl/Pqmj1cMyo/6EhAZF1ALxP68l8FLGvwEBGRCF1VlEdhVhcemruZoO6/Ol2zLQAgxd2bnBZCRESalphgfPGigdz9/CoWlFQyZXB20JEiuw/AzP6fmeWbWebJR8yTiYh0MDPGFpDZtTO/WbQ96ChAZAXgBPAD4B0+7P7RfAwiImcpuVMiN4/rzevr9lJ2qCroOBEVgG8Ruhms0N37hx9aElJE5BzcMr4PdfXOH5btCjpKRAWgBDgW6yAiIvFgQE4aEwdk8cziHdTXB3sxOJICcBRYYWa/NLP/O/mIdTARkY7qkxf2Zdf+47xVEuxU0ZGMAvpT+CEiIlFwxchcMrt25pl3d3DRkODmOGuyAITn7L/d3S9ppTwiIh1ecqdEbhpbwOMLtrH/6Al6dO0cSI4mu4DcvQ6oN7OMVsojIhIXrj+vF7X1zuvr9gaWIZIuoCPAKjN7ndD1ACA6U0GIiMSrUQUZ9O6RysurSvl4cZ/m3xADkRSA58MPERGJEjPjmlH5PL5gKweP1ZDRJanVMzQ7Cii8CMwzfHgT2NPhbSIi0gLXjMqnpi64bqBI1gS+GNgEPAj8HNhoZlNjG0tEpOM7r3cGBd1T+euq0kD2H0kX0I+AK9x9A4CZDSHUIhgXy2AiIh2dmXF1UR5PvrOdQ1U1pKe0bjdQJDeCJZ388gdw941A63dWiYh0QFePyudEXT2z17Z+N1AkBWCpmT1iZheHH79Ck8GJiETFmD7dyemWzJwN5a2+70i6gL4MzARODvt8i9C1ABERaaGEBGPywCzeLqnE3TFrveUiIxkFVO3u97v7jPDjx+5e3RrhRETiwaSB2VQcqaak7Eir7jeSUUCTzex1M9toZltOPlojnIhIPJg4MAuAhZsrW3W/kVwDeBS4H5gCjG/wEBGRKOiT2YU+maks3Ny6s4NGcg3goLv/NeZJRETi2KQB2byyZg919U5iQutcB4ikBTDHzH5gZhPNbOzJR8yTiYjEkUmDsjh4vIZ1pYdabZ+RtAAuDP9Z3GCbA9OiH0dEJD5NHHDyOkAFRQWtMwFzswVAawGIiMRez/QUBvVMY+HmSu6YOrBV9hlJF1DUmdnHzGyNmdWbWXHz7xAR6fgmDcxi8dZ91NTVt8r+AikAwGpgBjA/oP2LiLQ54wszOXaijg17DrfK/gIpAO6+ruH8QiIiAiN6pQOwtpUuBEdyERgzmwQUNny9uz8Zo0yn7/sO4A6Avn37tsYuRUQCUZjVldSkxFYbCdRsATCzp4CBwAqgLrzZgSYLgJnNBvLO8Kt73P3FSAO6+8PAwwDFxcUe6ftERNqbxARjaF63tlMACA3/HOHuZ/Xl6+6XnVskEZH4NTw/nZdXlbbKxHCRXANYzZn/Jy8iIlE2Ir8bB4/XUHqwKub7iqQFkA2sNbPFwKlZQN19+rnu1Mw+CjwA5AB/MbMV7n7luX6eiEhHMTw/fCH4g0P06p4a031FUgDujfZO3f0F4IVof66ISHs3LFwA1pUe4rIRuTHdVyR3As+LaQIRETklLbkT/bK6sG5P7C8ER7IewAQzW2JmR8zshJnVmVnrzVYkIhJnhuels6409jeDRXIR+GfAJ4BNQCrwBeDBWIYSEYlnw/PT2VZ5lGMnamO6n4juBHb3EiDR3evc/XHgqpimEhGJY8Pzu+EO62M8JUQkBeCYmXUGVpjZ983sGxG+T0REzsGpKSE+iG1veyRf5J8Ov+4rwFGgD3BTLEOJiMSzgu6ppKd0ivkdwZGMAtpuZqlAvrvfF9M0IiKCmTGoZxpbyo/GdD+RjAK6ntA8QK+En59vZi/FNJWISJzL757K3kOxvRs4ki6ge4ELgAMA7r4C6B+zRCIiQn56CqUHqzjLadjOSiQFoMbdD562TbNyiojEUF5GCsdr6jh0PHZDQSMpAGvM7JNAopkNNrMHgIUxSyQiIuRnhOYBKj10PGb7iKQA3AmMJDQR3DPAIeDrMUskIiLkZSQDxHRW0EhGAR0D7gk/RESkFeSFWwB7gygAzY30acl00CIi0rSe3ZIxC64FMBHYSajb510gtkvTiIjIKUmJCeSkJbMnoAKQB1xOaCK4TwJ/AZ5x9zUxSyMiIqfkZ6RQGsN7ARq9CBye+O0Vd78NmACUAHPN7CsxSyMiIqfkpqew52DsRgE1eRHYzJKBawm1AgqB/0MreYmItIr8jBTe2VIZs89v6iLwk0AR8DJwn7uvjlkKERH5O3kZqRyuquVodS1dkyNZwffsNHUfwKeAwcDXgIVmdij8OKwVwUREYi8/IwWAPTG6DtBoSXF3zfkvIhKgvJMF4GAVA3PSov75+pIXEWmj8tJDBSBW9wKoAIiItFEftgBiMxJIBUBEpI1KSUqkR5ekjtUCMLMfmNl6M1tpZi+YWfcgcoiItHV5GbFbGCaoFsDrQJG7jwY2AncHlENEpE3Lz0jpWC0Ad3/N3U+ucrAI6B1EDhGRti50N3AHKgCn+Rzw16BDiIi0RfkZKVQePUFVTV3UPzv6t5aFmdlsQhPKne4ed38x/Jp7gFrgt018zh3AHQB9+/aNQVIRkbbr5EigskPV9M3qEtXPjlkBcPfLmvq9md0OXAdc6k2seuzuDwMPAxQXF2stYhGJKw3vBm43BaApZnYVcBdwUXjFMREROYPCrK5cXZRHalJi1D/bmvjPd8yYWQmQDJyc5m6Ru3+pufcVFxf70qVLY5pNRKSjMbNl7l58+vZAWgDuPiiI/YqIyIfawiggEREJgAqAiEicUgEQEYlTKgAiInFKBUBEJE6pAIiIxCkVABGROBXIjWDnyszKge3n+PZsoCKKcYLWkY6nIx0L6Hjaso50LBD58fRz95zTN7arAtASZrb0THfCtVcd6Xg60rGAjqct60jHAi0/HnUBiYjEKRUAEZE4FU8F4OGgA0RZRzqejnQsoONpyzrSsUALjydurgGIiMjfiqcWgIiINBAXBcDMrjKzDWZWYmbfCTrP2TCzPmY2x8zWmtkaM/taeHummb1uZpvCf/YIOuvZMLNEM3vPzGaFn/c3s3fD5+h3ZtY56IyRMLPuZvacma03s3VmNrE9nxsz+0b479lqM3vGzFLa07kxs8fMrMzMVjfYdsbzYSH/Fz6ulWY2Nrjkf6+RY/lB+O/aSjN7wcy6N/jd3eFj2WBmV0ayjw5fAMwsEXgQuBoYAXzCzEYEm+qs1ALfcvcRwARgZjj/d4A33H0w8Eb4eXvyNWBdg+f/C/w4vFbEfuDzgaQ6ez8FXnH3YcB5hI6pXZ4bMysAvgoUu3sRkAjcQvs6N78GrjptW2Pn42pgcPhxB/BQK2WM1K/5+2N5HShy99HARuBugPB3wi3AyPB7fh7+7mtShy8AwAVAibtvcfcTwLPADQFnipi7l7r78vDPhwl9wRQQOoYnwi97ArgxkIDnwMx6A9cCj4SfGzANeC78knZxPGaWAUwFHgVw9xPufoB2fG4ILRKVamadgC5AKe3o3Lj7fGDfaZsbOx83AE96yCKgu5nlt0rQCJzpWNz9NXevDT9dBPQO/3wD8Ky7V7v7VqCE0Hdfk+KhABQAOxs83xXe1u6YWSEwBngXyHX30vCv9gC5QeU6Bz8htCZ0ffh5FnCgwV/s9nKO+gPlwOPh7qxHzKwr7fTcuPtu4IfADkJf/AeBZbTPc9NQY+ejvX83fA74a/jnczqWeCgAHYKZpQF/BL7u7oca/s5DQ7naxXAuM7sOKHP3ZUFniYJOwFjgIXcfAxzltO6ednZuehD6n2R/oBfQlb/vgmjX2tP5aIqZ3UOoe/i3LfmceCgAu4E+DZ73Dm9rN8wsidCX/2/d/fnw5r0nm6vhP8uCyneWJgPTzWwboe64aYT60buHux2g/ZyjXcAud383/Pw5QgWhvZ6by4Ct7l7u7jXA84TOV3s8Nw01dj7a5XeDmd0OXAfc6h+O4z+nY4mHArAEGBweydCZ0IWSlwLOFLFw//ijwDp3v7/Br14Cbgv/fBvwYmtnOxfufre793b3QkLn4k13vxWYA9wcflm7OB533wPsNLOh4U2XAmtpp+eGUNfPBDPrEv57d/J42t25OU1j5+Ml4DPh0UATgIMNuoraJDO7ilD36XR3P9bgVy8Bt5hZspn1J3Rhe3GzH+juHf4BXEPoivlm4J6g85xl9imEmqwrgRXhxzWE+s3fADYBs4HMoLOew7FdDMwK/zwg/Be2BPgDkBx0vgiP4Xxgafj8/Ano0Z7PDXAfsB5YDTwFJLencwM8Q+j6RQ2hFtrnGzsfgBEaIbgZWEVo9FPgx9DMsZQQ6us/+V3wiwavvyd8LBuAqyPZh+4EFhGJU/HQBSQiImegAiAiEqdUAERE4pQKgIhInFIBEBGJUyoAImdgZllmtiL82GNmu8M/HzGznwedTyQaNAxUpBlmdi9wxN1/GHQWkWhSC0DkLJjZxQ3WMLjXzJ4ws7fMbLuZzTCz75vZKjN7JTyFB2Y2zszmmdkyM3u1Lc04KfFNBUCkZQYSms9oOvAbYI67jwKOA9eGi8ADwM3uPg54DPjvoMKKNNSp+ZeISBP+6u41ZraK0AIqr4S3rwIKgaFAEfB6aHodEgnd3i8SOBUAkZapBnD3ejOr8Q8vqtUT+vdlwBp3nxhUQJHGqAtIJLY2ADlmNhFCU3ub2ciAM4kAKgAiMeWhZUhvBv7XzN4nNIPjpEBDiYRpGKiISJxSC0BEJE6pAIiIxCkVABGROKUCICISp1QARETilAqAiEicUgEQEYlTKgAiInHq/wMPGG6PNelTfwAAAABJRU5ErkJggg==\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -491,23 +573,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 89,
+   "execution_count": 23,
    "id": "464f19e7",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7fa6f68e2410>]"
+       "[<matplotlib.lines.Line2D at 0x7f81cd7cac50>]"
       ]
      },
-     "execution_count": 89,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -524,13 +606,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 90,
-   "id": "3c721410",
+   "execution_count": 24,
+   "id": "1cc1dc83",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -552,24 +634,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 93,
-   "id": "38bce0b9",
+   "execution_count": 25,
+   "id": "dcff94ad",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
-       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
-       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
-       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
-       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
-       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
-       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
-       "       0.])"
+       "array([ 0.        ,  0.00222005,  0.00809147,  0.0012631 ,  0.00715372,\n",
+       "        0.00472244,  0.01164685, -0.02193753,  0.00705938, -0.00575065,\n",
+       "        0.01159715,  0.01218249,  0.00756169, -0.01088867,  0.00391398,\n",
+       "        0.01271844, -0.03643547, -0.02459725,  0.03015856,  0.01530481,\n",
+       "        0.02311477, -0.03156213,  0.03450044, -0.0074543 , -0.04107368,\n",
+       "       -0.04513277, -0.04755333,  0.01681224,  0.02868896,  0.00597751,\n",
+       "        0.0062148 ,  0.03227652, -0.05788355, -0.03502477, -0.05127585,\n",
+       "       -0.04840637, -0.02264437, -0.01016401, -0.04317002,  0.01554684,\n",
+       "        0.04422656, -0.01825121, -0.05225021,  0.05681161, -0.02034541,\n",
+       "        0.02992888, -0.01631412,  0.03085562, -0.03086612,  0.07806968,\n",
+       "       -0.00208791, -0.03290248,  0.00225374,  0.00643284,  0.00942418,\n",
+       "        0.01848714,  0.00079372,  0.03766846,  0.07001856,  0.02767114,\n",
+       "       -0.00659404, -0.02168669, -0.0207974 , -0.05963123,  0.00159466,\n",
+       "       -0.06902993, -0.01631861,  0.03258728,  0.05195744,  0.01295495,\n",
+       "       -0.07574536,  0.05804067,  0.00946723,  0.04908705,  0.03198564,\n",
+       "       -0.02476253, -0.01308888, -0.02987224, -0.0402046 , -0.05912255,\n",
+       "       -0.03579365,  0.05592895, -0.01209768, -0.00462931, -0.00515618,\n",
+       "        0.03687773, -0.0470187 ,  0.07340151, -0.02497839, -0.06001675,\n",
+       "        0.0057467 , -0.114128  ,  0.03985532,  0.01473989,  0.03048939,\n",
+       "        0.01199857,  0.06194041,  0.03707683,  0.0146343 ,  0.06566299,\n",
+       "        0.04049083, -0.0182422 , -0.05992466, -0.02158895, -0.02265609,\n",
+       "       -0.0748654 ,  0.08375932,  0.02491707, -0.01224103,  0.02084308,\n",
+       "       -0.08846461, -0.02883666, -0.09607532,  0.01259047, -0.02288385,\n",
+       "       -0.02240209,  0.05049241, -0.01061027, -0.02799473,  0.00775624])"
       ]
      },
-     "execution_count": 93,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -581,7 +679,15 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "7c0e622a",
+   "id": "6cc8cfd2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7cfd234",
    "metadata": {},
    "outputs": [],
    "source": []

From 2d212ae101edc3f4ee68672a7d1c69aeb233409e Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 13 Nov 2023 11:23:48 -0500
Subject: [PATCH 21/27] track 'who_dies' to t-1 spot in history for HARK 0.13
 core; generic monte carlo now matches exact

---
 HARK/core.py                                  |    5 +-
 HARK/simulation/monte_carlo.py                |    2 +-
 ...eneric Monte Carlo Perfect Foresight.ipynb | 1623 ++++++++++++++---
 3 files changed, 1418 insertions(+), 212 deletions(-)

diff --git a/HARK/core.py b/HARK/core.py
index d7db51b30..09309e362 100644
--- a/HARK/core.py
+++ b/HARK/core.py
@@ -1061,7 +1061,10 @@ def simulate(self, sim_periods=None):
                     elif var_name in self.controls:
                         self.history[var_name][self.t_sim, :] = self.controls[var_name]
                     else:
-                        self.history[var_name][self.t_sim, :] = getattr(self, var_name)
+                        if var_name is 'who_dies' and self.t_sim > 1:
+                            self.history[var_name][self.t_sim - 1, :] = getattr(self, var_name)
+                        else:
+                            self.history[var_name][self.t_sim, :] = getattr(self, var_name)
                 self.t_sim += 1
 
             return self.history
diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 93b4605cd..2326186ed 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -404,7 +404,7 @@ def sim_birth(self, which_agents):
         None
         """
         if self.read_shocks:
-            t = self.t_sim - 1 if self.t_sim > 0 else 0
+            t = self.t_sim
             initial_vals = {
                 init_var: self.newborn_init_history[init_var][t, which_agents]
                 for init_var
diff --git a/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb b/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb
index 3894c3da5..e4749ea1d 100644
--- a/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb	
+++ b/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb	
@@ -33,7 +33,7 @@
     "PFexample.cycles = 0\n",
     "\n",
     "SimulationParams = {\n",
-    "    \"AgentCount\": 10000,  # Number of agents of this type\n",
+    "    \"AgentCount\": 3,  # Number of agents of this type\n",
     "    \"T_sim\": 120,  # Number of periods to simulate\n",
     "    \"aNrmInitMean\": -6.0,  # Mean of log initial assets\n",
     "    \"aNrmInitStd\": 0, #1.0,  # Standard deviation of log initial assets\n",
@@ -66,7 +66,7 @@
     {
      "data": {
       "text/plain": [
-       "<HARK.ConsumptionSaving.ConsIndShockModel.PerfForesightConsumerType object at 0x7f81cd8bae60.\n",
+       "<HARK.ConsumptionSaving.ConsIndShockModel.PerfForesightConsumerType object at 0x7f6482eab190.\n",
        "Parameters:\n",
        "cycles: 1\n",
        "CRRA: 2.0\n",
@@ -76,7 +76,7 @@
        "PermGroFac: [1.01]\n",
        "BoroCnstArt: None\n",
        "MaxKinks: 400\n",
-       "AgentCount: 10000\n",
+       "AgentCount: 3\n",
        "aNrmInitMean: -6.0\n",
        "aNrmInitStd: 0\n",
        "pLvlInitMean: 0.0\n",
@@ -106,39 +106,486 @@
     {
      "data": {
       "text/plain": [
-       "{'who_dies': array([[0., 0., 0., ..., 0., 0., 0.],\n",
-       "        [0., 0., 0., ..., 0., 0., 0.],\n",
-       "        [0., 0., 0., ..., 0., 0., 0.],\n",
-       "        ...,\n",
-       "        [0., 0., 0., ..., 1., 0., 0.],\n",
-       "        [0., 0., 1., ..., 0., 0., 0.],\n",
-       "        [0., 0., 0., ..., 0., 0., 0.]]),\n",
-       " 'mNrm': array([[  1.00252784,   1.00252784,   1.00252784, ...,   1.00252784,\n",
-       "           1.00252784,   1.00252784],\n",
-       "        [ -0.30338194,  -0.30338194,  -0.30338194, ...,  -0.30338194,\n",
-       "          -0.30338194,  -0.30338194],\n",
-       "        [ -1.57617872,  -1.57617872,  -1.57617872, ...,  -1.57617872,\n",
-       "          -1.57617872,  -1.57617872],\n",
-       "        ...,\n",
-       "        [-21.97112221,  -9.62650475, -36.60139796, ...,   1.00252784,\n",
-       "          -2.81670212, -46.01051785],\n",
-       "        [-22.6945059 , -10.6629019 ,   1.00252784, ...,  -0.30338194,\n",
-       "          -4.02577047, -46.12435211],\n",
-       "        [-23.39954727, -11.67301988,  -0.30338194, ...,  -1.57617872,\n",
-       "          -5.20418135, -46.23529996]]),\n",
-       " 'pLvl': array([[1.01      , 1.01      , 1.01      , ..., 1.01      , 1.01      ,\n",
-       "         1.01      ],\n",
-       "        [1.0201    , 1.0201    , 1.0201    , ..., 1.0201    , 1.0201    ,\n",
-       "         1.0201    ],\n",
-       "        [1.030301  , 1.030301  , 1.030301  , ..., 1.030301  , 1.030301  ,\n",
-       "         1.030301  ],\n",
-       "        ...,\n",
-       "        [1.26973465, 1.10462213, 1.67768892, ..., 1.01      , 1.04060401,\n",
-       "         2.59927293],\n",
-       "        [1.282432  , 1.11566835, 1.01      , ..., 1.0201    , 1.05101005,\n",
-       "         2.62526565],\n",
-       "        [1.29525631, 1.12682503, 1.0201    , ..., 1.030301  , 1.06152015,\n",
-       "         2.65151831]])}"
+       "{'who_dies': array([[ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  1.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  1.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  1.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 1.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 1.,  0.,  0.],\n",
+       "        [ 0.,  1.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 1.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  1.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [ 0.,  0.,  1.],\n",
+       "        [ 0.,  0.,  0.],\n",
+       "        [nan, nan, nan]]),\n",
+       " 'mNrm': array([[  1.00252784,   1.00252784,   1.00252784],\n",
+       "        [ -0.30338194,  -0.30338194,  -0.30338194],\n",
+       "        [ -1.57617872,  -1.57617872,  -1.57617872],\n",
+       "        [ -2.81670212,  -2.81670212,  -2.81670212],\n",
+       "        [ -4.02577047,  -4.02577047,  -4.02577047],\n",
+       "        [ -5.20418135,  -5.20418135,  -5.20418135],\n",
+       "        [ -6.35271213,  -6.35271213,  -6.35271213],\n",
+       "        [ -7.47212045,  -7.47212045,  -7.47212045],\n",
+       "        [ -8.56314476,  -8.56314476,  -8.56314476],\n",
+       "        [ -9.62650475,  -9.62650475,   1.00252784],\n",
+       "        [-10.6629019 , -10.6629019 ,  -0.30338194],\n",
+       "        [-11.67301988, -11.67301988,  -1.57617872],\n",
+       "        [-12.65752504, -12.65752504,  -2.81670212],\n",
+       "        [-13.61706682, -13.61706682,  -4.02577047],\n",
+       "        [-14.5522782 , -14.5522782 ,  -5.20418135],\n",
+       "        [-15.46377611, -15.46377611,  -6.35271213],\n",
+       "        [-16.35216182, -16.35216182,  -7.47212045],\n",
+       "        [-17.21802139, -17.21802139,  -8.56314476],\n",
+       "        [-18.06192599, -18.06192599,  -9.62650475],\n",
+       "        [-18.88443232, -18.88443232, -10.6629019 ],\n",
+       "        [-19.68608295, -19.68608295, -11.67301988],\n",
+       "        [-20.46740671, -20.46740671, -12.65752504],\n",
+       "        [-21.22891902, -21.22891902, -13.61706682],\n",
+       "        [-21.97112221, -21.97112221, -14.5522782 ],\n",
+       "        [-22.6945059 , -22.6945059 , -15.46377611],\n",
+       "        [-23.39954727, -23.39954727, -16.35216182],\n",
+       "        [-24.08671143, -24.08671143, -17.21802139],\n",
+       "        [-24.75645166, -24.75645166, -18.06192599],\n",
+       "        [-25.40920978, -25.40920978, -18.88443232],\n",
+       "        [-26.04541639, -26.04541639, -19.68608295],\n",
+       "        [-26.66549117, -26.66549117, -20.46740671],\n",
+       "        [-27.26984317, -27.26984317, -21.22891902],\n",
+       "        [-27.85887106, -27.85887106, -21.97112221],\n",
+       "        [-28.43296339, -28.43296339, -22.6945059 ],\n",
+       "        [-28.99249888, -28.99249888, -23.39954727],\n",
+       "        [-29.53784664, -29.53784664, -24.08671143],\n",
+       "        [-30.06936642, -30.06936642, -24.75645166],\n",
+       "        [-30.58740883, -30.58740883, -25.40920978],\n",
+       "        [-31.09231562, -31.09231562, -26.04541639],\n",
+       "        [-31.58441986, -31.58441986, -26.66549117],\n",
+       "        [-32.06404617, -32.06404617, -27.26984317],\n",
+       "        [-32.53151095, -32.53151095, -27.85887106],\n",
+       "        [-32.98712256, -32.98712256, -28.43296339],\n",
+       "        [-33.43118156, -33.43118156, -28.99249888],\n",
+       "        [-33.86398088, -33.86398088, -29.53784664],\n",
+       "        [-34.28580602, -34.28580602, -30.06936642],\n",
+       "        [-34.69693526, -34.69693526, -30.58740883],\n",
+       "        [-35.09763978, -35.09763978, -31.09231562],\n",
+       "        [-35.48818394, -35.48818394, -31.58441986],\n",
+       "        [-35.86882535, -35.86882535, -32.06404617],\n",
+       "        [-36.23981511, -36.23981511, -32.53151095],\n",
+       "        [-36.60139796,   1.00252784, -32.98712256],\n",
+       "        [-36.95381242,  -0.30338194, -33.43118156],\n",
+       "        [-37.29729095,  -1.57617872, -33.86398088],\n",
+       "        [-37.63206016,  -2.81670212, -34.28580602],\n",
+       "        [-37.95834086,  -4.02577047, -34.69693526],\n",
+       "        [-38.27634831,  -5.20418135, -35.09763978],\n",
+       "        [-38.58629227,  -6.35271213, -35.48818394],\n",
+       "        [-38.8883772 ,  -7.47212045, -35.86882535],\n",
+       "        [-39.18280239,  -8.56314476, -36.23981511],\n",
+       "        [-39.46976206,  -9.62650475, -36.60139796],\n",
+       "        [-39.7494455 , -10.6629019 , -36.95381242],\n",
+       "        [-40.02203721, -11.67301988, -37.29729095],\n",
+       "        [-40.28771701, -12.65752504, -37.63206016],\n",
+       "        [-40.54666016, -13.61706682, -37.95834086],\n",
+       "        [-40.79903748, -14.5522782 , -38.27634831],\n",
+       "        [-41.04501545, -15.46377611,   1.00252784],\n",
+       "        [-41.28475634, -16.35216182,  -0.30338194],\n",
+       "        [-41.51841829, -17.21802139,  -1.57617872],\n",
+       "        [-41.74615544, -18.06192599,  -2.81670212],\n",
+       "        [-41.96811803, -18.88443232,  -4.02577047],\n",
+       "        [-42.18445248, -19.68608295,  -5.20418135],\n",
+       "        [-42.3953015 , -20.46740671,  -6.35271213],\n",
+       "        [-42.60080416, -21.22891902,  -7.47212045],\n",
+       "        [-42.80109605, -21.97112221,  -8.56314476],\n",
+       "        [-42.99630928, -22.6945059 ,  -9.62650475],\n",
+       "        [-43.18657263, -23.39954727, -10.6629019 ],\n",
+       "        [  1.00252784, -24.08671143, -11.67301988],\n",
+       "        [ -0.30338194, -24.75645166, -12.65752504],\n",
+       "        [ -1.57617872, -25.40920978, -13.61706682],\n",
+       "        [ -2.81670212, -26.04541639, -14.5522782 ],\n",
+       "        [ -4.02577047, -26.66549117, -15.46377611],\n",
+       "        [  1.00252784, -27.26984317, -16.35216182],\n",
+       "        [ -0.30338194,   1.00252784, -17.21802139],\n",
+       "        [ -1.57617872,  -0.30338194, -18.06192599],\n",
+       "        [ -2.81670212,  -1.57617872, -18.88443232],\n",
+       "        [ -4.02577047,  -2.81670212, -19.68608295],\n",
+       "        [ -5.20418135,  -4.02577047, -20.46740671],\n",
+       "        [ -6.35271213,  -5.20418135, -21.22891902],\n",
+       "        [ -7.47212045,  -6.35271213, -21.97112221],\n",
+       "        [ -8.56314476,  -7.47212045, -22.6945059 ],\n",
+       "        [ -9.62650475,  -8.56314476, -23.39954727],\n",
+       "        [-10.6629019 ,  -9.62650475, -24.08671143],\n",
+       "        [-11.67301988, -10.6629019 , -24.75645166],\n",
+       "        [  1.00252784, -11.67301988, -25.40920978],\n",
+       "        [ -0.30338194, -12.65752504, -26.04541639],\n",
+       "        [ -1.57617872, -13.61706682, -26.66549117],\n",
+       "        [ -2.81670212, -14.5522782 , -27.26984317],\n",
+       "        [ -4.02577047, -15.46377611, -27.85887106],\n",
+       "        [ -5.20418135, -16.35216182, -28.43296339],\n",
+       "        [ -6.35271213, -17.21802139, -28.99249888],\n",
+       "        [ -7.47212045, -18.06192599, -29.53784664],\n",
+       "        [ -8.56314476, -18.88443232, -30.06936642],\n",
+       "        [ -9.62650475, -19.68608295, -30.58740883],\n",
+       "        [-10.6629019 , -20.46740671, -31.09231562],\n",
+       "        [-11.67301988, -21.22891902, -31.58441986],\n",
+       "        [-12.65752504, -21.97112221, -32.06404617],\n",
+       "        [-13.61706682, -22.6945059 , -32.53151095],\n",
+       "        [-14.5522782 ,   1.00252784, -32.98712256],\n",
+       "        [-15.46377611,  -0.30338194, -33.43118156],\n",
+       "        [-16.35216182,  -1.57617872, -33.86398088],\n",
+       "        [-17.21802139,  -2.81670212, -34.28580602],\n",
+       "        [-18.06192599,  -4.02577047, -34.69693526],\n",
+       "        [-18.88443232,  -5.20418135, -35.09763978],\n",
+       "        [-19.68608295,  -6.35271213, -35.48818394],\n",
+       "        [-20.46740671,  -7.47212045, -35.86882535],\n",
+       "        [-21.22891902,  -8.56314476, -36.23981511],\n",
+       "        [-21.97112221,  -9.62650475, -36.60139796],\n",
+       "        [-22.6945059 , -10.6629019 ,   1.00252784],\n",
+       "        [-23.39954727, -11.67301988,  -0.30338194]]),\n",
+       " 'pLvl': array([[1.01      , 1.01      , 1.01      ],\n",
+       "        [1.0201    , 1.0201    , 1.0201    ],\n",
+       "        [1.030301  , 1.030301  , 1.030301  ],\n",
+       "        [1.04060401, 1.04060401, 1.04060401],\n",
+       "        [1.05101005, 1.05101005, 1.05101005],\n",
+       "        [1.06152015, 1.06152015, 1.06152015],\n",
+       "        [1.07213535, 1.07213535, 1.07213535],\n",
+       "        [1.08285671, 1.08285671, 1.08285671],\n",
+       "        [1.09368527, 1.09368527, 1.09368527],\n",
+       "        [1.10462213, 1.10462213, 1.01      ],\n",
+       "        [1.11566835, 1.11566835, 1.0201    ],\n",
+       "        [1.12682503, 1.12682503, 1.030301  ],\n",
+       "        [1.13809328, 1.13809328, 1.04060401],\n",
+       "        [1.14947421, 1.14947421, 1.05101005],\n",
+       "        [1.16096896, 1.16096896, 1.06152015],\n",
+       "        [1.17257864, 1.17257864, 1.07213535],\n",
+       "        [1.18430443, 1.18430443, 1.08285671],\n",
+       "        [1.19614748, 1.19614748, 1.09368527],\n",
+       "        [1.20810895, 1.20810895, 1.10462213],\n",
+       "        [1.22019004, 1.22019004, 1.11566835],\n",
+       "        [1.23239194, 1.23239194, 1.12682503],\n",
+       "        [1.24471586, 1.24471586, 1.13809328],\n",
+       "        [1.25716302, 1.25716302, 1.14947421],\n",
+       "        [1.26973465, 1.26973465, 1.16096896],\n",
+       "        [1.282432  , 1.282432  , 1.17257864],\n",
+       "        [1.29525631, 1.29525631, 1.18430443],\n",
+       "        [1.30820888, 1.30820888, 1.19614748],\n",
+       "        [1.32129097, 1.32129097, 1.20810895],\n",
+       "        [1.33450388, 1.33450388, 1.22019004],\n",
+       "        [1.34784892, 1.34784892, 1.23239194],\n",
+       "        [1.3613274 , 1.3613274 , 1.24471586],\n",
+       "        [1.37494068, 1.37494068, 1.25716302],\n",
+       "        [1.38869009, 1.38869009, 1.26973465],\n",
+       "        [1.40257699, 1.40257699, 1.282432  ],\n",
+       "        [1.41660276, 1.41660276, 1.29525631],\n",
+       "        [1.43076878, 1.43076878, 1.30820888],\n",
+       "        [1.44507647, 1.44507647, 1.32129097],\n",
+       "        [1.45952724, 1.45952724, 1.33450388],\n",
+       "        [1.47412251, 1.47412251, 1.34784892],\n",
+       "        [1.48886373, 1.48886373, 1.3613274 ],\n",
+       "        [1.50375237, 1.50375237, 1.37494068],\n",
+       "        [1.51878989, 1.51878989, 1.38869009],\n",
+       "        [1.53397779, 1.53397779, 1.40257699],\n",
+       "        [1.54931757, 1.54931757, 1.41660276],\n",
+       "        [1.56481075, 1.56481075, 1.43076878],\n",
+       "        [1.58045885, 1.58045885, 1.44507647],\n",
+       "        [1.59626344, 1.59626344, 1.45952724],\n",
+       "        [1.61222608, 1.61222608, 1.47412251],\n",
+       "        [1.62834834, 1.62834834, 1.48886373],\n",
+       "        [1.64463182, 1.64463182, 1.50375237],\n",
+       "        [1.66107814, 1.66107814, 1.51878989],\n",
+       "        [1.67768892, 1.01      , 1.53397779],\n",
+       "        [1.69446581, 1.0201    , 1.54931757],\n",
+       "        [1.71141047, 1.030301  , 1.56481075],\n",
+       "        [1.72852457, 1.04060401, 1.58045885],\n",
+       "        [1.74580982, 1.05101005, 1.59626344],\n",
+       "        [1.76326792, 1.06152015, 1.61222608],\n",
+       "        [1.7809006 , 1.07213535, 1.62834834],\n",
+       "        [1.7987096 , 1.08285671, 1.64463182],\n",
+       "        [1.8166967 , 1.09368527, 1.66107814],\n",
+       "        [1.83486367, 1.10462213, 1.67768892],\n",
+       "        [1.8532123 , 1.11566835, 1.69446581],\n",
+       "        [1.87174443, 1.12682503, 1.71141047],\n",
+       "        [1.89046187, 1.13809328, 1.72852457],\n",
+       "        [1.90936649, 1.14947421, 1.74580982],\n",
+       "        [1.92846015, 1.16096896, 1.76326792],\n",
+       "        [1.94774475, 1.17257864, 1.01      ],\n",
+       "        [1.9672222 , 1.18430443, 1.0201    ],\n",
+       "        [1.98689442, 1.19614748, 1.030301  ],\n",
+       "        [2.00676337, 1.20810895, 1.04060401],\n",
+       "        [2.026831  , 1.22019004, 1.05101005],\n",
+       "        [2.04709931, 1.23239194, 1.06152015],\n",
+       "        [2.06757031, 1.24471586, 1.07213535],\n",
+       "        [2.08824601, 1.25716302, 1.08285671],\n",
+       "        [2.10912847, 1.26973465, 1.09368527],\n",
+       "        [2.13021975, 1.282432  , 1.10462213],\n",
+       "        [2.15152195, 1.29525631, 1.11566835],\n",
+       "        [1.01      , 1.30820888, 1.12682503],\n",
+       "        [1.0201    , 1.32129097, 1.13809328],\n",
+       "        [1.030301  , 1.33450388, 1.14947421],\n",
+       "        [1.04060401, 1.34784892, 1.16096896],\n",
+       "        [1.05101005, 1.3613274 , 1.17257864],\n",
+       "        [1.01      , 1.37494068, 1.18430443],\n",
+       "        [1.0201    , 1.01      , 1.19614748],\n",
+       "        [1.030301  , 1.0201    , 1.20810895],\n",
+       "        [1.04060401, 1.030301  , 1.22019004],\n",
+       "        [1.05101005, 1.04060401, 1.23239194],\n",
+       "        [1.06152015, 1.05101005, 1.24471586],\n",
+       "        [1.07213535, 1.06152015, 1.25716302],\n",
+       "        [1.08285671, 1.07213535, 1.26973465],\n",
+       "        [1.09368527, 1.08285671, 1.282432  ],\n",
+       "        [1.10462213, 1.09368527, 1.29525631],\n",
+       "        [1.11566835, 1.10462213, 1.30820888],\n",
+       "        [1.12682503, 1.11566835, 1.32129097],\n",
+       "        [1.01      , 1.12682503, 1.33450388],\n",
+       "        [1.0201    , 1.13809328, 1.34784892],\n",
+       "        [1.030301  , 1.14947421, 1.3613274 ],\n",
+       "        [1.04060401, 1.16096896, 1.37494068],\n",
+       "        [1.05101005, 1.17257864, 1.38869009],\n",
+       "        [1.06152015, 1.18430443, 1.40257699],\n",
+       "        [1.07213535, 1.19614748, 1.41660276],\n",
+       "        [1.08285671, 1.20810895, 1.43076878],\n",
+       "        [1.09368527, 1.22019004, 1.44507647],\n",
+       "        [1.10462213, 1.23239194, 1.45952724],\n",
+       "        [1.11566835, 1.24471586, 1.47412251],\n",
+       "        [1.12682503, 1.25716302, 1.48886373],\n",
+       "        [1.13809328, 1.26973465, 1.50375237],\n",
+       "        [1.14947421, 1.282432  , 1.51878989],\n",
+       "        [1.16096896, 1.01      , 1.53397779],\n",
+       "        [1.17257864, 1.0201    , 1.54931757],\n",
+       "        [1.18430443, 1.030301  , 1.56481075],\n",
+       "        [1.19614748, 1.04060401, 1.58045885],\n",
+       "        [1.20810895, 1.05101005, 1.59626344],\n",
+       "        [1.22019004, 1.06152015, 1.61222608],\n",
+       "        [1.23239194, 1.07213535, 1.62834834],\n",
+       "        [1.24471586, 1.08285671, 1.64463182],\n",
+       "        [1.25716302, 1.09368527, 1.66107814],\n",
+       "        [1.26973465, 1.10462213, 1.67768892],\n",
+       "        [1.282432  , 1.11566835, 1.01      ],\n",
+       "        [1.29525631, 1.12682503, 1.0201    ]]),\n",
+       " 'aNrm': array([[ -1.27807355,  -1.27807355,  -1.27807355],\n",
+       "        [ -2.52615583,  -2.52615583,  -2.52615583],\n",
+       "        [ -3.74259139,  -3.74259139,  -3.74259139],\n",
+       "        [ -4.92818269,  -4.92818269,  -4.92818269],\n",
+       "        [ -6.08371181,  -6.08371181,  -6.08371181],\n",
+       "        [ -7.20994102,  -7.20994102,  -7.20994102],\n",
+       "        [ -8.30761326,  -8.30761326,  -8.30761326],\n",
+       "        [ -9.37745262,  -9.37745262,  -9.37745262],\n",
+       "        [-10.42016485, -10.42016485, -10.42016485],\n",
+       "        [-11.43643779, -11.43643779,  -1.27807355],\n",
+       "        [-12.42694183, -12.42694183,  -2.52615583],\n",
+       "        [-13.39233038, -13.39233038,  -3.74259139],\n",
+       "        [-14.33324028, -14.33324028,  -4.92818269],\n",
+       "        [-15.25029222, -15.25029222,  -6.08371181],\n",
+       "        [-16.14409113, -16.14409113,  -7.20994102],\n",
+       "        [-17.01522664, -17.01522664,  -8.30761326],\n",
+       "        [-17.8642734 , -17.8642734 ,  -9.37745262],\n",
+       "        [-18.69179151, -18.69179151, -10.42016485],\n",
+       "        [-19.49832683, -19.49832683, -11.43643779],\n",
+       "        [-20.28441144, -20.28441144, -12.42694183],\n",
+       "        [-21.05056386, -21.05056386, -13.39233038],\n",
+       "        [-21.79728952, -21.79728952, -14.33324028],\n",
+       "        [-22.525081  , -22.525081  , -15.25029222],\n",
+       "        [-23.2344184 , -23.2344184 , -16.14409113],\n",
+       "        [-23.92576966, -23.92576966, -17.01522664],\n",
+       "        [-24.59959082, -24.59959082, -17.8642734 ],\n",
+       "        [-25.25632639, -25.25632639, -18.69179151],\n",
+       "        [-25.89640959, -25.89640959, -19.49832683],\n",
+       "        [-26.52026268, -26.52026268, -20.28441144],\n",
+       "        [-27.12829717, -27.12829717, -21.05056386],\n",
+       "        [-27.72091418, -27.72091418, -21.79728952],\n",
+       "        [-28.29850463, -28.29850463, -22.525081  ],\n",
+       "        [-28.86144954, -28.86144954, -23.2344184 ],\n",
+       "        [-29.41012026, -29.41012026, -23.92576966],\n",
+       "        [-29.94487875, -29.94487875, -24.59959082],\n",
+       "        [-30.46607775, -30.46607775, -25.25632639],\n",
+       "        [-30.97406109, -30.97406109, -25.89640959],\n",
+       "        [-31.46916387, -31.46916387, -26.52026268],\n",
+       "        [-31.95171268, -31.95171268, -27.12829717],\n",
+       "        [-32.42202586, -32.42202586, -27.72091418],\n",
+       "        [-32.88041365, -32.88041365, -28.29850463],\n",
+       "        [-33.32717843, -33.32717843, -28.86144954],\n",
+       "        [-33.76261493, -33.76261493, -29.41012026],\n",
+       "        [-34.18701038, -34.18701038, -29.94487875],\n",
+       "        [-34.60064474, -34.60064474, -30.46607775],\n",
+       "        [-35.00379088, -35.00379088, -30.97406109],\n",
+       "        [-35.39671474, -35.39671474, -31.46916387],\n",
+       "        [-35.77967551, -35.77967551, -31.95171268],\n",
+       "        [-36.15292583, -36.15292583, -32.42202586],\n",
+       "        [-36.51671191, -36.51671191, -32.88041365],\n",
+       "        [-36.87127373, -36.87127373, -33.32717843],\n",
+       "        [-37.21684518,  -1.27807355, -33.76261493],\n",
+       "        [-37.55365424,  -2.52615583, -34.18701038],\n",
+       "        [-37.88192307,  -3.74259139, -34.60064474],\n",
+       "        [-38.20186823,  -4.92818269, -35.00379088],\n",
+       "        [-38.51370077,  -6.08371181, -35.39671474],\n",
+       "        [-38.8176264 ,  -7.20994102, -35.77967551],\n",
+       "        [-39.11384561,  -8.30761326, -36.15292583],\n",
+       "        [-39.4025538 ,  -9.37745262, -36.51671191],\n",
+       "        [-39.68394144, -10.42016485, -36.87127373],\n",
+       "        [-39.95819413, -11.43643779, -37.21684518],\n",
+       "        [-40.2254928 , -12.42694183, -37.55365424],\n",
+       "        [-40.48601376, -13.39233038, -37.88192307],\n",
+       "        [-40.73992889, -14.33324028, -38.20186823],\n",
+       "        [-40.98740568, -15.25029222, -38.51370077],\n",
+       "        [-41.22860738, -16.14409113, -38.8176264 ],\n",
+       "        [-41.46369311, -17.01522664,  -1.27807355],\n",
+       "        [-41.69281793, -17.8642734 ,  -2.52615583],\n",
+       "        [-41.91613301, -18.69179151,  -3.74259139],\n",
+       "        [-42.13378565, -19.49832683,  -4.92818269],\n",
+       "        [-42.34591942, -20.28441144,  -6.08371181],\n",
+       "        [-42.55267428, -21.05056386,  -7.20994102],\n",
+       "        [-42.75418661, -21.79728952,  -8.30761326],\n",
+       "        [-42.95058933, -22.525081  ,  -9.37745262],\n",
+       "        [-43.14201201, -23.2344184 , -10.42016485],\n",
+       "        [-43.32858093, -23.92576966, -11.43643779],\n",
+       "        [-43.51041916, -24.59959082, -12.42694183],\n",
+       "        [ -1.27807355, -25.25632639, -13.39233038],\n",
+       "        [ -2.52615583, -25.89640959, -14.33324028],\n",
+       "        [ -3.74259139, -26.52026268, -15.25029222],\n",
+       "        [ -4.92818269, -27.12829717, -16.14409113],\n",
+       "        [ -6.08371181, -27.72091418, -17.01522664],\n",
+       "        [ -1.27807355, -28.29850463, -17.8642734 ],\n",
+       "        [ -2.52615583,  -1.27807355, -18.69179151],\n",
+       "        [ -3.74259139,  -2.52615583, -19.49832683],\n",
+       "        [ -4.92818269,  -3.74259139, -20.28441144],\n",
+       "        [ -6.08371181,  -4.92818269, -21.05056386],\n",
+       "        [ -7.20994102,  -6.08371181, -21.79728952],\n",
+       "        [ -8.30761326,  -7.20994102, -22.525081  ],\n",
+       "        [ -9.37745262,  -8.30761326, -23.2344184 ],\n",
+       "        [-10.42016485,  -9.37745262, -23.92576966],\n",
+       "        [-11.43643779, -10.42016485, -24.59959082],\n",
+       "        [-12.42694183, -11.43643779, -25.25632639],\n",
+       "        [-13.39233038, -12.42694183, -25.89640959],\n",
+       "        [ -1.27807355, -13.39233038, -26.52026268],\n",
+       "        [ -2.52615583, -14.33324028, -27.12829717],\n",
+       "        [ -3.74259139, -15.25029222, -27.72091418],\n",
+       "        [ -4.92818269, -16.14409113, -28.29850463],\n",
+       "        [ -6.08371181, -17.01522664, -28.86144954],\n",
+       "        [ -7.20994102, -17.8642734 , -29.41012026],\n",
+       "        [ -8.30761326, -18.69179151, -29.94487875],\n",
+       "        [ -9.37745262, -19.49832683, -30.46607775],\n",
+       "        [-10.42016485, -20.28441144, -30.97406109],\n",
+       "        [-11.43643779, -21.05056386, -31.46916387],\n",
+       "        [-12.42694183, -21.79728952, -31.95171268],\n",
+       "        [-13.39233038, -22.525081  , -32.42202586],\n",
+       "        [-14.33324028, -23.2344184 , -32.88041365],\n",
+       "        [-15.25029222, -23.92576966, -33.32717843],\n",
+       "        [-16.14409113,  -1.27807355, -33.76261493],\n",
+       "        [-17.01522664,  -2.52615583, -34.18701038],\n",
+       "        [-17.8642734 ,  -3.74259139, -34.60064474],\n",
+       "        [-18.69179151,  -4.92818269, -35.00379088],\n",
+       "        [-19.49832683,  -6.08371181, -35.39671474],\n",
+       "        [-20.28441144,  -7.20994102, -35.77967551],\n",
+       "        [-21.05056386,  -8.30761326, -36.15292583],\n",
+       "        [-21.79728952,  -9.37745262, -36.51671191],\n",
+       "        [-22.525081  , -10.42016485, -36.87127373],\n",
+       "        [-23.2344184 , -11.43643779, -37.21684518],\n",
+       "        [-23.92576966, -12.42694183,  -1.27807355],\n",
+       "        [-24.59959082, -13.39233038,  -2.52615583]])}"
       ]
      },
      "execution_count": 5,
@@ -147,7 +594,7 @@
     }
    ],
    "source": [
-    "PFexample.track_vars = [\"who_dies\",\"mNrm\",\"pLvl\"]\n",
+    "PFexample.track_vars = [\"who_dies\",\"mNrm\",\"pLvl\",\"aNrm\"]\n",
     "PFexample.make_shock_history()\n",
     "\n",
     "PFexample.initialize_sim()\n",
@@ -162,7 +609,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -188,7 +635,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -216,13 +663,13 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/tmp/ipykernel_82097/947589964.py:1: RuntimeWarning: divide by zero encountered in log\n",
+      "/tmp/ipykernel_14820/947589964.py:1: RuntimeWarning: divide by zero encountered in log\n",
       "  plt.plot(np.log(np.mean(PFexample.history[\"mNrm\"], axis=1) - np.min(np.mean(PFexample.history[\"mNrm\"], axis=1))))\n"
      ]
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEGCAYAAABsLkJ6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAwwElEQVR4nO3dd3xUddb48c9JL6SSAAESErpIFaRjwd7XtTcUdVl91rb6233cdZ9d3WfdZ11dFV0broW1u5bVtQNSREWK0nsLnSQQICGQen5/zI0GTLnJzGQyM+f9es2LzM3MnXO9OIdvO19RVYwxxoSfiEAHYIwxJjAsARhjTJiyBGCMMWHKEoAxxoQpSwDGGBOmogIdQHNkZGRobm5uoMMwxpigsmjRoiJVzTz6eFAlgNzcXBYuXBjoMIwxJqiISH59x60LyBhjwpQlAGOMCVOWAIwxJkxZAjDGmDBlCcAYY8KUJQBjjAlTlgCMMSZMhUUC+GJdIc/P3cThyupAh2KMMW1GWCSAaSt388cPVjLurzP5xxcbOVRhicAYY8IiAfzxgv68PmkkPTPb8acPVzHurzN5ds5GyiqqAh2aMcYEjATTjmDDhg1Tb0tBzN+0l8kz1vLl+j1ktIvhZ+O6c82obiTEBFVVDGOMcU1EFqnqsB8dD7cEUGvB5r08NmMdX6wrIj0xhkkndOeakd1IjLVEYIwJLZYAGrAov5jJM9YxZ20h6YmeFsGEUZYIjDGhwxJAE77dUszk6euYvbaQtIRofnZCdyaMyqWdJQJjTJCzBODSd1s8LYJZazyJYNIJPaxFYIwJam0uAYhIHDAHiMWzL8FbqvqHxt7TGgmg1uKt+3h0+lpmrfF0Dd0wNo8Jo7qRFBfdKp9vjDG+0hYTgACJqloqItHAXOB2VZ3X0HtaMwHUqts1lBwXxfVj85g4Jo+UeEsExpjg0FACCNg6APUodZ5GO4821x91XE4aU68fzvu3jGFE9/Y8On0dYx/4nEenr2X/ocpAh2eMMS0W0DEAEYkEFgE9gSdU9b/rec0kYBJATk7O0Pz8enc2azXLt+/nsRnr+GzlbpLiopg4Jo8bxuSRkmAtAmNM29TmuoCOCEIkFXgXuFVVlzf0ukB0ATVkxQ5PIvh0xW6SYqOYODaPG8Za15Axpu1pc11AdanqPmAmcGaAQ3Ht2M4pPHPNMD6+fRxjembw2AxP19Dk6es4cNi6howxbV+zEoCIpInIQF98sIhkOv/yR0TigdOA1b44d2s6JiuZp68Zyoe3jWVU9/Y8Mn0t4x6Yyd8/X0dpudUaMsa0XU12AYnILOB8PFM1FwEFwJeqeqdXH+xJJFOBSDyJ6E1V/WNj72lLXUANWb59P49OX8v0VQWkJkTzs3HduW50rq0jMMYETIvHAETkO1UdIiI3Atmq+gcRWaqqPmkJNEcwJIBaS5x1BDOdBWU3OiUmbB2BMaa1eTMGECUiWcClwAc+jyxEDcpO5YWJw3n3v0YzODuVBz9dw1jrGjLGtCFuEsAfgU+BDaq6QES6A+v8G1boGJKTxgsTPesIhnVL46HP1jLugc95ctZ624/AGBNQbWIaqFvB1AXUkCVb9/GIU2KifWIMN5/Ug6tGdCM+JjLQoRljQlSLu4BEpLeIzBCR5c7zgSLyO38EGQ4GZafy4sThvH3zaPpmJfGnD1cx5oHPeWLmeltZbIxpVW4GgWcDvwKeUdUhzrHlqtq/FeI7Qii0AI42f9Nenpy1nllrCkmKjWLC6G5cPyaP9u1iAx2aMSZENNQCcDM3MUFV53tqt33POq99ZHheOsPzhrN8+36emrWBJ2dt4Pm5m5kwuhs3n9iD1ISYQIdojAlRbgaBi0SkB06hNhG5GNjp16jCUP8uKTxx1XFM++UJnHFsR6bM2ci4v87kiZnrOWizhowxfuCmC6g7MAUYDRQDm4CrVXWz36M7Sih2ATVk9a4DPPTpGqavKvh+sPjqkd2Ii7bBYmNM83hdDE5EEoEIVS3xdXBuhVMCqPXtlmIe/mwtc9cXkZUSx+2n9OLioV2JimwTZZyMMUHAm1lAfxaRVFU9qKolTj2gP/knTHO043LSePnGEbz6sxF0Sonj7neWcdojc3hz4VYqq2sCHZ4xJoi5+WfkWU61TgBUtRg4228RmXqN7pHBOzePZso1Q4mPjuTXby3lpAdn8co3+ZYIjDEt4iYBRIrI93MSncqdNkcxAESE04/txIe3jeWFicfTKSWOe95dzhmPzOGT5TsJpkV9xpjAczMN9BVghoi84DyfiKeKpwkQEeHkPh04qXcm01cV8MAnq7np5W/p3yWZO07pzSnHdOCoabvGGPMjjQ4COxu3dwWOBU51Dk9T1U9bIbYfCcdBYDeqqmt497vtPP75erbsLePYzsn8/MQenN2/kw0WG2O8Kge9TFUH+C2yZrAE0LhKJxE8PXsDGwsPkp0ez41ju3PJsK4kxNh+BMaEK28SwFTg76q6wF/BuWUJwJ2aGmXaqt08PXsD323ZR2pCNFeP6MaE0d3okBQX6PCMMa3MmwSwGugJ5AMHAQHUNoQJDgs372XKnI1MW7Wb6IgILhjcmZtP6kH3zHaBDs0Y00q8qQV0hh/iMa1kWG46w3LT2Vx0kOe/3MS/Fm7jne+2c8nQrtx2Si86p8YHOkRjTIC4aQHk1HdcVbd49cEi2cA/gY546gxNUdXJjb3HWgDeKywp58lZ63ll3hYQmDg6l/86qScpCbZVpTGhyqtBYDxf0ALEAXnAGlU91suAsoAsVf1WRJLwbDj/E1Vd2dB7LAH4zrbiMh6etpZ3v9tOclw0N5/Ug2tH5drGNMaEoBaXglDVAao60PmzFzAc+NrbgFR1p6p+6/xcAqwCunh7XuNO17QEHr50MB/eOo7B2an85ePVnPDgTKZ+tZnyqupAh2eMaQUt2hLS11NDRSQXmAP0V9UDR/1uEjAJICcnZ2h+fr6vPtbUMX/TXh76bA3zN+2lS2o8t5/Si58e18XWERgTArzpArqzztMI4Digvar6ZHBYRNoBs4H7VfWdxl5rXUD+parMXV/EQ5+uYcm2/fTs0I57zj6Gk/pk2spiY4JYi7uAgKQ6j1jgQ+ACHwUVDbwNvNLUl7/xPxFhXK9M/v2LMTxzzVCqa5SJLy5gwvPzmbuuyGoNGRNimrMfQDsAVS31yQd7/kk5Fdirqne4eY+1AFpXRVUNL8/L5+8z17P3YAXdMxO5dlSurSw2Jsh40wXUH3gJSHcOFQHXqupyLwMaC3wBLANq6xn/VlU/aug9lgAC43BlNR8t28nUr/NZsnUfKfHRXDUih2tGdSMrxdYRGNPWeZMAvgLuUdWZzvOTgD+r6mg/xNkoSwCBtyh/L8/O2cSnK3cRIcJpx3RkwqhujOrR3sYJjGmjvFkJnFj75Q+gqrOc7SFNGBraLZ2h16SzZU8Zr3yTzxsLt/LJil30yEzkmpHduGhoV5LibFGZMcHATQvgXeBbPN1AAFcDQ1X1Qj/H9iPWAmh7DldW88HSnbw0z9M9lBQXxZUjcrh+TB4dk63wnDFtgTddQGnAfcBY59Ac4D5na8hWZQmgbVuydR9TvtjIx8t2EhkhXDy0Kzed2INu7a3BaEwgtTgBHHWSSDxdQgeafLEfWAIIDlv2lDHliw28uXAbVdU1nN6vE1eNzGFMjwwiImycwJjW5k0L4FXgJqAaWAAkA5NV9UF/BNoYSwDBpeDAYZ7/cjNvLNhCcVkleRmJ3Dq+JxcM7kKkJQJjWo03C8H6Of/i/wnwMZ5icNf4NjwTijokx3H3WX2Z99tTmHz5YOKjI7nzzSWcPfkLZq4uCHR4xoQ9Nwkg2lmx+xPgfVWtxFMd1BhXYqMiuWBwFz64dSx/v3IIFdU1THxxATdOXcjWvWWBDs+YsOUmATwDbAYSgTki0g0IyBiACW4REcK5Azvz6R0ncPdZfflqQxGnPDyb3767jI2FPllgboxphpZWA41S1So/xNMoGwMILTv3H+KxGet4+9vtVFbXcFLvTC4a2pVTj+lIXLTtS2CMr3gzCNwR+DPQWVXPEpF+wChVfc4/oTbMEkBoKiwp56WvN/Pmwm3sOnCYpLgobhvfi4ljcq0ctTE+4E0C+Bh4AU85iEEiEgV858v9ANyyBBDaqmuUeRv38NzcTXy+uoCBXVP484UD6N8lJdChGRPUvJkFlKGqb+IUbHO6fmzLKONzkRHCmJ4ZPHftMB6/Ygjbiw9x7uNzmfD8fOasLbRy1Mb4mJsEcFBE2uPM/BGRkcB+v0ZlwpqIcN6gzsy460TuOq03q3YeYMLz87nk6a9Zvt3+6hnjK266gI4DHgf6A8uBTOBiVV3q//COZF1A4am8qpq3F23nb5+tYW9ZBZcOzeamk3qQl2ElJoxxo0XVQJ3SDyc6jz6AAGuctQDGtIrYqEiuHJHDOQOzeGzGOl76Op83F23l9H4duXV8LxsjMKaF3LQA5qvq8FaKp1HWAjAABSWHeenrfF6al8+BQ5VcPbIbd53Wh5QEK0NtTH28mQX0CBANvAEcrD2uqt/6OsimWAIwde0/VMkj09byz683kxIfzaXHZ3PF8TnkWteQMUfwJgHMrOewqup4XwXnliUAU58VO/bz2Ix1TF9VQHWNcsHgztx/4QDaxdq+xcaAFzuCqerJ/gnJGN84tnMKz1wzjIIDh5n69WaemrWBFTsO8Mw1Q+mR2S7Q4RnTZgV0maWIPC8iBSLi1QbzxoCn+uivzujLyzeMYO/BCs5/fC5//3wdpeWtXrXEmKAQ6HX2LwJnBjgGE2JG98zgg1vHMqpHex76bC3jHvicydPXsXP/oUCHZkyb4mYMIFZVy5s61uIARHKBD1S1f1OvtTEA01yLt+7j0elrmbWmkAiBE3pnctOJPRjZvX2gQzOm1XgzCPytqh7X1DEvAsulkQQgIpOASQA5OTlD8/PzffGxJszk7znIvxZu442FWyksKWdcrwzuOr0Pg7NTAx2aMX7X7AQgIp2ALsDLwJV4FoGBZ0vIp1W1r48Cy8VaAKaVHK6s5uV5+Tw5awN7D1Zw9oBO/OqMvraq2IS0lswCOgO4DugKPFzn+AHgtz6NzphWEhcdyY3junP58ByenbORZ7/YyGcrdnPViBxuP7U36YkxgQ7RmFbjpgvoIlV9228BWAvABFBByWEmT1/Ha/O3kBgbxa3je3Ld6DxiogI9P8IY3/GmHPSXIvKcsy8AItJPRG7wUVCvAV8DfURkm6/Oa4xbHZLiuP/CAXx6xwkM7ZbGnz9azTmPfcG8jXsCHZoxfmcbwhhTx/SVu7n3PyvYVnyIcwdmcdfpfWx8wAQ92xDGGBdO7deRab88kdvG92TGqgJOfXg297y7jAOHrQCuCT22IYwxR4mPieTO0/sw+9cncfWIHF5fsJVzH5vLkq37Ah2aMT7lJgHcCbwP9BCRL4F/Arf6NSpj2oAOSXHcd0F/3vz5SKprlIue+op/fr050GEZ4zNuEkAxng1hRgM/B44FYv0ZlDFtydBu6Xx02zhO6tOB37+3gsdnrLP9iU1IcJMA3gI6quoKVV0OjAKe929YxrQtKQnRPH31cfz0uC78bdpaHvhkjSUBE/TcFEy/Cfi3iJwHHAf8H3C2X6Mypg2KiozgoYsHER8dydOzN7CpqJS/XjTIdiIzQavJFoCqLgBuAz4D7gVOVdWtfo7LmDYpIkL400/687tzjmHGqgLOefwLFuXvDXRYxrRIY7WA/oMz88fRD9iJZ0wAVT3f79EdxdYBmLbkuy3F3PLqd2zf51kz8P9O72PbUZo2qSXF4E5s7ISqOttHsblmCcC0NSWHK52aQpuorK7h3IFZTByTxyCrMmrakBaVgxaRSGB6W9kW0hKAaasKDhzmqdkb+NfCbZSWV3FcTirXjcnjrP6diI60ukImsLzZD2AG8FNVDfjiL0sApq0rOVzJW4u2MfWrzWzeU0aHpFiOz0una1o8fTomcd6gzpYQTKvzJgG8BwwBpgEHa4+r6m2+DrIplgBMsKipUWavK+S1b7awrqCU7cWHqKiuoXtmIvecfQzj+3ZARJo+kTE+0JL9AGq94zyMMS5FRAgn9+nAyX06AJ6EMHNNAfd/uIobpi4kOlIQhITYSM4ZkMUVw3Po3yUlwFGbcNNkC6AtsRaACXaV1TW8vWgb+XvLUIVd+w/x8fJdlFfVcHKfTB69bIitKzA+500XUC88i7/6AXG1x1W1u6+DbIolABOK9pdV8tqCLfztszV0SY3n2QnD6NUxKdBhmRDiTTnoF4CngCrgZDzF4F72bXjGhK+UhGhuOrEHr/1sJKXl1fzkiS9tQxrTKtwkgHhVnYGntZCvqvcC5/g3LGPCz7DcdP5z6xiyUuO54cUFLMovDnRIJsS5SQDlIhIBrBORW0TkQqCdn+MyJixlpcTz6o0jyEyK5brn57N0275Ah2RCmJsEcDuQgKce0FDgGuBaX3y4iJwpImtEZL2I3O2LcxoT7Dokx/Hqz0aSkhDNZc/M47X5W6zyqPGLgM0CclYZrwVOA7YBC4ArVHVlQ++xQWATTnYfOMydby7my/V7GN+3Ax2SYlmybT9JcVE8c/VQ0hJjAh2iCRItHgQWkWEi8q6IfCsiS2sfPohpOLBeVTeqagXwOnCBD85rTEjomBzHS9eP4HfnHMPc9UV8vHwXGe1iWLx1Hz9/eREVVTWBDtEEOTcLwV4BfgUsw9kY3ke6AHXLSm8DRvjw/MYEvYgI4cZx3blmVDdiIiMQEd5bvJ3bX1/Mb95ZxkOXDLQVxabF3CSAQlV93++RNEBEJgGTAHJycgIVhjEBFRsV+f3PFwzuwsbCg0yesY6YqAh+f24/4mMiG3m3MfVzkwD+ICL/AGYA5bUHVdXb8hDbgew6z7s6x46gqlOAKeAZA/DyM40JCXec2ovDldU8M2cj32zaw6OXDWZg19RAh2WCjJtZQBOBwcCZwHnO41wffPYCoJeI5IlIDHA5ELCWhjHBRET4zdnH8MqNIzhUUc3FT31tO5OZZnNTCmKNqvbxy4eLnA08CkQCz6vq/Y293mYBGfNjxQcr+MmTX1JWUc1/bhlLp5S4pt9kwoo3pSC+EpF+fogJVf1IVXurao+mvvyNMfVLS4zh2QnDKCuv4ucvL+JwZXWgQzJBwk0CGAksdhZsLRWRZT6aBmqM8ZHeHZP426WDWbJ1H3e/vZSaGhsuM01zMwh8pt+jMMZ47cz+nfjVGX148NM1dEiO47dnHxPokEwb12QCUNX81gjEGOO9/zqpB7sPHGbKnI1ktovlxnF5tk7ANMhNC8AYEyREhD+cdyxFpeXc/9EqXpqXz/i+HTh3YBZDu6VZMjBHsB3BjAlB5VXVvLVoGzNWFfDl+iLKq2oYnJ3KjePyGNm9Pe0TY75PBjU1yoLNe/n34h0s3rqP6hrPgv9bx/fivEGdA3kZxkdavCNYW2IJwJjmK6uo4u1F2/jH3E3k7ykDIC0hmsykWCqqath/qJLiskrioyMZ0T2d+OhI1heUsn3fIT694wSy0xMCfAXGW81OACJSAjSYHVQ12XfhuWMJwJiWq65Rvtm4h9W7SlhXUMLegxXERUcSFxXJqB7tOa1fRxJjPb3CO/Yd4vRH5tC/SzKv3jiSiAjrOgpmDSWABscAVDXJeeP/AjuBlwABrgKy/BSnMcZPIiOE0T0zGN0zo8nXdk6N53fnHMPd7yzjpXn5XDs61/8BmlbnZh3A+ar6pKqWqOoBVX0KK9tsTMi77PhsTuidyf0fruLW175j5uoCqqqtBHUocZMADorIVSISKSIRInIVcNDfgRljAktEeOTSQVx6fFe+WFfIxBcXcNJDs3ht/hbbiyBEuKkFlAtMBsbgGRP4ErhDVTf7O7ij2RiAMYFRUVXD56t389TsjSzZuo/OKXFMOqE7lx2fY6Wog4DNAjLGeE1VmbOuiMdnrGNhfjHtE2P4zdnHcPHQroEOzTTCmy0he4vIDBFZ7jwfKCK/80eQxpi2TUQ4sXcmb908mjd/PorcjET+++2lfLulONChmRZwMwbwLPAboBJAVZfiqd1vjAljw/PSeWHi8XRKjuOO1xdTWl4FwIHDlRSVljfx7iN9u6WYDYWl/gjTNMJNKYgEVZ1/1BLyKj/FY4wJIslx0Uy+fDCXPvM1d7+9lKyUOF79ZgtJcdHM+fXJxEQ1/W/MksOVTHhuPnHRkXxyxzgy2sW2QuQG3LUAikSkB86iMBG5GM+6AGOMYVhuOreM78UHS3fy/JebGdA1hV0HDvPZyl2u3v/Ggq2Ullex/1AFv/rXEoJpXDLYuWkB/ALPnrx9RWQ7sAm42q9RGWOCym3je5KTnsCIvHQ6p8Zz4oMzeXlePucObLyWUHWN8uJXmzk+N41zBmRx739W8tK8fCaMym2dwMNcky0AVd2oqqcCmUBfVR0biCmgxpi2KyoygouHdiU7PYHICOGK4TnM27iX9QVH9uurKu9+t43l2/cDMG3lLrYVH+L6MXlcOzqXk/t4Fp59taEoEJcRdtzMAqoWkb8AZapa4hz71u+RGWOC1mXHZxMdKbzyzQ/biagqf/l4Nb98Ywk/eeJLpszZwHNzN9E1LZ7Tj+2EiPDgJYPISU/g2ufn897i7QG8gvDgZgxghfO6z0Qk3TnmVWUoEblERFaISI2I/GhuqjEmuGW0i+XM/lm8vWgbhyqqUVX++MFKnpmzkStH5HDqMR3580erWbC5mOtG5xLpFJvLaBfLWzeNZmi3NG5/fTHPzd0U4CsJbW7GAKpU9dcichnwhYhMoJEqoS4tB34KPOPleYwxbdRVI3L4z5Id9L/3U6qdPYqvH5PH/5zr2ary1flbmLZyN5cen33E+1ISopl6/XBuf20x93+4koFdUzg+N/1H5zfec1MK4jtVHeL83B94FchR1VSvP1xkFvD/VNXV8l5bCWxM8FBVXvhyM0Wl5URFRpDbPoELh3RxvStZaXkVZ0/+ghpVPrp9HMlx0X6OOHQ1uxx0HTfW/qCqy0VkHK1YDVREJgGTAHJyclrrY40xXhIRrh+b1+L3t4uN4pHLPGsM7n1vBQ9fNth3wRmgkQQgIuNV9XOgm4h0O+rXTS7ZE5HpQKd6fnWPqr7nNkBVnYJnGirDhg2zCcLGhJGh3dK45eSeTJ6xjn6dk7lxXPdAhxRSGmsBnAh8DpxXz+8UeKexEztTR40xxiu3ju/J2t0l/OnDVRyurOYXJ/e0ze19pLEdwf7g/Dmx9cIxxpgjRUVG8PgVQ/j1W0t56LO1VFQrd57WO9BhhYTGuoDubOyNqvpwSz9URC4EHsezuOxDEVmsqme09HzGmNAWFRnBQ5cMorJGeXLmem4Yk0dKgg0Ke6uxdQBJTTxaTFXfVdWuqhqrqh3ty98Y05SICOGGsXlU1SjTVu0OdDghobEuoPtaMxBjjGnKoK4pdE6J45PlO20TGh9ochqoiMQBNwDHAnG1x1X1ej/GZYwxPyIinDUgi5e+zqfkcCVJtjbAK25KQbyEZzrnGcBsoCtQ4s+gjDGmIWcP6ERFdQ2fry4IdChBz00C6Kmq/wMcVNWpwDnACP+GZYwx9RuSnUbH5Fg+WmbbknjLTQKodP7c55SCSAE6+C8kY4xpWESEcOaxnZi1ppCD5bY5oTfcJIApIpIG/A/wPrAS+KtfozLGmEacNSCL8qoaZq6xbiBvNDkIrKr/cH6cDdg6bGNMwB2fm06HpFj+/d32JncdMw1zMwsoFZgA5NZ9vare5reojDGmEZERwoVDuvDc3E0UlZbbRvIt5KYL6CM8X/7LgEV1HsYYEzAXDe1KVY3y3uIdgQ4laLkpBx2nqo2WhTDGmNbWu2MSA7qk8PaibdzgRdnpcOZqHYCI/ExEskQkvfbh98iMMaYJFx3XhZU7D7Bq54FAh9Jsq3cd4OV5+TS1KZc/uUkAFcCDwNf80P1j23IZYwLu/MFdiI4U3l60LdCh1Kumpv4v91lrCrjoya/43b+Xs76gye1V/MZNArgLz2KwXFXNcx42G8gYE3DpiTGc3KcD/168ncOV1YEO5wjFBysY8r/TmPrV5iOOvz5/CzdMXUinFE9lnTnrigIQnYebBLAeKPN3IMYY0xLXjcmlqLSCl+flBzqUI6zeVcL+Q5X88YOVzHW+5J+ZvYG731nG2J4ZvHfLWLpnJvLFusKAxehmEPggsFhEZgLltQdtGqgxpi0Y3SODcb0yeGLmei47PrvNFIjbVHQQgE7Jcfzi1W+5cEgXXvxqM+cOzOKRywYTHRnBCb0yeX3BFsqrqomNimz1GN20AP4N3A98hU0DNca0Qb86ow/FZZU8O2djoEP53uY9B4mNiuCVG0cgAi9+tZlLhnZl8uVDiI70fPWO65XB4coaFm0uPuK9qsof3lvOb99dRkVVjd9ibLQFICKRwHWqerLfIjDGGC8N7JrKOQOy+MfcTVwzKpfMJO8Whu0vq6RdXBSRES3fe3hj4UFy2yeSm5HI1InD+W5LMRNG5RJR55wju7cnOlKYs66I0T0zvj/+wdKdTP3a06W1dW8ZT189lMRYNx02zdNoC0BVq4EaEUnx+ScbY4wP3XV6b8qranjp681enedQRTVj//o5r83f4tV5NhWVkpuRAMCg7FSuG5N3xJc/QGJsFMflpB0xDlBUWs7v31vOoK4p/OWnA/hqwx6ufHYee0rL8TU3XUClwDIReU5EHqt9+DwSY4zxQvfMduRlJLJmt3fblazdXULJ4SqvpmdW1yhb9paRl9Guydee0DuTFTsOUOR8wf/+veUcLK/mwUsGcfnwHJ65eijrC0pZscP3ax3ctCnecR4+IyIPAufhWWOwAZioqvt8+RnGmPCTnRbP1r2HvDrH6l2eL9rdBw63+Bzbiw9RWa3kOS2AxozrlcGDn67hj/9ZyY59h1iYX8yvzuhD746erddP7deRuf89nrTEmBbH05AmWwDOJjCv8cPg76vOMW9MA/qr6kBgLfAbL89njDHkpCewtdi7WeurdnpaEAUlLe9y2bTHMwPITQvg2M4pZCbF8v6SHZRVVPPrM/vw8xOOXGrljy9/cFcN9CRgKrAZECBbRK5V1Tkt/VBV/azO03nAxS09lzHG1MpOT6DkcBX7yypJSWjZdFBftAA2FXq6j/IyEpt8bWSE8M7NowFP/K3JTRfQ34DTVXUNgIj0xtMiGOqjGK4H3mjolyIyCZgEkJOT46OPNMaEoq5pni/QLXvLGJDQ/LkrqsrqXU4L4EA5qopI82cCbSo6SLvYKDLaufuXe2t/8ddyMwgcXfvlD6Cqa4EmU6uITBeR5fU8LqjzmnuAKuCVhs6jqlNUdZiqDsvMzHQRrjEmXGWnxwO0uBto94Fy9pVVkpeRSEV1DfvKKpt+Uz027SkjLyOxRcmjNblpASwUkX8ALzvPr8JFMThVPbWx34vIdcC5wCkayHJ4xpiQUfsv6a17W5YAVjndPyf2zmRT0UF2lxxuUf/7pqJSBmentSiG1uSmBXAznn2Ab3MeK51jLSYiZwK/Bs5XVaszZIzxieS4aFLio1vcAljtDACP6+VZlLX7QPMHgsurqtlefMhV/3+gudkTuBx42Hn4yt+BWGCa00Sap6o3+fD8xpgwlZ3e8qmga3YdoHNK3PdTMFsyELx1bxk1Ct1DIQGIyBjgXqAbR+4J3OKS0Kras6XvNcaYxmSnJbR4MdjqXSX0zUr+vpREQQsSwMZCzxTQ3FBIAMBzwC/xrAFoWwW3jTHmKNnpCcxYXUBNjf6o9EJjKqpqWF9Qyvi+HYiLjiQ1IbpFXUCba9cAtA+NBLBfVT/2eyTGGOMD2ekJVFTVUFhaTsfkONfv21BYSlWN0jcrGYCOSXEt6gLaVHSQ9MSYFq9DaE1uEsBMp3TDOxy5H8C3fovKGGNaKDvNMxV0y96yZiWA2gVgfTt5+v87JMeyu5mrgauqa5i5upCBXYOjfqabBDDC+XNYnWMKjPd9OMYY4526U0GPz013/b5vNu4lJjLi+9k7HZLiWF/QvO0aP19dwK4Dh7nvgmOb9b5AcTMLyPYCMMYEjS6pzmKwZswEmrmmgNcXbOXqkTnfb9bSMTmWwpLyZo0lvPLNFjomx3JK3w7NDzwA3KwDMMaYoBEXHUnH5FjXawF27DvEnW8s5pisZH53Tr/vj3dMjqOqRtlbVuHqPFv2lDFnXSGXH59DVGRwfLUGR5TGGNMM2WkJrlYDV1bXcNtr31FRVcMTVw4hLvqHfXk7JnumgrodCH5twRYEuHx4dotiDgRLAMaYkJOdnsC24qa7gP7y8WoW5hfzfxcNpHvmkaWbOzgDyAUupoKWV1Xz5oKtnHJMR7JS4lsWdAC42mRSREYDuRy5EOyfforJGGO8kp0Wz3uLD1FZXfN9n/7R3l+yg+fmbuK60bmcP6jzj35fO4PITQvgq/V72HOwgqtHdvMu8FbmZiXwS0APYDE/LARTwBKAMaZN6pqWQI3Crv2H6y21vHZ3Cf/91lKGdUvjt2cfU+85MtvVdgE13QI4uW8HPrh1LP2cNQTBwk0LYBjQzyp2GmOCRbpTwXPvwYp6E8DDn60lLjqCJ686jpio+lsIMVERtE+MYXeJuzGA/l2CY+5/XW7GAJYDnfwdiDHG+EpaomcVbnEDM3i27zvEoOzU7/v5G9IhOa5F9YCChZsWQAawUkTmc+RK4PP9FpUxxnghNcHTAmhoQ5ei0nL6OCt+G9MxObZF9YCChZsEcK+/gzDGGF9KcxJAfS0AVaWotJwMp4+/MR2T4li544DP42sr3KwEnt0agRhjjK+kxEcjAsX1tAD2H6qkslq/L/ncmA7JsRSVllNVXRM0i7uao8krEpGRIrJAREpFpEJEqkUkdFOiMSboRUYIyXHR7KunBVBU6unScbNhe6eUOGoUCktDsxvITUr7O3AFsA6IB24EnvBnUMYY4620hOh6WwAFToXPTBddQJ2dRV079oXmQLCrNo2qrgciVbVaVV8AzvRvWMYY453UhJgGWgCeY266gLJSPbOEdu5v2RaTbZ2bQeAyEYkBFovIX4GdeFlCQkT+F7gAqAEKgOtUdYc35zTGmLrSEqLr7bopKqntAnKRAJwWwM4wbgFc47zuFuAgkA1c5OXnPqiqA1V1MPAB8Hsvz2eMMUdIS4ih+OCPu4AKS8uJihBS4pvesSs5LorEmEh2hGsLQFXzRSQeyFLV+3zxoapadxA5EU9pCWOM8ZkGu4BKPFNA3dT4FxGyUuPDtwUgIufhqQP0ifN8sIi87+0Hi8j9IrIVuIpGWgAiMklEForIwsLCQm8/1hgTJtISojlYUU1FVc0Rx4tKy8lIanoGUK2slLiQHQNw0wV0LzAc2AegqouBvKbeJCLTRWR5PY8LnPPco6rZwCt4upfqpapTVHWYqg7LzMx0Ea4xxkBqYu1q4CNbAYUuF4HV6pwSz479odkCcDMIXKmq+0WOaC412WWjqqe6jOEV4CPgDy5fb4wxTUpLqK0HVHlEzZ+ikgqO6eS+amdWahxFpeVUVNU0WDguWLm5mhUiciUQKSK9RORx4CtvPlREetV5egGw2pvzGWPM0eorB1FTo+w5WE6GiymgtTqnxKPqfmewYOImAdwKHIunENxrwAHgDi8/9y9Od9BS4HTgdi/PZ4wxR0h1WgB1u4Bqy0A0pwuodi3Ajn2hNw7gZhZQGXCP8/AJVfV2GqkxxjTqhxbAD1NBa8tAuFkEVuv7tQAhOA7QYAJoaqaPlYM2xrRl9XUBFZa4rwNUq3NtCyAEZwI11gIYBWzF0+3zDdD0pFljjGkj4mMiiY2KOGJPgNqVwW7qANVKiIkiJT46JNcCNJYAOgGn4SkEdyXwIfCaqq5ojcCMMcZbntXAP7QAmlMHqK5QXQvQ4CCwU/jtE1W9FhgJrAdmiUiDc/aNMaYtST2qImhhSTnRke7KQNTVOTU+JCuCNjoILCKxwDl4WgG5wGPAu/4PyxhjvJd2VDmIotJy2ifGctS6piZlpcTx3ZZiX4cXcI0NAv8T6I9nkdZ9qrq81aIyxhgfSEuMZs2uku+fF5WWN7v7BzwtgOKySg5VVBMfE+nLEAOqsXUAVwO98MzR/0pEDjiPEtsRzBgTDDwF4Y7sAmrODKBaWSmhuS9AY2MAEaqa5DyS6zySVNX9OmpjjAmQtIRo9h2qRNVTvcbtZvBHq7sWYNXOA0x4fj77D/241HSwcVMLyBhjglJaQgzVNcqBw1UkxUaxp7SihV1AnhbAf5bs4MNlO2kXG8We0vJmDya3NZYAjDEhKzXhh4qg1TVKVU3zykDU6uR0Ab2+YCs9MhP55w0j6JIa79NYA8ESgDEmZNWtCFru7AvQnEJwtWKjIunWPoHUhBheuO540hObP47QFlkCMMaErNQ65SC27K0CoFOd0tDN8f4tY0mMiSQqMnRKQlsCMMaErLQ6FUGfn7uZ3PYJDO2W1qJzBXt/f31CJ5UZY8xRagvCvb94B8u27+emE3sQ6WIv4HBhCcAYE7KS46MRgZlrCumUHMeFx3UJdEhtiiUAY0zIioz4oe7PjePyiI0KnVW8vmBjAMaYkJaWEIMAVwzPCXQobY4lAGNMSLvl5J4kxUWRGGtfd0ez/yLGmJB20dCugQ6hzQroGICI3CUiKiIZgYzDGGPCUcASgIhkA6cDWwIVgzHGhLNAtgAeAX4NaABjMMaYsBWQBCAiFwDbVXWJi9dOEpGFIrKwsLCwFaIzxpjw4LdBYBGZjmdj+aPdA/wWT/dPk1R1CjAFYNiwYdZaMMYYH/FbAlDVU+s7LiIDgDxgibMvZ1fgWxEZrqq7/BWPMcaYI7X6NFBVXQZ0qH0uIpuBYapa1NqxGGNMOLNSEMYYE6akdq/MYCAihUB+C9+eAYRKK8Oupe0Kpeuxa2mbWnIt3VQ18+iDQZUAvCEiC1V1WKDj8AW7lrYrlK7HrqVt8uW1WBeQMcaEKUsAxhgTpsIpAUwJdAA+ZNfSdoXS9di1tE0+u5awGQMwxhhzpHBqARhjjKnDEoAxxoSpsEgAInKmiKwRkfUicneg42kOEckWkZkislJEVojI7c7xdBGZJiLrnD/TAh2rWyISKSLficgHzvM8EfnGuT9viEhMoGN0Q0RSReQtEVktIqtEZFSw3hcR+aXz92u5iLwmInHBdF9E5HkRKRCR5XWO1XsvxOMx57qWishxgYv8xxq4lgedv2dLReRdEUmt87vfONeyRkTOaM5nhXwCEJFI4AngLKAfcIWI9AtsVM1SBdylqv2AkcAvnPjvBmaoai9ghvM8WNwOrKrz/AHgEVXtCRQDNwQkquabDHyiqn2BQXiuKejui4h0AW7DU5KlPxAJXE5w3ZcXgTOPOtbQvTgL6OU8JgFPtVKMbr3Ij69lGtBfVQcCa4HfADjfBZcDxzrvedL5znMl5BMAMBxYr6obVbUCeB24IMAxuaaqO1X1W+fnEjxfMl3wXMNU52VTgZ8EJMBmEpGuwDnAP5znAowH3nJeEhTXIiIpwAnAcwCqWqGq+wjS+4KnLli8iEQBCcBOgui+qOocYO9Rhxu6FxcA/1SPeUCqiGS1SqAu1HctqvqZqlY5T+fhKaIJnmt5XVXLVXUTsB7Pd54r4ZAAugBb6zzf5hwLOiKSCwwBvgE6qupO51e7gI6BiquZHsWzEVCN87w9sK/OX+5guT95QCHwgtOd9Q8RSSQI74uqbgcewrM7305gP7CI4LwvdTV0L4L9O+F64GPnZ6+uJRwSQEgQkXbA28Adqnqg7u/UM5e3zc/nFZFzgQJVXRToWHwgCjgOeEpVhwAHOaq7J4juSxqef0nmAZ2BRH7cBRHUguVeNEVE7sHTLfyKL84XDglgO5Bd53lX51jQEJFoPF/+r6jqO87h3bXNVufPgkDF1wxjgPOdEuCv4+limIynCV5bmjxY7s82YJuqfuM8fwtPQgjG+3IqsElVC1W1EngHz70KxvtSV0P3Iii/E0TkOuBc4Cr9YQGXV9cSDglgAdDLmdEQg2fA5P0Ax+Sa00f+HLBKVR+u86v3gWudn68F3mvt2JpLVX+jql1VNRfPffhcVa8CZgIXOy8LlmvZBWwVkT7OoVOAlQThfcHT9TNSRBKcv2+11xJ09+UoDd2L94EJzmygkcD+Ol1FbZKInImn6/R8VS2r86v3gctFJFZE8vAMbM93fWJVDfkHcDaekfMNwD2BjqeZsY/F03RdCix2Hmfj6TufAawDpgPpgY61mdd1EvCB83N35y/teuBfQGyg43N5DYOBhc69+TeQFqz3BbgPWA0sB14CYoPpvgCv4Rm/qMTTOruhoXsBCJ6ZgRuAZXhmPwX8Gpq4lvV4+vprvwOervP6e5xrWQOc1ZzPslIQxhgTpsKhC8gYY0w9LAEYY0yYsgRgjDFhyhKAMcaEKUsAxhgTpiwBGFMPEWkvIoudxy4R2e78XCoiTwY6PmN8waaBGtMEEbkXKFXVhwIdizG+ZC0AY5pBRE6qs4/BvSIyVUS+EJF8EfmpiPxVRJaJyCdOCQ9EZKiIzBaRRSLyaVuqPGnCmyUAY7zTA09No/OBl4GZqjoAOASc4ySBx4GLVXUo8Dxwf6CCNaauqKZfYoxpxMeqWikiy/BspPKJc3wZkAv0AfoD0zxldojEs8zfmICzBGCMd8oBVLVGRCr1h0G1Gjz/fwmwQlVHBSpAYxpiXUDG+NcaIFNERoGntLeIHBvgmIwBLAEY41fq2Yb0YuABEVmCp5Lj6IAGZYzDpoEaY0yYshaAMcaEKUsAxhgTpiwBGGNMmLIEYIwxYcoSgDHGhClLAMYYE6YsARhjTJj6/437To7/IFZqAAAAAElFTkSuQmCC\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEGCAYAAABsLkJ6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAA0m0lEQVR4nO3dd3xUddb48c9J74EUCAm9S0dCV1exI+KKZcGGirr2supv3V13V31299nHXlERsIsuVuxrR1BCE6nSQZp0SEgh7fz+mAkGSLlJZuYmM+f9et0XmZvJ3DNMMme+7XxFVTHGGBN6wtwOwBhjjDssARhjTIiyBGCMMSHKEoAxxoQoSwDGGBOiItwOoC7S0tK0ffv2bodhjDFNyoIFC3apavqR55tUAmjfvj3z5893OwxjjGlSRGRjVeetC8gYY0KUJQBjjAlRlgCMMSZEWQIwxpgQZQnAGGNClCUAY4wJUZYAjDEmRIVEAvh+7W6mzFpPWbmVvjbGmAohkQA+WrKN//lgOWMmzmb51ly3wzHGmEYhJBLAfef05PFx/dmyr5Czn5zF/33yE0UlZW6HZYwxrgqJBCAijO6byed/+A1j+mfx9NdrOfOxb5mzbrfboRljjGtCIgFUaBYXxQMX9OWVCYMpLS9n7KQ5/PmdJeQVlbgdmjHGBFxIJYAKx3VJ49NbT+Cq4zrw+tyfOe2RmXz10w63wzLGmIAKyQQAEBcVwd2jevDWdcNIjIngihfm8Yf/LGJfQbHboRljTECEbAKo0L9tc96/6ThuGtGZ9xZt5dRHZvLZ8u1uh2WMMX4X8gkAIDoinNtP68Z7NwwnLSGaq1+az62v/2CtAWNMULMEUEmvrGTeu2E4t5zchQ8Wb+PUR2byxQprDRhT2a4DB7lz+o8s2bzf7VBMA1kCOEJURBi3ndqV924cTmp8FBNenM+d038kt5qZQm/M+5nLps5lzY68AEdqjDs+X76d6Qs289uJs3n4s1UUl5a7HZKpJ0sA1eiZmcyMG4/jxpM689bCzZz56Ld8t2bXYfdZvyufv723jJmrdjLy8VlM/nYd5VZuwgS51TsOEB0Rxui+mTz+xWrOnTibVdvtA1BTZAmgBlERYdxxejfeum4Y0RFhXDQ5h3tmLKOopIzycuWutxYTFRHGBzcdxwld0vjHhysY99wcNu8tcDt0Y/xm1fY8OrdI4JHf9ePZSwfwy/4iRj0xi+dm2gegpsYSgAP92zbnw5uP5/Jh7Xnhuw2MemIW//7kJ3LW7+Hus46hV1Yyz12Wzf3n92HZ1lzOfPRb3lywGVX7YzDBZ82OA3RtmQjA6T0z+PS2E/hN13T++dEKLpo8hy37Cl2O0DhVpwQgIs1FpI+/gmnMYqPCuWd0T16eMIi8ohImzVzH8M6pXJjdBvCUm7gwuw0f33I8x7RK4o7pP3LDawttJpEJKrlFJWzbX0SXlgmHzqUlRDPp0gHcf34flmzezxmPzuTdH7a4GKVxqtYEICJfi0iSiKQAC4HnRORh/4fWOB3fJZ1Pbz2BO07rykMX9ENEDvt+m5Q4pl0zhD+e0Z3Plm/n9EdnMvuIsQNjmqrV2w8A0KVF4mHnf/0AdALdWiZy6xuLuHnaD+wvtDIrjZmTFkCyquYCY4CXVHUwcIp/w2rcmsVFceOILmQkx1T5/fAw4boTO/HO9cNJiI7g4sk5/OujFRwstQqkpmmrmO3WtVILoLK2qXG8fs0Qbj+1Kx8u2cbIx75l7vo9gQzR1IGTBBAhIq2AC4EP/BxPUOmVlcwHNx3PxYPbMmnmOsZM/I61Ow+4HZYx9bZqu2cGUOvmcdXeJyI8jJtO7sJb1w0jMlwYO+l7Hv5sFaVlNl20sXGSAO4DPgXWquo8EekIrPZvWMEjNiqcf57bm0mXDmDrvkJGPT6L/8zfZAPEpklaveMAnVskEB4mtd63X5tmfHDz8Yw5tjWPf7Ga302yGXJ18Yc3FnH2E7P8usao1gSgqtNVtY+qXue9vU5Vz/NbREHqtJ4ZfHzLCfRr04z/9+Zibn59kZWhNq5ZumU/0+dvqvO0zdXb8w7NAHIiITqCBy/oy+Pj+rPqlzxGPvYtHy/ZVtdwQ9IPm/axZMt+Rj0xi9fn/uyXD41OBoG7isgXIrLUe7uPiNzt80hCQEZyDK9cNZg7TuvKR0u2MeqJWbac3rji6a/Xcuebixn//Fx25h109DMVM4A6t6i6/78mo/tm8uHNx9MhLZ7rXl3I3e8ucbwrX/7BUv745uKjFmIGu10HDnJW71Zkt0vhrreX8MFi3ydOJ11AzwF/AkoAVHUxMNbnkYSI8DDhxhFdeP2aIZSUljPm6dk8P3u9dQmZgNpfWEKzuEjmrt/DyMePXuVelTU7PONXdWkBVNY2NY7p1w7jmhM68sqcnzl34nesczAm9snSX3hj/iYunpLDw5+toiwEFpsVl5aTV1RKt4xEXrpyEA9e0Jcze2X4/DpOEkCcqs494lypzyMJMQPbp/DRLcfzm67p3Pv+cq57ZaFNmTMBk1tUQt/WzXjvxuEkxURwyZQcHvt8dY1vrqu31zwDyImoiDD+PPIYpl6ezS/7Czn7iVm8/+PWGn/moyXbyEyOYUx/z1jCJZNz2JFXVO8YmoI9+Z71Q6kJUYSFCecPaE1EuO/X7Tp5xF0i0glQABE5H7BOPB9oFhfFc5dl85eRx/D5iu2c/cQslm6xLiHjf7mFJSTFRtI9I4kZNx7HOf2yeOTzVYyfOpfdB6ruElrtYAaQUyO6t+Qj76LJm6b9wF/fXVrlNOn9hSXMXL2Ts/q04qEL+/LA+X34YdNeznp8Ft+vDd49vXd5X4PU+Gi/XsdJArgBeBboLiJbgFuB6xp6YRGJEZG5IvKjiCwTkXsb+phNkYhw9QkdeeP3QygpK2fM09/xWo5/BnyMqZBbVEpSTAQA8dERPHxhX/49pjdzN+zhrMdnsWDj0XP3V9VhBpATrZJjmXbNEK45oSMvz9nIBc98z6Y9h88S+nz5dkrKlJG9WwFwQXYb3rvhOBJjIrh48hwmfr0mKOsP7fa2ANISovx6HSezgNap6ilAOtBdVY9T1Q0+uPZBYISq9gX6AWeIyBAfPG6TNKBdCh/cdByDO6Tw53eWcMf0xY4HyYypC1U91AKoICKMHdSWt68bRlREGL97dg5TZ/06NvXFiu18v3YXfVon+zSWyHBPl9CkSwewflc+Zz85i69W/ro/94dLtpHVLJZ+bZodOtctI5EZNx7HWX0yuf+TlVzz8oKg6z6taIWlJrjcAhCRf4lIM1XNV9U8bz2gfzT0wupRMQIU6T2CL5XXQWpCNC9cMYhbTu7C2z9sZszE7/h5t82bNr5VWFJGabmSFBN51Pd6ZSXz/k3HcWK3Ftz3wXJueX0RHy7exnWvLOSYVkncdcYxfonptJ4ZvH/jcWQkxXDlC/N49PNV7C8o4dvVOxnZO+OokisJ0RE8PrYf95zdg69X7mD0k7NYsS3XL7G5YfeBX8cA/MlJF9CZqrqv4oaq7gVG+uLiIhIuIouAHcBnqppTxX2uEZH5IjJ/586dvrhsoxYeJtx2alemjh/I5r0FnP3kLL5ZFfzP2wRObqFnDkdSbESV30+OjWTSpQO48/RuvL94Kze8tpBuGYm8fOVgkuOOThq+0j4tnneuH865/bJ49PPVjH5qFiVlyll9Mqu8v4hw+fAOvPH7IRSVlHHuxNm8t8j/ReiKSsqYPn+TX1vou/IPEhUeRmJ01a+RrzhJAOEicqgdIiKxgE/aJapapqr9gNbAIBHpVcV9Jqlqtqpmp6en++KyTcJJ3VvwwU3H0yo5hsufn8tTX62xcQHjExW721XVAqgQFibccFJnXrpyEOMGteGVCf59868QGxXOQxf25b5zerJlbyGtm8fSt5ZupwHtUnj/puPok9WMW15fxP98sNyvZSdmLNrKnW8u5oJnvmern0pf7z5QTGpC1FEtH19zkl5eBb4Qkee9t68AXvRlEKq6T0S+As4AlvrysZuytqlxvH39MP741hIe+HQly7bu58EL+hIX5d9PBSa45Xr7yyuPAVTn+C7pHN8lsB+8RITLhrZncIdURHD0JtgiMYZXrx7MPz9cwZRZ61n5Sx5PjOtP83jfd6Fs2ltAmHh2BDz7iVlMvPhYBndM9ek19uQX+737B2ppAYjnf/414B/AMd7jf1T1/oZeWETSRaSZ9+tY4FTgp4Y+brCJi/L0df7pzO58svQXxkz87qiZEsbUxa8tgMb9QaJbRmKdFp1Fhodxz+ie3H9+H+au38Pop2ax8hff19HZsreQjKQY3r1hOMlxkVw8OYdX5mz06TV2HzhIip+ngEItCUA9fQ4fqeonqnqH9/jUR9duBXwlIouBeXjGAKzaaBVEhN//phNTLx/Iln2FnPPUbHLWBe8caONfv44B+L9Lxw0XZrfhjd8P4WBJOWMmzuaz5dt9+vib9xWS1TyWzi0SePeG4RzfJY27313KX95ZQomPup52HSgmzQ+tlyM5GQNYKCIDfX1hVV2sqv29heZ6qep9vr5GsDmxWwveu2E4zeIiuWRKDm/M+9ntkEwT5GQMoKnr37Y5M248jk4tErjm5flM/Np3Y2hb9haS1SwW8PwfTh4/kGt/04lXc37msilzG7wLoKqyO/+g+11AXoOB70VkrYgsFpEl3k/txgUd0xN45/rhDOmYyh/fWsI/P1weErVRjO9UjAEkNvIuoIbKSI7hP78fytne9QK3T/+xwZsylZaV80tuEVnNYw+dCw8T7jqzOw9d0JcFG/dybgP3/SgoLqOopNzvawDAWQI4HegEjADOBkZ5/zUuSY6N5PnLBzJ+aDue+3Y9176ygIJiK8/UlBUUlwZs4V9uUSnREWHERIYH5HpuiokM57Gx/bjtlK68vXALl0zOOVRnpz625x2krFzJanZ0OYzzBrTmtasHk1tYwpiJ39W7VMWhNQCNpAtIqzmMiyLCw7j3nF7cO7onX6zYzgXPfM/23OAukBXMrn91Iac8/I1fN/+ocOQq4GAnItxySheeGNefHzfvZ8zE2azflV+vx9qy1zPts3ILoLLs9im8e8NwWiRGc9nUHKbP31Tna+zK96wCTmskLYAP8WwF+SHwBbAO+NifQRnnxg9rz5TxA9mwK59zn5rtl1kPxv+25x5k895Cxkz8ju/W+rfufW5RSaOfAeQPZ/fNZNrVQ8gtKuXcibOZt6HuexVv2eeZgVcxBlCVNilxvHndMAZ1SOHONxfz8H9X1mn8IVCrgMFZLaDe3oHa3qraBRgEfO/3yIxjJ3VvwX+uHUqZKuc//R2zQ2zjjGBQVFLGoPYptEyKYfzUubz7g/9WtOYWloZUC6CyAe2a8871w0iJi+LiyTl8VMfdyQ61AGpIAODppn3hikFcmN2ax79cwx3TF1Nc6myGUKDqAIGzFsBhVHUhnoFh04j0zEzmneuHk9kslsufnxuQJfHGdwqLy+iQFs+b1w1jQLvm3PrGIp75Zq1fVn/nFpWQHKIJAKBdajxvXTeM3lnJ3PDaQqbOWu/4Z7fsKyQ1PorYqNrHTyLDw/i/8/pw2yldeWvhZia8OI8DB2sfq6uoBNooxgBE5A+VjjtE5DWg5h0cjCsym8Xyn2uHcmzb5tzy+iKem7nO7ZCMQwXFpcRGhZMcG8mLVw5iVJ9W/Pvjn7j3/eU+L3ecW1gS1FNAnWgeH8WrVw3mtB4tue+D5fzvRyscJdvNewur7f+vSsX4wwPn9+G7tbsZO+n7Wrfg3H2gmIToiIAM0jtpASRWOqLxjAWc48+gTP1VvIGc1bsV//xoBf9y+Itt3FVUUn7oDz46IpzHx/ZnwnEdeOG7Ddz6xiLH3QdO5BaVVlsILpTERIYz8eIBXDKkLc/OXMcd0xfXupBry77CWrt/qnJBdhsmX5bN2h35nP/Md2zcXf0g9O78g6QE4NM/OKgFpKr3AohIgvd2/Se4moCIiQzniXH9SU2IYtLMdezNL+Z/x/T2y5ZypuFKy8opLisnttInvrAw4e6zjiE9MZp/f/wTewuKeeaSAcQ3sDrkob0AQrwFUCE8TPifc3qRnhDDI5+vYm9BMU9ddGyVXTyqytZ9hYzo1qJe1zqpewteu3owV74wj/Of+Z6XrhzEMa2SjrpfRSG4QHDSBdRLRH4AlgHLRGRBVVU7TeMSFibcO7ont5zchekLNnPdqwttg5lGqsj76T426vA/RxHh2t904v7z+jB7zS4unZLD/oKGbXxyaC+AEB4DOFJFN80/ftuLr1buYPzzc8krOvr/eXd+MUUl5XXqAjpS/7bNmX7tUMJF+N2z31e589quAwf9vhVkBScfCScBf1DVdqraDrjde840ciKevQXuHd2Tz5Zv56oX59uCsUaosNiTmGOrqfJ64cA2TLx4AEu35PI7B33INTlUB8haAEe5ZEg7Hhvbn4Ub9zLuuTlH7Y3sdAZQbTq3SOTN64aSmhDNxZNz+Hb14ft97M4v9vtWkBWcJIB4Vf2q4oaqfg3E+y0i43Pjh7XnwQv68t3aXVw6ZW7QbZ/X1FW0zGJrGPQ7o1cGUy7PZuPuAi58tv516A/VAbIxgCqN7pvJpMsGsHr7AcZOmsOOSosrt+yreRFYXbRuHsf0a4fSIS2BCS/M53Nvwbrycg1YKWhwlgDWichfRaS997gbz2Iw04ScP6A1T110LIs37+OSyTkNLlhlfKfQQQIAT23+V64axK68g1z47NEbqDtxaC8AawFUa0T3ljx/hafy7u8mzTmUbCtaAK2rKANRH2kJ0Uy7ejDHZCZx7SsL+GDxVvYXllBWro2qC+hKPBvCv+090rznTBNzZu9WTLo0m5Xb8xj3XM5RTVzjjoJDXUC1/zkOaJfCq1cPJq+olAuf/b7OJQ1+bQFYAqjJsE5pvDzh8GS7ZV8hCdERPm09NYuL4pUJgzi2bXNunvYDz8/2rEloNC0AVd2rqjer6rHAQOBv3n2BTRN0UvcWTL4sm3U7DzDuuTnssiTguooxAKfzvvu0bsa0q4dwsLScsZPqlgR+HQOwLqDaDGiXwmtXDyGvqJSxk+bww6Z9ZDWL9fk2jYkxkbxw5UAGd0jl8S/XAIGpAwTOZgG9JiJJIhIPLAGWi8id/g/N+MsJXdN5/oqB/LyngItDqCWwN7+YS6fk8NMvuW6HchgnYwBH6pGZxLSrh1BSpnVKAtYCqJverZN59arBHDhYyo+b9vmk/78qcVERTL18IMd1TgOgZVKMX65zJCddQD1UNRf4LZ4icB2AS/0ZlPG/YZ3SmDp+IBt253Px5NBIAnlFpazefoCLn8th9fbGUzTv0BiAg/IClXXLSDwsCdS0uKhCqOwF4Eu9sjxJoHlcJN0ynG9RWVexUeFMHp/Na1cNpnOLBL9dpzInCSBSRCLxJIAZqlqClYMOCsM6pzH18oGs35XvmR3UwDnmjV3b1DhevXowYWHCRZNzWNeATTt86dA00Hos/e+WkchrVw+muLSci57LYfPemgeGc4tKiYkMIzoi+PcC8KVeWcnMvmsEd5zWza/XiYkMZ5i3FRAIThLAs8AGPFM/Z4pIO6BxtaFNvQ3vnMaky7JZs+MAl1WzACaYdEpP4LWrBlNerlz0XE69ZtL4Wn1bABW6ZyTx8oTB5BWVcNFzOfyyv/p9IWwVcP3FRUUQHubb/n+3ORkEflxVs1R1pHpsBE4KQGwmQH7TNZ0nL+rPsi37mfDi/EOfSINVl5aJvHLVYAqKS7lkSs5hc73dUJ8xgCP1ykrmpQmD2ZNfzCVTqt/1KrcotDaDMTVzMgjcUkSmiMjH3ts9gPF+j8wE1Gk9M3jkd/2Yt2EPN7y2sNaiWE3dMa2SePHKQezMO8glU3LY24BtAhuqrrOAqtOvTTOmjM9m054Cxk+tujWXW1hqM4DMIU66gF4APgUyvbdXAbf6KR7jorP7ZvLP3/bmy592cMf0H31ehrix6d+2OZPHZ7NhdwFXvDDPtTIZBSVlRIYLkT4o1je4YypPX3IsK7blMuHF+UfVf7IWgKnMyW9cmqr+BygHUNVSILj7CELYRYPbcufp3Xhv0Vbu+2B50JeSHtYpjSfH9Wfx5n1c+8pCn5ZddqqwuMyntd9HdG/JQxf2Zd6GPdzy+g+UVUrkNgZgKnOSAPJFJBXvzB8RGQLs92tUxlXXn9jpUC36SSGwqcxpPTP417m9mblqJ3e+GfiWT1FJWYP6/6tyTr8s/jaqB58u287f3lt6KJHbXgCmMie/CX8AZgCdRGQ2nrIQ5/s1KuMqEeEvI49hR95B/vfjn2iZFMNv+2e5HZZfjR3Ult35xTzw6Uoym8XyxzO6B+zahSVl9Z4BVJMrhndge+5BnvlmLRlJMdw4orO1AMxhakwAIhIO/MZ7dAMEWOldC2CCWFiY8OAFfdiVd5A73/yRFonRAZ2f7IbrT+zEln2FPP31WrKaxXLJkHYBuW5hse9bABX+eEY3duQW8dBnq0hJiLK9AMxhauwCUtUyYJyqlqrqMlVdam/+oSM6IpxnLxtAh7R4rn1lAWt2NI6FU/4iItw3uicndUvnb+8t5cuftgfkuv5qAYDnOf37vD4M7ZjK3e8uBawSqPmVkzGA2SLypIgcLyLHVhx+j8w0CkkxkUwZP5CoiDCueGFu0JeMiAgP48mLjqVHZhI3vfZDQOoG+WMMoLKoiDCeuWQAHdM823jYGICp4CQB9AN6AvcBD3mPB/0Yk2lk2qTE8dxl2ezIPcg1Ly/gYGlwTwKLj45g8mUDiY+OYMIL8/1eMbXQzwkAIDkukheuGMQZPTM4tm1zv17LNB1OVgKfVMUxIhDBmcajf9vmPHRhXxZs3Mtf310a9NNDM5JjmDw+m935B7nmpfl+TXoFxWXE+KkLqLI2KXE8c+kAMhu4paEJHg1feWJCxqg+mdw0ojP/mb+ZF77b4HY4ftendTMeuqAfC3/ex9/eXea3pFfkx0FgY2piCcDUyW2ndOXUHi35x4cr+G7NLrfD8buz+rTixpM688b8TbyS87NfrhGILiBjquKkFtBRW9NUdc6EhrAw4ZHf9aNDWjw3Tvuh3puTNyW3ndqVk7qlc++MZczbsMfnj+/PWUDG1MRJC+B7h+dMiEiIjuCZSwZQXFrOda8uDPpB4fAw4dGx/WmTEsf1ry5kR57vqoeWlytFJeU+LQVhjFPVJgARyRCRAUCsiPSvNAX0RCAuUAGaxqlziwQevKAPP27ax33vL3c7HL9Ljo3k6UuOJa+ohFumLaLUR9VSD3prD8VZC8C4oKYWwOl4pnu2Bh7m1ymgtwF/buiFRaSNiHwlIstFZJmI3NLQxzSBdUavVvz+hI68mvMzM37c6nY4ftc9I4l//LY336/bzSOfr/LJYxb6YC8AY+qr2hUhqvoi8KKInKeqb/nh2qXA7aq6UEQSgQUi8pmqBv/HySByx+ndmLdhD39+ewl9spJp711sFKzOH9Caeev38NRXaxnYPoUTu7Vo0ONZAjBucroS+LANYURkQkMvrKrbVHWh9+s8YAUQ3BXHglBkeBhPXHQs4WHCjdOCfzwA4N5zetKtZSJ3TP+RnXkNWyRW6N2DIBDrAIw5kpME8Dx+3hBGRNoD/YGcKr53jYjMF5H5O3fu9OVljY9kNYvlwQv6snRLLvd/stLtcPwuJjKcx8f1J6+olNsbuHFOYbFnDMBaAMYNrm8IIyIJwFvArap6VOEVVZ2kqtmqmp2enu6ryxofO7VHSy4b2o4ps9Yza3Xwrw/olpHI3aN6MHPVTqbOXl/vx7EuIOMmVzeEEZFIPG/+r6rq2754TOOeP515DJ3S47l9+iL2Fbi3x26gXDK4Laf1aMn9n6ysd9G4QwkgytZkmsBz8lt35IYwLwE3NfTCIiLAFGCFqj7c0Mcz7ouNCuexsf3ZfaCYP7+zJOjrBYkI/zumN0mxEfzhjR/rtZ2krzaEN6Y+nCSAvXg2hBkG/B5PZVBfrAQeDlwKjBCRRd5jpA8e17ioV1Yyt53alY+W/MIHi7e5HY7fpSZE869ze7N8Wy5PfLm6zj9fZF1AxkVOEsCbQMuKDWGAocDUhl5YVWepqqhqH1Xt5z0+aujjGvf9/oSO9G2dzN9nLPN7KeXG4LSeGZw/oDUTv17Lok376vSzFV1AcVFWo98EnpMEcC3wrndl8EjgCcA+qZtqRYSH8cAFfTlQVMrf31vmdjgB8beze9AiMZo/vrm4Tl1BBcXWAjDucbIfwDzgZuC/wD3AKaq6yc9xmSaua8tEbjmlCx8u2cZHS4K/KygpJpJ//LYXK7fn8cw3ax3/XEUXUIwNAhsX1FQL6H0RmSEiM4A/4an/cxCY4j1nTI1+f0JHemUl8fcZy8gtCv6tpE8+piWj+rTiyS/XsGZHnqOfKSwuI0wgKtwSgAm8mn7rHuTX+j8PAROAuyvdNqZGEeFh/Ovc3uw+cJAHPw3+BWIA94zuSVx0OHe9tcTRArGKvQA8k+KMCaxqE4CqfgPMAu5R1W+OPAIXomnK+rRuxmVD2/PynI11HiBtitISovnLyGOYv3Evby3cXOv9bS8A46Ya252qWgaUi0hygOIxQej207rSIjGaP7+9xGdllBuz845tTXa75vz745/YX1Bz11dRcZmtATCucdLxeABY4i0I93jF4e/ATPBIjInkb6N6snxbLtPmBf/8gbAw4b5zerG3oJiHPqu568u2gzRucpIA3gb+CswEFlQ6jHFsZO8MhnRM4eH/rgyJMhE9MpO4bGh7XpmzkaVbqq+cUlhSZpvBGNc4mQb6YlVHIIIzwUNE+NuonuwvLOHRz+u+YrYpuu3UrjSPi+K+95dXWxajwLqAjIucbArfRUTe9O7cta7iCERwJrj0yExi3KC2vDxnI6u3O5sm2ZQlx0Zy66ldmbthD/9dvr3K+xTZILBxkdP9AJ7Gs4PXSXiKwb3iz6BM8Lr9tG7ER4Xzjw9XuB1KQIwb2IbOLRL498c/VblCuLDYxgCMe5wkgFhV/QIQVd2oqvcAZ/k3LBOsUuKjuOGkznyzaiffr93tdjh+FxEexp9Hdmf9rnxezdl41PdtENi4yUkCOCgiYcBqEblRRM4FEvwclwli44e1p1VyDP/3yU9BXzIa4KRuLRjeOZXHvlh91IroopIy2w7SuMZJArgFTxmIm4EBeEo4j/dnUCa4xUSGc+spXVi0aR+fLqu6bzyYiAh/OvMY9hWUMOXbw3cPsy4g4yZHxeBU9YCqblbVK1R1jKrOCURwJnidd2xrOqXH88CnP4XE4rBeWcmc3rMlU2etPzQNVlWtC8i4ysksoGwReUdEForI4oojEMGZ4BURHsadp3dj7c583lu01e1wAuK2U7tyoLiUSTM9k+iKy8opV2wWkHGNky6gV/HMBDoPOLvSYUyDnN4zg+4ZiTz11RrKHBROa+q6ZyRxdp9Mnp+9gV0HDh7aDtJaAMYtThLATlWdoarrvbOANqrq0dMZjKkjEeHmk7uwblc+H4bAngEAt5zShYOlZTz7zdpKG8JbAjDucJIA/i4ik0VknIiMqTj8HpkJCWf0zKBLiwSe/HK1o/LJTV2n9ARG983ktZyf2ba/CLAWgHGPkwRwBdAPOINfu39G+TEmE0LCwoQbR3Rm1fYD/Hf5L26HExDXntiJ/OIynvOOBVgpCOMWJztRD1TVbn6PxISsUX0yefTz1Tz51RpO75kR9JujdM9IYkT3Fny81JPwrAvIuMVJC+A7Eenh90hMyAoPE64+viNLt+Qyd/0et8MJiOtO7HToa+sCMm5xkgCGAItEZKV3CugSmwZqfG3MsVk0j4tk8qz1td85CAxsn8KAds0BSwDGPU4SwBlAF+A0fu3/t2mgxqdiIsO5ZEg7Pl+xnQ278t0OJyD+cGpXMpJiyGoe63YoJkQ5WQm8saojEMGZ0HLp0HZEhoXx/OzQaAUM75zGnD+fTEp8lNuhmBDlpAVgTEC0SIzh7L6Z/Gf+5lr30jXGNJwlANOoTDiuA4UlZUxfEPx7BxvjNksAplHpkZlE/7bNmDb355AoFW2Mm6pNACKSJyK51R2BDNKElnGD2rJ2Zz7zN+51OxRjglq1CUBVE1U1CXgMuAvIAloDfwQeDUh0JiSN6tOKxOgIpuX87HYoxgQ1J11Ao1V1oqrmqWquqj4NnOPvwEzoiouKYHS/TD5css0Gg43xIycJIF9ELhaRcBEJE5GLgdCYqG1cM25QWw6WlvPuoi1uh2JM0HKSAC4CLgS2e48LvOeM8ZteWcn0zkpm2lzrBjLGX5wsBNugqueoapqqpqvqb1V1QwBiMyHu/AGt+emXPFb+kud2KMYEJSdbQnYVkS9EZKn3dh8Rudv/oZlQN7J3K8IEZvxo3UDG+IOTLqDngD8BJQCquhgY64uLi8hUEdlRkVyMqSw9MZrhndN4/8dttibAGD9wkgDiVHXuEedKfXT9F/AUmzOmSmf3zeTnPQUs2rTP7VCMCTpOEsAuEekEKICInA/4ZANXVZ0JhEYBeFMvp/fMICo8jBk/bnU7FGOCjpMEcAPwLNBdRLYAtwLX+TOoykTkGhGZLyLzd+7cGajLmkYiOTaSE7ul88HibZSFwJ7BxgSSk1lA61T1FCAd6K6qxwVyFpCqTlLVbFXNTk9PD9RlTSMyul8mO/MOkrNut9uhGBNUnMwCKhORfwMFqprnPbfQ75EZ43Vy95bERobzybLQ2DTemEBx0gW0zHu//4pIivdccO/abRqV2KhwhndO44sVO2w2kDE+5CQBlKrq/wMmA9+KyAC8A8INJSLTgO+BbiKyWUQm+OJxTfA5+ZgWbNlXyKrtB9wOxZigEeHgPgKgqm+IyDLgNaCtLy6uquN88Tgm+J3UrQUAX/y0nW4ZiS5HY0xwcNICuKriC1VdChwP3Oy3iIypQkZyDL2ykvhyxQ63QzEmaFTbAhCREar6JdBORNod8W1rh5uAG9G9JU9+uZo9+cW2kboxPlBTC+A33n/PruIY5ee4jDnKyd1bUK7wzSprBRjjC9W2AFT1795/rwhcOMZUr3dWMmkJ0XyxYgfn9m/tdjjGNHk1dQH9oaYfVNWHfR+OMdULCxNGdE/n46W/UFpWTkS4kyEsY0x1avoLSqzlMCbgju+STl5RKcu25rodijFNXk1dQPcGMhBjnBjc0bMWMWf9bvq2aeZuMMY0cbWuAxCRGGAC0BOIqTivqlf6MS5jqtQiMYaOafHkrNvDNSd0cjscY5o0J52oLwMZwOnAN0BrwPboM64Z3DGFuRv2WHVQYxrISQLorKp/BfJV9UXgLGCwf8MypnqDO6SSV1TKim02DmBMQzhJACXef/eJSC8gGWjhv5CMqdmv4wC2l5AxDeEkAUwSkebAX4EZwHLgfr9GZUwNWiXH0jYlzvYHMKaBah0EVtXJ3i+/ATr6NxxjnBncIYXPVmynvFwJC7Pq5MbUh5NZQM2Ay4D2le+vqlYQzrhmcMdUpi/YzKodeXTPSHI7HGOaJCfloD8C5gBLgHL/hmOMM4M7eMcB1u2xBGBMPTlJADGqWmNZCGMCrU1KHBlJMSz8eS/jh7V3OxxjmiRH6wBE5GoRaSUiKRWH3yMzpha9spKtJIQxDeAkARQDD+DZunGB95jvz6CMcaJnZhJrdx6goLjU7VCMaZKcdAHdjmcx2C5/B2NMXfTKSkYVVmzLY0C75m6HY0yT46QFsAYo8HcgxtRVz0zP4O+yrftdjsSYpslJCyAfWCQiXwEHK07aNFDjtlbJMaTER7Fsi40DGFMfThLAu97DmEZFROiZmcRSawEYUy81JgARCQcuV9WTAhSPMXXSMzOZKbPWUVxaTlSE7RBmTF3U+BejqmVAuYgkBygeY+qkZ2YSJWXKqu1WodyYunLSBXQAWCIin+EZDwBsDMA0Dr2yPJ9Nlm/NPfS1McYZJwngbe9hTKPTLiWOhOgIlm7dz4W0cTscY5oUJ9VAXxSRKKCr99RKVS2p6WeMCZSwMKFHqyRbEWxMPdQ6aiYiJwKrgaeAicAqETnBv2EZ41yPzCSWb821LSKNqSMnXUAPAaep6koAEekKTAMG+DMwY5zqkZlEYUkZP+8poENavNvhGNNkOJk3F1nx5g+gqquASP+FZEzddPS+6W/YnV/LPY0xlTlpAcwXkcnAK97bF2PF4Ewj0jY1DoCNu/Khm8vBGNOEOEkA1wE3ABXTPr/FMxZgTKOQnhBNXFQ4G/dYySpj6sLJLKCDwMPew5hGR0RomxLHxt2WAIypCyd7Ag8H7gHacfiewLZBvGk02qfGs3qHrQY2pi6cdAFNAW7DsxFMmX/DMaZ+2qXF8eVPOygrV8LDxO1wjGkSnMwC2q+qH6vqDlXdXXH44uIicoaIrBSRNSJyly8e04SmdinxFJeV80tukduhGNNkOEkAX4nIAyIyVESOrTgaemFvpdGngDOBHsA4EenR0Mc1oal95ZlAxhhHnHQBDfb+m13pnAIjGnjtQcAaVV0HICKvA+cAyxv4uCYEHZoKuqeAYS7HYkxT4WQWkL/2AsgCNlW6vZlfk80hInINcA1A27Zt/RSKaepaJccSFR5mi8GMqYNGv4OGqk5S1WxVzU5PT3c7HNNIhYcJrVNi+dmmghrjmJsJYAscVr+3tfecMfXSPjWeDZYAjHHMzQQwD+giIh285abHAjNcjMc0cZ7FYPmoWlVQY5xwMgiMiAwD2nP4QrCXGnJhVS0VkRuBT4FwYKqqLmvIY5rQ1j41joLiMnYdKCY9MdrtcIxp9JysBH4Z6AQs4teFYAo0KAEAqOpHwEcNfRxjANqleqqCbtydbwnAGAectACygR5q7WrTyLWrmAq6u4Ds9ikuR2NM4+dkDGApkOHvQIxpqNbN4wgTTwvAGFM7Jy2ANGC5iMwFDlacVNXRfovKmHqIiggjs1mslYU2xiEnCeAefwdhjK9kJMWwI/dg7Xc0xjhaCfxNIAIxxhdS4qNsNbAxDtU6BiAiQ0RknogcEJFiESkTkdxABGdMXaUmRLEnv9jtMIxpEpwMAj8JjANWA7HAVXiqeBrT6KTER7G3oITycpu0ZkxtHK0EVtU1QLiqlqnq88AZ/g3LmPpJiY+mrFzZX1jidijGNHpOBoELvKUaFonI/cA2mkAROROaUuOjANidX0xz79fGmKo5eSO/1Hu/G4F8PAXczvNnUMbUV4r3Td/GAYypnZNZQBtFJBZopar3BiAmY+otNaEiAdhUUGNq42QW0Nl46gB94r3dT0SsaqdplFLjPTWAdlsLwJhaOekCugfP9o37AFR1EdDBbxEZ0wDN4yMB2HPAEoAxtXGSAEpUdf8R52yOnWmUoiPCSYyOsBaAMQ44mQW0TEQuAsJFpAtwM/Cdf8Mypv5SbDGYMY44aQHcBPTEUwhuGpAL3OrHmIxpkJR4SwDGOOFkFlAB8BfvYUyjlxofxZZ9RW6HYUyjV20CqG2mj5WDNo1VSnwUizcfOWxljDlSTS2AocAmPN0+OYAEJCJjGiglPpq9BcWoKiL2a2tMdWpKABnAqXgKwV0EfAhMs43bTWOXGh9FSZmSW1RKcmyk2+EY02hVOwjsLfz2iaqOB4YAa4CvReTGgEVnTD1YOQhjnKlxEFhEooGz8LQC2gOPA+/4Pyxj6i+lUjmIDmnxLkdjTONV0yDwS0Av4CPgXlVdGrCojGmAQxVBbTWwMTWqqQVwCZ7qn7cAN1caTBNAVTXJz7EZUy/WBWSMM9UmAFW1mv+mSbKCcMY4Y2/yJujERoUTFxVuLQBjamEJwAQlKwdhTO0sAZiglBofZV1AxtTCEoAJSp4WgO0KZkxNLAGYoJQSH22bwhhTC0sAJiilJkSxK99TD8gYUzVLACYopcRHUVxaTn5xmduhGNNoWQIwQenQYjDrBjKmWpYATFA6VA7CBoKNqZYlABOU2qXGMbJ3BnFRTra9NiY0uZIAROQCEVkmIuUiku1GDCa4dW6RyMSLB9AtI9HtUIxptNxqASwFxgAzXbq+McaEPFfax6q6ArDt+owxxkWNfgxARK4RkfkiMn/nzp1uh2OMMUHDby0AEfkcz77CR/qLqr7n9HFUdRIwCSA7O9tW9RhjjI/4LQGo6in+emxjjDEN1+i7gIwxxviHW9NAzxWRzcBQ4EMR+dSNOIwxJpS5NQvoHeAdN65tjDHGQ5pStUQR2QlsrOePpwG7fBiOm+y5NF7B9HzsuTRO9Xku7VQ1/ciTTSoBNISIzFfVoFh1bM+l8Qqm52PPpXHy5XOxQWBjjAlRlgCMMSZEhVICmOR2AD5kz6XxCqbnY8+lcfLZcwmZMQBjjDGHC6UWgDHGmEosARhjTIgKiQQgImeIyEoRWSMid7kdT12ISBsR+UpElns30bnFez5FRD4TkdXef5u7HatTIhIuIj+IyAfe2x1EJMf7+rwhIlFux+iEiDQTkTdF5CcRWSEiQ5vq6yIit3l/v5aKyDQRiWlKr4uITBWRHSKytNK5Kl8L8Xjc+7wWi8ix7kV+tGqeywPe37PFIvKOiDSr9L0/eZ/LShE5vS7XCvoEICLhwFPAmUAPYJyI9HA3qjopBW5X1R7AEOAGb/x3AV+oahfgC+/tpuIWYEWl2/8HPKKqnYG9wARXoqq7x4BPVLU70BfPc2pyr4uIZAE3A9mq2gsIB8bStF6XF4AzjjhX3WtxJtDFe1wDPB2gGJ16gaOfy2dAL1XtA6wC/gTgfS8YC/T0/sxE73ueI0GfAIBBwBpVXaeqxcDrwDkux+SYqm5T1YXer/PwvMlk4XkOL3rv9iLwW1cCrCMRaQ2cBUz23hZgBPCm9y5N4rmISDJwAjAFQFWLVXUfTfR1wVMWJlZEIoA4YBtN6HVR1ZnAniNOV/danAO8pB5zgGYi0ioggTpQ1XNR1f+qaqn35hygtffrc4DXVfWgqq4H1uB5z3MkFBJAFrCp0u3N3nNNjoi0B/oDOUBLVd3m/dYvQEu34qqjR4H/B5R7b6cC+yr9cjeV16cDsBN43tudNVlE4mmCr4uqbgEeBH7G88a/H1hA03xdKqvutWjq7wlXAh97v27QcwmFBBAURCQBeAu4VVVzK39PPXN5G/18XhEZBexQ1QVux+IDEcCxwNOq2h/I54junib0ujTH80myA5AJxHN0F0ST1lRei9qIyF/wdAu/6ovHC4UEsAVoU+l2a++5JkNEIvG8+b+qqm97T2+vaLZ6/93hVnx1MBwYLSIb8HTFjcDTj97M2/UATef12QxsVtUc7+038SSEpvi6nAKsV9WdqloCvI3ntWqKr0tl1b0WTfI9QUQuB0YBF+uvC7ga9FxCIQHMA7p4ZzRE4RkwmeFyTI55+8inACtU9eFK35oBjPd+PR5wvM2mW1T1T6raWlXb43kdvlTVi4GvgPO9d2sqz+UXYJOIdPOeOhlYThN8XfB0/QwRkTjv71vFc2lyr8sRqnstZgCXeWcDDQH2V+oqapRE5Aw8XaejVbWg0rdmAGNFJFpEOuAZ2J7r+IFVNegPYCSekfO1ePYkdj2mOsR+HJ6m62JgkfcYiafv/AtgNfA5kOJ2rHV8XicCH3i/7uj9pV0DTAei3Y7P4XPoB8z3vjbvAs2b6usC3Av8BCwFXgaim9LrAkzDM35Rgqd1NqG61wIQPDMD1wJL8Mx+cv051PJc1uDp6694D3im0v3/4n0uK4Ez63ItKwVhjDEhKhS6gIwxxlTBEoAxxoQoSwDGGBOiLAEYY0yIsgRgjDEhyhKAMVUQkVQRWeQ9fhGRLd6vD4jIRLfjM8YXbBqoMbUQkXuAA6r6oNuxGONL1gIwpg5E5MRK+xjcIyIvisi3IrJRRMaIyP0iskREPvGW8EBEBojINyKyQEQ+bUyVJ01oswRgTMN0wlPTaDTwCvCVqvYGCoGzvEngCeB8VR0ATAX+6VawxlQWUftdjDE1+FhVS0RkCZ6NVD7xnl8CtAe6Ab2AzzxldgjHs8zfGNdZAjCmYQ4CqGq5iJTor4Nq5Xj+vgRYpqpD3QrQmOpYF5Ax/rUSSBeRoeAp7S0iPV2OyRjAEoAxfqWebUjPB/5PRH7EU8lxmKtBGeNl00CNMSZEWQvAGGNClCUAY4wJUZYAjDEmRFkCMMaYEGUJwBhjQpQlAGOMCVGWAIwxJkT9fzLGhZIM/TZqAAAAAElFTkSuQmCC\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -243,37 +690,16 @@
   {
    "cell_type": "code",
    "execution_count": 9,
-   "id": "31ec9e16",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([0., 0., 0., ..., 0., 0., 0.])"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "PFexample.history[\"who_dies\"][0,:]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
    "id": "603ae6e5",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(203,)"
+       "(0,)"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -284,17 +710,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "id": "567440dd",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(181,)"
+       "(0,)"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -313,7 +739,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 11,
    "id": "adfbe431",
    "metadata": {},
    "outputs": [],
@@ -325,14 +751,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 12,
    "id": "5a0c394b",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'shocks': {'live': <HARK.distribution.Bernoulli at 0x7f81cd6c33d0>},\n",
+       "{'shocks': {'live': <HARK.distribution.Bernoulli at 0x7f6482cab160>},\n",
        " 'parameters': {'DiscFac': 0.96,\n",
        "  'CRRA': (2.0,),\n",
        "  'Rfree': 1.03,\n",
@@ -343,12 +769,12 @@
        "  'r_eff': <function HARK.models.perfect_foresight_normalized.<lambda>(Rfree, PermGroFac)>,\n",
        "  'b_nrm': <function HARK.models.perfect_foresight_normalized.<lambda>(r_eff, a_nrm)>,\n",
        "  'm_nrm': <function HARK.models.perfect_foresight_normalized.<lambda>(b_nrm)>,\n",
-       "  'c_nrm': <HARK.model.Control at 0x7f81cd53bfa0>,\n",
+       "  'c_nrm': <HARK.model.Control at 0x7f6482cc5b40>,\n",
        "  'a_nrm': <function HARK.models.perfect_foresight_normalized.<lambda>(m_nrm, c_nrm)>},\n",
        " 'reward': {'u': <function HARK.models.perfect_foresight_normalized.<lambda>(c)>}}"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -359,7 +785,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 13,
    "id": "e9d068bd",
    "metadata": {},
    "outputs": [],
@@ -376,131 +802,888 @@
     "        #'live' : 1,\n",
     "        'p' : 1.0\n",
     "    },\n",
-    "    agent_count = 10000,\n",
+    "    agent_count = 3,\n",
     "    T_sim = 120\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 14,
    "id": "36ba1dda",
    "metadata": {},
    "outputs": [],
    "source": [
     "pfn_simulator.read_shocks = True\n",
+    "#pfn_simulator.shock_history['live'] = 1 - np.roll(PFexample.history[\"who_dies\"], -1)\n",
+    "\n",
     "pfn_simulator.shock_history['live'] = 1 - PFexample.history[\"who_dies\"]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 15,
    "id": "bc84d3e5",
    "metadata": {},
    "outputs": [],
    "source": [
     "pfn_simulator.newborn_init_history['a_nrm'] = PFexample.newborn_init_history['aNrm']\n",
     "pfn_simulator.newborn_init_history['p'] = PFexample.newborn_init_history['pLvl']\n",
-    "#pfn_simulator.newborn_init_history['live'] = np.ones(PFexample.newborn_init_history['pLvl'].shape)"
+    "#pfn_simulator.newborn_init_history['live'] = PFexample.newborn_init_history['pLvl']"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 16,
    "id": "65df3a7f",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'live': array([[1., 1., 1., ..., 1., 1., 1.],\n",
-       "        [1., 1., 1., ..., 1., 1., 1.],\n",
-       "        [1., 1., 1., ..., 1., 1., 1.],\n",
-       "        ...,\n",
-       "        [1., 1., 1., ..., 0., 1., 1.],\n",
-       "        [1., 1., 0., ..., 1., 1., 1.],\n",
-       "        [1., 1., 1., ..., 1., 1., 1.]]),\n",
-       " 'p': array([[1.01      , 1.01      , 1.01      , ..., 1.01      , 1.01      ,\n",
-       "         1.01      ],\n",
-       "        [1.0201    , 1.0201    , 1.0201    , ..., 1.0201    , 1.0201    ,\n",
-       "         1.0201    ],\n",
-       "        [1.030301  , 1.030301  , 1.030301  , ..., 1.030301  , 1.030301  ,\n",
-       "         1.030301  ],\n",
-       "        ...,\n",
-       "        [1.25716302, 1.09368527, 1.66107814, ..., 2.54805698, 1.030301  ,\n",
-       "         2.57353755],\n",
-       "        [1.26973465, 1.10462213, 1.67768892, ..., 1.01      , 1.04060401,\n",
-       "         2.59927293],\n",
-       "        [1.282432  , 1.11566835, 1.01      , ..., 1.0201    , 1.05101005,\n",
-       "         2.62526565]]),\n",
-       " 'r_eff': array([[1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
-       "         1.01980198],\n",
-       "        [1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
-       "         1.01980198],\n",
-       "        [1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
-       "         1.01980198],\n",
-       "        ...,\n",
-       "        [1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
-       "         1.01980198],\n",
-       "        [1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
-       "         1.01980198],\n",
-       "        [1.01980198, 1.01980198, 1.01980198, ..., 1.01980198, 1.01980198,\n",
-       "         1.01980198]]),\n",
-       " 'b_nrm': array([[ 2.52783638e-03,  2.52783638e-03,  2.52783638e-03, ...,\n",
-       "          2.52783638e-03,  2.52783638e-03,  2.52783638e-03],\n",
-       "        [-1.30338194e+00, -1.30338194e+00, -1.30338194e+00, ...,\n",
-       "         -1.30338194e+00, -1.30338194e+00, -1.30338194e+00],\n",
-       "        [-2.57617872e+00, -2.57617872e+00, -2.57617872e+00, ...,\n",
-       "         -2.57617872e+00, -2.57617872e+00, -2.57617872e+00],\n",
-       "        ...,\n",
-       "        [-2.22289190e+01, -9.56314476e+00, -3.72398151e+01, ...,\n",
-       "         -4.67738878e+01, -2.57617872e+00, -4.68937221e+01],\n",
-       "        [-2.29711222e+01, -1.06265047e+01, -3.76013980e+01, ...,\n",
-       "          2.52783638e-03, -3.81670212e+00, -4.70105178e+01],\n",
-       "        [-2.36945059e+01, -1.16629019e+01,  2.52783638e-03, ...,\n",
-       "         -1.30338194e+00, -5.02577047e+00, -4.71243521e+01]]),\n",
-       " 'm_nrm': array([[  1.00252784,   1.00252784,   1.00252784, ...,   1.00252784,\n",
-       "           1.00252784,   1.00252784],\n",
-       "        [ -0.30338194,  -0.30338194,  -0.30338194, ...,  -0.30338194,\n",
-       "          -0.30338194,  -0.30338194],\n",
-       "        [ -1.57617872,  -1.57617872,  -1.57617872, ...,  -1.57617872,\n",
-       "          -1.57617872,  -1.57617872],\n",
-       "        ...,\n",
-       "        [-21.22891902,  -8.56314476, -36.23981511, ..., -45.77388776,\n",
-       "          -1.57617872, -45.89372208],\n",
-       "        [-21.97112221,  -9.62650475, -36.60139796, ...,   1.00252784,\n",
-       "          -2.81670212, -46.01051785],\n",
-       "        [-22.6945059 , -10.6629019 ,   1.00252784, ...,  -0.30338194,\n",
-       "          -4.02577047, -46.12435211]]),\n",
-       " 'c_nrm': array([[2.28060139, 2.28060139, 2.28060139, ..., 2.28060139, 2.28060139,\n",
-       "         2.28060139],\n",
-       "        [2.22277389, 2.22277389, 2.22277389, ..., 2.22277389, 2.22277389,\n",
-       "         2.22277389],\n",
-       "        [2.16641268, 2.16641268, 2.16641268, ..., 2.16641268, 2.16641268,\n",
-       "         2.16641268],\n",
-       "        ...,\n",
-       "        [1.29616199, 1.8570201 , 0.63145862, ..., 0.20927661, 2.16641268,\n",
-       "         0.20397018],\n",
-       "        [1.26329619, 1.80993304, 0.61544722, ..., 2.28060139, 2.11148057,\n",
-       "         0.1987983 ],\n",
-       "        [1.23126376, 1.76403993, 2.28060139, ..., 2.22277389, 2.05794134,\n",
-       "         0.19375756]]),\n",
-       " 'a_nrm': array([[ -1.27807355,  -1.27807355,  -1.27807355, ...,  -1.27807355,\n",
-       "          -1.27807355,  -1.27807355],\n",
-       "        [ -2.52615583,  -2.52615583,  -2.52615583, ...,  -2.52615583,\n",
-       "          -2.52615583,  -2.52615583],\n",
-       "        [ -3.74259139,  -3.74259139,  -3.74259139, ...,  -3.74259139,\n",
-       "          -3.74259139,  -3.74259139],\n",
-       "        ...,\n",
-       "        [-22.525081  , -10.42016485, -36.87127373, ..., -45.98316437,\n",
-       "          -3.74259139, -46.09769226],\n",
-       "        [-23.2344184 , -11.43643779, -37.21684518, ...,  -1.27807355,\n",
-       "          -4.92818269, -46.20931615],\n",
-       "        [-23.92576966, -12.42694183,  -1.27807355, ...,  -2.52615583,\n",
-       "          -6.08371181, -46.31810967]])}"
+       "{'live': array([[ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  0.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  0.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  0.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 0.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 0.,  1.,  1.],\n",
+       "        [ 1.,  0.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 0.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  0.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [ 1.,  1.,  0.],\n",
+       "        [ 1.,  1.,  1.],\n",
+       "        [nan, nan, nan]]),\n",
+       " 'p': array([[1.01      , 1.01      , 1.01      ],\n",
+       "        [1.0201    , 1.0201    , 1.0201    ],\n",
+       "        [1.030301  , 1.030301  , 1.030301  ],\n",
+       "        [1.04060401, 1.04060401, 1.04060401],\n",
+       "        [1.05101005, 1.05101005, 1.05101005],\n",
+       "        [1.06152015, 1.06152015, 1.06152015],\n",
+       "        [1.07213535, 1.07213535, 1.07213535],\n",
+       "        [1.08285671, 1.08285671, 1.08285671],\n",
+       "        [1.09368527, 1.09368527, 1.09368527],\n",
+       "        [1.10462213, 1.10462213, 1.01      ],\n",
+       "        [1.11566835, 1.11566835, 1.0201    ],\n",
+       "        [1.12682503, 1.12682503, 1.030301  ],\n",
+       "        [1.13809328, 1.13809328, 1.04060401],\n",
+       "        [1.14947421, 1.14947421, 1.05101005],\n",
+       "        [1.16096896, 1.16096896, 1.06152015],\n",
+       "        [1.17257864, 1.17257864, 1.07213535],\n",
+       "        [1.18430443, 1.18430443, 1.08285671],\n",
+       "        [1.19614748, 1.19614748, 1.09368527],\n",
+       "        [1.20810895, 1.20810895, 1.10462213],\n",
+       "        [1.22019004, 1.22019004, 1.11566835],\n",
+       "        [1.23239194, 1.23239194, 1.12682503],\n",
+       "        [1.24471586, 1.24471586, 1.13809328],\n",
+       "        [1.25716302, 1.25716302, 1.14947421],\n",
+       "        [1.26973465, 1.26973465, 1.16096896],\n",
+       "        [1.282432  , 1.282432  , 1.17257864],\n",
+       "        [1.29525631, 1.29525631, 1.18430443],\n",
+       "        [1.30820888, 1.30820888, 1.19614748],\n",
+       "        [1.32129097, 1.32129097, 1.20810895],\n",
+       "        [1.33450388, 1.33450388, 1.22019004],\n",
+       "        [1.34784892, 1.34784892, 1.23239194],\n",
+       "        [1.3613274 , 1.3613274 , 1.24471586],\n",
+       "        [1.37494068, 1.37494068, 1.25716302],\n",
+       "        [1.38869009, 1.38869009, 1.26973465],\n",
+       "        [1.40257699, 1.40257699, 1.282432  ],\n",
+       "        [1.41660276, 1.41660276, 1.29525631],\n",
+       "        [1.43076878, 1.43076878, 1.30820888],\n",
+       "        [1.44507647, 1.44507647, 1.32129097],\n",
+       "        [1.45952724, 1.45952724, 1.33450388],\n",
+       "        [1.47412251, 1.47412251, 1.34784892],\n",
+       "        [1.48886373, 1.48886373, 1.3613274 ],\n",
+       "        [1.50375237, 1.50375237, 1.37494068],\n",
+       "        [1.51878989, 1.51878989, 1.38869009],\n",
+       "        [1.53397779, 1.53397779, 1.40257699],\n",
+       "        [1.54931757, 1.54931757, 1.41660276],\n",
+       "        [1.56481075, 1.56481075, 1.43076878],\n",
+       "        [1.58045885, 1.58045885, 1.44507647],\n",
+       "        [1.59626344, 1.59626344, 1.45952724],\n",
+       "        [1.61222608, 1.61222608, 1.47412251],\n",
+       "        [1.62834834, 1.62834834, 1.48886373],\n",
+       "        [1.64463182, 1.64463182, 1.50375237],\n",
+       "        [1.66107814, 1.66107814, 1.51878989],\n",
+       "        [1.67768892, 1.01      , 1.53397779],\n",
+       "        [1.69446581, 1.0201    , 1.54931757],\n",
+       "        [1.71141047, 1.030301  , 1.56481075],\n",
+       "        [1.72852457, 1.04060401, 1.58045885],\n",
+       "        [1.74580982, 1.05101005, 1.59626344],\n",
+       "        [1.76326792, 1.06152015, 1.61222608],\n",
+       "        [1.7809006 , 1.07213535, 1.62834834],\n",
+       "        [1.7987096 , 1.08285671, 1.64463182],\n",
+       "        [1.8166967 , 1.09368527, 1.66107814],\n",
+       "        [1.83486367, 1.10462213, 1.67768892],\n",
+       "        [1.8532123 , 1.11566835, 1.69446581],\n",
+       "        [1.87174443, 1.12682503, 1.71141047],\n",
+       "        [1.89046187, 1.13809328, 1.72852457],\n",
+       "        [1.90936649, 1.14947421, 1.74580982],\n",
+       "        [1.92846015, 1.16096896, 1.76326792],\n",
+       "        [1.94774475, 1.17257864, 1.01      ],\n",
+       "        [1.9672222 , 1.18430443, 1.0201    ],\n",
+       "        [1.98689442, 1.19614748, 1.030301  ],\n",
+       "        [2.00676337, 1.20810895, 1.04060401],\n",
+       "        [2.026831  , 1.22019004, 1.05101005],\n",
+       "        [2.04709931, 1.23239194, 1.06152015],\n",
+       "        [2.06757031, 1.24471586, 1.07213535],\n",
+       "        [2.08824601, 1.25716302, 1.08285671],\n",
+       "        [2.10912847, 1.26973465, 1.09368527],\n",
+       "        [2.13021975, 1.282432  , 1.10462213],\n",
+       "        [2.15152195, 1.29525631, 1.11566835],\n",
+       "        [1.01      , 1.30820888, 1.12682503],\n",
+       "        [1.0201    , 1.32129097, 1.13809328],\n",
+       "        [1.030301  , 1.33450388, 1.14947421],\n",
+       "        [1.04060401, 1.34784892, 1.16096896],\n",
+       "        [1.05101005, 1.3613274 , 1.17257864],\n",
+       "        [1.01      , 1.37494068, 1.18430443],\n",
+       "        [1.0201    , 1.01      , 1.19614748],\n",
+       "        [1.030301  , 1.0201    , 1.20810895],\n",
+       "        [1.04060401, 1.030301  , 1.22019004],\n",
+       "        [1.05101005, 1.04060401, 1.23239194],\n",
+       "        [1.06152015, 1.05101005, 1.24471586],\n",
+       "        [1.07213535, 1.06152015, 1.25716302],\n",
+       "        [1.08285671, 1.07213535, 1.26973465],\n",
+       "        [1.09368527, 1.08285671, 1.282432  ],\n",
+       "        [1.10462213, 1.09368527, 1.29525631],\n",
+       "        [1.11566835, 1.10462213, 1.30820888],\n",
+       "        [1.12682503, 1.11566835, 1.32129097],\n",
+       "        [1.01      , 1.12682503, 1.33450388],\n",
+       "        [1.0201    , 1.13809328, 1.34784892],\n",
+       "        [1.030301  , 1.14947421, 1.3613274 ],\n",
+       "        [1.04060401, 1.16096896, 1.37494068],\n",
+       "        [1.05101005, 1.17257864, 1.38869009],\n",
+       "        [1.06152015, 1.18430443, 1.40257699],\n",
+       "        [1.07213535, 1.19614748, 1.41660276],\n",
+       "        [1.08285671, 1.20810895, 1.43076878],\n",
+       "        [1.09368527, 1.22019004, 1.44507647],\n",
+       "        [1.10462213, 1.23239194, 1.45952724],\n",
+       "        [1.11566835, 1.24471586, 1.47412251],\n",
+       "        [1.12682503, 1.25716302, 1.48886373],\n",
+       "        [1.13809328, 1.26973465, 1.50375237],\n",
+       "        [1.14947421, 1.282432  , 1.51878989],\n",
+       "        [1.16096896, 1.01      , 1.53397779],\n",
+       "        [1.17257864, 1.0201    , 1.54931757],\n",
+       "        [1.18430443, 1.030301  , 1.56481075],\n",
+       "        [1.19614748, 1.04060401, 1.58045885],\n",
+       "        [1.20810895, 1.05101005, 1.59626344],\n",
+       "        [1.22019004, 1.06152015, 1.61222608],\n",
+       "        [1.23239194, 1.07213535, 1.62834834],\n",
+       "        [1.24471586, 1.08285671, 1.64463182],\n",
+       "        [1.25716302, 1.09368527, 1.66107814],\n",
+       "        [1.26973465, 1.10462213, 1.67768892],\n",
+       "        [1.282432  , 1.11566835, 1.01      ],\n",
+       "        [1.29525631, 1.12682503, 1.0201    ]]),\n",
+       " 'r_eff': array([[1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198],\n",
+       "        [1.01980198, 1.01980198, 1.01980198]]),\n",
+       " 'b_nrm': array([[ 2.52783638e-03,  2.52783638e-03,  2.52783638e-03],\n",
+       "        [-1.30338194e+00, -1.30338194e+00, -1.30338194e+00],\n",
+       "        [-2.57617872e+00, -2.57617872e+00, -2.57617872e+00],\n",
+       "        [-3.81670212e+00, -3.81670212e+00, -3.81670212e+00],\n",
+       "        [-5.02577047e+00, -5.02577047e+00, -5.02577047e+00],\n",
+       "        [-6.20418135e+00, -6.20418135e+00, -6.20418135e+00],\n",
+       "        [-7.35271213e+00, -7.35271213e+00, -7.35271213e+00],\n",
+       "        [-8.47212045e+00, -8.47212045e+00, -8.47212045e+00],\n",
+       "        [-9.56314476e+00, -9.56314476e+00, -9.56314476e+00],\n",
+       "        [-1.06265047e+01, -1.06265047e+01,  2.52783638e-03],\n",
+       "        [-1.16629019e+01, -1.16629019e+01, -1.30338194e+00],\n",
+       "        [-1.26730199e+01, -1.26730199e+01, -2.57617872e+00],\n",
+       "        [-1.36575250e+01, -1.36575250e+01, -3.81670212e+00],\n",
+       "        [-1.46170668e+01, -1.46170668e+01, -5.02577047e+00],\n",
+       "        [-1.55522782e+01, -1.55522782e+01, -6.20418135e+00],\n",
+       "        [-1.64637761e+01, -1.64637761e+01, -7.35271213e+00],\n",
+       "        [-1.73521618e+01, -1.73521618e+01, -8.47212045e+00],\n",
+       "        [-1.82180214e+01, -1.82180214e+01, -9.56314476e+00],\n",
+       "        [-1.90619260e+01, -1.90619260e+01, -1.06265047e+01],\n",
+       "        [-1.98844323e+01, -1.98844323e+01, -1.16629019e+01],\n",
+       "        [-2.06860829e+01, -2.06860829e+01, -1.26730199e+01],\n",
+       "        [-2.14674067e+01, -2.14674067e+01, -1.36575250e+01],\n",
+       "        [-2.22289190e+01, -2.22289190e+01, -1.46170668e+01],\n",
+       "        [-2.29711222e+01, -2.29711222e+01, -1.55522782e+01],\n",
+       "        [-2.36945059e+01, -2.36945059e+01, -1.64637761e+01],\n",
+       "        [-2.43995473e+01, -2.43995473e+01, -1.73521618e+01],\n",
+       "        [-2.50867114e+01, -2.50867114e+01, -1.82180214e+01],\n",
+       "        [-2.57564517e+01, -2.57564517e+01, -1.90619260e+01],\n",
+       "        [-2.64092098e+01, -2.64092098e+01, -1.98844323e+01],\n",
+       "        [-2.70454164e+01, -2.70454164e+01, -2.06860829e+01],\n",
+       "        [-2.76654912e+01, -2.76654912e+01, -2.14674067e+01],\n",
+       "        [-2.82698432e+01, -2.82698432e+01, -2.22289190e+01],\n",
+       "        [-2.88588711e+01, -2.88588711e+01, -2.29711222e+01],\n",
+       "        [-2.94329634e+01, -2.94329634e+01, -2.36945059e+01],\n",
+       "        [-2.99924989e+01, -2.99924989e+01, -2.43995473e+01],\n",
+       "        [-3.05378466e+01, -3.05378466e+01, -2.50867114e+01],\n",
+       "        [-3.10693664e+01, -3.10693664e+01, -2.57564517e+01],\n",
+       "        [-3.15874088e+01, -3.15874088e+01, -2.64092098e+01],\n",
+       "        [-3.20923156e+01, -3.20923156e+01, -2.70454164e+01],\n",
+       "        [-3.25844199e+01, -3.25844199e+01, -2.76654912e+01],\n",
+       "        [-3.30640462e+01, -3.30640462e+01, -2.82698432e+01],\n",
+       "        [-3.35315109e+01, -3.35315109e+01, -2.88588711e+01],\n",
+       "        [-3.39871226e+01, -3.39871226e+01, -2.94329634e+01],\n",
+       "        [-3.44311816e+01, -3.44311816e+01, -2.99924989e+01],\n",
+       "        [-3.48639809e+01, -3.48639809e+01, -3.05378466e+01],\n",
+       "        [-3.52858060e+01, -3.52858060e+01, -3.10693664e+01],\n",
+       "        [-3.56969353e+01, -3.56969353e+01, -3.15874088e+01],\n",
+       "        [-3.60976398e+01, -3.60976398e+01, -3.20923156e+01],\n",
+       "        [-3.64881839e+01, -3.64881839e+01, -3.25844199e+01],\n",
+       "        [-3.68688253e+01, -3.68688253e+01, -3.30640462e+01],\n",
+       "        [-3.72398151e+01, -3.72398151e+01, -3.35315109e+01],\n",
+       "        [-3.76013980e+01,  2.52783638e-03, -3.39871226e+01],\n",
+       "        [-3.79538124e+01, -1.30338194e+00, -3.44311816e+01],\n",
+       "        [-3.82972910e+01, -2.57617872e+00, -3.48639809e+01],\n",
+       "        [-3.86320602e+01, -3.81670212e+00, -3.52858060e+01],\n",
+       "        [-3.89583409e+01, -5.02577047e+00, -3.56969353e+01],\n",
+       "        [-3.92763483e+01, -6.20418135e+00, -3.60976398e+01],\n",
+       "        [-3.95862923e+01, -7.35271213e+00, -3.64881839e+01],\n",
+       "        [-3.98883772e+01, -8.47212045e+00, -3.68688253e+01],\n",
+       "        [-4.01828024e+01, -9.56314476e+00, -3.72398151e+01],\n",
+       "        [-4.04697621e+01, -1.06265047e+01, -3.76013980e+01],\n",
+       "        [-4.07494455e+01, -1.16629019e+01, -3.79538124e+01],\n",
+       "        [-4.10220372e+01, -1.26730199e+01, -3.82972910e+01],\n",
+       "        [-4.12877170e+01, -1.36575250e+01, -3.86320602e+01],\n",
+       "        [-4.15466602e+01, -1.46170668e+01, -3.89583409e+01],\n",
+       "        [-4.17990375e+01, -1.55522782e+01, -3.92763483e+01],\n",
+       "        [-4.20450154e+01, -1.64637761e+01,  2.52783638e-03],\n",
+       "        [-4.22847563e+01, -1.73521618e+01, -1.30338194e+00],\n",
+       "        [-4.25184183e+01, -1.82180214e+01, -2.57617872e+00],\n",
+       "        [-4.27461554e+01, -1.90619260e+01, -3.81670212e+00],\n",
+       "        [-4.29681180e+01, -1.98844323e+01, -5.02577047e+00],\n",
+       "        [-4.31844525e+01, -2.06860829e+01, -6.20418135e+00],\n",
+       "        [-4.33953015e+01, -2.14674067e+01, -7.35271213e+00],\n",
+       "        [-4.36008042e+01, -2.22289190e+01, -8.47212045e+00],\n",
+       "        [-4.38010961e+01, -2.29711222e+01, -9.56314476e+00],\n",
+       "        [-4.39963093e+01, -2.36945059e+01, -1.06265047e+01],\n",
+       "        [-4.41865726e+01, -2.43995473e+01, -1.16629019e+01],\n",
+       "        [ 2.52783638e-03, -2.50867114e+01, -1.26730199e+01],\n",
+       "        [-1.30338194e+00, -2.57564517e+01, -1.36575250e+01],\n",
+       "        [-2.57617872e+00, -2.64092098e+01, -1.46170668e+01],\n",
+       "        [-3.81670212e+00, -2.70454164e+01, -1.55522782e+01],\n",
+       "        [-5.02577047e+00, -2.76654912e+01, -1.64637761e+01],\n",
+       "        [ 2.52783638e-03, -2.82698432e+01, -1.73521618e+01],\n",
+       "        [-1.30338194e+00,  2.52783638e-03, -1.82180214e+01],\n",
+       "        [-2.57617872e+00, -1.30338194e+00, -1.90619260e+01],\n",
+       "        [-3.81670212e+00, -2.57617872e+00, -1.98844323e+01],\n",
+       "        [-5.02577047e+00, -3.81670212e+00, -2.06860829e+01],\n",
+       "        [-6.20418135e+00, -5.02577047e+00, -2.14674067e+01],\n",
+       "        [-7.35271213e+00, -6.20418135e+00, -2.22289190e+01],\n",
+       "        [-8.47212045e+00, -7.35271213e+00, -2.29711222e+01],\n",
+       "        [-9.56314476e+00, -8.47212045e+00, -2.36945059e+01],\n",
+       "        [-1.06265047e+01, -9.56314476e+00, -2.43995473e+01],\n",
+       "        [-1.16629019e+01, -1.06265047e+01, -2.50867114e+01],\n",
+       "        [-1.26730199e+01, -1.16629019e+01, -2.57564517e+01],\n",
+       "        [ 2.52783638e-03, -1.26730199e+01, -2.64092098e+01],\n",
+       "        [-1.30338194e+00, -1.36575250e+01, -2.70454164e+01],\n",
+       "        [-2.57617872e+00, -1.46170668e+01, -2.76654912e+01],\n",
+       "        [-3.81670212e+00, -1.55522782e+01, -2.82698432e+01],\n",
+       "        [-5.02577047e+00, -1.64637761e+01, -2.88588711e+01],\n",
+       "        [-6.20418135e+00, -1.73521618e+01, -2.94329634e+01],\n",
+       "        [-7.35271213e+00, -1.82180214e+01, -2.99924989e+01],\n",
+       "        [-8.47212045e+00, -1.90619260e+01, -3.05378466e+01],\n",
+       "        [-9.56314476e+00, -1.98844323e+01, -3.10693664e+01],\n",
+       "        [-1.06265047e+01, -2.06860829e+01, -3.15874088e+01],\n",
+       "        [-1.16629019e+01, -2.14674067e+01, -3.20923156e+01],\n",
+       "        [-1.26730199e+01, -2.22289190e+01, -3.25844199e+01],\n",
+       "        [-1.36575250e+01, -2.29711222e+01, -3.30640462e+01],\n",
+       "        [-1.46170668e+01, -2.36945059e+01, -3.35315109e+01],\n",
+       "        [-1.55522782e+01,  2.52783638e-03, -3.39871226e+01],\n",
+       "        [-1.64637761e+01, -1.30338194e+00, -3.44311816e+01],\n",
+       "        [-1.73521618e+01, -2.57617872e+00, -3.48639809e+01],\n",
+       "        [-1.82180214e+01, -3.81670212e+00, -3.52858060e+01],\n",
+       "        [-1.90619260e+01, -5.02577047e+00, -3.56969353e+01],\n",
+       "        [-1.98844323e+01, -6.20418135e+00, -3.60976398e+01],\n",
+       "        [-2.06860829e+01, -7.35271213e+00, -3.64881839e+01],\n",
+       "        [-2.14674067e+01, -8.47212045e+00, -3.68688253e+01],\n",
+       "        [-2.22289190e+01, -9.56314476e+00, -3.72398151e+01],\n",
+       "        [-2.29711222e+01, -1.06265047e+01, -3.76013980e+01],\n",
+       "        [-2.36945059e+01, -1.16629019e+01,  2.52783638e-03],\n",
+       "        [-2.43995473e+01, -1.26730199e+01, -1.30338194e+00]]),\n",
+       " 'm_nrm': array([[  1.00252784,   1.00252784,   1.00252784],\n",
+       "        [ -0.30338194,  -0.30338194,  -0.30338194],\n",
+       "        [ -1.57617872,  -1.57617872,  -1.57617872],\n",
+       "        [ -2.81670212,  -2.81670212,  -2.81670212],\n",
+       "        [ -4.02577047,  -4.02577047,  -4.02577047],\n",
+       "        [ -5.20418135,  -5.20418135,  -5.20418135],\n",
+       "        [ -6.35271213,  -6.35271213,  -6.35271213],\n",
+       "        [ -7.47212045,  -7.47212045,  -7.47212045],\n",
+       "        [ -8.56314476,  -8.56314476,  -8.56314476],\n",
+       "        [ -9.62650475,  -9.62650475,   1.00252784],\n",
+       "        [-10.6629019 , -10.6629019 ,  -0.30338194],\n",
+       "        [-11.67301988, -11.67301988,  -1.57617872],\n",
+       "        [-12.65752504, -12.65752504,  -2.81670212],\n",
+       "        [-13.61706682, -13.61706682,  -4.02577047],\n",
+       "        [-14.5522782 , -14.5522782 ,  -5.20418135],\n",
+       "        [-15.46377611, -15.46377611,  -6.35271213],\n",
+       "        [-16.35216182, -16.35216182,  -7.47212045],\n",
+       "        [-17.21802139, -17.21802139,  -8.56314476],\n",
+       "        [-18.06192599, -18.06192599,  -9.62650475],\n",
+       "        [-18.88443232, -18.88443232, -10.6629019 ],\n",
+       "        [-19.68608295, -19.68608295, -11.67301988],\n",
+       "        [-20.46740671, -20.46740671, -12.65752504],\n",
+       "        [-21.22891902, -21.22891902, -13.61706682],\n",
+       "        [-21.97112221, -21.97112221, -14.5522782 ],\n",
+       "        [-22.6945059 , -22.6945059 , -15.46377611],\n",
+       "        [-23.39954727, -23.39954727, -16.35216182],\n",
+       "        [-24.08671143, -24.08671143, -17.21802139],\n",
+       "        [-24.75645166, -24.75645166, -18.06192599],\n",
+       "        [-25.40920978, -25.40920978, -18.88443232],\n",
+       "        [-26.04541639, -26.04541639, -19.68608295],\n",
+       "        [-26.66549117, -26.66549117, -20.46740671],\n",
+       "        [-27.26984317, -27.26984317, -21.22891902],\n",
+       "        [-27.85887106, -27.85887106, -21.97112221],\n",
+       "        [-28.43296339, -28.43296339, -22.6945059 ],\n",
+       "        [-28.99249888, -28.99249888, -23.39954727],\n",
+       "        [-29.53784664, -29.53784664, -24.08671143],\n",
+       "        [-30.06936642, -30.06936642, -24.75645166],\n",
+       "        [-30.58740883, -30.58740883, -25.40920978],\n",
+       "        [-31.09231562, -31.09231562, -26.04541639],\n",
+       "        [-31.58441986, -31.58441986, -26.66549117],\n",
+       "        [-32.06404617, -32.06404617, -27.26984317],\n",
+       "        [-32.53151095, -32.53151095, -27.85887106],\n",
+       "        [-32.98712256, -32.98712256, -28.43296339],\n",
+       "        [-33.43118156, -33.43118156, -28.99249888],\n",
+       "        [-33.86398088, -33.86398088, -29.53784664],\n",
+       "        [-34.28580602, -34.28580602, -30.06936642],\n",
+       "        [-34.69693526, -34.69693526, -30.58740883],\n",
+       "        [-35.09763978, -35.09763978, -31.09231562],\n",
+       "        [-35.48818394, -35.48818394, -31.58441986],\n",
+       "        [-35.86882535, -35.86882535, -32.06404617],\n",
+       "        [-36.23981511, -36.23981511, -32.53151095],\n",
+       "        [-36.60139796,   1.00252784, -32.98712256],\n",
+       "        [-36.95381242,  -0.30338194, -33.43118156],\n",
+       "        [-37.29729095,  -1.57617872, -33.86398088],\n",
+       "        [-37.63206016,  -2.81670212, -34.28580602],\n",
+       "        [-37.95834086,  -4.02577047, -34.69693526],\n",
+       "        [-38.27634831,  -5.20418135, -35.09763978],\n",
+       "        [-38.58629227,  -6.35271213, -35.48818394],\n",
+       "        [-38.8883772 ,  -7.47212045, -35.86882535],\n",
+       "        [-39.18280239,  -8.56314476, -36.23981511],\n",
+       "        [-39.46976206,  -9.62650475, -36.60139796],\n",
+       "        [-39.7494455 , -10.6629019 , -36.95381242],\n",
+       "        [-40.02203721, -11.67301988, -37.29729095],\n",
+       "        [-40.28771701, -12.65752504, -37.63206016],\n",
+       "        [-40.54666016, -13.61706682, -37.95834086],\n",
+       "        [-40.79903748, -14.5522782 , -38.27634831],\n",
+       "        [-41.04501545, -15.46377611,   1.00252784],\n",
+       "        [-41.28475634, -16.35216182,  -0.30338194],\n",
+       "        [-41.51841829, -17.21802139,  -1.57617872],\n",
+       "        [-41.74615544, -18.06192599,  -2.81670212],\n",
+       "        [-41.96811803, -18.88443232,  -4.02577047],\n",
+       "        [-42.18445248, -19.68608295,  -5.20418135],\n",
+       "        [-42.3953015 , -20.46740671,  -6.35271213],\n",
+       "        [-42.60080416, -21.22891902,  -7.47212045],\n",
+       "        [-42.80109605, -21.97112221,  -8.56314476],\n",
+       "        [-42.99630928, -22.6945059 ,  -9.62650475],\n",
+       "        [-43.18657263, -23.39954727, -10.6629019 ],\n",
+       "        [  1.00252784, -24.08671143, -11.67301988],\n",
+       "        [ -0.30338194, -24.75645166, -12.65752504],\n",
+       "        [ -1.57617872, -25.40920978, -13.61706682],\n",
+       "        [ -2.81670212, -26.04541639, -14.5522782 ],\n",
+       "        [ -4.02577047, -26.66549117, -15.46377611],\n",
+       "        [  1.00252784, -27.26984317, -16.35216182],\n",
+       "        [ -0.30338194,   1.00252784, -17.21802139],\n",
+       "        [ -1.57617872,  -0.30338194, -18.06192599],\n",
+       "        [ -2.81670212,  -1.57617872, -18.88443232],\n",
+       "        [ -4.02577047,  -2.81670212, -19.68608295],\n",
+       "        [ -5.20418135,  -4.02577047, -20.46740671],\n",
+       "        [ -6.35271213,  -5.20418135, -21.22891902],\n",
+       "        [ -7.47212045,  -6.35271213, -21.97112221],\n",
+       "        [ -8.56314476,  -7.47212045, -22.6945059 ],\n",
+       "        [ -9.62650475,  -8.56314476, -23.39954727],\n",
+       "        [-10.6629019 ,  -9.62650475, -24.08671143],\n",
+       "        [-11.67301988, -10.6629019 , -24.75645166],\n",
+       "        [  1.00252784, -11.67301988, -25.40920978],\n",
+       "        [ -0.30338194, -12.65752504, -26.04541639],\n",
+       "        [ -1.57617872, -13.61706682, -26.66549117],\n",
+       "        [ -2.81670212, -14.5522782 , -27.26984317],\n",
+       "        [ -4.02577047, -15.46377611, -27.85887106],\n",
+       "        [ -5.20418135, -16.35216182, -28.43296339],\n",
+       "        [ -6.35271213, -17.21802139, -28.99249888],\n",
+       "        [ -7.47212045, -18.06192599, -29.53784664],\n",
+       "        [ -8.56314476, -18.88443232, -30.06936642],\n",
+       "        [ -9.62650475, -19.68608295, -30.58740883],\n",
+       "        [-10.6629019 , -20.46740671, -31.09231562],\n",
+       "        [-11.67301988, -21.22891902, -31.58441986],\n",
+       "        [-12.65752504, -21.97112221, -32.06404617],\n",
+       "        [-13.61706682, -22.6945059 , -32.53151095],\n",
+       "        [-14.5522782 ,   1.00252784, -32.98712256],\n",
+       "        [-15.46377611,  -0.30338194, -33.43118156],\n",
+       "        [-16.35216182,  -1.57617872, -33.86398088],\n",
+       "        [-17.21802139,  -2.81670212, -34.28580602],\n",
+       "        [-18.06192599,  -4.02577047, -34.69693526],\n",
+       "        [-18.88443232,  -5.20418135, -35.09763978],\n",
+       "        [-19.68608295,  -6.35271213, -35.48818394],\n",
+       "        [-20.46740671,  -7.47212045, -35.86882535],\n",
+       "        [-21.22891902,  -8.56314476, -36.23981511],\n",
+       "        [-21.97112221,  -9.62650475, -36.60139796],\n",
+       "        [-22.6945059 , -10.6629019 ,   1.00252784],\n",
+       "        [-23.39954727, -11.67301988,  -0.30338194]]),\n",
+       " 'c_nrm': array([[2.28060139, 2.28060139, 2.28060139],\n",
+       "        [2.22277389, 2.22277389, 2.22277389],\n",
+       "        [2.16641268, 2.16641268, 2.16641268],\n",
+       "        [2.11148057, 2.11148057, 2.11148057],\n",
+       "        [2.05794134, 2.05794134, 2.05794134],\n",
+       "        [2.00575967, 2.00575967, 2.00575967],\n",
+       "        [1.95490113, 1.95490113, 1.95490113],\n",
+       "        [1.90533217, 1.90533217, 1.90533217],\n",
+       "        [1.8570201 , 1.8570201 , 1.8570201 ],\n",
+       "        [1.80993304, 1.80993304, 2.28060139],\n",
+       "        [1.76403993, 1.76403993, 2.22277389],\n",
+       "        [1.7193105 , 1.7193105 , 2.16641268],\n",
+       "        [1.67571524, 1.67571524, 2.11148057],\n",
+       "        [1.63322539, 1.63322539, 2.05794134],\n",
+       "        [1.59181293, 1.59181293, 2.00575967],\n",
+       "        [1.55145054, 1.55145054, 1.95490113],\n",
+       "        [1.51211158, 1.51211158, 1.90533217],\n",
+       "        [1.47377011, 1.47377011, 1.8570201 ],\n",
+       "        [1.43640084, 1.43640084, 1.80993304],\n",
+       "        [1.39997912, 1.39997912, 1.76403993],\n",
+       "        [1.36448091, 1.36448091, 1.7193105 ],\n",
+       "        [1.32988281, 1.32988281, 1.67571524],\n",
+       "        [1.29616199, 1.29616199, 1.63322539],\n",
+       "        [1.26329619, 1.26329619, 1.59181293],\n",
+       "        [1.23126376, 1.23126376, 1.55145054],\n",
+       "        [1.20004355, 1.20004355, 1.51211158],\n",
+       "        [1.16961496, 1.16961496, 1.47377011],\n",
+       "        [1.13995793, 1.13995793, 1.43640084],\n",
+       "        [1.11105289, 1.11105289, 1.39997912],\n",
+       "        [1.08288078, 1.08288078, 1.36448091],\n",
+       "        [1.055423  , 1.055423  , 1.32988281],\n",
+       "        [1.02866146, 1.02866146, 1.29616199],\n",
+       "        [1.00257848, 1.00257848, 1.26329619],\n",
+       "        [0.97715687, 0.97715687, 1.23126376],\n",
+       "        [0.95237986, 0.95237986, 1.20004355],\n",
+       "        [0.92823111, 0.92823111, 1.16961496],\n",
+       "        [0.90469467, 0.90469467, 1.13995793],\n",
+       "        [0.88175503, 0.88175503, 1.11105289],\n",
+       "        [0.85939706, 0.85939706, 1.08288078],\n",
+       "        [0.837606  , 0.837606  , 1.055423  ],\n",
+       "        [0.81636748, 0.81636748, 1.02866146],\n",
+       "        [0.79566748, 0.79566748, 1.00257848],\n",
+       "        [0.77549237, 0.77549237, 0.97715687],\n",
+       "        [0.75582882, 0.75582882, 0.95237986],\n",
+       "        [0.73666386, 0.73666386, 0.92823111],\n",
+       "        [0.71798486, 0.71798486, 0.90469467],\n",
+       "        [0.69977948, 0.69977948, 0.88175503],\n",
+       "        [0.68203573, 0.68203573, 0.85939706],\n",
+       "        [0.66474189, 0.66474189, 0.837606  ],\n",
+       "        [0.64788656, 0.64788656, 0.81636748],\n",
+       "        [0.63145862, 0.63145862, 0.79566748],\n",
+       "        [0.61544722, 2.28060139, 0.77549237],\n",
+       "        [0.59984182, 2.22277389, 0.75582882],\n",
+       "        [0.58463211, 2.16641268, 0.73666386],\n",
+       "        [0.56980807, 2.11148057, 0.71798486],\n",
+       "        [0.5553599 , 2.05794134, 0.69977948],\n",
+       "        [0.54127809, 2.00575967, 0.68203573],\n",
+       "        [0.52755334, 1.95490113, 0.66474189],\n",
+       "        [0.5141766 , 1.90533217, 0.64788656],\n",
+       "        [0.50113904, 1.8570201 , 0.63145862],\n",
+       "        [0.48843207, 1.80993304, 0.61544722],\n",
+       "        [0.4760473 , 1.76403993, 0.59984182],\n",
+       "        [0.46397656, 1.7193105 , 0.58463211],\n",
+       "        [0.45221189, 1.67571524, 0.56980807],\n",
+       "        [0.44074552, 1.63322539, 0.5553599 ],\n",
+       "        [0.4295699 , 1.59181293, 0.54127809],\n",
+       "        [0.41867766, 1.55145054, 2.28060139],\n",
+       "        [0.4080616 , 1.51211158, 2.22277389],\n",
+       "        [0.39771472, 1.47377011, 2.16641268],\n",
+       "        [0.3876302 , 1.43640084, 2.11148057],\n",
+       "        [0.37780139, 1.39997912, 2.05794134],\n",
+       "        [0.3682218 , 1.36448091, 2.00575967],\n",
+       "        [0.35888511, 1.32988281, 1.95490113],\n",
+       "        [0.34978517, 1.29616199, 1.90533217],\n",
+       "        [0.34091596, 1.26329619, 1.8570201 ],\n",
+       "        [0.33227165, 1.23126376, 1.80993304],\n",
+       "        [0.32384652, 1.20004355, 1.76403993],\n",
+       "        [2.28060139, 1.16961496, 1.7193105 ],\n",
+       "        [2.22277389, 1.13995793, 1.67571524],\n",
+       "        [2.16641268, 1.11105289, 1.63322539],\n",
+       "        [2.11148057, 1.08288078, 1.59181293],\n",
+       "        [2.05794134, 1.055423  , 1.55145054],\n",
+       "        [2.28060139, 1.02866146, 1.51211158],\n",
+       "        [2.22277389, 2.28060139, 1.47377011],\n",
+       "        [2.16641268, 2.22277389, 1.43640084],\n",
+       "        [2.11148057, 2.16641268, 1.39997912],\n",
+       "        [2.05794134, 2.11148057, 1.36448091],\n",
+       "        [2.00575967, 2.05794134, 1.32988281],\n",
+       "        [1.95490113, 2.00575967, 1.29616199],\n",
+       "        [1.90533217, 1.95490113, 1.26329619],\n",
+       "        [1.8570201 , 1.90533217, 1.23126376],\n",
+       "        [1.80993304, 1.8570201 , 1.20004355],\n",
+       "        [1.76403993, 1.80993304, 1.16961496],\n",
+       "        [1.7193105 , 1.76403993, 1.13995793],\n",
+       "        [2.28060139, 1.7193105 , 1.11105289],\n",
+       "        [2.22277389, 1.67571524, 1.08288078],\n",
+       "        [2.16641268, 1.63322539, 1.055423  ],\n",
+       "        [2.11148057, 1.59181293, 1.02866146],\n",
+       "        [2.05794134, 1.55145054, 1.00257848],\n",
+       "        [2.00575967, 1.51211158, 0.97715687],\n",
+       "        [1.95490113, 1.47377011, 0.95237986],\n",
+       "        [1.90533217, 1.43640084, 0.92823111],\n",
+       "        [1.8570201 , 1.39997912, 0.90469467],\n",
+       "        [1.80993304, 1.36448091, 0.88175503],\n",
+       "        [1.76403993, 1.32988281, 0.85939706],\n",
+       "        [1.7193105 , 1.29616199, 0.837606  ],\n",
+       "        [1.67571524, 1.26329619, 0.81636748],\n",
+       "        [1.63322539, 1.23126376, 0.79566748],\n",
+       "        [1.59181293, 2.28060139, 0.77549237],\n",
+       "        [1.55145054, 2.22277389, 0.75582882],\n",
+       "        [1.51211158, 2.16641268, 0.73666386],\n",
+       "        [1.47377011, 2.11148057, 0.71798486],\n",
+       "        [1.43640084, 2.05794134, 0.69977948],\n",
+       "        [1.39997912, 2.00575967, 0.68203573],\n",
+       "        [1.36448091, 1.95490113, 0.66474189],\n",
+       "        [1.32988281, 1.90533217, 0.64788656],\n",
+       "        [1.29616199, 1.8570201 , 0.63145862],\n",
+       "        [1.26329619, 1.80993304, 0.61544722],\n",
+       "        [1.23126376, 1.76403993, 2.28060139],\n",
+       "        [1.20004355, 1.7193105 , 2.22277389]]),\n",
+       " 'a_nrm': array([[ -1.27807355,  -1.27807355,  -1.27807355],\n",
+       "        [ -2.52615583,  -2.52615583,  -2.52615583],\n",
+       "        [ -3.74259139,  -3.74259139,  -3.74259139],\n",
+       "        [ -4.92818269,  -4.92818269,  -4.92818269],\n",
+       "        [ -6.08371181,  -6.08371181,  -6.08371181],\n",
+       "        [ -7.20994102,  -7.20994102,  -7.20994102],\n",
+       "        [ -8.30761326,  -8.30761326,  -8.30761326],\n",
+       "        [ -9.37745262,  -9.37745262,  -9.37745262],\n",
+       "        [-10.42016485, -10.42016485, -10.42016485],\n",
+       "        [-11.43643779, -11.43643779,  -1.27807355],\n",
+       "        [-12.42694183, -12.42694183,  -2.52615583],\n",
+       "        [-13.39233038, -13.39233038,  -3.74259139],\n",
+       "        [-14.33324028, -14.33324028,  -4.92818269],\n",
+       "        [-15.25029222, -15.25029222,  -6.08371181],\n",
+       "        [-16.14409113, -16.14409113,  -7.20994102],\n",
+       "        [-17.01522664, -17.01522664,  -8.30761326],\n",
+       "        [-17.8642734 , -17.8642734 ,  -9.37745262],\n",
+       "        [-18.69179151, -18.69179151, -10.42016485],\n",
+       "        [-19.49832683, -19.49832683, -11.43643779],\n",
+       "        [-20.28441144, -20.28441144, -12.42694183],\n",
+       "        [-21.05056386, -21.05056386, -13.39233038],\n",
+       "        [-21.79728952, -21.79728952, -14.33324028],\n",
+       "        [-22.525081  , -22.525081  , -15.25029222],\n",
+       "        [-23.2344184 , -23.2344184 , -16.14409113],\n",
+       "        [-23.92576966, -23.92576966, -17.01522664],\n",
+       "        [-24.59959082, -24.59959082, -17.8642734 ],\n",
+       "        [-25.25632639, -25.25632639, -18.69179151],\n",
+       "        [-25.89640959, -25.89640959, -19.49832683],\n",
+       "        [-26.52026268, -26.52026268, -20.28441144],\n",
+       "        [-27.12829717, -27.12829717, -21.05056386],\n",
+       "        [-27.72091418, -27.72091418, -21.79728952],\n",
+       "        [-28.29850463, -28.29850463, -22.525081  ],\n",
+       "        [-28.86144954, -28.86144954, -23.2344184 ],\n",
+       "        [-29.41012026, -29.41012026, -23.92576966],\n",
+       "        [-29.94487875, -29.94487875, -24.59959082],\n",
+       "        [-30.46607775, -30.46607775, -25.25632639],\n",
+       "        [-30.97406109, -30.97406109, -25.89640959],\n",
+       "        [-31.46916387, -31.46916387, -26.52026268],\n",
+       "        [-31.95171268, -31.95171268, -27.12829717],\n",
+       "        [-32.42202586, -32.42202586, -27.72091418],\n",
+       "        [-32.88041365, -32.88041365, -28.29850463],\n",
+       "        [-33.32717843, -33.32717843, -28.86144954],\n",
+       "        [-33.76261493, -33.76261493, -29.41012026],\n",
+       "        [-34.18701038, -34.18701038, -29.94487875],\n",
+       "        [-34.60064474, -34.60064474, -30.46607775],\n",
+       "        [-35.00379088, -35.00379088, -30.97406109],\n",
+       "        [-35.39671474, -35.39671474, -31.46916387],\n",
+       "        [-35.77967551, -35.77967551, -31.95171268],\n",
+       "        [-36.15292583, -36.15292583, -32.42202586],\n",
+       "        [-36.51671191, -36.51671191, -32.88041365],\n",
+       "        [-36.87127373, -36.87127373, -33.32717843],\n",
+       "        [-37.21684518,  -1.27807355, -33.76261493],\n",
+       "        [-37.55365424,  -2.52615583, -34.18701038],\n",
+       "        [-37.88192307,  -3.74259139, -34.60064474],\n",
+       "        [-38.20186823,  -4.92818269, -35.00379088],\n",
+       "        [-38.51370077,  -6.08371181, -35.39671474],\n",
+       "        [-38.8176264 ,  -7.20994102, -35.77967551],\n",
+       "        [-39.11384561,  -8.30761326, -36.15292583],\n",
+       "        [-39.4025538 ,  -9.37745262, -36.51671191],\n",
+       "        [-39.68394144, -10.42016485, -36.87127373],\n",
+       "        [-39.95819413, -11.43643779, -37.21684518],\n",
+       "        [-40.2254928 , -12.42694183, -37.55365424],\n",
+       "        [-40.48601376, -13.39233038, -37.88192307],\n",
+       "        [-40.73992889, -14.33324028, -38.20186823],\n",
+       "        [-40.98740568, -15.25029222, -38.51370077],\n",
+       "        [-41.22860738, -16.14409113, -38.8176264 ],\n",
+       "        [-41.46369311, -17.01522664,  -1.27807355],\n",
+       "        [-41.69281793, -17.8642734 ,  -2.52615583],\n",
+       "        [-41.91613301, -18.69179151,  -3.74259139],\n",
+       "        [-42.13378565, -19.49832683,  -4.92818269],\n",
+       "        [-42.34591942, -20.28441144,  -6.08371181],\n",
+       "        [-42.55267428, -21.05056386,  -7.20994102],\n",
+       "        [-42.75418661, -21.79728952,  -8.30761326],\n",
+       "        [-42.95058933, -22.525081  ,  -9.37745262],\n",
+       "        [-43.14201201, -23.2344184 , -10.42016485],\n",
+       "        [-43.32858093, -23.92576966, -11.43643779],\n",
+       "        [-43.51041916, -24.59959082, -12.42694183],\n",
+       "        [ -1.27807355, -25.25632639, -13.39233038],\n",
+       "        [ -2.52615583, -25.89640959, -14.33324028],\n",
+       "        [ -3.74259139, -26.52026268, -15.25029222],\n",
+       "        [ -4.92818269, -27.12829717, -16.14409113],\n",
+       "        [ -6.08371181, -27.72091418, -17.01522664],\n",
+       "        [ -1.27807355, -28.29850463, -17.8642734 ],\n",
+       "        [ -2.52615583,  -1.27807355, -18.69179151],\n",
+       "        [ -3.74259139,  -2.52615583, -19.49832683],\n",
+       "        [ -4.92818269,  -3.74259139, -20.28441144],\n",
+       "        [ -6.08371181,  -4.92818269, -21.05056386],\n",
+       "        [ -7.20994102,  -6.08371181, -21.79728952],\n",
+       "        [ -8.30761326,  -7.20994102, -22.525081  ],\n",
+       "        [ -9.37745262,  -8.30761326, -23.2344184 ],\n",
+       "        [-10.42016485,  -9.37745262, -23.92576966],\n",
+       "        [-11.43643779, -10.42016485, -24.59959082],\n",
+       "        [-12.42694183, -11.43643779, -25.25632639],\n",
+       "        [-13.39233038, -12.42694183, -25.89640959],\n",
+       "        [ -1.27807355, -13.39233038, -26.52026268],\n",
+       "        [ -2.52615583, -14.33324028, -27.12829717],\n",
+       "        [ -3.74259139, -15.25029222, -27.72091418],\n",
+       "        [ -4.92818269, -16.14409113, -28.29850463],\n",
+       "        [ -6.08371181, -17.01522664, -28.86144954],\n",
+       "        [ -7.20994102, -17.8642734 , -29.41012026],\n",
+       "        [ -8.30761326, -18.69179151, -29.94487875],\n",
+       "        [ -9.37745262, -19.49832683, -30.46607775],\n",
+       "        [-10.42016485, -20.28441144, -30.97406109],\n",
+       "        [-11.43643779, -21.05056386, -31.46916387],\n",
+       "        [-12.42694183, -21.79728952, -31.95171268],\n",
+       "        [-13.39233038, -22.525081  , -32.42202586],\n",
+       "        [-14.33324028, -23.2344184 , -32.88041365],\n",
+       "        [-15.25029222, -23.92576966, -33.32717843],\n",
+       "        [-16.14409113,  -1.27807355, -33.76261493],\n",
+       "        [-17.01522664,  -2.52615583, -34.18701038],\n",
+       "        [-17.8642734 ,  -3.74259139, -34.60064474],\n",
+       "        [-18.69179151,  -4.92818269, -35.00379088],\n",
+       "        [-19.49832683,  -6.08371181, -35.39671474],\n",
+       "        [-20.28441144,  -7.20994102, -35.77967551],\n",
+       "        [-21.05056386,  -8.30761326, -36.15292583],\n",
+       "        [-21.79728952,  -9.37745262, -36.51671191],\n",
+       "        [-22.525081  , -10.42016485, -36.87127373],\n",
+       "        [-23.2344184 , -11.43643779, -37.21684518],\n",
+       "        [-23.92576966, -12.42694183,  -1.27807355],\n",
+       "        [-24.59959082, -13.39233038,  -2.52615583]])}"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -513,13 +1696,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 17,
    "id": "9e2c7ad0",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -539,7 +1722,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 18,
    "id": "2b471cf1",
    "metadata": {},
    "outputs": [
@@ -547,13 +1730,13 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/tmp/ipykernel_82097/2889722531.py:1: RuntimeWarning: divide by zero encountered in log\n",
+      "/tmp/ipykernel_14820/2889722531.py:1: RuntimeWarning: divide by zero encountered in log\n",
       "  plt.plot(np.log(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1) - np.min(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1))))\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -573,23 +1756,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 19,
    "id": "464f19e7",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x7f81cd7cac50>]"
+       "[<matplotlib.lines.Line2D at 0x7f6482c7c670>]"
       ]
      },
-     "execution_count": 23,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -606,13 +1789,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 20,
    "id": "1cc1dc83",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -624,8 +1807,8 @@
     }
    ],
    "source": [
-    "plt.plot(np.mean(pfn_simulator.history['m_nrm'], axis=1), label = 'Generic monte carlo')\n",
-    "plt.plot(np.mean(PFexample.history[\"mNrm\"], axis=1), label = 'HARK 0.13 PerfForesightConsumerType')\n",
+    "plt.plot(np.mean(pfn_simulator.history['a_nrm'], axis=1), label = 'Generic monte carlo')\n",
+    "plt.plot(np.mean(PFexample.history[\"aNrm\"], axis=1), label = 'HARK 0.13 PerfForesightConsumerType')\n",
     "plt.xlabel(\"Time\")\n",
     "plt.ylabel(\"Mean normalized market resources\")\n",
     "plt.legend()\n",
@@ -634,60 +1817,80 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 21,
    "id": "dcff94ad",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([ 0.        ,  0.00222005,  0.00809147,  0.0012631 ,  0.00715372,\n",
-       "        0.00472244,  0.01164685, -0.02193753,  0.00705938, -0.00575065,\n",
-       "        0.01159715,  0.01218249,  0.00756169, -0.01088867,  0.00391398,\n",
-       "        0.01271844, -0.03643547, -0.02459725,  0.03015856,  0.01530481,\n",
-       "        0.02311477, -0.03156213,  0.03450044, -0.0074543 , -0.04107368,\n",
-       "       -0.04513277, -0.04755333,  0.01681224,  0.02868896,  0.00597751,\n",
-       "        0.0062148 ,  0.03227652, -0.05788355, -0.03502477, -0.05127585,\n",
-       "       -0.04840637, -0.02264437, -0.01016401, -0.04317002,  0.01554684,\n",
-       "        0.04422656, -0.01825121, -0.05225021,  0.05681161, -0.02034541,\n",
-       "        0.02992888, -0.01631412,  0.03085562, -0.03086612,  0.07806968,\n",
-       "       -0.00208791, -0.03290248,  0.00225374,  0.00643284,  0.00942418,\n",
-       "        0.01848714,  0.00079372,  0.03766846,  0.07001856,  0.02767114,\n",
-       "       -0.00659404, -0.02168669, -0.0207974 , -0.05963123,  0.00159466,\n",
-       "       -0.06902993, -0.01631861,  0.03258728,  0.05195744,  0.01295495,\n",
-       "       -0.07574536,  0.05804067,  0.00946723,  0.04908705,  0.03198564,\n",
-       "       -0.02476253, -0.01308888, -0.02987224, -0.0402046 , -0.05912255,\n",
-       "       -0.03579365,  0.05592895, -0.01209768, -0.00462931, -0.00515618,\n",
-       "        0.03687773, -0.0470187 ,  0.07340151, -0.02497839, -0.06001675,\n",
-       "        0.0057467 , -0.114128  ,  0.03985532,  0.01473989,  0.03048939,\n",
-       "        0.01199857,  0.06194041,  0.03707683,  0.0146343 ,  0.06566299,\n",
-       "        0.04049083, -0.0182422 , -0.05992466, -0.02158895, -0.02265609,\n",
-       "       -0.0748654 ,  0.08375932,  0.02491707, -0.01224103,  0.02084308,\n",
-       "       -0.08846461, -0.02883666, -0.09607532,  0.01259047, -0.02288385,\n",
-       "       -0.02240209,  0.05049241, -0.01061027, -0.02799473,  0.00775624])"
+       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+       "       0.])"
       ]
      },
-     "execution_count": 25,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "np.mean(pfn_simulator.history['m_nrm'], axis=1) - np.mean(PFexample.history[\"mNrm\"], axis=1)"
+    "np.mean(pfn_simulator.history['a_nrm'], axis=1) - np.mean(PFexample.history[\"aNrm\"], axis=1)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "6cc8cfd2",
+   "execution_count": 22,
+   "id": "70de1058",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([  8,  50,  65,  76,  81,  82,  93, 107, 117]),\n",
+       " array([2, 1, 2, 0, 0, 1, 0, 1, 2]))"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.where(pfn_simulator.history['live'] < 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "0e37528d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([  8,  50,  65,  76,  81,  82,  93, 107, 117]),\n",
+       " array([2, 1, 2, 0, 0, 1, 0, 1, 2]))"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.where(1 - PFexample.history['who_dies'] < 1)"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "a7cfd234",
+   "id": "7e5cf6a1",
    "metadata": {},
    "outputs": [],
    "source": []
@@ -709,7 +1912,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

From 1bd53cfb08b4f18fff5bdcd15f99b6426d7d00d7 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 13 Nov 2023 11:36:03 -0500
Subject: [PATCH 22/27] black

---
 HARK/core.py                                |  16 ++-
 HARK/model.py                               |   1 +
 HARK/models/perfect_foresight.py            |  12 +-
 HARK/models/perfect_foresight_normalized.py |  40 +++---
 HARK/simulation/monte_carlo.py              | 111 ++++++++--------
 HARK/simulation/test_monte_carlo.py         | 136 +++++++++-----------
 6 files changed, 151 insertions(+), 165 deletions(-)

diff --git a/HARK/core.py b/HARK/core.py
index 5cdd1bc82..ab1c4a548 100644
--- a/HARK/core.py
+++ b/HARK/core.py
@@ -29,6 +29,12 @@
 from HARK.parallel import multi_thread_commands, multi_thread_commands_fake
 from HARK.utilities import NullFunc, get_arg_names
 
+<<<<<<< HEAD
+=======
+# Set logging and define basic functions
+import logging
+
+>>>>>>> 7c443df5 (black)
 logging.basicConfig(format="%(message)s")
 _log = logging.getLogger("HARK")
 _log.setLevel(logging.ERROR)
@@ -1061,10 +1067,14 @@ def simulate(self, sim_periods=None):
                     elif var_name in self.controls:
                         self.history[var_name][self.t_sim, :] = self.controls[var_name]
                     else:
-                        if var_name is 'who_dies' and self.t_sim > 1:
-                            self.history[var_name][self.t_sim - 1, :] = getattr(self, var_name)
+                        if var_name is "who_dies" and self.t_sim > 1:
+                            self.history[var_name][self.t_sim - 1, :] = getattr(
+                                self, var_name
+                            )
                         else:
-                            self.history[var_name][self.t_sim, :] = getattr(self, var_name)
+                            self.history[var_name][self.t_sim, :] = getattr(
+                                self, var_name
+                            )
                 self.t_sim += 1
 
             return self.history
diff --git a/HARK/model.py b/HARK/model.py
index 67632a8ef..44e47261b 100644
--- a/HARK/model.py
+++ b/HARK/model.py
@@ -11,6 +11,7 @@ class Aggregate:
     If so designated, draws from the shock will be scalar rather
     than array valued.
     """
+
     def __init__(self, dist: Distribution):
         self.dist = dist
 
diff --git a/HARK/models/perfect_foresight.py b/HARK/models/perfect_foresight.py
index 644f351f5..38bedd97d 100644
--- a/HARK/models/perfect_foresight.py
+++ b/HARK/models/perfect_foresight.py
@@ -19,12 +19,12 @@
         "PermGroFac": 1.01,
         "BoroCnstArt": None,
     },
-    'dynamics' : {
-        'y' : lambda p : p,
-        'm' : lambda Rfree, a, y : Rfree * a + y,
-        'c' : Control(['m']),
-        'p' : lambda PermGroFac, p: PermGroFac * p,
-        'a' : lambda m, c : m - c
+    "dynamics": {
+        "y": lambda p: p,
+        "m": lambda Rfree, a, y: Rfree * a + y,
+        "c": Control(["m"]),
+        "p": lambda PermGroFac, p: PermGroFac * p,
+        "a": lambda m, c: m - c,
     },
     "reward": {"u": lambda c: c ** (1 - CRRA) / (1 - CRRA)},
 }
diff --git a/HARK/models/perfect_foresight_normalized.py b/HARK/models/perfect_foresight_normalized.py
index 22211db45..79fab78dc 100644
--- a/HARK/models/perfect_foresight_normalized.py
+++ b/HARK/models/perfect_foresight_normalized.py
@@ -4,30 +4,28 @@
 # This way of distributing parameters across the scope is clunky
 # Can be handled better if parsed from a YAML file, probably
 # But it would be better to have a more graceful Python version as well.
-CRRA = 2.0,
+CRRA = (2.0,)
 LivPrb = 0.98
 
 model = {
-    'shocks' : {
-        'live' : Bernoulli(p=LivPrb),
+    "shocks": {
+        "live": Bernoulli(p=LivPrb),
     },
-    'parameters' : {
-        'DiscFac' : 0.96,
-        'CRRA' : CRRA,
-        'Rfree' : 1.03,
-        'LivPrb' : LivPrb,
-        'PermGroFac' : 1.01,
-        'BoroCnstArt' : None,
+    "parameters": {
+        "DiscFac": 0.96,
+        "CRRA": CRRA,
+        "Rfree": 1.03,
+        "LivPrb": LivPrb,
+        "PermGroFac": 1.01,
+        "BoroCnstArt": None,
     },
-    'dynamics' : {
-        'p' : lambda PermGroFac, p: PermGroFac * p,
-        'r_eff' : lambda Rfree, PermGroFac : Rfree / PermGroFac,
-        'b_nrm' : lambda r_eff, a_nrm: r_eff * a_nrm,
-        'm_nrm' : lambda b_nrm: b_nrm + 1,
-        'c_nrm' : Control(['m_nrm']),
-        'a_nrm' : lambda m_nrm, c_nrm : m_nrm - c_nrm
+    "dynamics": {
+        "p": lambda PermGroFac, p: PermGroFac * p,
+        "r_eff": lambda Rfree, PermGroFac: Rfree / PermGroFac,
+        "b_nrm": lambda r_eff, a_nrm: r_eff * a_nrm,
+        "m_nrm": lambda b_nrm: b_nrm + 1,
+        "c_nrm": Control(["m_nrm"]),
+        "a_nrm": lambda m_nrm, c_nrm: m_nrm - c_nrm,
     },
-    'reward' : {
-        'u' : lambda c : c ** (1 - CRRA) / (1 - CRRA)
-    }
-}
\ No newline at end of file
+    "reward": {"u": lambda c: c ** (1 - CRRA) / (1 - CRRA)},
+}
diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 2326186ed..eaf544148 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -2,16 +2,18 @@
 Functions to support Monte Carlo simulation of models.
 """
 from copy import copy
-from HARK.distribution import Distribution, IndexDistribution, TimeVaryingDiscreteDistribution
+from HARK.distribution import (
+    Distribution,
+    IndexDistribution,
+    TimeVaryingDiscreteDistribution,
+)
 from HARK.model import Aggregate, Control
 from inspect import signature
 import numpy as np
 from typing import Any, Callable, Mapping, Sequence, Union
 
-def draw_shocks(
-        shocks: Mapping[str, Distribution],
-        conditions: Sequence[int]
-        ):
+
+def draw_shocks(shocks: Mapping[str, Distribution], conditions: Sequence[int]):
     """
 
     Parameters
@@ -32,8 +34,9 @@ def draw_shocks(
             draws[shock_var] = np.ones(len(conditions)) * shock
         elif isinstance(shock, Aggregate):
             draws[shock_var] = shock.dist.draw(1)[0]
-        elif isinstance(shock, IndexDistribution) \
-            or isinstance(shock, TimeVaryingDiscreteDistribution):
+        elif isinstance(shock, IndexDistribution) or isinstance(
+            shock, TimeVaryingDiscreteDistribution
+        ):
             ## TODO  his type test is awkward. They should share a superclass.
             draws[shock_var] = shock.draw(conditions)
         else:
@@ -41,10 +44,11 @@ def draw_shocks(
 
     return draws
 
+
 def simulate_dynamics(
-        dynamics : Mapping[str, Union[Callable, Control]],
-        pre : Mapping[str, Any],
-        dr : Mapping[str, Callable]
+    dynamics: Mapping[str, Union[Callable, Control]],
+    pre: Mapping[str, Any],
+    dr: Mapping[str, Callable],
 ):
     """
 
@@ -78,23 +82,25 @@ def simulate_dynamics(
                 ## Now we have to loop through each agent, and apply the decision rule.
                 ## This is quite slow.
                 for i in range(dr[varn].size):
-                    vals_i = {var : vals[var][i] if isinstance(vals[var], np.ndarray) else vals[var]
-                              for var in vals
-                              }
-                    vals[varn][i] = dr[varn][i](*[
-                        vals_i[var]
-                        for var
-                        in signature(dr[varn][i]).parameters])
+                    vals_i = {
+                        var: vals[var][i]
+                        if isinstance(vals[var], np.ndarray)
+                        else vals[var]
+                        for var in vals
+                    }
+                    vals[varn][i] = dr[varn][i](
+                        *[vals_i[var] for var in signature(dr[varn][i]).parameters]
+                    )
             else:
-                vals[varn] = dr[varn](*[
-                    vals[var]
-                    for var
-                    in signature(dr[varn]).parameters]) # TODO: test for signature match with Control
+                vals[varn] = dr[varn](
+                    *[vals[var] for var in signature(dr[varn]).parameters]
+                )  # TODO: test for signature match with Control
         else:
             vals[varn] = feq(*[vals[var] for var in signature(feq).parameters])
 
     return vals
 
+
 def parameters_by_age(ages, parameters):
     """
     Returns parameters for this model, but with vectorized
@@ -115,29 +121,24 @@ def parameters_by_age(ages, parameters):
         If a parameter is age-varying, the value is a vector
         corresponding to the values for each input age.
     """
+
     def aged_param(ages, p_value):
         if isinstance(p_value, (float, int)) or callable(p_value):
             return p_value
         elif isinstance(p_value, list) and len(p_value) > 1:
             pv_array = np.array(p_value)
 
-            return np.apply_along_axis(
-                lambda a: pv_array[a],
-                0,
-                ages
-            )
+            return np.apply_along_axis(lambda a: pv_array[a], 0, ages)
         else:
             return np.empty(ages.size)
 
-    return {
-        p : aged_param(ages, parameters[p])
-        for p
-        in parameters
-    }
+    return {p: aged_param(ages, parameters[p]) for p in parameters}
 
-class Simulator():
+
+class Simulator:
     pass
 
+
 class AgentTypeMonteCarloSimulator(Simulator):
     """
     A Monte Carlo simulation engine based on the HARK.core.AgentType framework.
@@ -150,7 +151,7 @@ class AgentTypeMonteCarloSimulator(Simulator):
 
     This simulator makes assumptions about population birth and mortality which
     are not generic. They are: TODO.
-    
+
     Parameters
     ----------
     TODO
@@ -168,15 +169,7 @@ class AgentTypeMonteCarloSimulator(Simulator):
     state_vars = []
 
     def __init__(
-        self,
-        parameters,
-        shocks,
-        dynamics,
-        dr,
-        initial,
-        seed=0,
-        agent_count = 1,
-        T_sim = 10
+        self, parameters, shocks, dynamics, dr, initial, seed=0, agent_count=1, T_sim=10
     ):
         super().__init__()
 
@@ -255,7 +248,9 @@ def initialize_sim(self):
         # Get recorded newborn conditions or initialize blank history.
         if self.read_shocks and bool(self.newborn_init_history):
             for init_var_name in self.initial:
-                self.vars_now[init_var_name] = self.newborn_init_history[init_var_name][self.t_sim, :]
+                self.vars_now[init_var_name] = self.newborn_init_history[init_var_name][
+                    self.t_sim, :
+                ]
         else:
             for var_name in self.initial:
                 self.newborn_init_history[var_name] = (
@@ -309,13 +304,13 @@ def sim_one_period(self):
 
         pre.update(self.vars_prev)
         pre.update(shocks_now)
-        #Won't work for 3.8: self.parameters | self.vars_prev | shocks_now
+        # Won't work for 3.8: self.parameters | self.vars_prev | shocks_now
 
         # Age-varying decision rules captured here
         dr = parameters_by_age(self.t_age, self.dr)
-        
+
         post = simulate_dynamics(self.dynamics, pre, dr)
-        
+
         self.vars_now = post
         ### BIG CHANGES HERE
 
@@ -323,10 +318,10 @@ def sim_one_period(self):
         self.t_age = self.t_age + 1  # Age all consumers by one period
 
         # What will we do with cycles?
-        #self.t_cycle = self.t_cycle + 1  # Age all consumers within their cycle
-        #self.t_cycle[
+        # self.t_cycle = self.t_cycle + 1  # Age all consumers within their cycle
+        # self.t_cycle[
         #    self.t_cycle == self.T_cycle
-        #] = 0  # Resetting to zero for those who have reached the end
+        # ] = 0  # Resetting to zero for those who have reached the end
 
     def make_shock_history(self):
         """
@@ -382,7 +377,7 @@ def get_mortality(self):
         -------
         None
         """
-        who_dies = self.vars_now['live'] <= 0
+        who_dies = self.vars_now["live"] <= 0
 
         self.sim_birth(who_dies)
 
@@ -407,20 +402,18 @@ def sim_birth(self, which_agents):
             t = self.t_sim
             initial_vals = {
                 init_var: self.newborn_init_history[init_var][t, which_agents]
-                for init_var
-                in self.initial
+                for init_var in self.initial
             }
 
         else:
-            initial_vals = draw_shocks(
-                self.initial,
-                np.zeros(which_agents.sum())
-            )
+            initial_vals = draw_shocks(self.initial, np.zeros(which_agents.sum()))
 
         if np.sum(which_agents) > 0:
             for varn in initial_vals:
                 self.vars_now[varn][which_agents] = initial_vals[varn]
-                self.newborn_init_history[varn][self.t_sim, which_agents] = initial_vals[varn]
+                self.newborn_init_history[varn][
+                    self.t_sim, which_agents
+                ] = initial_vals[varn]
 
         self.t_age[which_agents] = 0
         self.t_cycle[which_agents] = 0
@@ -468,7 +461,7 @@ def simulate(self, sim_periods=None):
                 # track all the vars -- shocks and dynamics
                 for var_name in self.vars:
                     self.history[var_name][self.t_sim, :] = self.vars_now[var_name]
-                    
+
                 self.t_sim += 1
 
             return self.history
@@ -487,4 +480,4 @@ def clear_history(self):
         """
         for var_name in self.vars:
             self.history[var_name] = np.empty((self.T_sim, self.agent_count))
-            self.history[var_name].fill(np.nan)
\ No newline at end of file
+            self.history[var_name].fill(np.nan)
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
index bf999b008..9b5a5dad2 100644
--- a/HARK/simulation/test_monte_carlo.py
+++ b/HARK/simulation/test_monte_carlo.py
@@ -8,82 +8,73 @@
 from HARK.simulation.monte_carlo import *
 
 cons_shocks = {
-    'agg_gro' : Aggregate(MeanOneLogNormal(1)),
-    'psi' : IndexDistribution(
-        MeanOneLogNormal,
-        {
-            'sigma' : [1.0, 1.1]
-        }),
-    'theta' : MeanOneLogNormal(1),
-    'live' : Bernoulli(p=0.98)
+    "agg_gro": Aggregate(MeanOneLogNormal(1)),
+    "psi": IndexDistribution(MeanOneLogNormal, {"sigma": [1.0, 1.1]}),
+    "theta": MeanOneLogNormal(1),
+    "live": Bernoulli(p=0.98),
 }
 
 cons_pre = {
-    'R' : 1.05,
-    'aNrm' : 1,
-    'gamma' : 1.1,
-    'psi' : 1.1, # TODO: draw this from a shock,
-    'theta' : 1.1 # TODO: draw this from a shock
+    "R": 1.05,
+    "aNrm": 1,
+    "gamma": 1.1,
+    "psi": 1.1,  # TODO: draw this from a shock,
+    "theta": 1.1,  # TODO: draw this from a shock
 }
 
 cons_dynamics = {
-    'G' : lambda gamma, psi : gamma * psi,
-    'Rnrm' : lambda R, G : R / G,
-    'bNrm' : lambda Rnrm, aNrm : Rnrm * aNrm,
-    'mNrm' : lambda bNrm, theta : bNrm + theta,
-    'cNrm' : Control(['mNrm']),
-    'aNrm' : lambda mNrm, cNrm : mNrm - cNrm
+    "G": lambda gamma, psi: gamma * psi,
+    "Rnrm": lambda R, G: R / G,
+    "bNrm": lambda Rnrm, aNrm: Rnrm * aNrm,
+    "mNrm": lambda bNrm, theta: bNrm + theta,
+    "cNrm": Control(["mNrm"]),
+    "aNrm": lambda mNrm, cNrm: mNrm - cNrm,
 }
 
-cons_dr = {
-    'cNrm' : lambda mNrm : mNrm / 2
-}
+cons_dr = {"cNrm": lambda mNrm: mNrm / 2}
+
 
 class test_draw_shocks(unittest.TestCase):
     def test_draw_shocks(self):
 
-        drawn = draw_shocks(cons_shocks, np.array([0,1]))
+        drawn = draw_shocks(cons_shocks, np.array([0, 1]))
+
+        self.assertEqual(len(drawn["theta"]), 2)
+        self.assertEqual(len(drawn["psi"]), 2)
+        self.assertTrue(isinstance(drawn["agg_gro"], float))
 
-        self.assertEqual(len(drawn['theta']), 2)
-        self.assertEqual(len(drawn['psi']), 2)
-        self.assertTrue(isinstance(drawn['agg_gro'], float))
 
 class test_simulate_dynamics(unittest.TestCase):
     def test_simulate_dynamics(self):
 
         post = simulate_dynamics(cons_dynamics, cons_pre, cons_dr)
 
-        self.assertAlmostEqual(post['cNrm'], 0.98388429)
+        self.assertAlmostEqual(post["cNrm"], 0.98388429)
 
 
 class test_AgentTypeMonteCarloSimulator(unittest.TestCase):
     def setUp(self):
 
         self.shocks = {
-            'theta' : MeanOneLogNormal(1),
-            'agg_R' : Aggregate(MeanOneLogNormal(1)),
-            'live' : Bernoulli(p=0.98)
+            "theta": MeanOneLogNormal(1),
+            "agg_R": Aggregate(MeanOneLogNormal(1)),
+            "live": Bernoulli(p=0.98),
         }
 
-        self.initial = {
-            'a' : MeanOneLogNormal(1),
-            'live' : 1
-        }
+        self.initial = {"a": MeanOneLogNormal(1), "live": 1}
 
-        self.parameters = { # TODO
-            'G' : 1.05,
+        self.parameters = {  # TODO
+            "G": 1.05,
         }
 
         self.dynamics = {
-            'b' : lambda agg_R, G, a : agg_R * G * a,
-            'm' : lambda b, theta : b + theta,
-            'c' : Control(['m']),
-            'a' : lambda m, c : m - c
+            "b": lambda agg_R, G, a: agg_R * G * a,
+            "m": lambda b, theta: b + theta,
+            "c": Control(["m"]),
+            "a": lambda m, c: m - c,
         }
 
-        self.dr = {
-            'c' : lambda m : m / 2
-        }
+        self.dr = {"c": lambda m: m / 2}
 
     def test_simulate(self):
         self.simulator = AgentTypeMonteCarloSimulator(
@@ -92,14 +83,18 @@ def test_simulate(self):
             self.dynamics,
             self.dr,
             self.initial,
-            agent_count = 3
+            agent_count=3,
         )
 
         self.simulator.initialize_sim()
         history = self.simulator.simulate()
 
-        a1 = history['a'][5]
-        b1 = history['a'][4] * history['agg_R'][5] * self.parameters['G'] + history['theta'][5]  - history['c'][5]
+        a1 = history["a"][5]
+        b1 = (
+            history["a"][4] * history["agg_R"][5] * self.parameters["G"]
+            + history["theta"][5]
+            - history["c"][5]
+        )
 
         self.assertTrue((a1 == b1).all())
 
@@ -110,7 +105,7 @@ def test_make_shock_history(self):
             self.dynamics,
             self.dr,
             self.initial,
-            agent_count = 3
+            agent_count=3,
         )
 
         self.simulator.make_shock_history()
@@ -122,44 +117,33 @@ def test_make_shock_history(self):
         self.simulator.simulate()
 
         self.assertEqual(newborn_init_1, self.simulator.newborn_init_history)
-        self.assertTrue(
-            np.all(self.simulator.history['theta'] == shocks_1['theta'])
-            )
-        
+        self.assertTrue(np.all(self.simulator.history["theta"] == shocks_1["theta"]))
+
 
 class test_AgentTypeMonteCarloSimulatorAgeVariance(unittest.TestCase):
     def setUp(self):
 
         self.shocks = {
-            'theta' : MeanOneLogNormal(1),
-            'agg_R' : Aggregate(MeanOneLogNormal(1)),
-            'live' : Bernoulli(p=0.98),
-            'psi' : IndexDistribution(
-                MeanOneLogNormal,
-                {
-                'sigma' : [1.0, 1.1]
-                })
+            "theta": MeanOneLogNormal(1),
+            "agg_R": Aggregate(MeanOneLogNormal(1)),
+            "live": Bernoulli(p=0.98),
+            "psi": IndexDistribution(MeanOneLogNormal, {"sigma": [1.0, 1.1]}),
         }
 
-        self.initial = {
-            'a' : MeanOneLogNormal(1),
-            'live' : 1
-        }
+        self.initial = {"a": MeanOneLogNormal(1), "live": 1}
 
-        self.parameters = { # TODO
-            'G' : 1.05,
+        self.parameters = {  # TODO
+            "G": 1.05,
         }
 
         self.dynamics = {
-            'b' : lambda agg_R, G, a : agg_R * G * a,
-            'm' : lambda b, theta : b + theta,
-            'c' : Control(['m']),
-            'a' : lambda m, c : m - c
+            "b": lambda agg_R, G, a: agg_R * G * a,
+            "m": lambda b, theta: b + theta,
+            "c": Control(["m"]),
+            "a": lambda m, c: m - c,
         }
 
-        self.dr = {
-            'c' : [lambda m : m * 0.5, lambda m : m * 0.9]
-        }
+        self.dr = {"c": [lambda m: m * 0.5, lambda m: m * 0.9]}
 
     def test_simulate(self):
         self.simulator = AgentTypeMonteCarloSimulator(
@@ -168,13 +152,13 @@ def test_simulate(self):
             self.dynamics,
             self.dr,
             self.initial,
-            agent_count = 3
+            agent_count=3,
         )
 
         self.simulator.initialize_sim()
         history = self.simulator.simulate(sim_periods=2)
 
-        a1 = history['a'][1]
-        b1 = history['m'][1] - self.dr['c'][1](history['m'][1])
+        a1 = history["a"][1]
+        b1 = history["m"][1] - self.dr["c"][1](history["m"][1])
 
-        self.assertTrue((a1 == b1).all())
\ No newline at end of file
+        self.assertTrue((a1 == b1).all())

From c4feeb3bc5e50b091a5ba82b9ed512fe76d53d40 Mon Sep 17 00:00:00 2001
From: Sebastian Benthall <sbenthall@gmail.com>
Date: Mon, 13 Nov 2023 13:09:31 -0500
Subject: [PATCH 23/27] Update core.py -- fixing bad merge

---
 HARK/core.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/HARK/core.py b/HARK/core.py
index ab1c4a548..ab2560859 100644
--- a/HARK/core.py
+++ b/HARK/core.py
@@ -29,12 +29,8 @@
 from HARK.parallel import multi_thread_commands, multi_thread_commands_fake
 from HARK.utilities import NullFunc, get_arg_names
 
-<<<<<<< HEAD
-=======
 # Set logging and define basic functions
 import logging
-
->>>>>>> 7c443df5 (black)
 logging.basicConfig(format="%(message)s")
 _log = logging.getLogger("HARK")
 _log.setLevel(logging.ERROR)

From 1a33be6badf25b6747de5051e7889c0102b839c6 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 13 Nov 2023 13:20:03 -0500
Subject: [PATCH 24/27] pre-commit fixes

---
 HARK/core.py                        | 5 ++---
 HARK/simulation/monte_carlo.py      | 8 +++++---
 HARK/simulation/test_monte_carlo.py | 6 +-----
 3 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/HARK/core.py b/HARK/core.py
index ab2560859..71a79e2a9 100644
--- a/HARK/core.py
+++ b/HARK/core.py
@@ -7,6 +7,7 @@
 problem by finding a general equilibrium dynamic rule.
 """
 # Set logging and define basic functions
+# Set logging and define basic functions
 import logging
 import sys
 from collections import defaultdict, namedtuple
@@ -29,8 +30,6 @@
 from HARK.parallel import multi_thread_commands, multi_thread_commands_fake
 from HARK.utilities import NullFunc, get_arg_names
 
-# Set logging and define basic functions
-import logging
 logging.basicConfig(format="%(message)s")
 _log = logging.getLogger("HARK")
 _log.setLevel(logging.ERROR)
@@ -1063,7 +1062,7 @@ def simulate(self, sim_periods=None):
                     elif var_name in self.controls:
                         self.history[var_name][self.t_sim, :] = self.controls[var_name]
                     else:
-                        if var_name is "who_dies" and self.t_sim > 1:
+                        if var_name == "who_dies" and self.t_sim > 1:
                             self.history[var_name][self.t_sim - 1, :] = getattr(
                                 self, var_name
                             )
diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index eaf544148..6ec22a196 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -2,15 +2,17 @@
 Functions to support Monte Carlo simulation of models.
 """
 from copy import copy
+from inspect import signature
+from typing import Any, Callable, Mapping, Sequence, Union
+
+import numpy as np
+
 from HARK.distribution import (
     Distribution,
     IndexDistribution,
     TimeVaryingDiscreteDistribution,
 )
 from HARK.model import Aggregate, Control
-from inspect import signature
-import numpy as np
-from typing import Any, Callable, Mapping, Sequence, Union
 
 
 def draw_shocks(shocks: Mapping[str, Distribution], conditions: Sequence[int]):
diff --git a/HARK/simulation/test_monte_carlo.py b/HARK/simulation/test_monte_carlo.py
index 9b5a5dad2..bb1620c3c 100644
--- a/HARK/simulation/test_monte_carlo.py
+++ b/HARK/simulation/test_monte_carlo.py
@@ -3,7 +3,7 @@
 """
 import unittest
 
-from HARK.distribution import Bernoulli, MeanOneLogNormal, IndexDistribution
+from HARK.distribution import Bernoulli, IndexDistribution, MeanOneLogNormal
 from HARK.model import Aggregate, Control
 from HARK.simulation.monte_carlo import *
 
@@ -36,7 +36,6 @@
 
 class test_draw_shocks(unittest.TestCase):
     def test_draw_shocks(self):
-
         drawn = draw_shocks(cons_shocks, np.array([0, 1]))
 
         self.assertEqual(len(drawn["theta"]), 2)
@@ -46,7 +45,6 @@ def test_draw_shocks(self):
 
 class test_simulate_dynamics(unittest.TestCase):
     def test_simulate_dynamics(self):
-
         post = simulate_dynamics(cons_dynamics, cons_pre, cons_dr)
 
         self.assertAlmostEqual(post["cNrm"], 0.98388429)
@@ -54,7 +52,6 @@ def test_simulate_dynamics(self):
 
 class test_AgentTypeMonteCarloSimulator(unittest.TestCase):
     def setUp(self):
-
         self.shocks = {
             "theta": MeanOneLogNormal(1),
             "agg_R": Aggregate(MeanOneLogNormal(1)),
@@ -122,7 +119,6 @@ def test_make_shock_history(self):
 
 class test_AgentTypeMonteCarloSimulatorAgeVariance(unittest.TestCase):
     def setUp(self):
-
         self.shocks = {
             "theta": MeanOneLogNormal(1),
             "agg_R": Aggregate(MeanOneLogNormal(1)),

From 62e8d5feff5e8c72f82d894901ffef99e40c9316 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 13 Nov 2023 13:47:51 -0500
Subject: [PATCH 25/27] ruff format the example notebook

---
 ...eneric Monte Carlo Perfect Foresight.ipynb | 75 +++++++++++--------
 1 file changed, 44 insertions(+), 31 deletions(-)

diff --git a/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb b/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb
index e4749ea1d..2699e7125 100644
--- a/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb	
+++ b/examples/MonteCarlo/Generic Monte Carlo Perfect Foresight.ipynb	
@@ -36,12 +36,12 @@
     "    \"AgentCount\": 3,  # Number of agents of this type\n",
     "    \"T_sim\": 120,  # Number of periods to simulate\n",
     "    \"aNrmInitMean\": -6.0,  # Mean of log initial assets\n",
-    "    \"aNrmInitStd\": 0, #1.0,  # Standard deviation of log initial assets\n",
+    "    \"aNrmInitStd\": 0,  # 1.0,  # Standard deviation of log initial assets\n",
     "    \"pLvlInitMean\": 0.0,  # Mean of log initial permanent income\n",
     "    \"pLvlInitStd\": 0.0,  # Standard deviation of log initial permanent income\n",
     "    \"PermGroFacAgg\": 1.0,  # Aggregate permanent income growth factor\n",
     "    \"T_age\": None,  # Age after which simulated agents are automatically killed,\n",
-    "    \"LivPrb\": [0.98]\n",
+    "    \"LivPrb\": [0.98],\n",
     "}\n",
     "\n",
     "PFexample.assign_parameters(**SimulationParams)"
@@ -594,7 +594,7 @@
     }
    ],
    "source": [
-    "PFexample.track_vars = [\"who_dies\",\"mNrm\",\"pLvl\",\"aNrm\"]\n",
+    "PFexample.track_vars = [\"who_dies\", \"mNrm\", \"pLvl\", \"aNrm\"]\n",
     "PFexample.make_shock_history()\n",
     "\n",
     "PFexample.initialize_sim()\n",
@@ -681,7 +681,12 @@
     }
    ],
    "source": [
-    "plt.plot(np.log(np.mean(PFexample.history[\"mNrm\"], axis=1) - np.min(np.mean(PFexample.history[\"mNrm\"], axis=1))))\n",
+    "plt.plot(\n",
+    "    np.log(\n",
+    "        np.mean(PFexample.history[\"mNrm\"], axis=1)\n",
+    "        - np.min(np.mean(PFexample.history[\"mNrm\"], axis=1))\n",
+    "    )\n",
+    ")\n",
     "plt.xlabel(\"Time\")\n",
     "plt.ylabel(\"Mean normalized market resources\")\n",
     "plt.show()"
@@ -705,7 +710,7 @@
     }
    ],
    "source": [
-    "PFexample.newborn_init_history['pLvl'][1,PFexample.history[\"who_dies\"][1,:] > 0].shape"
+    "PFexample.newborn_init_history[\"pLvl\"][1, PFexample.history[\"who_dies\"][1, :] > 0].shape"
    ]
   },
   {
@@ -726,7 +731,7 @@
     }
    ],
    "source": [
-    "PFexample.newborn_init_history['aNrm'][2, PFexample.history[\"who_dies\"][2,:] > 0].shape"
+    "PFexample.newborn_init_history[\"aNrm\"][2, PFexample.history[\"who_dies\"][2, :] > 0].shape"
    ]
   },
   {
@@ -791,19 +796,17 @@
    "outputs": [],
    "source": [
     "pfn_simulator = AgentTypeMonteCarloSimulator(\n",
-    "    pfn.model['parameters'],\n",
-    "    pfn.model['shocks'],\n",
-    "    pfn.model['dynamics'],\n",
-    "    {\n",
-    "        'c_nrm' : lambda m_nrm: PFexample.solution[0].cFunc(m_nrm)\n",
-    "    },\n",
-    "    { # initial states\n",
-    "        'a_nrm' : Lognormal(-6, 0),\n",
+    "    pfn.model[\"parameters\"],\n",
+    "    pfn.model[\"shocks\"],\n",
+    "    pfn.model[\"dynamics\"],\n",
+    "    {\"c_nrm\": lambda m_nrm: PFexample.solution[0].cFunc(m_nrm)},\n",
+    "    {  # initial states\n",
+    "        \"a_nrm\": Lognormal(-6, 0),\n",
     "        #'live' : 1,\n",
-    "        'p' : 1.0\n",
+    "        \"p\": 1.0,\n",
     "    },\n",
-    "    agent_count = 3,\n",
-    "    T_sim = 120\n",
+    "    agent_count=3,\n",
+    "    T_sim=120,\n",
     ")"
    ]
   },
@@ -815,9 +818,9 @@
    "outputs": [],
    "source": [
     "pfn_simulator.read_shocks = True\n",
-    "#pfn_simulator.shock_history['live'] = 1 - np.roll(PFexample.history[\"who_dies\"], -1)\n",
+    "# pfn_simulator.shock_history['live'] = 1 - np.roll(PFexample.history[\"who_dies\"], -1)\n",
     "\n",
-    "pfn_simulator.shock_history['live'] = 1 - PFexample.history[\"who_dies\"]"
+    "pfn_simulator.shock_history[\"live\"] = 1 - PFexample.history[\"who_dies\"]"
    ]
   },
   {
@@ -827,9 +830,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "pfn_simulator.newborn_init_history['a_nrm'] = PFexample.newborn_init_history['aNrm']\n",
-    "pfn_simulator.newborn_init_history['p'] = PFexample.newborn_init_history['pLvl']\n",
-    "#pfn_simulator.newborn_init_history['live'] = PFexample.newborn_init_history['pLvl']"
+    "pfn_simulator.newborn_init_history[\"a_nrm\"] = PFexample.newborn_init_history[\"aNrm\"]\n",
+    "pfn_simulator.newborn_init_history[\"p\"] = PFexample.newborn_init_history[\"pLvl\"]\n",
+    "# pfn_simulator.newborn_init_history['live'] = PFexample.newborn_init_history['pLvl']"
    ]
   },
   {
@@ -1689,7 +1692,7 @@
     }
    ],
    "source": [
-    "#pf_simulator.track_vars = [\"mNrm\"]\n",
+    "# pf_simulator.track_vars = [\"mNrm\"]\n",
     "pfn_simulator.initialize_sim()\n",
     "pfn_simulator.simulate(sim_periods=120)"
    ]
@@ -1714,7 +1717,7 @@
     }
    ],
    "source": [
-    "plt.plot(np.mean(pfn_simulator.history['m_nrm'], axis=1))\n",
+    "plt.plot(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1))\n",
     "plt.xlabel(\"Time\")\n",
     "plt.ylabel(\"Mean normalized market resources\")\n",
     "plt.show()"
@@ -1748,7 +1751,12 @@
     }
    ],
    "source": [
-    "plt.plot(np.log(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1) - np.min(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1))))\n",
+    "plt.plot(\n",
+    "    np.log(\n",
+    "        np.mean(pfn_simulator.history[\"m_nrm\"], axis=1)\n",
+    "        - np.min(np.mean(pfn_simulator.history[\"m_nrm\"], axis=1))\n",
+    "    )\n",
+    ")\n",
     "plt.xlabel(\"Time\")\n",
     "plt.ylabel(\"Mean normalized market resources\")\n",
     "plt.show()"
@@ -1784,7 +1792,7 @@
     }
    ],
    "source": [
-    "plt.plot(pfn_simulator.history['live'].sum(axis=1))"
+    "plt.plot(pfn_simulator.history[\"live\"].sum(axis=1))"
    ]
   },
   {
@@ -1807,8 +1815,11 @@
     }
    ],
    "source": [
-    "plt.plot(np.mean(pfn_simulator.history['a_nrm'], axis=1), label = 'Generic monte carlo')\n",
-    "plt.plot(np.mean(PFexample.history[\"aNrm\"], axis=1), label = 'HARK 0.13 PerfForesightConsumerType')\n",
+    "plt.plot(np.mean(pfn_simulator.history[\"a_nrm\"], axis=1), label=\"Generic monte carlo\")\n",
+    "plt.plot(\n",
+    "    np.mean(PFexample.history[\"aNrm\"], axis=1),\n",
+    "    label=\"HARK 0.13 PerfForesightConsumerType\",\n",
+    ")\n",
     "plt.xlabel(\"Time\")\n",
     "plt.ylabel(\"Mean normalized market resources\")\n",
     "plt.legend()\n",
@@ -1840,7 +1851,9 @@
     }
    ],
    "source": [
-    "np.mean(pfn_simulator.history['a_nrm'], axis=1) - np.mean(PFexample.history[\"aNrm\"], axis=1)"
+    "np.mean(pfn_simulator.history[\"a_nrm\"], axis=1) - np.mean(\n",
+    "    PFexample.history[\"aNrm\"], axis=1\n",
+    ")"
    ]
   },
   {
@@ -1862,7 +1875,7 @@
     }
    ],
    "source": [
-    "np.where(pfn_simulator.history['live'] < 1)"
+    "np.where(pfn_simulator.history[\"live\"] < 1)"
    ]
   },
   {
@@ -1884,7 +1897,7 @@
     }
    ],
    "source": [
-    "np.where(1 - PFexample.history['who_dies'] < 1)"
+    "np.where(1 - PFexample.history[\"who_dies\"] < 1)"
    ]
   },
   {

From 4f4b9bae581e2c974d4f1a4c6934a4635c77e8ec Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 27 Nov 2023 11:22:01 -0500
Subject: [PATCH 26/27] improving documentation for Generic Monte Carlo

---
 Documentation/CHANGELOG.md                   |  2 +
 Documentation/reference/index.rst            |  1 +
 Documentation/reference/tools/simulation.rst |  2 +-
 HARK/simulation.py                           |  7 --
 HARK/simulation/monte_carlo.py               | 91 ++++++--------------
 5 files changed, 32 insertions(+), 71 deletions(-)
 delete mode 100644 HARK/simulation.py

diff --git a/Documentation/CHANGELOG.md b/Documentation/CHANGELOG.md
index 79b0a3eb8..d91d204f1 100644
--- a/Documentation/CHANGELOG.md
+++ b/Documentation/CHANGELOG.md
@@ -27,6 +27,8 @@ Release Date: TBD
 - Fixes bug that prevented risky-asset consumer types from working with time-varying interest rates `Rfree`. [1343](https://github.com/econ-ark/HARK/pull/1343)
 - Overhauls and expands condition checking for the ConsIndShock model [#1294](https://github.com/econ-ark/HARK/pull/1294). Condition values and a description of their interpretation is stored in the bilt dictionary of IndShockConsumerType.
 - Creates a `models/` directory with Python model configurations for perfect foresight and Fisher 2-period models. [1347](https://github.com/econ-ark/HARK/pull/1347)
+- Fixes bug in AgentType simulations where 'who_dies' for period t was being recorded in period t-1in the history Carlo simulation functions using Python model configurations.[1296](https://github.com/econ-ark/HARK/pull/1296)
+- Removes unused `simulation.py` .[1296](https://github.com/econ-ark/HARK/pull/1296)
 
 ### 0.13.0
 
diff --git a/Documentation/reference/index.rst b/Documentation/reference/index.rst
index 1d9cced2f..de65cad62 100644
--- a/Documentation/reference/index.rst
+++ b/Documentation/reference/index.rst
@@ -13,6 +13,7 @@ API Reference
    tools/frame
    tools/helpers
    tools/interpolation
+   tools/model
    tools/numba_tools
    tools/parallel
    tools/rewards
diff --git a/Documentation/reference/tools/simulation.rst b/Documentation/reference/tools/simulation.rst
index 55e17756f..a56040159 100644
--- a/Documentation/reference/tools/simulation.rst
+++ b/Documentation/reference/tools/simulation.rst
@@ -1,7 +1,7 @@
 Simulation
 ------------
 
-.. automodule:: HARK.simulation
+.. automodule:: HARK.simulation.monte_carlo
    :members:
    :undoc-members:
    :show-inheritance:
diff --git a/HARK/simulation.py b/HARK/simulation.py
deleted file mode 100644
index 918e4e377..000000000
--- a/HARK/simulation.py
+++ /dev/null
@@ -1,7 +0,0 @@
-"""
-Currently empty. Will be used for future simulation handling code.
-"""
-
-import warnings  # A library for runtime warnings
-
-import numpy as np  # Numerical Python
diff --git a/HARK/simulation/monte_carlo.py b/HARK/simulation/monte_carlo.py
index 6ec22a196..13a3e34af 100644
--- a/HARK/simulation/monte_carlo.py
+++ b/HARK/simulation/monte_carlo.py
@@ -1,6 +1,7 @@
 """
 Functions to support Monte Carlo simulation of models.
 """
+
 from copy import copy
 from inspect import signature
 from typing import Any, Callable, Mapping, Sequence, Union
@@ -17,6 +18,7 @@
 
 def draw_shocks(shocks: Mapping[str, Distribution], conditions: Sequence[int]):
     """
+    Draw from each shock distribution values, subject to given conditions.
 
     Parameters
     ------------
@@ -26,6 +28,11 @@ def draw_shocks(shocks: Mapping[str, Distribution], conditions: Sequence[int]):
     conditions: Sequence[int]
         An array of conditions, one for each agent.
         Typically these will be agent ages.
+
+    Parameters
+    ------------
+    draws : Mapping[str, Sequence]
+        A mapping from shock names to drawn shock values.
     """
     draws = {}
 
@@ -53,6 +60,8 @@ def simulate_dynamics(
     dr: Mapping[str, Callable],
 ):
     """
+    From the beginning-of-period state (pre), follow the dynamics,
+    including any decision rules, to compute the end-of-period state.
 
     Parameters
     ------------
@@ -144,19 +153,27 @@ class Simulator:
 class AgentTypeMonteCarloSimulator(Simulator):
     """
     A Monte Carlo simulation engine based on the HARK.core.AgentType framework.
-    Unlike HARK.core.AgentType, this class:
-      * does not do any model solving
-      * depends on dynamic equations, shocks, and decision rules paased into it
+
+    Unlike HARK.core.AgentType, this class does not do any model solving,
+    and depends on dynamic equations, shocks, and decision rules paased into it.
 
     The purpose of this class is to provide a way to simulate models without
     relying on inheritance from the AgentType class.
 
     This simulator makes assumptions about population birth and mortality which
-    are not generic. They are: TODO.
+    are not generic. All agents are replaced with newborns when they expire.
 
     Parameters
-    ----------
-    TODO
+    ------------
+    parameters: Mapping[str, Any]
+
+    shocks: Mapping[str, Distribution]
+
+    dynamics: Mapping[str, Union[Callable, Control]]
+
+    dr: Mapping[str, Callable]
+
+    initial: dict
 
     seed : int
         A seed for this instance's random number generator.
@@ -166,6 +183,8 @@ class AgentTypeMonteCarloSimulator(Simulator):
     agent_count : int
         The number of agents of this type to use in simulation.
 
+    T_sim : int
+        The number of periods to simulate.
     """
 
     state_vars = []
@@ -201,14 +220,6 @@ def __init__(
     def reset_rng(self):
         """
         Reset the random number generator for this type.
-
-        Parameters
-        ----------
-        none
-
-        Returns
-        -------
-        none
         """
         self.RNG = np.random.default_rng(self.seed)
 
@@ -216,14 +227,6 @@ def initialize_sim(self):
         """
         Prepares for a new simulation.  Resets the internal random number generator,
         makes initial states for all agents (using sim_birth), clears histories of tracked variables.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
         """
         if self.T_sim <= 0:
             raise Exception(
@@ -270,14 +273,6 @@ def sim_one_period(self):
         read_shocks, get_states(), get_controls(), and get_poststates().  These should be defined for
         AgentType subclasses, except get_mortality (define its components sim_death and sim_birth
         instead) and read_shocks.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
         """
         # Mortality adjusts the agent population
         self.get_mortality()  # Replace some agents with "newborns"
@@ -328,18 +323,12 @@ def sim_one_period(self):
     def make_shock_history(self):
         """
         Makes a pre-specified history of shocks for the simulation.  Shock variables should be named
-        in self.shock_vars, a list of strings that is subclass-specific.  This method runs a subset
+        in self.shock, a mapping from shock names to distributions.  This method runs a subset
         of the standard simulation loop by simulating only mortality and shocks; each variable named
-        in shock_vars is stored in a T_sim x agent_count array in history dictionary self.history[X].
+        in shocks is stored in a T_sim x agent_count array in history dictionary self.history[X].
         Automatically sets self.read_shocks to True so that these pre-specified shocks are used for
         all subsequent calls to simulate().
 
-        ### TODO: Rethink this for when shocks are passed in.
-
-        Parameters
-        ----------
-        None
-
         Returns
         -------
         shock_history: dict
@@ -360,24 +349,8 @@ def make_shock_history(self):
 
     def get_mortality(self):
         """
-        Simulates mortality or agent turnover according to some model-specific rules named sim_death
-        and sim_birth (methods of an AgentType subclass).
-
+        Simulates mortality or agent turnover.
         Agents die when their states `live` is less than or equal to zero.
-
-        a Boolean array of size agent_count, indicating which agents of this type have "died" and
-        must be replaced.
-
-        sim_birth takes such a Boolean array as an argument and generates initial
-        states for those agent indices.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
         """
         who_dies = self.vars_now["live"] <= 0
 
@@ -471,14 +444,6 @@ def simulate(self, sim_periods=None):
     def clear_history(self):
         """
         Clears the histories.
-
-        Parameters
-        ----------
-        None
-
-        Returns
-        -------
-        None
         """
         for var_name in self.vars:
             self.history[var_name] = np.empty((self.T_sim, self.agent_count))

From a3294738aa60c5ff2e9b248ff7566e6a5783b3f5 Mon Sep 17 00:00:00 2001
From: sb <sbenthall@gmail.com>
Date: Mon, 27 Nov 2023 11:28:28 -0500
Subject: [PATCH 27/27] adding model.rst file to docs

---
 Documentation/reference/tools/model.rst | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 Documentation/reference/tools/model.rst

diff --git a/Documentation/reference/tools/model.rst b/Documentation/reference/tools/model.rst
new file mode 100644
index 000000000..141b2ac93
--- /dev/null
+++ b/Documentation/reference/tools/model.rst
@@ -0,0 +1,7 @@
+Model
+-------------
+
+.. automodule:: HARK.model
+   :members:
+   :undoc-members:
+   :show-inheritance: