bsm1_cl ¶

def __init__(
    self,
    data_in: np.ndarray | str | None = None,
    timestep: float | None = 1 / 60 / 24,
    endtime: float | None = None,
    evaltime: int | np.ndarray | None = None,
    use_noise: int = 1,
    noise_file: str | None = None,
    noise_seed: int = 1,
    data_out: str | None = None,
    *,
    tempmodel: bool = False,
    activate: bool = False,
):
    if timestep is not None and timestep > 1 / 60 / 24:
        logger.warning(
            'Timestep should not be larger than 1 minute due to sensor sensitivity. \
                       Will continue with provided timestep, but most probably fail.'
        )

    super().__init__(
        data_in=data_in,
        timestep=timestep,
        endtime=endtime,
        evaltime=evaltime,
        tempmodel=tempmodel,
        activate=activate,
        data_out=data_out,
    )
    num_sen = 1
    num_act = 1

    den_sno2 = [
        ac_init.T_SNO2**8,
        8 * ac_init.T_SNO2**7,
        28 * ac_init.T_SNO2**6,
        56 * ac_init.T_SNO2**5,
        70 * ac_init.T_SNO2**4,
        56 * ac_init.T_SNO2**3,
        28 * ac_init.T_SNO2**2,
        8 * ac_init.T_SNO2,
        1,
    ]
    self.sno2_sensor = Sensor(num_sen, den_sno2, ac_init.MIN_SNO2, ac_init.MAX_SNO2, ac_init.STD_SNO2)
    self.qintr_pid = PID(**ac_init.PID_QINTR_PARAMS)
    den_qintr = [ac_init.QINTRT, 1]
    self.qintr_actuator = Actuator(num_act, den_qintr)

    den_sen5 = [ac_init.T_SO5**2, 2 * ac_init.T_SO5, 1]
    self.so5_sensor = Sensor(num_sen, den_sen5, ac_init.MIN_SO5, ac_init.MAX_SO5, ac_init.STD_SO5)
    self.kla5_pid = PID(**ac_init.PID_KLA5_PARAMS)
    den_act5 = [ac_init.T_KLA5**2, 2 * ac_init.T_KLA5, 1]
    self.kla5_actuator = Actuator(num_act, den_act5)

    if use_noise == 0:
        self.noise_so4 = np.zeros(2)
        self.noise_timestep = np.array((0, self.endtime)).flatten()
    elif use_noise == 1:
        if noise_file is None:
            noise_file = path_name + '/data/sensornoise.csv'
        with open(noise_file, encoding='utf-8-sig') as f:
            noise_data = np.array(list(csv.reader(f, delimiter=','))).astype(np.float64)
        if noise_data[-1, 0] < self.endtime:
            err = 'Noise file does not cover the whole simulation time.\n \
                Please provide a valid noise file.'
            raise ValueError(err)
        noise_shape_criteria = 2
        if noise_data.shape[1] < noise_shape_criteria:
            err = 'Noise file needs to have at least 2 columns: time and noise data'
            raise ValueError(err)
        self.noise_so4 = noise_data[:, 1].flatten()
        self.noise_timestep = noise_data[:, 0].flatten()
        del noise_data

    if timestep is None:
        # calculate difference between each time step in data_in
        self.simtime = self.noise_timestep
        self.timesteps = np.diff(
            self.noise_timestep, append=(2 * self.noise_timestep[-1,] - self.noise_timestep[-2,])
        )
    else:
        self.simtime = np.arange(0, self.data_in[-1, 0], timestep)
        self.timesteps = timestep * np.ones(len(self.simtime))

    self.simtime = self.simtime[self.simtime <= self.endtime]

    rng_mode = 2  # random number generator mode
    if use_noise in {0, 1}:
        pass
    elif use_noise == rng_mode:
        np.random.seed(noise_seed)
        # create random noise array with mean 0 and variance 1
        self.noise_so4 = np.random.normal(0, 1, len(self.simtime)).flatten()
        self.noise_timestep = self.simtime
    else:
        err = 'use_noise has to be 0, 1 or 2'
        raise ValueError(err)

    self.data_time = self.data_in[:, 0]
    # self.simtime = np.arange(0, self.endtime, self.timestep)

    self.kla3_a = ac_init.KLA3_INIT
    self.kla4_a = ac_init.KLA4_INIT
    self.kla5_a = ac_init.KLA5_INIT