class BoldMonitorForm(MonitorForm):
    def __init__(self,
                 session_stored_simulator=None,
                 prefix='',
                 project_id=None):
        super(BoldMonitorForm, self).__init__(session_stored_simulator, prefix,
                                              project_id)
        self.hrf_kernel_choices = get_ui_name_to_monitor_equation_dict()
        default_hrf_kernel = list(self.hrf_kernel_choices.values())[0]

        self.period = ScalarField(Bold.period, self)
        self.hrf_kernel = SelectField(Attr(HRFKernelEquation,
                                           label='Equation',
                                           default=default_hrf_kernel),
                                      self,
                                      name='hrf_kernel',
                                      choices=self.hrf_kernel_choices)

    def fill_trait(self, datatype):
        super(BoldMonitorForm, self).fill_trait(datatype)
        datatype.period = self.period.data
        if type(datatype.hrf_kernel) != self.hrf_kernel.data:
            datatype.hrf_kernel = self.hrf_kernel.data()

    def fill_from_trait(self, trait):
        super(BoldMonitorForm, self).fill_from_trait(trait)
        self.hrf_kernel.data = trait.hrf_kernel.__class__
class MultiplicativeNoiseForm(NoiseForm):
    def __init__(self):
        super(MultiplicativeNoiseForm, self).__init__()
        self.equation_choices = get_ui_name_to_equation_dict()
        default_equation = list(self.equation_choices.values())[0]

        self.nsig = ArrayField(MultiplicativeNoiseViewModel.nsig,
                               self.project_id)
        self.equation = SelectField(
            Attr(Equation, label='Equation', default=default_equation),
            self.project_id,
            name='equation',
            choices=self.equation_choices,
            subform=get_form_for_equation(default_equation))

    def fill_trait(self, datatype):
        super(MultiplicativeNoiseForm, self).fill_trait(datatype)
        datatype.nsig = self.nsig.data
        if type(datatype.b) != self.equation.data:
            datatype.b = self.equation.data()

    def fill_from_trait(self, trait):
        # type: (NoiseViewModel) -> None
        super(MultiplicativeNoiseForm, self).fill_from_trait(trait)
        self.equation.data = trait.b.__class__
class IntegratorStochasticForm(IntegratorForm):
    template = 'form_fields/select_field.html'

    def __init__(self, prefix=''):
        super(IntegratorStochasticForm, self).__init__(prefix)
        self.noise_choices = get_ui_name_to_noise_dict()
        default_noise = list(self.noise_choices.values())[0]

        self.noise = SelectField(Attr(NoiseViewModel, label='Noise', default=default_noise), self, name='noise',
                                 choices=self.noise_choices, subform=get_form_for_noise(default_noise))

    def fill_trait(self, datatype):
        super(IntegratorStochasticForm, self).fill_trait(datatype)
        if type(datatype.noise) != self.noise.data:
            datatype.noise = self.noise.data()

    def fill_from_trait(self, trait):
        # type: (IntegratorStochasticViewModel) -> None
        self.noise.data = trait.noise.__class__