def run(self,sorn):
        super(Experiment_hesselmann,self).run(sorn)
        c = self.params.c
        
        sorn.simulation(c.steps_plastic)
        sorn.update = False
        
        ## Generate Training and test data
        # Andreea also did this
        sorn.x = np.zeros(sorn.c.N_e)
        sorn.y = np.zeros(sorn.c.N_i)
        sorn.source = self.trainsource
        # Generate Training Data
        sorn.simulation(c.steps_noplastic_train)
        sorn.x = np.zeros(sorn.c.N_e)
        sorn.y = np.zeros(sorn.c.N_i)

        # Generate new source with mixed letters
        # Save old mappings
        old_W_eu = sorn.W_eu.W
        source = self.source.source
        A_neurons = where(sorn.W_eu.W[:,source.lookup['A']]==1)[0]
        B_neurons = where(sorn.W_eu.W[:,source.lookup['B']]==1)[0]
        X_neurons = where(sorn.W_eu.W[:,source.lookup['X']]==1)[0]
        # First generate source with len(frac_A) words of equal prob
        N_words = len(c.frac_A)
        letters = "CDEFGHIJKL" 
        Xes = (sorn.c.source.N_x*'X')
        word_list = ['A%s_'%Xes,'B%s_'%Xes]                               
        frac_A_letters = ['B']
        for i in range(N_words-2):
            word_list.append('%s%s_'%(letters[i],Xes))                     
            frac_A_letters.append(letters[i])
        frac_A_letters.append('A')
        
        probs = np.ones((N_words,N_words))*(1.0/N_words)
        source_new = CountingSource(word_list,probs,c.N_u_e,True,
                           permute_ambiguous=c.source.permute_ambiguous)
        # Then take weight matrices of these guys and set them according
        # to frac_A
        new_W_eu = source_new.generate_connection_e(c.N_e)
        new_W_eu.W *= 0
        new_W_eu.W[A_neurons,source_new.lookup['A']] = 1
        new_W_eu.W[B_neurons,source_new.lookup['B']] = 1
        new_W_eu.W[X_neurons,source_new.lookup['X']] = 1
        # from 1 to len-1 because 0 and 1 already included in fracs
        for i in range(1,len(frac_A_letters)-1):
            new_neurons = hstack(
                          (A_neurons[:int(len(A_neurons)*c.frac_A[i])],
                           B_neurons[int(len(A_neurons)*c.frac_A[i]):]))
            new_W_eu.W[new_neurons,
                       source_new.lookup[frac_A_letters[i]]] = 1
            
        # Assign the source and new Matrix to SORN
        sorn.W_eu = new_W_eu
        sorn.W_iu = source_new.generate_connection_i(c.N_i)
        trialsource_new = TrialSource(source_new, c.wait_min_test,
                                c.wait_var_test, zeros(source_new.N_a), 
                                'reset')
        sorn.source = trialsource_new
        
        sorn.simulation(c.steps_noplastic_test)
        
        return {'source_plastic':self.source,
                'source_train':self.trainsource,
                'source_test':trialsource_new}