def test_memory_leaks_destructors(): print("\n\n\n\n\n") for i in range(1000): print("\n\nRound %i" % (i + 1)) # Test destructors root = Node("root") node1 = Node("node1") node2 = Node("node2") node3 = Node("node3") refc_before_link_root = node_ctype._get_reference_counts(root) refc_before_link1 = node_ctype._get_reference_counts(node1) refc_before_link2 = node_ctype._get_reference_counts(node2) refc_before_link3 = node_ctype._get_reference_counts(node3) # root._add_children([node1, node2, node3]) # node1 +1, node2 + 1, node3 + 1, root +3 root._add_child(node1) root._add_child(node2) root._add_child(node3) assert node_ctype._get_reference_counts( root) == refc_before_link_root + 3 assert node_ctype._get_reference_counts(node1) == refc_before_link1 + 1 assert node_ctype._get_reference_counts(node2) == refc_before_link2 + 1 assert node_ctype._get_reference_counts(node3) == refc_before_link3 + 1 # # Let's destroy the tree root._remove_child("node1") root._remove_child("node2") root._remove_child("node3")
def test_get_child(): t = _SimpleInheritance("test") n = Node("node") t._add_child(n) assert t._get_child("node") == n with pytest.raises(AttributeError): t._get_child("not existing") clean()
def test_remove_child(): t = _SimpleInheritance("test") n = Node("node") for i in range(1000): t._add_child(n) assert t._get_child("node") == n t._remove_child("node") with pytest.raises(AttributeError): print t.node with pytest.raises(AttributeError): t._get_child("node") clean()
def __init__(self, name, distribution_shape=None, components=None): Node.__init__(self, name) if components is None: if distribution_shape is None: log.error("You have to either provied a list of components, or a " \ "distribution shape") raise AssertionError() components = [SpectralComponent("main", distribution_shape)] Source.__init__(self, components, SourceType.PARTICLE_SOURCE) # Add a node called 'spectrum' spectrum_node = Node('spectrum') spectrum_node._add_children(list(self._components.values())) self._add_child(spectrum_node) type(self).__call__ = type(self).get_flux # Set the units # Now sets the units of the parameters for the energy domain current_units = get_units() # energy as x and particle flux as y x_unit = current_units.energy y_unit = old_div(1, current_units.energy) # Now set the units of the components for component in list(self._components.values()): component.shape.set_units(x_unit, y_unit)
def __init__(self, source_name, spatial_shape, spectral_shape=None, components=None): # Check that we have all the required information # and set the units current_u = get_units() if spatial_shape.n_dim == 2: # Now gather the component(s) # We need either a single component, or a list of components, but not both # (that's the ^ symbol) assert (spectral_shape is not None) ^ (components is not None), "You have to provide either a single " \ "component, or a list of components " \ "(but not both)." # If the user specified only one component, make a list of one element with a default name ("main") if spectral_shape is not None: components = [SpectralComponent("main", spectral_shape)] # Components in this case have energy as x and differential flux as y diff_flux_units = (current_u.energy * current_u.area * current_u.time) ** (-1) # Now set the units of the components for component in components: component.shape.set_units(current_u.energy, diff_flux_units) # Set the units of the brightness spatial_shape.set_units(current_u.angle, current_u.angle, current_u.angle**(-2)) elif spatial_shape.n_dim == 3: # If there is no spectral component then assume that the input is a template, which will provide the # spectrum by itself. We just use a renormalization (a bias) if spectral_shape is None and components is None: # This is a template. Add a component which is just a renormalization spectral_shape = Constant() components = [SpectralComponent("main", spectral_shape)] # set the units diff_flux_units = (current_u.energy * current_u.area * current_u.time * current_u.angle**2) ** (-1) spatial_shape.set_units(current_u.angle, current_u.angle, current_u.energy, diff_flux_units) else: # the spectral shape has been given, so this is a case where the spatial template gives an # energy-dependent shape and the spectral components give the spectrum assert (spectral_shape is not None) ^ (components is not None), "You can provide either a single " \ "component, or a list of components " \ "(but not both)." if spectral_shape is not None: components = [SpectralComponent("main", spectral_shape)] # Assign units diff_flux_units = (current_u.energy * current_u.area * current_u.time) ** (-1) # Now set the units of the components for component in components: component.shape.set_units(current_u.energy, diff_flux_units) # Set the unit of the spatial template spatial_shape.set_units(current_u.angle, current_u.angle, current_u.energy, current_u.angle**(-2)) else: raise RuntimeError("The spatial shape must have either 2 or 3 dimensions.") # Here we have a list of components Source.__init__(self, components, EXTENDED_SOURCE) # A source is also a Node in the tree Node.__init__(self, source_name) # Add the spatial shape as a child node, with an explicit name self._spatial_shape = spatial_shape self._add_child(self._spatial_shape) # Add the same node also with the name of the function #self._add_child(self._shape, self._shape.__name__) # Add a node called 'spectrum' spectrum_node = Node('spectrum') spectrum_node._add_children(self._components.values()) self._add_child(spectrum_node)
def __init__(self, source_name: str, ra: Optional[float] = None, dec: Optional[float] = None, spectral_shape: Optional[Function1D] = None, l: Optional[float] = None, b: Optional[float] = None, components=None, sky_position: Optional[SkyDirection] = None): # Check that we have all the required information # (the '^' operator acts as XOR on booleans) # Check that we have one and only one specification of the position if not ((ra is not None and dec is not None) ^ (l is not None and b is not None) ^ (sky_position is not None)): log.error( "You have to provide one and only one specification for the position" ) raise AssertionError() # Gather the position if not isinstance(sky_position, SkyDirection): if (ra is not None) and (dec is not None): # Check that ra and dec are actually numbers try: ra = float(ra) dec = float(dec) except (TypeError, ValueError): log.error( "RA and Dec must be numbers. If you are confused by this message, you " "are likely using the constructor in the wrong way. Check the documentation." ) raise AssertionError() sky_position = SkyDirection(ra=ra, dec=dec) else: sky_position = SkyDirection(l=l, b=b) self._sky_position: SkyDirection = sky_position # Now gather the component(s) # We need either a single component, or a list of components, but not both # (that's the ^ symbol) if not (spectral_shape is not None) ^ (components is not None): log.error( "You have to provide either a single component, or a list of components (but not both)." ) raise AssertionError() # If the user specified only one component, make a list of one element with a default name ("main") if spectral_shape is not None: components = [SpectralComponent("main", spectral_shape)] Source.__init__(self, components, src_type=SourceType.POINT_SOURCE) # A source is also a Node in the tree Node.__init__(self, source_name) # Add the position as a child node, with an explicit name self._add_child(self._sky_position) # Add a node called 'spectrum' spectrum_node = Node('spectrum') spectrum_node._add_children(list(self._components.values())) self._add_child(spectrum_node) # Now set the units # Now sets the units of the parameters for the energy domain current_units = get_units() # Components in this case have energy as x and differential flux as y x_unit = current_units.energy y_unit = (current_units.energy * current_units.area * current_units.time)**(-1) # Now set the units of the components for component in list(self._components.values()): component.shape.set_units(x_unit, y_unit)
def test_add_children(): t = _SimpleInheritance("children") t._add_children([Node("node1"), Node("node2")]) clean()
def test_memory_leaks_getters(): # Now test the getters root = Node("root") node1 = Node("node1") node2 = Node("node2") node3 = Node("node3") refc_before_link_root = node_ctype._get_reference_counts(root) refc_before_link1 = node_ctype._get_reference_counts(node1) refc_before_link2 = node_ctype._get_reference_counts(node2) refc_before_link3 = node_ctype._get_reference_counts(node3) None_counts_before = node_ctype._get_reference_counts(None) # Add 3 nodes to root root._add_children([node1, node2, node3]) # node1 +1, node2 +1, node3 + 1, root +3 node_again = root._get_child("node1") # node1 +1 assert node_ctype._get_reference_counts(node1) == refc_before_link1 + 2 del node_again # node1 -1 assert node_ctype._get_reference_counts(node1) == refc_before_link1 + 1 children = root._get_children() #node1 +1, node2 +1, node3 +1 assert len(children) == 3 assert node_ctype._get_reference_counts(node1) == refc_before_link1 + 2 assert node_ctype._get_reference_counts(node2) == refc_before_link2 + 2 assert node_ctype._get_reference_counts(node3) == refc_before_link3 + 2 assert node_ctype._get_reference_counts(root) == refc_before_link_root + 3 # test get_parent root_again = node1._get_parent() # root +1 assert node_ctype._get_reference_counts(root) == refc_before_link_root + 4 del root_again # root -1 assert node_ctype._get_reference_counts(root) == refc_before_link_root + 3 # test _get_path path = node2._get_path() # this shouldn't change any ref count assert node_ctype._get_reference_counts(node1) == refc_before_link1 + 2 assert node_ctype._get_reference_counts(node2) == refc_before_link2 + 2 assert node_ctype._get_reference_counts(node3) == refc_before_link3 + 2 assert node_ctype._get_reference_counts(root) == refc_before_link_root + 3 # test _get_child_from_path node4 = Node("node4") refc_before_link4 = node_ctype._get_reference_counts(node4) node3._add_child(node4) # node3 +1, node4 + 1 node4_again = root._get_child_from_path("node3.node4") # node4 +1 assert node_ctype._get_reference_counts(node4) == refc_before_link4 + 2 assert node_ctype._get_reference_counts(node3) == refc_before_link3 + 3 del node4_again # node4 -1 assert node_ctype._get_reference_counts(node4) == refc_before_link4 + 1