RHS Not Being Updated in MultiScenario Problem

class SensitivityAnalyzer:

    def __init__(
            self,
            base_problem : VBAProblem,
    ):
        """
        Arguments
        ------------
        base_problem : VBA_Problem
          Base problem we'll build the scenarios from
        increment : int
          How much to increment each element we'll generate a scenario for.
        sets : typing.Iterable[str]
          Any of ('L','C','V','S') that indicate which set we want to generate scenarios over. We will increment each element of teh requested sets and generate a scenario for each incremented element
        omissions : dict[str, set[str]]
          A dict whose keys must be contained in sets.  For the requested sets, do not generate a scenario for the element's in this args keys.
        """
        self.Model=base_problem.Model

        self.Model.num_scenarios = 0

    def generate_scenarios(self, base_problem, increment, sets, omissions = None) :

        scen_index = 0

        for it in sets:
            #elements to generate scenario which are the base set - the elements of the set
            #that are present in omissions
            els = base_problem.getSet(it)

            #if they provided some omissions, remove them from this elements
            if omissions :
              els = els - omissions.get(it,set())

            self.Model.num_scenarios += len(els)

            self.Model.update()

            for e in els:
                # logging.debug(f'Generating scenario {scen_index+1} / {self.Model.NumScenarios}')
                #make scenario where this element is incremented
                self.generate_constraint_scenario(
                    scen_index,
                    f'{it}_supply_{e.ID}',
                    increment
                    )
                #increment scenario number so next loop is new scenario
                scen_index += 1

            logging.info(f'{len(els)} scenarios generated for set {it}.')

    def generate_constraint_scenario(self,scenNum , element_name, increment) :

        #Initialize the scenario with the scenario number, give it a name
        self.Model.Params.ScenarioNumber =scenNum
        self.Model.ScenNName = element_name

        #get the constraint we're gonna modify
        constr = self.Model.getConstrByName(element_name)

        assert constr is not None, f'Unable to retrieve constraint {element_name}'

        #save the original value
        og_rhs = constr.RHS

        #increment it
        new_rhs=og_rhs+increment

        logging.debug(f'Setting {element_name} RHS to {new_rhs} from {og_rhs}')

        #set constraint right hand side to new value  
        constr.ScenNRHS=new_rhs

sa = SensitivityAnalyzer(P)
sa.generate_scenarios(P, 500000, ['C'])

sa.Model.optimize()

and inspect the constraint RHS in each of the scenarios, they are still at their original values. 

for i in range(sa.Model.num_scenarios):
    sa.Model.Params.ScenarioNumber =i

    print(sa.Model.ScenNName)
    print('Base Problem RHS:', P.Model.getConstrByName(sa.Model.ScenNName).RHS)
    print(f'Scenario {i} RHS: ', sa.Model.getConstrByName(sa.Model.ScenNName).RHS)
    print(f'Scenario {i} Obj Val', sa.Model.ScenNObjVal)