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 isins... | 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 ) i... | 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_attribute... | 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... | 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 ... | 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... | 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 ( hyp... | 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 ( ) sel... | 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 ( ... | 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 . c... | 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 . ... | 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 ... | 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 )... | 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 ... | 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_... | 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 = frozen... | 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 ( hyp... | 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... |
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_versi... | 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... | 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_hig... | 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_'... | 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 ... | 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 codestri... | 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 . pat... | 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 (... | 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 . ... | 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 . ... | 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... | 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 . SetT... | 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 ( "se... | 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 ... | 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 . MakeSingleCha... | 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 . p... | 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_n... | 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 ) ... | 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 Initia... | 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 ) )... | 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`" ) p... | 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 ... | 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'... | 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 Attri... | 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 ) excep... | 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... | 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 exc... | 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 ... | 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 . ... | 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 : vari... | 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_yl... | 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... | 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... | 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 ... | 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 ( ... | 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.