idx int64 0 252k | question stringlengths 48 5.28k | target stringlengths 5 1.23k |
|---|---|---|
246,800 | def as_int ( n ) : try : result = int ( n ) if result != n : raise TypeError except TypeError : raise ValueError ( '%s is not an integer' % n ) return result | Convert the argument to a builtin integer . |
246,801 | def default_sort_key ( item , order = None ) : from sympy . core import S , Basic from sympy . core . sympify import sympify , SympifyError from sympy . core . compatibility import iterable if isinstance ( item , Basic ) : return item . sort_key ( order = order ) if iterable ( item , exclude = string_types ) : if isinstance ( item , dict ) : args = item . items ( ) unordered = True elif isinstance ( item , set ) : args = item unordered = True else : args = list ( item ) unordered = False args = [ default_sort_key ( arg , order = order ) for arg in args ] if unordered : args = sorted ( args ) cls_index , args = 10 , ( len ( args ) , tuple ( args ) ) else : if not isinstance ( item , string_types ) : try : item = sympify ( item ) except SympifyError : pass else : if isinstance ( item , Basic ) : return default_sort_key ( item ) cls_index , args = 0 , ( 1 , ( str ( item ) , ) ) return ( cls_index , 0 , item . __class__ . __name__ ) , args , S . One . sort_key ( ) , S . One | Return a key that can be used for sorting . |
246,802 | def var ( names , ** args ) : def traverse ( symbols , frame ) : for symbol in symbols : if isinstance ( symbol , Basic ) : frame . f_globals [ symbol . __str__ ( ) ] = symbol else : traverse ( symbol , frame ) from inspect import currentframe frame = currentframe ( ) . f_back try : syms = symbols ( names , ** args ) if syms is not None : if isinstance ( syms , Basic ) : frame . f_globals [ syms . __str__ ( ) ] = syms else : traverse ( syms , frame ) finally : del frame return syms | Create symbols and inject them into the global namespace . |
246,803 | def _combine_attribute_arguments ( self , attr_dict , attr ) : if attr_dict is None : attr_dict = attr else : try : attr_dict . update ( attr ) except AttributeError : raise AttributeError ( "attr_dict argument \ must be a dictionary." ) return attr_dict | Combines attr_dict and attr dictionaries by updating attr_dict with attr . |
246,804 | def remove_node ( self , node ) : if not self . has_node ( node ) : raise ValueError ( "No such node exists." ) for hyperedge_id in self . _star [ node ] : frozen_nodes = self . _hyperedge_attributes [ hyperedge_id ] [ "__frozen_nodes" ] del self . _node_set_to_hyperedge [ frozen_nodes ] del self . _hyperedge_attributes [ hyperedge_id ] del self . _star [ node ] del self . _node_attributes [ node ] | Removes a node and its attributes from the hypergraph . Removes every hyperedge that contains this node . |
246,805 | def add_hyperedge ( self , nodes , attr_dict = None , ** attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) if not nodes : raise ValueError ( "nodes argument cannot be empty." ) frozen_nodes = frozenset ( nodes ) is_new_hyperedge = not self . has_hyperedge ( frozen_nodes ) if is_new_hyperedge : self . add_nodes ( frozen_nodes ) hyperedge_id = self . _assign_next_hyperedge_id ( ) for node in frozen_nodes : self . _star [ node ] . add ( hyperedge_id ) self . _node_set_to_hyperedge [ frozen_nodes ] = hyperedge_id self . _hyperedge_attributes [ hyperedge_id ] = { "nodes" : nodes , "__frozen_nodes" : frozen_nodes , "weight" : 1 } else : hyperedge_id = self . _node_set_to_hyperedge [ frozen_nodes ] self . _hyperedge_attributes [ hyperedge_id ] . update ( attr_dict ) return hyperedge_id | Adds a hyperedge to the hypergraph along with any related attributes of the hyperedge . This method will automatically add any node from the node set that was not in the hypergraph . A hyperedge without a weight attribute specified will be assigned the default value of 1 . |
246,806 | def add_hyperedges ( self , hyperedges , attr_dict = None , ** attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) hyperedge_ids = [ ] for nodes in hyperedges : hyperedge_id = self . add_hyperedge ( nodes , attr_dict . copy ( ) ) hyperedge_ids . append ( hyperedge_id ) return hyperedge_ids | Adds multiple hyperedges to the graph along with any related attributes of the hyperedges . If any node of a hyperedge has not previously been added to the hypergraph it will automatically be added here . Hyperedges without a weight attribute specified will be assigned the default value of 1 . |
246,807 | def get_hyperedge_id ( self , nodes ) : frozen_nodes = frozenset ( nodes ) if not self . has_hyperedge ( frozen_nodes ) : raise ValueError ( "No such hyperedge exists." ) return self . _node_set_to_hyperedge [ frozen_nodes ] | From a set of nodes returns the ID of the hyperedge that this set comprises . |
246,808 | def get_hyperedge_attribute ( self , hyperedge_id , attribute_name ) : if not self . has_hyperedge_id ( hyperedge_id ) : raise ValueError ( "No such hyperedge exists." ) elif attribute_name not in self . _hyperedge_attributes [ hyperedge_id ] : raise ValueError ( "No such attribute exists." ) else : return copy . copy ( self . _hyperedge_attributes [ hyperedge_id ] [ attribute_name ] ) | Given a hyperedge ID and the name of an attribute get a copy of that hyperedge s attribute . |
246,809 | def get_hyperedge_attributes ( self , hyperedge_id ) : if not self . has_hyperedge_id ( hyperedge_id ) : raise ValueError ( "No such hyperedge exists." ) dict_to_copy = self . _hyperedge_attributes [ hyperedge_id ] . items ( ) attributes = { } for attr_name , attr_value in dict_to_copy : if attr_name != "__frozen_nodes" : attributes [ attr_name ] = copy . copy ( attr_value ) return attributes | Given a hyperedge ID get a dictionary of copies of that hyperedge s attributes . |
246,810 | def get_star ( self , node ) : if node not in self . _node_attributes : raise ValueError ( "No such node exists." ) return self . _star [ node ] . copy ( ) | Given a node get a copy of that node s star that is the set of hyperedges that the node belongs to . |
246,811 | def _F_outdegree ( H , F ) : if not isinstance ( H , DirectedHypergraph ) : raise TypeError ( "Algorithm only applicable to directed hypergraphs" ) return F ( [ len ( H . get_forward_star ( node ) ) for node in H . get_node_set ( ) ] ) | Returns the result of a function F applied to the set of outdegrees in in the hypergraph . |
246,812 | def _F_indegree ( H , F ) : if not isinstance ( H , DirectedHypergraph ) : raise TypeError ( "Algorithm only applicable to directed hypergraphs" ) return F ( [ len ( H . get_backward_star ( node ) ) for node in H . get_node_set ( ) ] ) | Returns the result of a function F applied to the list of indegrees in in the hypergraph . |
246,813 | def _F_hyperedge_tail_cardinality ( H , F ) : if not isinstance ( H , DirectedHypergraph ) : raise TypeError ( "Algorithm only applicable to directed hypergraphs" ) return F ( [ len ( H . get_hyperedge_tail ( hyperedge_id ) ) for hyperedge_id in H . get_hyperedge_id_set ( ) ] ) | Returns the result of a function F applied to the set of cardinalities of hyperedge tails in the hypergraph . |
246,814 | def _F_hyperedge_head_cardinality ( H , F ) : if not isinstance ( H , DirectedHypergraph ) : raise TypeError ( "Algorithm only applicable to directed hypergraphs" ) return F ( [ len ( H . get_hyperedge_head ( hyperedge_id ) ) for hyperedge_id in H . get_hyperedge_id_set ( ) ] ) | Returns the result of a function F applied to the set of cardinalities of hyperedge heads in the hypergraph . |
246,815 | def get_hyperedge_weight_matrix ( H , hyperedge_ids_to_indices ) : hyperedge_weights = { } for hyperedge_id in H . hyperedge_id_iterator ( ) : hyperedge_weights . update ( { hyperedge_ids_to_indices [ hyperedge_id ] : H . get_hyperedge_weight ( hyperedge_id ) } ) hyperedge_weight_vector = [ ] for i in range ( len ( hyperedge_weights . keys ( ) ) ) : hyperedge_weight_vector . append ( hyperedge_weights . get ( i ) ) return sparse . diags ( [ hyperedge_weight_vector ] , [ 0 ] ) | Creates the diagonal matrix W of hyperedge weights as a sparse matrix . |
246,816 | def get_hyperedge_degree_matrix ( M ) : degrees = M . sum ( 0 ) . transpose ( ) new_degree = [ ] for degree in degrees : new_degree . append ( int ( degree [ 0 : ] ) ) return sparse . diags ( [ new_degree ] , [ 0 ] ) | Creates the diagonal matrix of hyperedge degrees D_e as a sparse matrix where a hyperedge degree is the cardinality of the hyperedge . |
246,817 | def fast_inverse ( M ) : diags = M . diagonal ( ) new_diag = [ ] for value in diags : new_diag . append ( 1.0 / value ) return sparse . diags ( [ new_diag ] , [ 0 ] ) | Computes the inverse of a diagonal matrix . |
246,818 | def node_iterator ( self ) : return iter ( self . _node_attributes ) def has_hypernode ( self , hypernode ) : return hypernode in self . _hypernode_attributes | Provides an iterator over the nodes . |
246,819 | def add_hypernode ( self , hypernode , composing_nodes = set ( ) , attr_dict = None , ** attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) if not self . has_hypernode ( hypernode ) : attr_dict [ "__composing_nodes" ] = composing_nodes added_nodes = composing_nodes removed_nodes = set ( ) self . _hypernode_attributes [ hypernode ] = attr_dict else : self . _hypernode_attributes [ hypernode ] . update ( attr_dict ) added_nodes = composing_nodes - self . _hypernode_attributes [ hypernode ] [ "__composing_nodes" ] removed_nodes = self . _hypernode_attributes [ hypernode ] [ "__composing_nodes" ] - composing_nodes for node in added_nodes : _add_hypernode_membership ( node , hypernode ) for node in remove_nodes : _remove_hypernode_membership ( node , hypernode ) | Adds a hypernode to the graph along with any related attributes of the hypernode . |
246,820 | def _create_random_starter ( node_count ) : pi = np . zeros ( node_count , dtype = float ) for i in range ( node_count ) : pi [ i ] = random . random ( ) summation = np . sum ( pi ) for i in range ( node_count ) : pi [ i ] = pi [ i ] / summation return pi | Creates the random starter for the random walk . |
246,821 | def _has_converged ( pi_star , pi ) : node_count = pi . shape [ 0 ] EPS = 10e-6 for i in range ( node_count ) : if pi [ i ] - pi_star [ i ] > EPS : return False return True | Checks if the random walk has converged . |
246,822 | def add_element ( self , priority , element , count = None ) : if count is None : count = next ( self . counter ) entry = [ priority , count , element ] self . element_finder [ element ] = entry heapq . heappush ( self . pq , entry ) | Adds an element with a specific priority . |
246,823 | def reprioritize ( self , priority , element ) : if element not in self . element_finder : raise ValueError ( "No such element in the priority queue." ) entry = self . element_finder [ element ] self . add_element ( priority , element , entry [ 1 ] ) entry [ 1 ] = self . INVALID | Updates the priority of an element . |
246,824 | def contains_element ( self , element ) : return ( element in self . element_finder ) and ( self . element_finder [ element ] [ 1 ] != self . INVALID ) | Determines if an element is contained in the priority queue . |
246,825 | def is_empty ( self ) : while self . pq : if self . pq [ 0 ] [ 1 ] != self . INVALID : return False else : _ , _ , element = heapq . heappop ( self . pq ) if element in self . element_finder : del self . element_finder [ element ] return True | Determines if the priority queue has any elements . Performs removal of any elements that were marked - as - invalid . |
246,826 | def is_connected ( H , source_node , target_node ) : visited_nodes , Pv , Pe = visit ( H , source_node ) return target_node in visited_nodes | Checks if a target node is connected to a source node . That is this method determines if a target node can be visited from the source node in the sense of the Visit algorithm . |
246,827 | def is_b_connected ( H , source_node , target_node ) : b_visited_nodes , Pv , Pe , v = b_visit ( H , source_node ) return target_node in b_visited_nodes | Checks if a target node is B - connected to a source node . |
246,828 | def is_f_connected ( H , source_node , target_node ) : f_visited_nodes , Pv , Pe , v = f_visit ( H , source_node ) return target_node in f_visited_nodes | Checks if a target node is F - connected to a source node . |
246,829 | def from_networkx_graph ( nx_graph ) : import networkx as nx if not isinstance ( nx_graph , nx . Graph ) : raise TypeError ( "Transformation only applicable to undirected \ NetworkX graphs" ) G = UndirectedHypergraph ( ) for node in nx_graph . nodes_iter ( ) : G . add_node ( node , copy . copy ( nx_graph . node [ node ] ) ) for edge in nx_graph . edges_iter ( ) : G . add_hyperedge ( [ edge [ 0 ] , edge [ 1 ] ] , copy . copy ( nx_graph [ edge [ 0 ] ] [ edge [ 1 ] ] ) ) return G | Returns an UndirectedHypergraph object that is the graph equivalent of the given NetworkX Graph object . |
246,830 | def from_networkx_digraph ( nx_digraph ) : import networkx as nx if not isinstance ( nx_digraph , nx . DiGraph ) : raise TypeError ( "Transformation only applicable to directed \ NetworkX graphs" ) G = DirectedHypergraph ( ) for node in nx_digraph . nodes_iter ( ) : G . add_node ( node , copy . copy ( nx_digraph . node [ node ] ) ) for edge in nx_digraph . edges_iter ( ) : tail_node = edge [ 0 ] head_node = edge [ 1 ] G . add_hyperedge ( tail_node , head_node , copy . copy ( nx_digraph [ tail_node ] [ head_node ] ) ) return G | Returns a DirectedHypergraph object that is the graph equivalent of the given NetworkX DiGraph object . |
246,831 | def get_tail_incidence_matrix ( H , nodes_to_indices , hyperedge_ids_to_indices ) : if not isinstance ( H , DirectedHypergraph ) : raise TypeError ( "Algorithm only applicable to directed hypergraphs" ) rows , cols = [ ] , [ ] for hyperedge_id , hyperedge_index in hyperedge_ids_to_indices . items ( ) : for node in H . get_hyperedge_tail ( hyperedge_id ) : rows . append ( nodes_to_indices . get ( node ) ) cols . append ( hyperedge_index ) values = np . ones ( len ( rows ) , dtype = int ) node_count = len ( H . get_node_set ( ) ) hyperedge_count = len ( H . get_hyperedge_id_set ( ) ) return sparse . csc_matrix ( ( values , ( rows , cols ) ) , shape = ( node_count , hyperedge_count ) ) | Creates the incidence matrix of the tail nodes of the given hypergraph as a sparse matrix . |
246,832 | def add_node ( self , node , attr_dict = None , ** attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) if not self . has_node ( node ) : self . _node_attributes [ node ] = attr_dict self . _forward_star [ node ] = set ( ) self . _backward_star [ node ] = set ( ) else : self . _node_attributes [ node ] . update ( attr_dict ) | Adds a node to the graph along with any related attributes of the node . |
246,833 | def add_nodes ( self , nodes , attr_dict = None , ** attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) for node in nodes : if type ( node ) is tuple : new_node , node_attr_dict = node new_dict = attr_dict . copy ( ) new_dict . update ( node_attr_dict ) self . add_node ( new_node , new_dict ) else : self . add_node ( node , attr_dict . copy ( ) ) | Adds multiple nodes to the graph along with any related attributes of the nodes . |
246,834 | def remove_node ( self , node ) : if not self . has_node ( node ) : raise ValueError ( "No such node exists." ) forward_star = self . get_forward_star ( node ) for hyperedge_id in forward_star : self . remove_hyperedge ( hyperedge_id ) backward_star = self . get_backward_star ( node ) for hyperedge_id in backward_star - forward_star : self . remove_hyperedge ( hyperedge_id ) del self . _forward_star [ node ] del self . _backward_star [ node ] del self . _node_attributes [ node ] | Removes a node and its attributes from the hypergraph . Removes every hyperedge that contains this node in either the head or the tail . |
246,835 | def get_node_attribute ( self , node , attribute_name ) : if not self . has_node ( node ) : raise ValueError ( "No such node exists." ) elif attribute_name not in self . _node_attributes [ node ] : raise ValueError ( "No such attribute exists." ) else : return copy . copy ( self . _node_attributes [ node ] [ attribute_name ] ) | Given a node and the name of an attribute get a copy of that node s attribute . |
246,836 | def get_node_attributes ( self , node ) : if not self . has_node ( node ) : raise ValueError ( "No such node exists." ) attributes = { } for attr_name , attr_value in self . _node_attributes [ node ] . items ( ) : attributes [ attr_name ] = copy . copy ( attr_value ) return attributes | Given a node get a dictionary with copies of that node s attributes . |
246,837 | def add_hyperedge ( self , tail , head , attr_dict = None , ** attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) if not tail and not head : raise ValueError ( "tail and head arguments \ cannot both be empty." ) frozen_tail = frozenset ( tail ) frozen_head = frozenset ( head ) if frozen_tail not in self . _successors : self . _successors [ frozen_tail ] = { } if frozen_head not in self . _predecessors : self . _predecessors [ frozen_head ] = { } is_new_hyperedge = not self . has_hyperedge ( frozen_tail , frozen_head ) if is_new_hyperedge : self . add_nodes ( frozen_head ) self . add_nodes ( frozen_tail ) hyperedge_id = self . _assign_next_hyperedge_id ( ) for node in frozen_tail : self . _forward_star [ node ] . add ( hyperedge_id ) for node in frozen_head : self . _backward_star [ node ] . add ( hyperedge_id ) self . _successors [ frozen_tail ] [ frozen_head ] = hyperedge_id self . _predecessors [ frozen_head ] [ frozen_tail ] = hyperedge_id self . _hyperedge_attributes [ hyperedge_id ] = { "tail" : tail , "__frozen_tail" : frozen_tail , "head" : head , "__frozen_head" : frozen_head , "weight" : 1 } else : hyperedge_id = self . _successors [ frozen_tail ] [ frozen_head ] self . _hyperedge_attributes [ hyperedge_id ] . update ( attr_dict ) return hyperedge_id | Adds a hyperedge to the hypergraph along with any related attributes of the hyperedge . This method will automatically add any node from the tail and head that was not in the hypergraph . A hyperedge without a weight attribute specified will be assigned the default value of 1 . |
246,838 | def add_hyperedges ( self , hyperedges , attr_dict = None , ** attr ) : attr_dict = self . _combine_attribute_arguments ( attr_dict , attr ) hyperedge_ids = [ ] for hyperedge in hyperedges : if len ( hyperedge ) == 3 : tail , head , hyperedge_attr_dict = hyperedge new_dict = attr_dict . copy ( ) new_dict . update ( hyperedge_attr_dict ) hyperedge_id = self . add_hyperedge ( tail , head , new_dict ) else : tail , head = hyperedge hyperedge_id = self . add_hyperedge ( tail , head , attr_dict . copy ( ) ) hyperedge_ids . append ( hyperedge_id ) return hyperedge_ids | Adds multiple hyperedges to the graph along with any related attributes of the hyperedges . If any node in the tail or head of any hyperedge has not previously been added to the hypergraph it will automatically be added here . Hyperedges without a weight attribute specified will be assigned the default value of 1 . |
246,839 | def get_hyperedge_id ( self , tail , head ) : frozen_tail = frozenset ( tail ) frozen_head = frozenset ( head ) if not self . has_hyperedge ( frozen_tail , frozen_head ) : raise ValueError ( "No such hyperedge exists." ) return self . _successors [ frozen_tail ] [ frozen_head ] | From a tail and head set of nodes returns the ID of the hyperedge that these sets comprise . |
246,840 | def get_forward_star ( self , node ) : if node not in self . _node_attributes : raise ValueError ( "No such node exists." ) return self . _forward_star [ node ] . copy ( ) | Given a node get a copy of that node s forward star . |
246,841 | def get_backward_star ( self , node ) : if node not in self . _node_attributes : raise ValueError ( "No such node exists." ) return self . _backward_star [ node ] . copy ( ) | Given a node get a copy of that node s backward star . |
246,842 | def get_successors ( self , tail ) : frozen_tail = frozenset ( tail ) if frozen_tail not in self . _successors : return set ( ) return set ( self . _successors [ frozen_tail ] . values ( ) ) | Given a tail set of nodes get a list of edges of which the node set is the tail of each edge . |
246,843 | def get_predecessors ( self , head ) : frozen_head = frozenset ( head ) if frozen_head not in self . _predecessors : return set ( ) return set ( self . _predecessors [ frozen_head ] . values ( ) ) | Given a head set of nodes get a list of edges of which the node set is the head of each edge . |
246,844 | def is_BF_hypergraph ( self ) : for hyperedge_id in self . _hyperedge_attributes : tail = self . get_hyperedge_tail ( hyperedge_id ) head = self . get_hyperedge_head ( hyperedge_id ) if len ( tail ) > 1 and len ( head ) > 1 : return False return True | Indicates whether the hypergraph is a BF - hypergraph . A BF - hypergraph consists of only B - hyperedges and F - hyperedges . See is_B_hypergraph or is_F_hypergraph for more details . |
246,845 | def get_induced_subhypergraph ( self , nodes ) : sub_H = self . copy ( ) sub_H . remove_nodes ( sub_H . get_node_set ( ) - set ( nodes ) ) return sub_H | Gives a new hypergraph that is the subhypergraph of the current hypergraph induced by the provided set of nodes . That is the induced subhypergraph s node set corresponds precisely to the nodes provided and the coressponding hyperedges in the subhypergraph are only those from the original graph consist of tail and head sets that are subsets of the provided nodes . |
246,846 | def getall ( self , key , default = _marker ) : identity = self . _title ( key ) res = [ v for i , k , v in self . _impl . _items if i == identity ] if res : return res if not res and default is not _marker : return default raise KeyError ( 'Key not found: %r' % key ) | Return a list of all values matching the key . |
246,847 | def extend ( self , * args , ** kwargs ) : self . _extend ( args , kwargs , 'extend' , self . _extend_items ) | Extend current MultiDict with more values . |
246,848 | def setdefault ( self , key , default = None ) : identity = self . _title ( key ) for i , k , v in self . _impl . _items : if i == identity : return v self . add ( key , default ) return default | Return value for key set value to default if key is not present . |
246,849 | def popall ( self , key , default = _marker ) : found = False identity = self . _title ( key ) ret = [ ] for i in range ( len ( self . _impl . _items ) - 1 , - 1 , - 1 ) : item = self . _impl . _items [ i ] if item [ 0 ] == identity : ret . append ( item [ 2 ] ) del self . _impl . _items [ i ] self . _impl . incr_version ( ) found = True if not found : if default is _marker : raise KeyError ( key ) else : return default else : ret . reverse ( ) return ret | Remove all occurrences of key and return the list of corresponding values . |
246,850 | def total ( self , xbin1 = 1 , xbin2 = - 2 ) : return self . hist . integral ( xbin1 = xbin1 , xbin2 = xbin2 , error = True ) | Return the total yield and its associated statistical uncertainty . |
246,851 | def iter_sys ( self ) : names = self . sys_names ( ) for name in names : osys = self . GetOverallSys ( name ) hsys = self . GetHistoSys ( name ) yield name , osys , hsys | Iterate over sys_name overall_sys histo_sys . overall_sys or histo_sys may be None for any given sys_name . |
246,852 | def sys_hist ( self , name = None ) : if name is None : low = self . hist . Clone ( shallow = True ) high = self . hist . Clone ( shallow = True ) return low , high osys = self . GetOverallSys ( name ) hsys = self . GetHistoSys ( name ) if osys is None : osys_high , osys_low = 1. , 1. else : osys_high , osys_low = osys . high , osys . low if hsys is None : hsys_high = self . hist . Clone ( shallow = True ) hsys_low = self . hist . Clone ( shallow = True ) else : hsys_high = hsys . high . Clone ( shallow = True ) hsys_low = hsys . low . Clone ( shallow = True ) return hsys_low * osys_low , hsys_high * osys_high | Return the effective low and high histogram for a given systematic . If this sample does not contain the named systematic then return the nominal histogram for both low and high variations . |
246,853 | def sys_hist ( self , name = None , where = None ) : total_low , total_high = None , None for sample in self . samples : if where is not None and not where ( sample ) : continue low , high = sample . sys_hist ( name ) if total_low is None : total_low = low . Clone ( shallow = True ) else : total_low += low if total_high is None : total_high = high . Clone ( shallow = True ) else : total_high += high return total_low , total_high | Return the effective total low and high histogram for a given systematic over samples in this channel . If a sample does not contain the named systematic then its nominal histogram is used for both low and high variations . |
246,854 | def apply_snapshot ( self , argset ) : clone = self . Clone ( ) args = [ var for var in argset if not ( var . name . startswith ( 'binWidth_obs_x_' ) or var . name . startswith ( 'gamma_stat' ) or var . name . startswith ( 'nom_' ) ) ] nargs = [ ] for var in args : is_norm = False name = var . name . replace ( 'alpha_' , '' ) for sample in clone . samples : if sample . GetNormFactor ( name ) is not None : log . info ( "applying snapshot of {0} on sample {1}" . format ( name , sample . name ) ) is_norm = True sample *= var . value osys = OverallSys ( name , low = 1. - var . error / var . value , high = 1. + var . error / var . value ) sample . AddOverallSys ( osys ) sample . RemoveNormFactor ( name ) if not is_norm : nargs . append ( var ) for sample in clone . samples : if sample . hist is None : raise RuntimeError ( "sample {0} does not have a " "nominal histogram" . format ( sample . name ) ) nominal = sample . hist . Clone ( shallow = True ) for var in nargs : name = var . name . replace ( 'alpha_' , '' ) if not sample . has_sys ( name ) : continue log . info ( "applying snapshot of {0} on sample {1}" . format ( name , sample . name ) ) low , high = sample . sys_hist ( name ) val = var . value if val > 0 : sample . hist += ( high - nominal ) * val elif val < 0 : sample . hist += ( nominal - low ) * val return clone | Create a clone of this Channel where histograms are modified according to the values of the nuisance parameters in the snapshot . This is useful when creating post - fit distribution plots . |
246,855 | def printcodelist ( codelist , to = sys . stdout ) : labeldict = { } pendinglabels = [ ] for i , ( op , arg ) in enumerate ( codelist ) : if isinstance ( op , Label ) : pendinglabels . append ( op ) elif op is SetLineno : pass else : while pendinglabels : labeldict [ pendinglabels . pop ( ) ] = i lineno = None islabel = False for i , ( op , arg ) in enumerate ( codelist ) : if op is SetLineno : lineno = arg print >> to continue if isinstance ( op , Label ) : islabel = True continue if lineno is None : linenostr = '' else : linenostr = str ( lineno ) lineno = None if islabel : islabelstr = '>>' islabel = False else : islabelstr = '' if op in hasconst : argstr = repr ( arg ) elif op in hasjump : try : argstr = 'to ' + str ( labeldict [ arg ] ) except KeyError : argstr = repr ( arg ) elif op in hasarg : argstr = str ( arg ) else : argstr = '' print >> to , '%3s %2s %4d %-20s %s' % ( linenostr , islabelstr , i , op , argstr ) | Get a code list . Print it nicely . |
246,856 | def recompile ( filename ) : import os import imp import marshal import struct f = open ( filename , 'U' ) try : timestamp = long ( os . fstat ( f . fileno ( ) ) . st_mtime ) except AttributeError : timestamp = long ( os . stat ( filename ) . st_mtime ) codestring = f . read ( ) f . close ( ) if codestring and codestring [ - 1 ] != '\n' : codestring = codestring + '\n' try : codeobject = compile ( codestring , filename , 'exec' ) except SyntaxError : print >> sys . stderr , "Skipping %s - syntax error." % filename return cod = Code . from_code ( codeobject ) message = "reassembled %r imported.\n" % filename cod . code [ : 0 ] = [ ( LOAD_GLOBAL , '__import__' ) , ( LOAD_CONST , 'sys' ) , ( CALL_FUNCTION , 1 ) , ( LOAD_ATTR , 'stderr' ) , ( LOAD_ATTR , 'write' ) , ( LOAD_CONST , message ) , ( CALL_FUNCTION , 1 ) , ( POP_TOP , None ) , ] codeobject2 = cod . to_code ( ) fc = open ( filename + 'c' , 'wb' ) fc . write ( '\0\0\0\0' ) fc . write ( struct . pack ( '<l' , timestamp ) ) marshal . dump ( codeobject2 , fc ) fc . flush ( ) fc . seek ( 0 , 0 ) fc . write ( imp . get_magic ( ) ) fc . close ( ) | Create a . pyc by disassembling the file and assembling it again printing a message that the reassembled file was loaded . |
246,857 | def recompile_all ( path ) : import os if os . path . isdir ( path ) : for root , dirs , files in os . walk ( path ) : for name in files : if name . endswith ( '.py' ) : filename = os . path . abspath ( os . path . join ( root , name ) ) print >> sys . stderr , filename recompile ( filename ) else : filename = os . path . abspath ( path ) recompile ( filename ) | recursively recompile all . py files in the directory |
246,858 | def from_code ( cls , co ) : co_code = co . co_code labels = dict ( ( addr , Label ( ) ) for addr in findlabels ( co_code ) ) linestarts = dict ( cls . _findlinestarts ( co ) ) cellfree = co . co_cellvars + co . co_freevars code = CodeList ( ) n = len ( co_code ) i = 0 extended_arg = 0 while i < n : op = Opcode ( ord ( co_code [ i ] ) ) if i in labels : code . append ( ( labels [ i ] , None ) ) if i in linestarts : code . append ( ( SetLineno , linestarts [ i ] ) ) i += 1 if op in hascode : lastop , lastarg = code [ - 1 ] if lastop != LOAD_CONST : raise ValueError ( "%s should be preceded by LOAD_CONST code" % op ) code [ - 1 ] = ( LOAD_CONST , Code . from_code ( lastarg ) ) if op not in hasarg : code . append ( ( op , None ) ) else : arg = ord ( co_code [ i ] ) + ord ( co_code [ i + 1 ] ) * 256 + extended_arg extended_arg = 0 i += 2 if op == opcode . EXTENDED_ARG : extended_arg = arg << 16 elif op in hasconst : code . append ( ( op , co . co_consts [ arg ] ) ) elif op in hasname : code . append ( ( op , co . co_names [ arg ] ) ) elif op in hasjabs : code . append ( ( op , labels [ arg ] ) ) elif op in hasjrel : code . append ( ( op , labels [ i + arg ] ) ) elif op in haslocal : code . append ( ( op , co . co_varnames [ arg ] ) ) elif op in hascompare : code . append ( ( op , cmp_op [ arg ] ) ) elif op in hasfree : code . append ( ( op , cellfree [ arg ] ) ) else : code . append ( ( op , arg ) ) varargs = bool ( co . co_flags & CO_VARARGS ) varkwargs = bool ( co . co_flags & CO_VARKEYWORDS ) newlocals = bool ( co . co_flags & CO_NEWLOCALS ) args = co . co_varnames [ : co . co_argcount + varargs + varkwargs ] if co . co_consts and isinstance ( co . co_consts [ 0 ] , basestring ) : docstring = co . co_consts [ 0 ] else : docstring = None return cls ( code = code , freevars = co . co_freevars , args = args , varargs = varargs , varkwargs = varkwargs , newlocals = newlocals , name = co . co_name , filename = co . co_filename , firstlineno = co . co_firstlineno , docstring = docstring , ) | Disassemble a Python code object into a Code object . |
246,859 | def effective_sample_size ( h ) : sum = 0 ew = 0 w = 0 for bin in h . bins ( overflow = False ) : sum += bin . value ew = bin . error w += ew * ew esum = sum * sum / w return esum | Calculate the effective sample size for a histogram the same way as ROOT does . |
246,860 | def critical_value ( n , p ) : dn = 1 delta = 0.5 res = ROOT . TMath . KolmogorovProb ( dn * sqrt ( n ) ) while res > 1.0001 * p or res < 0.9999 * p : if ( res > 1.0001 * p ) : dn = dn + delta if ( res < 0.9999 * p ) : dn = dn - delta delta = delta / 2. res = ROOT . TMath . KolmogorovProb ( dn * sqrt ( n ) ) return dn | This function calculates the critical value given n and p and confidence level = 1 - p . |
246,861 | def dump ( obj , root_file , proto = 0 , key = None ) : if isinstance ( root_file , string_types ) : root_file = root_open ( root_file , 'recreate' ) own_file = True else : own_file = False ret = Pickler ( root_file , proto ) . dump ( obj , key ) if own_file : root_file . Close ( ) return ret | Dump an object into a ROOT TFile . |
246,862 | def load ( root_file , use_proxy = True , key = None ) : if isinstance ( root_file , string_types ) : root_file = root_open ( root_file ) own_file = True else : own_file = False obj = Unpickler ( root_file , use_proxy ) . load ( key ) if own_file : root_file . Close ( ) return obj | Load an object from a ROOT TFile . |
246,863 | def dump ( self , obj , key = None ) : if key is None : key = '_pickle' with preserve_current_directory ( ) : self . __file . cd ( ) if sys . version_info [ 0 ] < 3 : pickle . Pickler . dump ( self , obj ) else : super ( Pickler , self ) . dump ( obj ) s = ROOT . TObjString ( self . __io . getvalue ( ) ) self . __io . reopen ( ) s . Write ( key ) self . __file . GetFile ( ) . Flush ( ) self . __pmap . clear ( ) | Write a pickled representation of obj to the open TFile . |
246,864 | def load ( self , key = None ) : if key is None : key = '_pickle' obj = None if _compat_hooks : save = _compat_hooks [ 0 ] ( ) try : self . __n += 1 s = self . __file . Get ( key + ';{0:d}' . format ( self . __n ) ) self . __io . setvalue ( s . GetName ( ) ) if sys . version_info [ 0 ] < 3 : obj = pickle . Unpickler . load ( self ) else : obj = super ( Unpickler , self ) . load ( ) self . __io . reopen ( ) finally : if _compat_hooks : save = _compat_hooks [ 1 ] ( save ) return obj | Read a pickled object representation from the open file . |
246,865 | def iter_ROOT_classes ( ) : class_index = "http://root.cern.ch/root/html/ClassIndex.html" for s in minidom . parse ( urlopen ( class_index ) ) . getElementsByTagName ( "span" ) : if ( "class" , "typename" ) in s . attributes . items ( ) : class_name = s . childNodes [ 0 ] . nodeValue try : yield getattr ( QROOT , class_name ) except AttributeError : pass | Iterator over all available ROOT classes |
246,866 | def CMS_label ( text = "Preliminary 2012" , sqrts = 8 , pad = None ) : if pad is None : pad = ROOT . gPad with preserve_current_canvas ( ) : pad . cd ( ) left_margin = pad . GetLeftMargin ( ) top_margin = pad . GetTopMargin ( ) ypos = 1 - top_margin / 2. l = ROOT . TLatex ( left_margin , ypos , "CMS " + text ) l . SetTextAlign ( 12 ) l . SetNDC ( ) l . SetTextSize ( 0.90 * top_margin ) l . Draw ( ) keepalive ( pad , l ) if sqrts : right_margin = pad . GetRightMargin ( ) p = ROOT . TLatex ( 1 - right_margin , ypos , "#sqrt{{s}}={0:d}TeV" . format ( sqrts ) ) p . SetTextAlign ( 32 ) p . SetNDC ( ) p . SetTextSize ( 0.90 * top_margin ) p . Draw ( ) keepalive ( pad , p ) else : p = None pad . Modified ( ) pad . Update ( ) return l , p | Add a CMS Preliminary style label to the current Pad . |
246,867 | def make_channel ( name , samples , data = None , verbose = False ) : if verbose : llog = log [ 'make_channel' ] llog . info ( "creating channel {0}" . format ( name ) ) chan = Channel ( 'channel_{0}' . format ( name ) ) chan . SetStatErrorConfig ( 0.05 , "Poisson" ) if data is not None : if verbose : llog . info ( "setting data" ) chan . SetData ( data ) for sample in samples : if verbose : llog . info ( "adding sample {0}" . format ( sample . GetName ( ) ) ) chan . AddSample ( sample ) return chan | Create a Channel from a list of Samples |
246,868 | def make_measurement ( name , channels , lumi = 1.0 , lumi_rel_error = 0.1 , output_prefix = './histfactory' , POI = None , const_params = None , verbose = False ) : if verbose : llog = log [ 'make_measurement' ] llog . info ( "creating measurement {0}" . format ( name ) ) if not isinstance ( channels , ( list , tuple ) ) : channels = [ channels ] meas = Measurement ( 'measurement_{0}' . format ( name ) , '' ) meas . SetOutputFilePrefix ( output_prefix ) if POI is not None : if isinstance ( POI , string_types ) : if verbose : llog . info ( "setting POI {0}" . format ( POI ) ) meas . SetPOI ( POI ) else : if verbose : llog . info ( "adding POIs {0}" . format ( ', ' . join ( POI ) ) ) for p in POI : meas . AddPOI ( p ) if verbose : llog . info ( "setting lumi={0:f} +/- {1:f}" . format ( lumi , lumi_rel_error ) ) meas . lumi = lumi meas . lumi_rel_error = lumi_rel_error for channel in channels : if verbose : llog . info ( "adding channel {0}" . format ( channel . GetName ( ) ) ) meas . AddChannel ( channel ) if const_params is not None : if verbose : llog . info ( "adding constant parameters {0}" . format ( ', ' . join ( const_params ) ) ) for param in const_params : meas . AddConstantParam ( param ) return meas | Create a Measurement from a list of Channels |
246,869 | def make_workspace ( measurement , channel = None , name = None , silence = False ) : context = silence_sout_serr if silence else do_nothing with context ( ) : hist2workspace = ROOT . RooStats . HistFactory . HistoToWorkspaceFactoryFast ( measurement ) if channel is not None : workspace = hist2workspace . MakeSingleChannelModel ( measurement , channel ) else : workspace = hist2workspace . MakeCombinedModel ( measurement ) workspace = asrootpy ( workspace ) keepalive ( workspace , measurement ) if name is not None : workspace . SetName ( 'workspace_{0}' . format ( name ) ) return workspace | Create a workspace containing the model for a measurement |
246,870 | def measurements_from_xml ( filename , collect_histograms = True , cd_parent = False , silence = False ) : if not os . path . isfile ( filename ) : raise OSError ( "the file {0} does not exist" . format ( filename ) ) silence_context = silence_sout_serr if silence else do_nothing filename = os . path . abspath ( os . path . normpath ( filename ) ) if cd_parent : xml_directory = os . path . dirname ( filename ) parent = os . path . abspath ( os . path . join ( xml_directory , os . pardir ) ) cd_context = working_directory else : parent = None cd_context = do_nothing log . info ( "parsing XML in {0} ..." . format ( filename ) ) with cd_context ( parent ) : parser = ROOT . RooStats . HistFactory . ConfigParser ( ) with silence_context ( ) : measurements_vect = parser . GetMeasurementsFromXML ( filename ) ROOT . SetOwnership ( measurements_vect , False ) measurements = [ ] for m in measurements_vect : if collect_histograms : with silence_context ( ) : m . CollectHistograms ( ) measurements . append ( asrootpy ( m ) ) return measurements | Read in a list of Measurements from XML |
246,871 | def write_measurement ( measurement , root_file = None , xml_path = None , output_path = None , output_suffix = None , write_workspaces = False , apply_xml_patches = True , silence = False ) : context = silence_sout_serr if silence else do_nothing output_name = measurement . name if output_suffix is not None : output_name += '_{0}' . format ( output_suffix ) output_name = output_name . replace ( ' ' , '_' ) if xml_path is None : xml_path = 'xml_{0}' . format ( output_name ) if output_path is not None : xml_path = os . path . join ( output_path , xml_path ) if not os . path . exists ( xml_path ) : mkdir_p ( xml_path ) if root_file is None : root_file = 'ws_{0}.root' . format ( output_name ) if output_path is not None : root_file = os . path . join ( output_path , root_file ) own_file = False if isinstance ( root_file , string_types ) : root_file = root_open ( root_file , 'recreate' ) own_file = True with preserve_current_directory ( ) : root_file . cd ( ) log . info ( "writing histograms and measurement in {0} ..." . format ( root_file . GetName ( ) ) ) with context ( ) : measurement . writeToFile ( root_file ) out_m = root_file . Get ( measurement . name ) log . info ( "writing XML in {0} ..." . format ( xml_path ) ) with context ( ) : out_m . PrintXML ( xml_path ) if write_workspaces : log . info ( "writing combined model in {0} ..." . format ( root_file . GetName ( ) ) ) workspace = make_workspace ( measurement , silence = silence ) workspace . Write ( ) for channel in measurement . channels : log . info ( "writing model for channel `{0}` in {1} ..." . format ( channel . name , root_file . GetName ( ) ) ) workspace = make_workspace ( measurement , channel = channel , silence = silence ) workspace . Write ( ) if apply_xml_patches : patch_xml ( glob ( os . path . join ( xml_path , '*.xml' ) ) , root_file = os . path . basename ( root_file . GetName ( ) ) ) if own_file : root_file . Close ( ) | Write a measurement and RooWorkspaces for all contained channels into a ROOT file and write the XML files into a directory . |
246,872 | def patch_xml ( files , root_file = None , float_precision = 3 ) : if float_precision < 0 : raise ValueError ( "precision must be greater than 0" ) def fix_path ( match ) : path = match . group ( 1 ) if path : head , tail = os . path . split ( path ) new_path = os . path . join ( os . path . basename ( head ) , tail ) else : new_path = '' return '<Input>{0}</Input>' . format ( new_path ) for xmlfilename in files : xmlfilename = os . path . abspath ( os . path . normpath ( xmlfilename ) ) patched_xmlfilename = '{0}.tmp' . format ( xmlfilename ) log . info ( "patching {0} ..." . format ( xmlfilename ) ) fin = open ( xmlfilename , 'r' ) fout = open ( patched_xmlfilename , 'w' ) for line in fin : if root_file is not None : line = re . sub ( 'InputFile="[^"]*"' , 'InputFile="{0}"' . format ( root_file ) , line ) line = line . replace ( '<StatError Activate="True" InputFile="" ' 'HistoName="" HistoPath="" />' , '<StatError Activate="True" />' ) line = re . sub ( '<Combination OutputFilePrefix="(\S*)" >' , '<Combination OutputFilePrefix="hist2workspace" >' , line ) line = re . sub ( '\w+=""' , '' , line ) line = re . sub ( '\s+/>' , ' />' , line ) line = re . sub ( '(\S)\s+</' , r'\1</' , line ) line = re . sub ( 'InputFileHigh="\S+"' , '' , line ) line = re . sub ( 'InputFileLow="\S+"' , '' , line ) line = line . replace ( '<ParamSetting Const="True"></ParamSetting>' , '' ) line = re . sub ( r'"(\d*\.\d{{{0:d},}})"' . format ( float_precision + 1 ) , lambda x : '"{0}"' . format ( str ( round ( float ( x . group ( 1 ) ) , float_precision ) ) ) , line ) line = re . sub ( '"\s\s+(\S)' , r'" \1' , line ) line = re . sub ( '<Input>(.*)</Input>' , fix_path , line ) fout . write ( line ) fin . close ( ) fout . close ( ) shutil . move ( patched_xmlfilename , xmlfilename ) if not os . path . isfile ( os . path . join ( os . path . dirname ( xmlfilename ) , 'HistFactorySchema.dtd' ) ) : rootsys = os . getenv ( 'ROOTSYS' , None ) if rootsys is not None : dtdfile = os . path . join ( rootsys , 'etc/HistFactorySchema.dtd' ) target = os . path . dirname ( xmlfilename ) if os . path . isfile ( dtdfile ) : log . info ( "copying {0} to {1} ..." . format ( dtdfile , target ) ) shutil . copy ( dtdfile , target ) else : log . warning ( "{0} does not exist" . format ( dtdfile ) ) else : log . warning ( "$ROOTSYS is not set so cannot find HistFactorySchema.dtd" ) | Apply patches to HistFactory XML output from PrintXML |
246,873 | def path ( self ) : if isinstance ( self . dir , Directory ) : return self . dir . _path elif isinstance ( self . dir , ROOT . TDirectory ) : return self . dir . GetPath ( ) elif isinstance ( self . dir , _FolderView ) : return self . dir . path ( ) else : return str ( self . dir ) | Get the path of the wrapped folder |
246,874 | def Get ( self , path ) : return self . merge_views ( x . Get ( path ) for x in self . dirs ) | Merge the objects at path in all subdirectories |
246,875 | def python_logging_error_handler ( level , root_says_abort , location , msg ) : from . . utils import quickroot as QROOT if not Initialized . value : try : QROOT . kTRUE except AttributeError : return QROOT . kInfo , QROOT . kWarning , QROOT . kError , QROOT . kFatal , QROOT . kSysError QROOT . gErrorIgnoreLevel Initialized . value = True try : QROOT . kTRUE except RuntimeError : _ , exc , traceback = sys . exc_info ( ) caller = sys . _getframe ( 2 ) re_execute_with_exception ( caller , exc , traceback ) if level < QROOT . gErrorIgnoreLevel : return if sys . version_info [ 0 ] >= 3 : location = location . decode ( 'utf-8' ) msg = msg . decode ( 'utf-8' ) log = ROOT_log . getChild ( location . replace ( "::" , "." ) ) if level >= QROOT . kSysError or level >= QROOT . kFatal : lvl = logging . CRITICAL elif level >= QROOT . kError : lvl = logging . ERROR elif level >= QROOT . kWarning : lvl = logging . WARNING elif level >= QROOT . kInfo : lvl = logging . INFO else : lvl = logging . DEBUG if not SANE_REGEX . match ( msg ) : msg = repr ( msg ) [ 1 : - 1 ] lvl , msg = fixup_msg ( lvl , msg ) log . log ( lvl , msg ) abort = lvl >= ABORT_LEVEL or "rootpy.ALWAYSABORT" in msg or root_says_abort if abort and not "rootpy.NEVERABORT" in msg : caller = sys . _getframe ( 1 ) try : from . . import ROOTError raise ROOTError ( level , location , msg ) except RuntimeError : _ , exc , traceback = sys . exc_info ( ) if SHOWTRACE . enabled : from traceback import print_stack print_stack ( caller ) if DANGER . enabled : re_execute_with_exception ( caller , exc , traceback ) if root_says_abort : log . critical ( "abort().. expect a stack trace" ) ctypes . CDLL ( None ) . abort ( ) | A python error handler for ROOT which maps ROOT s errors and warnings on to python s . |
246,876 | def preserve_current_canvas ( ) : old = ROOT . gPad try : yield finally : if old : old . cd ( ) elif ROOT . gPad : with invisible_canvas ( ) : pass | Context manager which ensures that the current canvas remains the current canvas when the context is left . |
246,877 | def preserve_batch_state ( ) : with LOCK : old = ROOT . gROOT . IsBatch ( ) try : yield finally : ROOT . gROOT . SetBatch ( old ) | Context manager which ensures the batch state is the same on exit as it was on entry . |
246,878 | def invisible_canvas ( ) : with preserve_current_canvas ( ) : with preserve_batch_state ( ) : ROOT . gROOT . SetBatch ( ) c = ROOT . TCanvas ( ) try : c . cd ( ) yield c finally : c . Close ( ) c . IsA ( ) . Destructor ( c ) | Context manager yielding a temporary canvas drawn in batch mode invisible to the user . Original state is restored on exit . |
246,879 | def thread_specific_tmprootdir ( ) : with preserve_current_directory ( ) : dname = "rootpy-tmp/thread/{0}" . format ( threading . current_thread ( ) . ident ) d = ROOT . gROOT . mkdir ( dname ) if not d : d = ROOT . gROOT . GetDirectory ( dname ) assert d , "Unexpected failure, can't cd to tmpdir." d . cd ( ) yield d | Context manager which makes a thread specific gDirectory to avoid interfering with the current file . |
246,880 | def working_directory ( path ) : prev_cwd = os . getcwd ( ) os . chdir ( path ) try : yield finally : os . chdir ( prev_cwd ) | A context manager that changes the working directory to the given path and then changes it back to its previous value on exit . |
246,881 | def autobinning ( data , method = "freedman_diaconis" ) : name = method . replace ( "-" , "_" ) try : method = getattr ( BinningMethods , name ) if not isinstance ( method , types . FunctionType ) : raise AttributeError except AttributeError : raise ValueError ( "`{0}` is not a valid binning method" . format ( name ) ) if len ( data ) < 4 : return 1 , np . min ( data ) , np . max ( data ) return int ( np . ceil ( method ( data ) ) ) , np . min ( data ) , np . max ( data ) | This method determines the optimal binning for histogramming . |
246,882 | def all_methods ( cls ) : def name ( fn ) : return fn . __get__ ( cls ) . __name__ . replace ( "_" , "-" ) return sorted ( name ( f ) for f in cls . __dict__ . values ( ) if isinstance ( f , staticmethod ) ) | Return the names of all available binning methods |
246,883 | def doane ( data ) : from scipy . stats import skew n = len ( data ) sigma = np . sqrt ( 6. * ( n - 2. ) / ( n + 1. ) / ( n + 3. ) ) return 1 + np . log2 ( n ) + np . log2 ( 1 + np . abs ( skew ( data ) ) / sigma ) | Modified Doane modified |
246,884 | def lock ( path , poll_interval = 5 , max_age = 60 ) : if max_age < 30 : raise ValueError ( "`max_age` must be at least 30 seconds" ) if poll_interval < 1 : raise ValueError ( "`poll_interval` must be at least 1 second" ) if poll_interval >= max_age : raise ValueError ( "`poll_interval` must be less than `max_age`" ) proc = '{0:d}@{1}' . format ( os . getpid ( ) , platform . node ( ) ) lock = LockFile ( path ) log . debug ( "{0} attempting to lock {1}" . format ( proc , path ) ) while not lock . i_am_locking ( ) : if lock . is_locked ( ) : try : age = time . time ( ) - os . stat ( lock . lock_file ) [ stat . ST_MTIME ] if age > max_age : lock . break_lock ( ) log . warning ( "{0} broke lock on {1} " "that is {2:d} seconds old" . format ( proc , path , int ( age ) ) ) except OSError : pass time . sleep ( 0.5 ) try : log . debug ( "{0} waiting for {1:d} seconds " "for lock on {2} to be released" . format ( proc , poll_interval , path ) ) lock . acquire ( timeout = float ( poll_interval ) ) except LockTimeout : pass log . debug ( "{0} locked {1}" . format ( proc , path ) ) yield lock lock . release ( ) log . debug ( "{0} released lock on {1}" . format ( proc , path ) ) | Aquire a file lock in a thread - safe manner that also reaps stale locks possibly left behind by processes that crashed hard . |
246,885 | def proxy_global ( name , no_expand_macro = False , fname = 'func' , args = ( ) ) : if no_expand_macro : @ property def gSomething_no_func ( self ) : glob = self ( getattr ( ROOT , name ) ) def func ( ) : return glob glob . func = func return glob return gSomething_no_func @ property def gSomething ( self ) : obj_func = getattr ( getattr ( ROOT , name ) , fname ) try : obj = obj_func ( * args ) except ReferenceError : return None return self ( obj ) return gSomething | Used to automatically asrootpy ROOT s thread local variables |
246,886 | def AddEntry ( self , thing , label = None , style = None ) : if isinstance ( thing , HistStack ) : things = thing else : things = [ thing ] for thing in things : if getattr ( thing , 'inlegend' , True ) : thing_label = thing . GetTitle ( ) if label is None else label thing_style = getattr ( thing , 'legendstyle' , 'P' ) if style is None else style super ( Legend , self ) . AddEntry ( thing , thing_label , thing_style ) keepalive ( self , thing ) | Add an entry to the legend . |
246,887 | def get_seh ( ) : if ON_RTD : return lambda x : x ErrorHandlerFunc_t = ctypes . CFUNCTYPE ( None , ctypes . c_int , ctypes . c_bool , ctypes . c_char_p , ctypes . c_char_p ) import ROOT dll = get_dll ( "libCore" ) SetErrorHandler = None try : if dll : SetErrorHandler = dll . _Z15SetErrorHandlerPFvibPKcS0_E except AttributeError : pass if not SetErrorHandler : log . warning ( "Couldn't find SetErrorHandler. " "Please submit a rootpy bug report." ) return lambda x : None SetErrorHandler . restype = ErrorHandlerFunc_t SetErrorHandler . argtypes = ErrorHandlerFunc_t , def _SetErrorHandler ( fn ) : log . debug ( "called SetErrorHandler()" ) eh = ErrorHandlerFunc_t ( fn ) _keep_alive . append ( eh ) return SetErrorHandler ( eh ) return _SetErrorHandler | Makes a function which can be used to set the ROOT error handler with a python function and returns the existing error handler . |
246,888 | def get_f_code_idx ( ) : frame = sys . _getframe ( ) frame_ptr = id ( frame ) LARGE_ENOUGH = 20 ptrs = [ ctypes . c_voidp . from_address ( frame_ptr + i * svp ) for i in range ( LARGE_ENOUGH ) ] ptrs = [ p . value for p in ptrs ] fcode_ptr = id ( frame . f_code ) try : threadstate_idx = ptrs . index ( fcode_ptr ) except ValueError : log . critical ( "rootpy bug! Please report this." ) raise return threadstate_idx | How many pointers into PyFrame is the f_code variable? |
246,889 | def get_frame_pointers ( frame = None ) : if frame is None : frame = sys . _getframe ( 2 ) frame = id ( frame ) F_TRACE_OFFSET = 6 Ppy_object = ctypes . POINTER ( ctypes . py_object ) trace = Ppy_object . from_address ( frame + ( F_CODE_IDX + F_TRACE_OFFSET ) * svp ) LASTI_OFFSET = F_TRACE_OFFSET + 4 lasti_addr = LASTI_OFFSET lineno_addr = LASTI_OFFSET + ctypes . sizeof ( ctypes . c_int ) f_lineno = ctypes . c_int . from_address ( lineno_addr ) f_lasti = ctypes . c_int . from_address ( lasti_addr ) return trace , f_lineno , f_lasti | Obtain writable pointers to frame . f_trace and frame . f_lineno . |
246,890 | def set_linetrace_on_frame ( f , localtrace = None ) : traceptr , _ , _ = get_frame_pointers ( f ) if localtrace is not None : ctypes . pythonapi . Py_IncRef ( localtrace ) addr = id ( localtrace ) else : addr = 0 traceptr . contents = ctypes . py_object . from_address ( addr ) | Non - portable function to modify linetracing . |
246,891 | def re_execute_with_exception ( frame , exception , traceback ) : if sys . gettrace ( ) == globaltrace : return call_lineno = frame . f_lineno def intercept_next_line ( f , why , * args ) : if f is not frame : return set_linetrace_on_frame ( f ) back_like_nothing_happened ( ) if sys . version_info [ 0 ] < 3 : raise exception raise exception . with_traceback ( traceback ) set_linetrace_on_frame ( frame , intercept_next_line ) linestarts = list ( dis . findlinestarts ( frame . f_code ) ) linestarts = [ a for a , l in linestarts if l >= call_lineno ] dest = linestarts [ 0 ] oc = frame . f_code . co_code [ frame . f_lasti ] if sys . version_info [ 0 ] < 3 : oc = ord ( oc ) opcode_size = 2 if oc >= opcode . HAVE_ARGUMENT else 0 where = frame . f_lasti + 1 + opcode_size pc = PyCodeObject . from_address ( id ( frame . f_code ) ) back_like_nothing_happened = pc . co_code . contents . inject_jump ( where , dest ) sys . settrace ( globaltrace ) | Dark magic . Causes frame to raise an exception at the current location with traceback appended to it . |
246,892 | def _inject_jump ( self , where , dest ) : if sys . version_info [ 0 ] < 3 : old_check_interval = sys . getcheckinterval ( ) sys . setcheckinterval ( 2 ** 20 ) else : old_check_interval = sys . getswitchinterval ( ) sys . setswitchinterval ( 1000 ) pb = ctypes . pointer ( self . ob_sval ) orig_bytes = [ pb [ where + i ] [ 0 ] for i in range ( 3 ) ] v = struct . pack ( "<BH" , opcode . opmap [ "JUMP_ABSOLUTE" ] , dest ) if sys . version_info [ 0 ] < 3 : for i in range ( 3 ) : pb [ where + i ] [ 0 ] = ord ( v [ i ] ) else : for i in range ( 3 ) : pb [ where + i ] [ 0 ] = v [ i ] def tidy_up ( ) : if sys . version_info [ 0 ] < 3 : sys . setcheckinterval ( old_check_interval ) else : sys . setswitchinterval ( old_check_interval ) for i in range ( 3 ) : pb [ where + i ] [ 0 ] = orig_bytes [ i ] return tidy_up | Monkeypatch bytecode at where to force it to jump to dest . |
246,893 | def Draw ( self , * args , ** kwargs ) : self . reset ( ) output = None while self . _rollover ( ) : if output is None : output = self . _tree . Draw ( * args , ** kwargs ) if output is not None : output = output . Clone ( ) if hasattr ( output , 'SetDirectory' ) : output . SetDirectory ( 0 ) else : newoutput = self . _tree . Draw ( * args , ** kwargs ) if newoutput is not None : if isinstance ( output , _GraphBase ) : output . Append ( newoutput ) else : output += newoutput return output | Loop over subfiles draw each and sum the output into a single histogram . |
246,894 | def interact_plain ( header = UP_LINE , local_ns = None , module = None , dummy = None , stack_depth = 1 , global_ns = None ) : frame = sys . _getframe ( stack_depth ) variables = { } if local_ns is not None : variables . update ( local_ns ) else : variables . update ( frame . f_locals ) if global_ns is not None : variables . update ( local_ns ) else : variables . update ( frame . f_globals ) shell = code . InteractiveConsole ( variables ) return shell . interact ( banner = header ) | Create an interactive python console |
246,895 | def hist ( hists , stacked = True , reverse = False , xpadding = 0 , ypadding = .1 , yerror_in_padding = True , logy = None , snap = True , axes = None , ** kwargs ) : if axes is None : axes = plt . gca ( ) if logy is None : logy = axes . get_yscale ( ) == 'log' curr_xlim = axes . get_xlim ( ) curr_ylim = axes . get_ylim ( ) was_empty = not axes . has_data ( ) returns = [ ] if isinstance ( hists , _Hist ) : returns = _hist ( hists , axes = axes , logy = logy , ** kwargs ) _set_bounds ( hists , axes = axes , was_empty = was_empty , prev_xlim = curr_xlim , prev_ylim = curr_ylim , xpadding = xpadding , ypadding = ypadding , yerror_in_padding = yerror_in_padding , snap = snap , logy = logy ) elif stacked : if not reverse : hists = list ( hists ) [ : : - 1 ] for i , h in enumerate ( hists ) : kwargs_local = kwargs . copy ( ) if i == len ( hists ) - 1 : low = h . Clone ( ) low . Reset ( ) else : low = sum ( hists [ i + 1 : ] ) high = h + low high . alpha = getattr ( h , 'alpha' , None ) proxy = _hist ( high , bottom = low , axes = axes , logy = logy , ** kwargs ) returns . append ( proxy ) if not reverse : returns = returns [ : : - 1 ] _set_bounds ( sum ( hists ) , axes = axes , was_empty = was_empty , prev_xlim = curr_xlim , prev_ylim = curr_ylim , xpadding = xpadding , ypadding = ypadding , yerror_in_padding = yerror_in_padding , snap = snap , logy = logy ) else : for h in _maybe_reversed ( hists , reverse ) : returns . append ( _hist ( h , axes = axes , logy = logy , ** kwargs ) ) if reverse : returns = returns [ : : - 1 ] _set_bounds ( hists [ max ( range ( len ( hists ) ) , key = lambda idx : hists [ idx ] . max ( ) ) ] , axes = axes , was_empty = was_empty , prev_xlim = curr_xlim , prev_ylim = curr_ylim , xpadding = xpadding , ypadding = ypadding , yerror_in_padding = yerror_in_padding , snap = snap , logy = logy ) return returns | Make a matplotlib hist plot from a ROOT histogram stack or list of histograms . |
246,896 | def errorbar ( hists , xerr = True , yerr = True , xpadding = 0 , ypadding = .1 , xerror_in_padding = True , yerror_in_padding = True , emptybins = True , snap = True , axes = None , ** kwargs ) : if axes is None : axes = plt . gca ( ) curr_xlim = axes . get_xlim ( ) curr_ylim = axes . get_ylim ( ) was_empty = not axes . has_data ( ) if isinstance ( hists , ( _Hist , _Graph1DBase ) ) : returns = _errorbar ( hists , xerr , yerr , axes = axes , emptybins = emptybins , ** kwargs ) _set_bounds ( hists , axes = axes , was_empty = was_empty , prev_ylim = curr_ylim , xpadding = xpadding , ypadding = ypadding , xerror_in_padding = xerror_in_padding , yerror_in_padding = yerror_in_padding , snap = snap ) else : returns = [ ] for h in hists : returns . append ( errorbar ( h , xerr = xerr , yerr = yerr , axes = axes , xpadding = xpadding , ypadding = ypadding , xerror_in_padding = xerror_in_padding , yerror_in_padding = yerror_in_padding , snap = snap , emptybins = emptybins , ** kwargs ) ) return returns | Make a matplotlib errorbar plot from a ROOT histogram or graph or list of histograms and graphs . |
246,897 | def step ( h , logy = None , axes = None , ** kwargs ) : if axes is None : axes = plt . gca ( ) if logy is None : logy = axes . get_yscale ( ) == 'log' _set_defaults ( h , kwargs , [ 'common' , 'line' ] ) if kwargs . get ( 'color' ) is None : kwargs [ 'color' ] = h . GetLineColor ( 'mpl' ) y = np . array ( list ( h . y ( ) ) + [ 0. ] ) if logy : np . clip ( y , 1E-300 , 1E300 , out = y ) return axes . step ( list ( h . xedges ( ) ) , y , where = 'post' , ** kwargs ) | Make a matplotlib step plot from a ROOT histogram . |
246,898 | def fill_between ( a , b , logy = None , axes = None , ** kwargs ) : if axes is None : axes = plt . gca ( ) if logy is None : logy = axes . get_yscale ( ) == 'log' if not isinstance ( a , _Hist ) or not isinstance ( b , _Hist ) : raise TypeError ( "fill_between only operates on 1D histograms" ) a . check_compatibility ( b , check_edges = True ) x = [ ] top = [ ] bottom = [ ] for abin , bbin in zip ( a . bins ( overflow = False ) , b . bins ( overflow = False ) ) : up = max ( abin . value , bbin . value ) dn = min ( abin . value , bbin . value ) x . extend ( [ abin . x . low , abin . x . high ] ) top . extend ( [ up , up ] ) bottom . extend ( [ dn , dn ] ) x = np . array ( x ) top = np . array ( top ) bottom = np . array ( bottom ) if logy : np . clip ( top , 1E-300 , 1E300 , out = top ) np . clip ( bottom , 1E-300 , 1E300 , out = bottom ) return axes . fill_between ( x , top , bottom , ** kwargs ) | Fill the region between two histograms or graphs . |
246,899 | def hist2d ( h , axes = None , colorbar = False , ** kwargs ) : if axes is None : axes = plt . gca ( ) X , Y = np . meshgrid ( list ( h . x ( ) ) , list ( h . y ( ) ) ) x = X . ravel ( ) y = Y . ravel ( ) z = np . array ( h . z ( ) ) . T return_values = axes . hist2d ( x , y , weights = z . ravel ( ) , bins = ( list ( h . xedges ( ) ) , list ( h . yedges ( ) ) ) , ** kwargs ) if colorbar : mappable = return_values [ - 1 ] plt . colorbar ( mappable , ax = axes ) return return_values | Draw a 2D matplotlib histogram plot from a 2D ROOT histogram . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.