Add an Effect to the Frame.

        :param effect: The Effect to be added.
339610
def add_effect(self, effect):
        
        effect.register_scene(self._scene)
        self._effects.append(effect)
1373901
def _updateEffects(self, time_passed):
        """"""

        for name in self._effects:
            update_func = getattr(
                self,
                '_effectupdate_{}'.format(name.replace("-", "_")),
            )
            update_func(time_passed)
192689
def add(self, feature):
        
        self.features_.append(feature)
        self.num_features_ = len(self.features_)
103245
def add(self, scene):
        """"""
        if not isinstance(scene, Scene):
            raise TypeError()
        for i, j in enumerate(self.__scenes):
            if j.scene_id == scene.scene_id:
                self.__scenes[i] = scene
                return
        self.__scenes.append(scene)
1081281
def expand_effect_repertoire(self, new_purview=None):
        """"""
        return self.subsystem.expand_effect_repertoire(
            self.effect.repertoire, new_purview)
1127760
def add_observation(self, obs):
        
        if len(self._observations)==0:
            self._observations.append(obs)
        else:
            res = obs.resolution
            ind = 0
            for o in self._observations:
                if res > o.resolution:
                    break
                ind += 1
            self._observations.insert(ind, obs)

        self._build_tree()
        self._clear_cache()
541232
def _add_crc(self, frame):
        
        crc = struct.pack('<H', crc16(frame))
        return frame + crc
1361707
def add(self, option):
				
		if option.__class__ == Option:
			for _option in self.options:
				if option.name == _option.name:
					raise OptionDuplicateError(_option.name)
			self.options.append(option)
		else:
			raise TypeError("invalid type supplied")
1229101
def add_deferred_effect(self, effect, pos):
        
        if not isinstance(pos, (unicode, str)):
            raise Exception("Invalid POS tag. Must be string not %d" % (type(pos)))
        if self['speaker_model']['is_syntax_stacked'] == True:
            self.__dict__['deferred_effects'].insert(0,(pos, effect,))
        elif self['speaker_model']['is_syntax_stacked'] == False:
            self.__dict__['deferred_effects'].append((pos, effect,))
        else:
            raise Contradiction("Speaker Model undefined")
862556
def _add_action(self, action):
        
        kwargs = self._get_method_params()

        kwargs['action'] = action

        self._bulk_actions.append(kwargs)
303772
def add(self, name, *vals):
        '''
        
        '''
        item = self.frames[-1].get(name)
        if item is None:
            self.frames[-1][name] = item = []
        item.extend(vals)
927075
def add_subvisual(self, visual):
        
        visual.transforms = self.transforms
        visual._prepare_transforms(visual)
        self._subvisuals.append(visual)
        visual.events.update.connect(self._subv_update)
        self.update()
775300
def add(self, layer, verbosity = 0, position = None):
        
        layer._verbosity = verbosity
        layer._maxRandom = self._maxRandom
        layer.minTarget = 0.0
        layer.maxTarget = 1.0
        layer.minActivation = 0.0
        layer.maxActivation = 1.0
        if position == None:
            self.layers.append(layer)
        else:
            self.layers.insert(position, layer)
        self.layersByName[layer.name] = layer
1137686
def add(self, *args, **kwargs):
        
        return self._apply(operator.add, *args, **kwargs)
1211363
def addFixedEffect(self,F=None,A=None):
        
        if A==None:
            A = SP.eye(self.P)
        if F==None:
            F = SP.ones((self.N,1))
        
        assert A.shape[1]==self.P, 'Incompatible shape'
        assert F.shape[0]==self.N, 'Incompatible shape'
       
        if F.shape[1]>1:
            for m in range(F.shape[1]):
                self.vd.addFixedEffTerm(A,F[:,m:m+1])
        else:
            self.vd.addFixedEffTerm(A,F)

        #TODO: what is this gp object doing, is this initialization correct?
        self.gp      = None
        self.init    = False
        self.fast    = False
        self.optimum = None

        self.cache['Sigma']   = None
        self.cache['Hessian'] = None
        self.cache['Lparams'] = None
        self.cache['paramsST']= None
1248292
def addEvent(self, event, fd, action):
        
        self._events[event] = (fd, action)
596818
def add_shot(self, shot):
        """"""
        shot.declination = self.declination
        if shot.is_splay:
            self.splays[shot['FROM']].append(shot)
        self.shots.append(shot)