idx int64 0 251k | question stringlengths 53 3.53k | target stringlengths 5 1.23k | len_question int64 20 893 | len_target int64 3 238 |
|---|---|---|---|---|
4,000 | def read_wv_master_file ( wv_master_file , lines = 'brightest' , debugplot = 0 ) : # protection if lines not in [ 'brightest' , 'all' ] : raise ValueError ( 'Unexpected lines=' + str ( lines ) ) # read table from txt file master_table = np . genfromtxt ( wv_master_file ) wv_master = read_wv_master_from_array ( master_table , lines ) if abs ( debugplot ) >= 10 : print ( "Reading master table: " + wv_master_file ) print ( "wv_master:\n" , wv_master ) return wv_master | read arc line wavelengths from external file . | 154 | 8 |
4,001 | def wvcal_spectrum ( sp , fxpeaks , poly_degree_wfit , wv_master , wv_ini_search = None , wv_end_search = None , wvmin_useful = None , wvmax_useful = None , geometry = None , debugplot = 0 ) : # check there are enough lines for fit if len ( fxpeaks ) <= poly_degree_wfit : print ( ">>> Warning: not enough lines to fit spectrum" ) return None # spectrum dimension naxis1 = sp . shape [ 0 ] wv_master_range = wv_master [ - 1 ] - wv_master [ 0 ] delta_wv_master_range = 0.20 * wv_master_range if wv_ini_search is None : wv_ini_search = wv_master [ 0 ] - delta_wv_master_range if wv_end_search is None : wv_end_search = wv_master [ - 1 ] + delta_wv_master_range # use channels (pixels from 1 to naxis1) xchannel = fxpeaks + 1.0 # wavelength calibration list_of_wvfeatures = arccalibration ( wv_master = wv_master , xpos_arc = xchannel , naxis1_arc = naxis1 , crpix1 = 1.0 , wv_ini_search = wv_ini_search , wv_end_search = wv_end_search , wvmin_useful = wvmin_useful , wvmax_useful = wvmax_useful , error_xpos_arc = 3 , times_sigma_r = 3.0 , frac_triplets_for_sum = 0.50 , times_sigma_theil_sen = 10.0 , poly_degree_wfit = poly_degree_wfit , times_sigma_polfilt = 10.0 , times_sigma_cook = 10.0 , times_sigma_inclusion = 10.0 , geometry = geometry , debugplot = debugplot ) title = "Wavelength calibration" solution_wv = fit_list_of_wvfeatures ( list_of_wvfeatures = list_of_wvfeatures , naxis1_arc = naxis1 , crpix1 = 1.0 , poly_degree_wfit = poly_degree_wfit , weighted = False , plot_title = title , geometry = geometry , debugplot = debugplot ) if abs ( debugplot ) % 10 != 0 : # final plot with identified lines xplot = np . arange ( 1 , naxis1 + 1 , dtype = float ) ax = ximplotxy ( xplot , sp , title = title , show = False , xlabel = 'pixel (from 1 to NAXIS1)' , ylabel = 'number of counts' , geometry = geometry ) ymin = sp . min ( ) ymax = sp . max ( ) dy = ymax - ymin ymin -= dy / 20. ymax += dy / 20. ax . set_ylim ( [ ymin , ymax ] ) # plot wavelength of each identified line for feature in solution_wv . features : xpos = feature . xpos reference = feature . reference ax . text ( xpos , sp [ int ( xpos + 0.5 ) - 1 ] , str ( reference ) , fontsize = 8 , horizontalalignment = 'center' ) # show plot print ( 'Plot with identified lines' ) pause_debugplot ( 12 , pltshow = True ) # return the wavelength calibration solution return solution_wv | Execute wavelength calibration of a spectrum using fixed line peaks . | 811 | 12 |
4,002 | def get_thumbnail ( file_ , name ) : options = settings . OPTIONS_DICT [ name ] opt = copy ( options ) geometry = opt . pop ( 'geometry' ) return original_get_thumbnail ( file_ , geometry , * * opt ) | get_thumbnail version that uses aliasses defined in THUMBNAIL_OPTIONS_DICT | 58 | 23 |
4,003 | def bitset ( name , members , base = bases . BitSet , list = False , tuple = False ) : if not name : raise ValueError ( 'empty bitset name: %r' % name ) if not hasattr ( members , '__getitem__' ) or not hasattr ( members , '__len__' ) : raise ValueError ( 'non-sequence bitset members: %r' % members ) if not len ( members ) : raise ValueError ( 'less than one bitset member: %r' % ( members , ) ) if len ( set ( members ) ) != len ( members ) : raise ValueError ( 'bitset members contains duplicates: %r' % ( members , ) ) if not issubclass ( base . __class__ , meta . MemberBitsMeta ) : raise ValueError ( 'base does not subclass bitset.bases: %r' % base ) list = { False : None , True : series . List } . get ( list , list ) tuple = { False : None , True : series . Tuple } . get ( tuple , tuple ) return base . _make_subclass ( name , members , listcls = list , tuplecls = tuple ) | Return a new bitset class with given name and members . | 260 | 12 |
4,004 | def _extrapolation ( self , extrapolate ) : modes = [ 'extrapolate' , 'raise' , 'const' , 'border' ] if extrapolate not in modes : msg = 'invalid extrapolation mode {}' . format ( extrapolate ) raise ValueError ( msg ) if extrapolate == 'raise' : self . bounds_error = True self . extrapolate = False else : self . extrapolate = True self . bounds_error = False self . extrapolate_mode = extrapolate | Check permited values of extrapolation . | 107 | 8 |
4,005 | def _create_h ( x ) : h = np . zeros_like ( x ) h [ : - 1 ] = x [ 1 : ] - x [ : - 1 ] # border h [ - 1 ] = h [ - 2 ] return h | increase between samples | 54 | 4 |
4,006 | def _eval ( self , v , in_bounds , der ) : result = np . zeros_like ( v , dtype = 'float' ) x_indices = np . searchsorted ( self . _x , v , side = 'rigth' ) ids = x_indices [ in_bounds ] - 1 u = v [ in_bounds ] - self . _x [ ids ] result [ in_bounds ] = self . _poly_eval ( u , ids , der ) return result | Eval polynomial inside bounds . | 116 | 8 |
4,007 | def _extrapolate ( self , result , v , below_bounds , above_bounds , der ) : if self . extrapolate_mode == 'const' : fill_b = fill_a = self . fill_value elif self . extrapolate_mode == 'border' : fill_b = self . _poly_eval ( 0 , 0 , der ) fill_a = self . _poly_eval ( 0 , - 1 , der ) elif self . extrapolate_mode == 'extrapolate' : u = v [ above_bounds ] - self . _x [ - 2 ] fill_a = self . _poly_eval ( u , - 2 , der ) u = v [ below_bounds ] - self . _x [ 0 ] fill_b = self . _poly_eval ( u , 0 , der ) else : raise ValueError ( "extrapolation method doesn't exist" ) result [ below_bounds ] = fill_b result [ above_bounds ] = fill_a | Extrapolate result based on extrapolation mode . | 221 | 10 |
4,008 | def _check_bounds ( self , v ) : below_bounds = v < self . _x [ 0 ] above_bounds = v > self . _x [ - 1 ] if self . bounds_error and below_bounds . any ( ) : raise ValueError ( "A value in x_new is below the interpolation " "range." ) if self . bounds_error and above_bounds . any ( ) : raise ValueError ( "A value in x_new is above the interpolation " "range." ) return below_bounds , above_bounds | Check which values are out of bounds . | 125 | 8 |
4,009 | def filtmask ( sp , fmin = 0.02 , fmax = 0.15 , debugplot = 0 ) : # Fourier filtering xf = np . fft . fftfreq ( sp . size ) yf = np . fft . fft ( sp ) if abs ( debugplot ) in ( 21 , 22 ) : iok = np . where ( xf > 0 ) ximplotxy ( xf [ iok ] , yf [ iok ] . real , plottype = 'loglog' , xlabel = 'frequency' , ylabel = 'power' , title = 'before masking' , debugplot = debugplot ) cut = ( np . abs ( xf ) > fmax ) yf [ cut ] = 0.0 cut = ( np . abs ( xf ) < fmin ) yf [ cut ] = 0.0 if abs ( debugplot ) in ( 21 , 22 ) : iok = np . where ( xf > 0 ) ximplotxy ( xf [ iok ] , yf [ iok ] . real , plottype = 'loglog' , xlabel = 'frequency' , ylabel = 'power' , title = 'after masking' , debugplot = debugplot ) sp_filt = np . fft . ifft ( yf ) . real if abs ( debugplot ) in ( 21 , 22 ) : xdum = np . arange ( 1 , sp_filt . size + 1 ) ximplotxy ( xdum , sp_filt , title = "filtered median spectrum" , debugplot = debugplot ) sp_filtmask = sp_filt * cosinebell ( sp_filt . size , 0.1 ) if abs ( debugplot ) in ( 21 , 22 ) : xdum = np . arange ( 1 , sp_filt . size + 1 ) ximplotxy ( xdum , sp_filtmask , title = "filtered and masked median spectrum" , debugplot = debugplot ) return sp_filtmask | Filter spectrum in Fourier space and apply cosine bell . | 448 | 12 |
4,010 | def cosinebell ( n , fraction ) : mask = np . ones ( n ) nmasked = int ( fraction * n ) for i in range ( nmasked ) : yval = 0.5 * ( 1 - np . cos ( np . pi * float ( i ) / float ( nmasked ) ) ) mask [ i ] = yval mask [ n - i - 1 ] = yval return mask | Return a cosine bell spanning n pixels masking a fraction of pixels | 89 | 14 |
4,011 | def convolve_comb_lines ( lines_wave , lines_flux , sigma , crpix1 , crval1 , cdelt1 , naxis1 ) : # generate wavelengths for output spectrum xwave = crval1 + ( np . arange ( naxis1 ) + 1 - crpix1 ) * cdelt1 # initialize output spectrum spectrum = np . zeros ( naxis1 ) # convolve each line for wave , flux in zip ( lines_wave , lines_flux ) : sp_tmp = gauss_box_model ( x = xwave , amplitude = flux , mean = wave , stddev = sigma ) spectrum += sp_tmp return xwave , spectrum | Convolve a set of lines of known wavelengths and flux . | 151 | 13 |
4,012 | def _split_refextract_authors_str ( authors_str ) : author_seq = ( x . strip ( ) for x in RE_SPLIT_AUTH . split ( authors_str ) if x ) res = [ ] current = '' for author in author_seq : if not isinstance ( author , six . text_type ) : author = six . text_type ( author . decode ( 'utf8' , 'ignore' ) ) # First clean the token. author = re . sub ( r'\(|\)' , '' , author , re . U ) # Names usually start with characters. author = re . sub ( r'^[\W\d]+' , '' , author , re . U ) # Names should end with characters or dot. author = re . sub ( r'[^.\w]+$' , '' , author , re . U ) # If we have initials join them with the previous token. if RE_INITIALS_ONLY . match ( author ) : current += ', ' + author . strip ( ) . replace ( '. ' , '.' ) else : if current : res . append ( current ) current = author # Add last element. if current : res . append ( current ) # Manual filterings that we don't want to add in regular expressions since # it would make them more complex. # * ed might sneak in # * many legacy refs look like 'X. and Somebody E.' # * might miss lowercase initials filters = [ lambda a : a == 'ed' , lambda a : a . startswith ( ',' ) , lambda a : len ( a ) == 1 ] res = [ r for r in res if all ( not f ( r ) for f in filters ) ] return res | Extract author names out of refextract authors output . | 377 | 12 |
4,013 | def _set_publication_info_field ( self , field_name , value ) : self . _ensure_reference_field ( 'publication_info' , { } ) self . obj [ 'reference' ] [ 'publication_info' ] [ field_name ] = value | Put a value in the publication info of the reference . | 63 | 11 |
4,014 | def set_pubnote ( self , pubnote ) : if 'publication_info' in self . obj . get ( 'reference' , { } ) : self . add_misc ( u'Additional pubnote: {}' . format ( pubnote ) ) return if self . RE_VALID_PUBNOTE . match ( pubnote ) : pubnote = split_pubnote ( pubnote ) pubnote = convert_old_publication_info_to_new ( [ pubnote ] ) [ 0 ] self . _ensure_reference_field ( 'publication_info' , pubnote ) else : self . add_misc ( pubnote ) | Parse pubnote and populate correct fields . | 140 | 9 |
4,015 | def _add_uid ( self , uid , skip_handle = False ) : # We might add None values from wherever. Kill them here. uid = uid or '' if is_arxiv ( uid ) : self . _ensure_reference_field ( 'arxiv_eprint' , normalize_arxiv ( uid ) ) elif idutils . is_doi ( uid ) : self . _ensure_reference_field ( 'dois' , [ ] ) self . obj [ 'reference' ] [ 'dois' ] . append ( idutils . normalize_doi ( uid ) ) elif idutils . is_handle ( uid ) and not skip_handle : self . _ensure_reference_field ( 'persistent_identifiers' , [ ] ) self . obj [ 'reference' ] [ 'persistent_identifiers' ] . append ( { 'schema' : 'HDL' , 'value' : idutils . normalize_handle ( uid ) , } ) elif idutils . is_urn ( uid ) : self . _ensure_reference_field ( 'persistent_identifiers' , [ ] ) self . obj [ 'reference' ] [ 'persistent_identifiers' ] . append ( { 'schema' : 'URN' , 'value' : uid , } ) elif self . RE_VALID_CNUM . match ( uid ) : self . _ensure_reference_field ( 'publication_info' , { } ) self . obj [ 'reference' ] [ 'publication_info' ] [ 'cnum' ] = uid elif is_cds_url ( uid ) : self . _ensure_reference_field ( 'external_system_identifiers' , [ ] ) self . obj [ 'reference' ] [ 'external_system_identifiers' ] . append ( { 'schema' : 'CDS' , 'value' : extract_cds_id ( uid ) , } ) elif is_ads_url ( uid ) : self . _ensure_reference_field ( 'external_system_identifiers' , [ ] ) self . obj [ 'reference' ] [ 'external_system_identifiers' ] . append ( { 'schema' : 'ADS' , 'value' : extract_ads_id ( uid ) , } ) else : # ``idutils.is_isbn`` is too strict in what it accepts. try : isbn = str ( ISBN ( uid ) ) self . _ensure_reference_field ( 'isbn' , { } ) self . obj [ 'reference' ] [ 'isbn' ] = isbn except Exception : raise ValueError ( 'Unrecognized uid type' ) | Add unique identifier in correct field . | 612 | 7 |
4,016 | def set_page_artid ( self , page_start = None , page_end = None , artid = None ) : if page_end and not page_start : raise ValueError ( 'End_page provided without start_page' ) self . _ensure_reference_field ( 'publication_info' , { } ) publication_info = self . obj [ 'reference' ] [ 'publication_info' ] if page_start : publication_info [ 'page_start' ] = page_start if page_end : publication_info [ 'page_end' ] = page_end if artid : publication_info [ 'artid' ] = artid | Add artid start end pages to publication info of a reference . | 147 | 13 |
4,017 | def separate_globs ( globs ) : exclude = [ ] include = [ ] for path in globs : if path . startswith ( "!" ) : exclude . append ( path [ 1 : ] ) else : include . append ( path ) return ( exclude , include ) | Separate include and exclude globs . | 59 | 8 |
4,018 | def parse_glob ( path , included ) : files = glob . glob ( path , recursive = True ) array = [ ] for file in files : file = os . path . abspath ( file ) if file not in included : array . append ( file ) included += array return array | Parse a glob . | 60 | 5 |
4,019 | def find_base ( path ) : result = _pattern . match ( path ) if result : base = result . group ( 0 ) else : base = "./" if base . endswith ( '/' ) or base . endswith ( '\\' ) : return os . path . abspath ( base ) else : return os . path . dirname ( os . path . abspath ( base ) ) | Find the base of a glob . | 87 | 7 |
4,020 | def fun_wv ( xchannel , crpix1 , crval1 , cdelt1 ) : wv = crval1 + ( xchannel - crpix1 ) * cdelt1 return wv | Compute wavelengths from channels . | 46 | 6 |
4,021 | def update_poly_wlcalib ( coeff_ini , coeff_residuals , naxis1_ini , debugplot ) : # define initial wavelength calibration polynomial (use generic # code valid for lists of numpy.arrays) coeff = [ ] for fdum in coeff_ini : coeff . append ( fdum ) poly_ini = np . polynomial . Polynomial ( coeff ) poldeg_wlcalib = len ( coeff ) - 1 # return initial polynomial when there is no need to compute an # updated version if len ( coeff_residuals ) == 0 : return poly_ini . coef else : if np . count_nonzero ( poly_ini . coef ) == 0 : return poly_ini . coef # define polynomial corresponding to the residuals fit carried # out by check_wlcalib_sp() coeff = [ ] for fdum in coeff_residuals : coeff . append ( fdum ) poly_residuals = np . polynomial . Polynomial ( coeff ) # define new points to be fitted xfit = np . zeros ( naxis1_ini ) yfit = np . zeros ( naxis1_ini ) for i in range ( naxis1_ini ) : xfit [ i ] = float ( i + 1 ) wv_tmp = poly_ini ( xfit [ i ] ) yfit [ i ] = wv_tmp + poly_residuals ( wv_tmp ) # fit to get the updated polynomial if len ( xfit ) > poldeg_wlcalib : poldeg_effective = poldeg_wlcalib else : poldeg_effective = len ( xfit ) - 1 poly_updated , ydum = polfit_residuals ( x = xfit , y = yfit , deg = poldeg_effective , debugplot = debugplot ) # return coefficients of updated polynomial return poly_updated . coef | Update wavelength calibration polynomial using the residuals fit . | 450 | 12 |
4,022 | def generate_docs ( klass ) : import numina . types . datatype attrh = ( 'Attributes\n' '----------\n' ) doc = getattr ( klass , '__doc__' , None ) if doc is None or doc == '' : doc = "%s documentation." % klass . __name__ if len ( klass . stored ( ) ) : doc = doc + '\n\n' + attrh skeys = sorted ( klass . stored ( ) . keys ( ) ) for key in skeys : y = klass . stored ( ) [ key ] if isinstance ( y , Requirement ) : modo = 'requirement' elif isinstance ( y , Result ) : modo = 'product' else : modo = "" if y . type . isproduct ( ) : tipo = y . type . __class__ . __name__ elif isinstance ( y . type , numina . types . datatype . PlainPythonType ) : tipo = y . type . internal_type . __name__ else : tipo = y . type . __class__ . __name__ if y . optional : if y . default_value ( ) : modo = "%s, optional, default=%s" % ( modo , y . default ) else : modo = "%s, optional" % ( modo , ) descript = y . description if descript : field = "%s : %s, %s\n %s\n" % ( key , tipo , modo , descript ) else : field = "%s : %s, %s\n" % ( key , tipo , modo ) doc = doc + field klass . __doc__ = doc return klass | Add documentation to generated classes | 374 | 5 |
4,023 | def reinverted ( n , r ) : result = 0 r = 1 << ( r - 1 ) while n : if not n & 1 : result |= r r >>= 1 n >>= 1 if r : result |= ( r << 1 ) - 1 return result | Integer with reversed and inverted bits of n assuming bit length r . | 57 | 13 |
4,024 | def rank ( items , sequence = string . ascii_lowercase ) : items = set ( items ) return sum ( 1 << i for i , s in enumerate ( sequence ) if s in items ) | Rank items from sequence in colexicographical order . | 44 | 11 |
4,025 | def unrank ( n , sequence = string . ascii_lowercase ) : return list ( map ( sequence . __getitem__ , indexes ( n ) ) ) | Unrank n from sequence in colexicographical order . | 36 | 12 |
4,026 | def background_estimator ( bdata ) : crowded = False std = numpy . std ( bdata ) std0 = std mean = bdata . mean ( ) while True : prep = len ( bdata ) numpy . clip ( bdata , mean - 3 * std , mean + 3 * std , out = bdata ) if prep == len ( bdata ) : if std < 0.8 * std0 : crowded = True break std = numpy . std ( bdata ) mean = bdata . mean ( ) if crowded : median = numpy . median ( bdata ) mean = bdata . mean ( ) std = bdata . std ( ) return 2.5 * median - 1.5 * mean , std return bdata . mean ( ) , bdata . std ( ) | Estimate the background in a 2D array | 169 | 9 |
4,027 | def create_background_map ( data , bsx , bsy ) : sx , sy = data . shape mx = sx // bsx my = sy // bsy comp = [ ] rms = [ ] # Rows sp = numpy . split ( data , numpy . arange ( bsx , sx , bsx ) , axis = 0 ) for s in sp : # Columns rp = numpy . split ( s , numpy . arange ( bsy , sy , bsy ) , axis = 1 ) for r in rp : b , r = background_estimator ( r ) comp . append ( b ) rms . append ( r ) # Reconstructed image z = numpy . array ( comp ) z . shape = ( mx , my ) # median filter ndfilter . median_filter ( z , size = ( 3 , 3 ) , output = z ) # Interpolate to the original size new = _interpolation ( z , sx , sy , mx , my ) # Interpolate the rms z = numpy . array ( rms ) z . shape = ( mx , my ) nrms = _interpolation ( z , sx , sy , mx , my ) return new , nrms | Create a background map with a given mesh size | 281 | 9 |
4,028 | def _read_columns_file ( f ) : try : columns = json . loads ( open ( f , 'r' ) . read ( ) , object_pairs_hook = collections . OrderedDict ) except Exception as err : raise InvalidColumnsFileError ( "There was an error while reading {0}: {1}" . format ( f , err ) ) # Options are not supported yet: if '__options' in columns : del columns [ '__options' ] return columns | Return the list of column queries read from the given JSON file . | 105 | 13 |
4,029 | def _table_to_csv ( table_ ) : f = cStringIO . StringIO ( ) try : _write_csv ( f , table_ ) return f . getvalue ( ) finally : f . close ( ) | Return the given table converted to a CSV string . | 48 | 10 |
4,030 | def table ( dicts , columns , csv = False , pretty = False ) : # Optionally read columns from file. if isinstance ( columns , basestring ) : columns = _read_columns_file ( columns ) # Either "pattern" or "pattern_path" (but not both) is allowed in the # columns.json file, but "pattern" gets normalised to "pattern_path" here. for column in columns . values ( ) : if "pattern" in column : assert "pattern_path" not in column , ( 'A column must have either a "pattern" or a "pattern_path"' "but not both" ) column [ "pattern_path" ] = column [ "pattern" ] del column [ "pattern" ] table_ = [ ] for d in dicts : row = collections . OrderedDict ( ) # The row we'll return in the table. for column_title , column_spec in columns . items ( ) : if not column_spec . get ( 'return_multiple_columns' , False ) : row [ column_title ] = query ( dict_ = d , * * column_spec ) else : multiple_columns = query ( dict_ = d , * * column_spec ) for k , v in multiple_columns . items ( ) : row [ k ] = v table_ . append ( row ) if pretty : # Return a pretty-printed string (looks like a nice table when printed # to stdout). return tabulate . tabulate ( table_ , tablefmt = "grid" , headers = "keys" ) elif csv : # Return a string of CSV-formatted text. return _table_to_csv ( table_ ) else : # Return a list of dicts. return table_ | Query a list of dicts with a list of queries and return a table . | 383 | 16 |
4,031 | def query ( pattern_path , dict_ , max_length = None , strip = False , case_sensitive = False , unique = False , deduplicate = False , string_transformations = None , hyperlink = False , return_multiple_columns = False ) : if string_transformations is None : string_transformations = [ ] if max_length : string_transformations . append ( lambda x : x [ : max_length ] ) if hyperlink : string_transformations . append ( lambda x : '=HYPERLINK("{0}")' . format ( x ) ) if isinstance ( pattern_path , basestring ) : pattern_path = [ pattern_path ] # Copy the pattern_path because we're going to modify it which can be # unexpected and confusing to user code. original_pattern_path = pattern_path pattern_path = pattern_path [ : ] # We're going to be popping strings off the end of the pattern path # (because Python lists don't come with a convenient pop-from-front method) # so we need the list in reverse order. pattern_path . reverse ( ) result = _process_object ( pattern_path , dict_ , string_transformations = string_transformations , strip = strip , case_sensitive = case_sensitive , return_multiple_columns = return_multiple_columns ) if not result : return None # Empty lists finally get turned into None. elif isinstance ( result , dict ) : return _flatten ( result ) elif len ( result ) == 1 : return result [ 0 ] # One-item lists just get turned into the item. else : if unique : msg = "pattern_path: {0}\n\n" . format ( original_pattern_path ) msg = msg + pprint . pformat ( dict_ ) raise UniqueError ( msg ) if deduplicate : # Deduplicate the list while maintaining order. new_result = [ ] for item in result : if item not in new_result : new_result . append ( item ) result = new_result return result | Query the given dict with the given pattern path and return the result . | 450 | 14 |
4,032 | def get_reactions ( columns = 'all' , n_results = 20 , write_db = False , * * kwargs ) : if write_db or columns == 'all' : columns = all_columns [ 'reactions' ] queries = { } for key , value in kwargs . items ( ) : key = map_column_names ( key ) if key == 'distinct' : if value in [ True , 'True' , 'true' ] : queries . update ( { key : True } ) continue if isinstance ( value , int ) or isinstance ( value , float ) : queries . update ( { key : value } ) else : queries . update ( { key : '{0}' . format ( value ) } ) subtables = [ ] if write_db : subtables = [ 'reactionSystems' , 'publication' ] else : subtables = [ ] data = query ( table = 'reactions' , subtables = subtables , columns = columns , n_results = n_results , queries = queries ) if not write_db : return data print ( 'Writing result to Reactions.db' ) unique_ids = [ ] for row in data [ 'reactions' ] [ 'edges' ] : with CathubSQLite ( 'Reactions.db' ) as db : row = row [ 'node' ] key_values = { } for key in all_columns [ 'reactions' ] : v = row [ key ] # if isinstance(v, unicode): # v = v.encode('utf-8') try : v = json . loads ( v ) except BaseException : pass key_values [ convert ( key ) ] = v ase_ids = { } energy_corrections = { } for row_rs in row [ 'reactionSystems' ] : if row_rs [ 'name' ] == 'N/A' : continue ase_ids [ row_rs [ 'name' ] ] = row_rs [ 'aseId' ] energy_corrections [ row_rs [ 'name' ] ] = row_rs [ 'energyCorrection' ] if not ase_ids : ase_ids = None energy_corrections = None else : unique_ids += ase_ids . values ( ) key_values [ 'ase_ids' ] = ase_ids key_values [ 'energy_corrections' ] = ase_ids # publications pub_key_values = { } row_p = row [ 'publication' ] for key in all_columns [ 'publications' ] : pub_key_values [ convert ( key ) ] = row_p [ key ] db . write_publication ( pub_key_values ) # reactions and reaction_systems id = db . check ( key_values [ 'chemical_composition' ] , key_values [ 'reaction_energy' ] ) if id is None : id = db . write ( key_values ) else : db . update ( id , key_values ) if ase_ids is not None : # Ase structures with ase . db . connect ( 'Reactions.db' ) as ase_db : con = ase_db . connection cur = con . cursor ( ) cur . execute ( 'SELECT unique_id from systems;' ) unique_ids0 = cur . fetchall ( ) unique_ids0 = [ un [ 0 ] for un in unique_ids0 ] unique_ids = [ un for un in unique_ids if un not in unique_ids0 ] for unique_id in list ( set ( unique_ids ) ) : # if ase_db.count('unique_id={}'.format(unique_id)) == 0: atomsrow = get_atomsrow_by_id ( unique_id ) ase_db . write ( atomsrow ) print ( 'Writing complete!' ) return data | Get reactions from server | 846 | 4 |
4,033 | def create_recipe_file_logger ( logger , logfile , logformat ) : recipe_formatter = logging . Formatter ( logformat ) fh = logging . FileHandler ( logfile , mode = 'w' ) fh . setLevel ( logging . DEBUG ) fh . setFormatter ( recipe_formatter ) return fh | Redirect Recipe log messages to a file . | 75 | 9 |
4,034 | def run_recipe ( recipe , task , rinput , workenv , logger_control ) : # Creating custom logger file recipe_logger = logging . getLogger ( logger_control [ 'default' ] ) if logger_control [ 'enabled' ] : logfile = os . path . join ( workenv . resultsdir , logger_control [ 'logfile' ] ) logformat = logger_control [ 'format' ] _logger . debug ( 'creating file logger %r from Recipe logger' , logfile ) fh = create_recipe_file_logger ( recipe_logger , logfile , logformat ) else : fh = logging . NullHandler ( ) recipe_logger . addHandler ( fh ) with working_directory ( workenv . workdir ) : try : run_recipe_timed ( task , recipe , rinput ) return task finally : recipe_logger . removeHandler ( fh ) | Recipe execution mode of numina . | 203 | 7 |
4,035 | def run_recipe_timed ( task , recipe , rinput ) : _logger . info ( 'running recipe' ) now1 = datetime . datetime . now ( ) task . state = 1 task . time_start = now1 # result = recipe ( rinput ) _logger . info ( 'result: %r' , result ) task . result = result # now2 = datetime . datetime . now ( ) task . state = 2 task . time_end = now2 return task | Run the recipe and count the time it takes . | 109 | 10 |
4,036 | def stop_db_session ( exc = None ) : # print('==> Stop session', type(exc)) if has_db_session ( ) : exc_type = None tb = None if exc : exc_type , exc , tb = get_exc_info ( exc ) db_session . __exit__ ( exc_type , exc , tb ) | Stops the last db_session | 79 | 7 |
4,037 | def get_path ( dest , file , cwd = None ) : if callable ( dest ) : return dest ( file ) if not cwd : cwd = file . cwd if not os . path . isabs ( dest ) : dest = os . path . join ( cwd , dest ) relative = os . path . relpath ( file . path , file . base ) return os . path . join ( dest , relative ) | Get the writing path of a file . | 92 | 8 |
4,038 | def write_file ( path , contents ) : os . makedirs ( os . path . dirname ( path ) , exist_ok = True ) with open ( path , "w" ) as file : file . write ( contents ) | Write contents to a local file . | 50 | 7 |
4,039 | def get_pub_id ( title , authors , year ) : if len ( title . split ( ' ' ) ) > 1 and title . split ( ' ' ) [ 0 ] . lower ( ) in [ 'the' , 'a' ] : _first_word = title . split ( ' ' ) [ 1 ] . split ( '_' ) [ 0 ] else : _first_word = title . split ( ' ' ) [ 0 ] . split ( '_' ) [ 0 ] pub_id = authors [ 0 ] . split ( ',' ) [ 0 ] . split ( ' ' ) [ 0 ] + _first_word + str ( year ) return pub_id | construct publication id | 145 | 3 |
4,040 | def extract_atoms ( molecule ) : if molecule == '' : return molecule try : return float ( molecule ) except BaseException : pass atoms = '' if not molecule [ 0 ] . isalpha ( ) : i = 0 while not molecule [ i ] . isalpha ( ) : i += 1 prefactor = float ( molecule [ : i ] ) if prefactor < 0 : prefactor = abs ( prefactor ) sign = '-' else : sign = '' molecule = molecule [ i : ] else : prefactor = 1 sign = '' for k in range ( len ( molecule ) ) : if molecule [ k ] . isdigit ( ) : for j in range ( int ( molecule [ k ] ) - 1 ) : atoms += molecule [ k - 1 ] else : atoms += molecule [ k ] if prefactor % 1 == 0 : atoms *= int ( prefactor ) elif prefactor % 1 == 0.5 : atoms_sort = sorted ( atoms ) N = len ( atoms ) atoms = '' for n in range ( N ) : for m in range ( int ( prefactor - 0.5 ) ) : atoms += atoms_sort [ n ] if n % 2 == 0 : atoms += atoms_sort [ n ] return sign + '' . join ( sorted ( atoms ) ) | Return a string with all atoms in molecule | 268 | 8 |
4,041 | def check_reaction ( reactants , products ) : reactant_list = [ reactant . split ( '@' ) [ 0 ] . strip ( 'star' ) . strip ( 'gas' ) for reactant in reactants ] product_list = [ product . split ( '@' ) [ 0 ] . strip ( 'star' ) . strip ( 'gas' ) for product in products ] reactant_atoms = [ extract_atoms ( reactant ) for reactant in reactant_list ] product_atoms = [ extract_atoms ( product ) for product in product_list ] reactants = add_atoms ( reactant_atoms ) products = add_atoms ( product_atoms ) r_stars = 0 p_stars = 0 for i , a in enumerate ( reactant_atoms ) : if a == '' or 'star' in reactant_list [ i ] : r_stars += 1 elif isinstance ( a , float ) : r_stars += a for a in product_atoms : if a == '' : p_stars += 1 elif isinstance ( a , float ) : p_stars += a assert '' . join ( sorted ( reactants ) ) == '' . join ( sorted ( products ) ) | Check the stoichiometry and format of chemical reaction used for folder structure . list of reactants - > list of products | 272 | 24 |
4,042 | def check_section ( node , section , keys = None ) : if keys : for key in keys : if key not in node : raise ValueError ( 'Missing key %r inside %r node' % ( key , section ) ) | Validate keys in a section | 49 | 6 |
4,043 | def drp_load ( package , resource , confclass = None ) : data = pkgutil . get_data ( package , resource ) return drp_load_data ( package , data , confclass = confclass ) | Load the DRPS from a resource file . | 48 | 9 |
4,044 | def drp_load_data ( package , data , confclass = None ) : drpdict = yaml . safe_load ( data ) ins = load_instrument ( package , drpdict , confclass = confclass ) if ins . version == 'undefined' : pkg = importlib . import_module ( package ) ins . version = getattr ( pkg , '__version__' , 'undefined' ) return ins | Load the DRPS from data . | 95 | 7 |
4,045 | def load_modes ( node ) : if isinstance ( node , list ) : values = [ load_mode ( child ) for child in node ] keys = [ mode . key for mode in values ] return dict ( zip ( keys , values ) ) elif isinstance ( node , dict ) : values = { key : load_mode ( child ) for key , child in node } return values else : raise NotImplementedError | Load all observing modes | 91 | 4 |
4,046 | def load_mode ( node ) : obs_mode = ObservingMode ( ) obs_mode . __dict__ . update ( node ) # handle validator load_mode_validator ( obs_mode , node ) # handle builder load_mode_builder ( obs_mode , node ) # handle tagger: load_mode_tagger ( obs_mode , node ) return obs_mode | Load one observing mdode | 83 | 5 |
4,047 | def load_mode_tagger ( obs_mode , node ) : # handle tagger: ntagger = node . get ( 'tagger' ) if ntagger is None : pass elif isinstance ( ntagger , list ) : def full_tagger ( obsres ) : return get_tags_from_full_ob ( obsres , reqtags = ntagger ) obs_mode . tagger = full_tagger elif isinstance ( ntagger , six . string_types ) : # load function obs_mode . tagger = import_object ( ntagger ) else : raise TypeError ( 'tagger must be None, a list or a string' ) return obs_mode | Load observing mode OB tagger | 153 | 6 |
4,048 | def load_mode_builder ( obs_mode , node ) : # Check 'builder' and 'builder_options' nval1 = node . get ( 'builder' ) if nval1 is not None : if isinstance ( nval1 , str ) : # override method newmethod = import_object ( nval1 ) obs_mode . build_ob = newmethod . __get__ ( obs_mode ) else : raise TypeError ( 'builder must be None or a string' ) else : nval2 = node . get ( 'builder_options' ) if nval2 is not None : if isinstance ( nval2 , list ) : for opt_dict in nval2 : if 'result_of' in opt_dict : fields = opt_dict [ 'result_of' ] obs_mode . build_ob_options = ResultOf ( * * fields ) break else : raise TypeError ( 'builder_options must be None or a list' ) return obs_mode | Load observing mode OB builder | 212 | 5 |
4,049 | def load_mode_validator ( obs_mode , node ) : nval = node . get ( 'validator' ) if nval is None : pass elif isinstance ( nval , str ) : # load function obs_mode . validator = import_object ( nval ) else : raise TypeError ( 'validator must be None or a string' ) return obs_mode | Load observing mode validator | 83 | 5 |
4,050 | def frommembers ( cls , members ) : return cls . frombitsets ( map ( cls . BitSet . frommembers , members ) ) | Series from iterable of member iterables . | 32 | 9 |
4,051 | def frombools ( cls , bools ) : return cls . frombitsets ( map ( cls . BitSet . frombools , bools ) ) | Series from iterable of boolean evaluable iterables . | 36 | 11 |
4,052 | def frombits ( cls , bits ) : return cls . frombitsets ( map ( cls . BitSet . frombits , bits ) ) | Series from binary string arguments . | 32 | 6 |
4,053 | def fromints ( cls , ints ) : return cls . frombitsets ( map ( cls . BitSet . fromint , ints ) ) | Series from integer rank arguments . | 34 | 6 |
4,054 | def index_sets ( self , as_set = False ) : indexes = frozenset if as_set else tuple return [ indexes ( b . iter_set ( ) ) for b in self ] | Return the series as list of index set tuples . | 42 | 11 |
4,055 | def append_arrays ( many , single ) : assert np . ndim ( single ) == 1 # Check if the values need to be padded to for equal length diff = single . shape [ 0 ] - many . shape [ 0 ] if diff < 0 : single = np . pad ( single , ( 0 , - diff ) , 'constant' , constant_values = np . nan ) elif diff > 0 : many = np . pad ( many , ( ( 0 , diff ) , ) , 'constant' , constant_values = np . nan ) else : # No padding needed pass return np . c_ [ many , single ] | Append an array to another padding with NaNs for constant length . | 135 | 14 |
4,056 | def _get_locations ( self , calc ) : return ( self . _location_in ( calc . profile ) , self . _location_out ( calc . profile ) ) | Locate locations within the profile . | 38 | 7 |
4,057 | def find_pix_borders ( sp , sought_value ) : if sp . ndim != 1 : raise ValueError ( 'Unexpected number of dimensions:' , sp . ndim ) naxis1 = len ( sp ) jborder_min = - 1 jborder_max = naxis1 # only spectra with values different from 'sought_value' if not np . alltrue ( sp == sought_value ) : # left border while True : jborder_min += 1 if sp [ jborder_min ] != sought_value : break # right border while True : jborder_max -= 1 if sp [ jborder_max ] != sought_value : break return jborder_min , jborder_max | Find useful region of a given spectrum | 154 | 7 |
4,058 | def fix_pix_borders ( image2d , nreplace , sought_value , replacement_value ) : # input image size naxis2 , naxis1 = image2d . shape for i in range ( naxis2 ) : # only spectra with values different from 'sought_value' jborder_min , jborder_max = find_pix_borders ( image2d [ i , : ] , sought_value = sought_value ) # left border if jborder_min != - 1 : j1 = jborder_min j2 = min ( j1 + nreplace , naxis1 ) image2d [ i , j1 : j2 ] = replacement_value # right border if jborder_max != naxis1 : j2 = jborder_max + 1 j1 = max ( j2 - nreplace , 0 ) image2d [ i , j1 : j2 ] = replacement_value return image2d | Replace a few pixels at the borders of each spectrum . | 206 | 12 |
4,059 | def define_mask_borders ( image2d , sought_value , nadditional = 0 ) : # input image size naxis2 , naxis1 = image2d . shape # initialize mask mask2d = np . zeros ( ( naxis2 , naxis1 ) , dtype = bool ) # initialize list to store borders borders = [ ] for i in range ( naxis2 ) : # only spectra with values different from 'sought_value' jborder_min , jborder_max = find_pix_borders ( image2d [ i , : ] , sought_value = sought_value ) borders . append ( ( jborder_min , jborder_max ) ) if ( jborder_min , jborder_max ) != ( - 1 , naxis1 ) : if jborder_min != - 1 : j1 = 0 j2 = jborder_min + nadditional + 1 mask2d [ i , j1 : j2 ] = True if jborder_max != naxis1 : j1 = jborder_max - nadditional j2 = naxis1 mask2d [ i , j1 : j2 ] = True return mask2d , borders | Generate mask avoiding undesired values at the borders . | 261 | 11 |
4,060 | def update_features ( self , poly ) : for feature in self . features : feature . wavelength = poly ( feature . xpos ) | Evaluate wavelength at xpos using the provided polynomial . | 28 | 14 |
4,061 | def dataframe_from_list ( values ) : if ( isinstance ( values , six . string_types ) ) : return DataFrame ( filename = values ) elif ( isinstance ( values , fits . HDUList ) ) : return DataFrame ( frame = values ) else : return None | Build a DataFrame object from a list . | 62 | 9 |
4,062 | def obsres_from_dict ( values ) : obsres = ObservationResult ( ) ikey = 'frames' # Workaround if 'images' in values : ikey = 'images' obsres . id = values . get ( 'id' , 1 ) obsres . mode = values [ 'mode' ] obsres . instrument = values [ 'instrument' ] obsres . configuration = values . get ( 'configuration' , 'default' ) obsres . pipeline = values . get ( 'pipeline' , 'default' ) obsres . children = values . get ( 'children' , [ ] ) obsres . parent = values . get ( 'parent' , None ) obsres . results = values . get ( 'results' , { } ) obsres . requirements = values . get ( 'requirements' , { } ) try : obsres . frames = [ dataframe_from_list ( val ) for val in values [ ikey ] ] except Exception : obsres . frames = [ ] return obsres | Build a ObservationResult object from a dictionary . | 222 | 10 |
4,063 | def get_sample_frame ( self ) : for frame in self . frames : return frame . open ( ) for res in self . results . values ( ) : return res . open ( ) return None | Return first available image in observation result | 42 | 7 |
4,064 | def fowler_array ( fowlerdata , ti = 0.0 , ts = 0.0 , gain = 1.0 , ron = 1.0 , badpixels = None , dtype = 'float64' , saturation = 65631 , blank = 0 , normalize = False ) : import numina . array . _nirproc as _nirproc if gain <= 0 : raise ValueError ( "invalid parameter, gain <= 0.0" ) if ron <= 0 : raise ValueError ( "invalid parameter, ron < 0.0" ) if ti < 0 : raise ValueError ( "invalid parameter, ti < 0.0" ) if ts < 0 : raise ValueError ( "invalid parameter, ts < 0.0" ) if saturation <= 0 : raise ValueError ( "invalid parameter, saturation <= 0" ) fowlerdata = numpy . asarray ( fowlerdata ) if fowlerdata . ndim != 3 : raise ValueError ( 'fowlerdata must be 3D' ) npairs = fowlerdata . shape [ 0 ] // 2 if 2 * npairs != fowlerdata . shape [ 0 ] : raise ValueError ( 'axis-0 in fowlerdata must be even' ) # change byteorder ndtype = fowlerdata . dtype . newbyteorder ( '=' ) fowlerdata = numpy . asarray ( fowlerdata , dtype = ndtype ) # type of the output fdtype = numpy . result_type ( fowlerdata . dtype , dtype ) # Type of the mask mdtype = numpy . dtype ( 'uint8' ) fshape = ( fowlerdata . shape [ 1 ] , fowlerdata . shape [ 2 ] ) if badpixels is None : badpixels = numpy . zeros ( fshape , dtype = mdtype ) else : if badpixels . shape != fshape : raise ValueError ( 'shape of badpixels is not ' 'compatible with shape of fowlerdata' ) if badpixels . dtype != mdtype : raise ValueError ( 'dtype of badpixels must be uint8' ) result = numpy . empty ( fshape , dtype = fdtype ) var = numpy . empty_like ( result ) npix = numpy . empty ( fshape , dtype = mdtype ) mask = badpixels . copy ( ) _nirproc . _process_fowler_intl ( fowlerdata , ti , ts , gain , ron , badpixels , saturation , blank , result , var , npix , mask ) return result , var , npix , mask | Loop over the first axis applying Fowler processing . | 571 | 9 |
4,065 | def ramp_array ( rampdata , ti , gain = 1.0 , ron = 1.0 , badpixels = None , dtype = 'float64' , saturation = 65631 , blank = 0 , nsig = None , normalize = False ) : import numina . array . _nirproc as _nirproc if ti <= 0 : raise ValueError ( "invalid parameter, ti <= 0.0" ) if gain <= 0 : raise ValueError ( "invalid parameter, gain <= 0.0" ) if ron <= 0 : raise ValueError ( "invalid parameter, ron < 0.0" ) if saturation <= 0 : raise ValueError ( "invalid parameter, saturation <= 0" ) rampdata = numpy . asarray ( rampdata ) if rampdata . ndim != 3 : raise ValueError ( 'rampdata must be 3D' ) # change byteorder ndtype = rampdata . dtype . newbyteorder ( '=' ) rampdata = numpy . asarray ( rampdata , dtype = ndtype ) # type of the output fdtype = numpy . result_type ( rampdata . dtype , dtype ) # Type of the mask mdtype = numpy . dtype ( 'uint8' ) fshape = ( rampdata . shape [ 1 ] , rampdata . shape [ 2 ] ) if badpixels is None : badpixels = numpy . zeros ( fshape , dtype = mdtype ) else : if badpixels . shape != fshape : msg = 'shape of badpixels is not compatible with shape of rampdata' raise ValueError ( msg ) if badpixels . dtype != mdtype : raise ValueError ( 'dtype of badpixels must be uint8' ) result = numpy . empty ( fshape , dtype = fdtype ) var = numpy . empty_like ( result ) npix = numpy . empty ( fshape , dtype = mdtype ) mask = badpixels . copy ( ) _nirproc . _process_ramp_intl ( rampdata , ti , gain , ron , badpixels , saturation , blank , result , var , npix , mask ) return result , var , npix , mask | Loop over the first axis applying ramp processing . | 486 | 9 |
4,066 | def accept_freeware_license ( ) : ntab = 3 if version ( ) . startswith ( '6.6.' ) else 2 for _ in range ( ntab ) : EasyProcess ( 'xdotool key KP_Tab' ) . call ( ) time . sleep ( 0.5 ) EasyProcess ( 'xdotool key KP_Space' ) . call ( ) time . sleep ( 0.5 ) # say OK to any more question EasyProcess ( 'xdotool key KP_Space' ) . call ( ) | different Eagle versions need differnt TAB count . 6 . 5 - > 2 6 . 6 - > 3 7 . 4 - > 2 | 114 | 28 |
4,067 | def fully_qualified_name ( obj , sep = '.' ) : if inspect . isclass ( obj ) : return obj . __module__ + sep + obj . __name__ else : return obj . __module__ + sep + obj . __class__ . __name__ | Return fully qualified name from object | 58 | 6 |
4,068 | def fun_residuals ( params , xnor , ynor , w , bbox , k , ext ) : spl = LSQUnivariateSpline ( x = xnor , y = ynor , t = [ item . value for item in params . values ( ) ] , w = w , bbox = bbox , k = k , ext = ext , check_finite = False ) return spl . get_residual ( ) | Compute fit residuals | 96 | 5 |
4,069 | def parse_as_yaml ( strdict ) : interm = "" for key , val in strdict . items ( ) : interm = "%s: %s, %s" % ( key , val , interm ) fin = '{%s}' % interm return yaml . load ( fin ) | Parse a dictionary of strings as if yaml reads it | 68 | 12 |
4,070 | def folder2db ( folder_name , debug , energy_limit , skip_folders , goto_reaction ) : folder_name = folder_name . rstrip ( '/' ) skip = [ ] for s in skip_folders . split ( ', ' ) : for sk in s . split ( ',' ) : skip . append ( sk ) pub_id = _folder2db . main ( folder_name , debug , energy_limit , skip , goto_reaction ) if pub_id : print ( '' ) print ( '' ) print ( 'Ready to release the data?' ) print ( " Send it to the Catalysis-Hub server with 'cathub db2server {folder_name}/{pub_id}.db'." . format ( * * locals ( ) ) ) print ( " Then log in at www.catalysis-hub.org/upload/ to verify and release. " ) | Read folder and collect data in local sqlite3 database | 194 | 11 |
4,071 | def db2server ( dbfile , block_size , dbuser , dbpassword ) : _db2server . main ( dbfile , write_reaction = True , write_ase = True , write_publication = True , write_reaction_system = True , block_size = block_size , start_block = 0 , user = dbuser , password = dbpassword ) | Transfer data from local database to Catalysis Hub server | 82 | 10 |
4,072 | def reactions ( columns , n_results , write_db , queries ) : if not isinstance ( queries , dict ) : query_dict = { } for q in queries : key , value = q . split ( '=' ) if key == 'distinct' : if value in [ 'True' , 'true' ] : query_dict . update ( { key : True } ) continue try : value = int ( value ) query_dict . update ( { key : value } ) except BaseException : query_dict . update ( { key : '{0}' . format ( value ) } ) # Keep {0} in string.format for python2.6 compatibility if write_db and n_results > 1000 : print ( """Warning: You're attempting to write more than a 1000 rows with geometries. This could take some time""" ) data = query . get_reactions ( columns = columns , n_results = n_results , write_db = write_db , * * query_dict ) if write_db : return table = [ ] headers = [ ] for row in data [ 'reactions' ] [ 'edges' ] : table += [ list ( row [ 'node' ] . values ( ) ) ] headers = list ( row [ 'node' ] . keys ( ) ) print ( tabulate ( table , headers ) + '\n' ) | Search for reactions | 293 | 3 |
4,073 | def publications ( columns , n_results , queries ) : if not isinstance ( queries , dict ) : query_dict = { } for q in queries : key , value = q . split ( '=' ) if key == 'distinct' : if value in [ 'True' , 'true' ] : query_dict . update ( { key : True } ) continue try : value = int ( value ) query_dict . update ( { key : value } ) except BaseException : query_dict . update ( { key : '{0}' . format ( value ) } ) if 'sort' not in query_dict : query_dict . update ( { 'order' : '-year' } ) data = query . query ( table = 'publications' , columns = columns , n_results = n_results , queries = query_dict ) table = [ ] headers = [ ] for row in data [ 'publications' ] [ 'edges' ] : value = list ( row [ 'node' ] . values ( ) ) for n , v in enumerate ( value ) : if isinstance ( v , str ) and len ( v ) > 20 : splited = v . split ( ' ' ) size = 0 sentence = '' for word in splited : if size < 20 : size += len ( word ) sentence += ' ' + word else : sentence += '\n' + word size = 0 sentence += '\n' value [ n ] = sentence table += [ value ] headers = list ( row [ 'node' ] . keys ( ) ) print ( tabulate ( table , headers , tablefmt = "grid" ) + '\n' ) | Search for publications | 355 | 3 |
4,074 | def make_folders ( template , custom_base ) : def dict_representer ( dumper , data ) : return dumper . represent_dict ( data . items ( ) ) Dumper . add_representer ( collections . OrderedDict , dict_representer ) if custom_base is None : custom_base = os . path . abspath ( os . path . curdir ) template = custom_base + '/' + template template_data = ase_tools . REACTION_TEMPLATE if not os . path . exists ( template ) : with open ( template , 'w' ) as outfile : outfile . write ( yaml . dump ( template_data , indent = 4 , Dumper = Dumper ) + '\n' ) print ( "Created template file: {template}\n" . format ( * * locals ( ) ) + ' Please edit it and run the script again to create your folderstructure.\n' + ' Run cathub make_folders --help for instructions' ) return with open ( template ) as infile : template_data = yaml . load ( infile ) title = template_data [ 'title' ] authors = template_data [ 'authors' ] journal = template_data [ 'journal' ] volume = template_data [ 'volume' ] number = template_data [ 'number' ] pages = template_data [ 'pages' ] year = template_data [ 'year' ] email = template_data [ 'email' ] publisher = template_data [ 'publisher' ] doi = template_data [ 'doi' ] dft_code = template_data [ 'DFT_code' ] dft_functionals = template_data [ 'DFT_functionals' ] reactions = template_data [ 'reactions' ] crystal_structures = template_data [ 'crystal_structures' ] bulk_compositions = template_data [ 'bulk_compositions' ] facets = template_data [ 'facets' ] energy_corrections = template_data [ 'energy_corrections' ] make_folders_template . main ( title = title , authors = eval ( authors ) if isinstance ( authors , six . string_types ) else authors , journal = journal , volume = volume , number = number , pages = pages , year = year , email = email , publisher = publisher , doi = doi , DFT_code = dft_code , DFT_functionals = dft_functionals , reactions = eval ( reactions ) if isinstance ( reactions , six . string_types ) else reactions , custom_base = custom_base , bulk_compositions = bulk_compositions , crystal_structures = crystal_structures , facets = facets , energy_corrections = energy_corrections ) pub_id = tools . get_pub_id ( title , authors , year ) print ( "Now dump your DFT output files into the folder, and run 'cathub folder2db {pub_id}'" . format ( * * locals ( ) ) ) | Create a basic folder tree for dumping DFT calculcations for reaction energies . | 661 | 16 |
4,075 | def organize ( * * kwargs ) : # do argument wrangling before turning it into an obect # since namedtuples are immutable if len ( kwargs [ 'adsorbates' ] ) == 0 : print ( """Warning: no adsorbates specified, can't pick up reaction reaction energies.""" ) print ( " Enter adsorbates like so --adsorbates CO,O,CO2" ) print ( " [Comma-separated list without spaces.]" ) kwargs [ 'adsorbates' ] = list ( map ( lambda x : ( '' . join ( sorted ( string2symbols ( x ) ) ) ) , kwargs [ 'adsorbates' ] . split ( ',' ) , ) ) if kwargs [ 'energy_corrections' ] : e_c_dict = { } for e_c in kwargs [ 'energy_corrections' ] . split ( ',' ) : key , value = e_c . split ( '=' ) e_c_dict . update ( { key : float ( value ) } ) kwargs [ 'energy_corrections' ] = e_c_dict options = collections . namedtuple ( 'options' , kwargs . keys ( ) ) ( * * kwargs ) _organize . main ( options = options ) | Read reactions from non - organized folder | 287 | 7 |
4,076 | def initCurses ( self ) : curses . noecho ( ) curses . cbreak ( ) curses . curs_set ( 0 ) curses . start_color ( ) curses . use_default_colors ( ) curses . init_pair ( 1 , curses . COLOR_WHITE , - 1 ) curses . init_pair ( 2 , curses . COLOR_YELLOW , - 1 ) curses . init_pair ( 3 , curses . COLOR_MAGENTA , - 1 ) curses . init_pair ( 4 , curses . COLOR_CYAN , - 1 ) curses . init_pair ( 5 , curses . COLOR_GREEN , - 1 ) curses . init_pair ( 6 , curses . COLOR_BLUE , - 1 ) curses . init_pair ( 7 , curses . COLOR_RED , - 1 ) | Set up screen properties | 179 | 4 |
4,077 | def patchCurses ( self ) : if ( sys . version_info ) [ : 3 ] == ( 3 , 4 , 0 ) : self . addchar = lambda y , x , * args : self . win . addch ( x , y , * args ) else : self . addchar = self . win . addch | Fix curses addch function for python 3 . 4 . 0 | 69 | 12 |
4,078 | def splash ( self ) : dirname = os . path . split ( os . path . abspath ( __file__ ) ) [ 0 ] try : splash = open ( os . path . join ( dirname , "splash" ) , "r" ) . readlines ( ) except IOError : return width = len ( max ( splash , key = len ) ) y = int ( self . y_grid / 2 ) - len ( splash ) x = int ( self . x_grid / 2 ) - int ( width / 2 ) if self . x_grid > width : for i , line in enumerate ( splash ) : self . win . addstr ( y + i , x , line , curses . color_pair ( 5 ) ) | Draw splash screen | 158 | 3 |
4,079 | def drawHUD ( self ) : self . win . move ( self . height - 2 , self . x_pad ) self . win . clrtoeol ( ) self . win . box ( ) self . addstr ( 2 , self . x_pad + 1 , "Population: %i" % len ( self . grid ) ) self . addstr ( 3 , self . x_pad + 1 , "Generation: %s" % self . current_gen ) self . addstr ( 3 , self . x_grid - 21 , "s: start p: pause" ) self . addstr ( 2 , self . x_grid - 21 , "r: restart q: quit" ) | Draw information on population size and current generation | 148 | 8 |
4,080 | def drawGrid ( self ) : for cell in self . grid : y , x = cell y += self . y_pad x += self . x_pad if self . traditional : sprite = '.' color = curses . color_pair ( 4 ) else : sprite = self . char [ self . grid [ cell ] - 1 ] color = curses . color_pair ( self . grid [ cell ] ) self . addchar ( y , x , sprite , color ) self . win . refresh ( ) | Redraw the grid with the new generation | 104 | 8 |
4,081 | def nextGen ( self ) : self . current_gen += 1 self . change_gen [ self . current_gen % 3 ] = copy . copy ( self . grid ) grid_cp = copy . copy ( self . grid ) for cell in self . grid : y , x = cell y1 = ( y - 1 ) % self . y_grid y2 = ( y + 1 ) % self . y_grid x1 = ( x - 1 ) % self . x_grid x2 = ( x + 1 ) % self . x_grid n = self . countNeighbours ( cell ) if n < 2 or n > 3 : del grid_cp [ cell ] self . addchar ( y + self . y_pad , x + self . x_pad , ' ' ) else : grid_cp [ cell ] = min ( self . grid [ cell ] + 1 , self . color_max ) for neighbour in product ( [ y1 , y , y2 ] , [ x1 , x , x2 ] ) : if not self . grid . get ( neighbour ) : if self . countNeighbours ( neighbour ) == 3 : y , x = neighbour y = y % self . y_grid x = x % self . x_grid neighbour = y , x grid_cp [ neighbour ] = 1 self . grid = grid_cp | Decide the fate of the cells | 287 | 7 |
4,082 | def countNeighbours ( self , cell ) : count = 0 y , x = cell y = y % self . y_grid x = x % self . x_grid y1 = ( y - 1 ) % self . y_grid y2 = ( y + 1 ) % self . y_grid x1 = ( x - 1 ) % self . x_grid x2 = ( x + 1 ) % self . x_grid cell = y , x for neighbour in product ( [ y1 , y , y2 ] , [ x1 , x , x2 ] ) : if neighbour != cell and self . grid . get ( neighbour ) : count += 1 return count | Return the number active neighbours within one positions away from cell | 143 | 11 |
4,083 | def initGrid ( self ) : blinker = [ ( 4 , 4 ) , ( 4 , 5 ) , ( 4 , 6 ) ] toad = [ ( 9 , 5 ) , ( 9 , 6 ) , ( 9 , 7 ) , ( 10 , 4 ) , ( 10 , 5 ) , ( 10 , 6 ) ] glider = [ ( 4 , 11 ) , ( 5 , 12 ) , ( 6 , 10 ) , ( 6 , 11 ) , ( 6 , 12 ) ] r_pentomino = [ ( 10 , 60 ) , ( 9 , 61 ) , ( 10 , 61 ) , ( 11 , 61 ) , ( 9 , 62 ) ] self . grid = { } if self . test : for cell in chain ( blinker , toad , glider , r_pentomino ) : self . grid [ cell ] = 1 else : for _ in range ( self . initsize ) : ry = random . randint ( self . y_pad , self . y_grid - 1 ) rx = random . randint ( self . x_pad , self . x_grid - 1 ) self . grid [ ( ry , rx ) ] = 1 | Initialise the game grid | 252 | 5 |
4,084 | def restart ( self ) : self . initGrid ( ) self . win . clear ( ) self . current_gen = 1 self . start | Restart the game from a new generation 0 | 29 | 9 |
4,085 | def end ( self ) : if self . loop : self . restart return self . addstr ( 2 , self . x_grid / 2 - 4 , "GAMEOVER" , 7 ) if self . hud : self . addstr ( 2 , self . x_pad + 13 , len ( self . grid ) , 5 ) self . addstr ( 3 , self . x_pad + 13 , self . current_gen , 5 ) if self . test : exit ( ) while self . state == 'stopped' : key = self . win . getch ( ) if key == ord ( 'q' ) : exit ( ) if key in [ ord ( 's' ) , ord ( 'r' ) ] : self . restart | Game Finished - Restart or Quit | 157 | 7 |
4,086 | def mean ( arrays , masks = None , dtype = None , out = None , zeros = None , scales = None , weights = None ) : return generic_combine ( intl_combine . mean_method ( ) , arrays , masks = masks , dtype = dtype , out = out , zeros = zeros , scales = scales , weights = weights ) | Combine arrays using the mean with masks and offsets . | 80 | 11 |
4,087 | def median ( arrays , masks = None , dtype = None , out = None , zeros = None , scales = None , weights = None ) : return generic_combine ( intl_combine . median_method ( ) , arrays , masks = masks , dtype = dtype , out = out , zeros = zeros , scales = scales , weights = weights ) | Combine arrays using the median with masks . | 80 | 9 |
4,088 | def minmax ( arrays , masks = None , dtype = None , out = None , zeros = None , scales = None , weights = None , nmin = 1 , nmax = 1 ) : return generic_combine ( intl_combine . minmax_method ( nmin , nmax ) , arrays , masks = masks , dtype = dtype , out = out , zeros = zeros , scales = scales , weights = weights ) | Combine arrays using mix max rejection with masks . | 97 | 10 |
4,089 | def flatcombine ( arrays , masks = None , dtype = None , scales = None , low = 3.0 , high = 3.0 , blank = 1.0 ) : result = sigmaclip ( arrays , masks = masks , dtype = dtype , scales = scales , low = low , high = high ) # Substitute values <= 0 by blank mm = result [ 0 ] <= 0 result [ 0 , mm ] = blank # Add values to mask result [ 1 : 2 , mm ] = 0 return result | Combine flat arrays . | 111 | 5 |
4,090 | def zerocombine ( arrays , masks , dtype = None , scales = None ) : result = median ( arrays , masks = masks , dtype = dtype , scales = scales ) return result | Combine zero arrays . | 43 | 5 |
4,091 | def sum ( arrays , masks = None , dtype = None , out = None , zeros = None , scales = None ) : return generic_combine ( intl_combine . sum_method ( ) , arrays , masks = masks , dtype = dtype , out = out , zeros = zeros , scales = scales ) | Combine arrays by addition with masks and offsets . | 72 | 10 |
4,092 | def generic_combine ( method , arrays , masks = None , dtype = None , out = None , zeros = None , scales = None , weights = None ) : arrays = [ numpy . asarray ( arr , dtype = dtype ) for arr in arrays ] if masks is not None : masks = [ numpy . asarray ( msk ) for msk in masks ] if out is None : # Creating out if needed # We need three numbers try : outshape = ( 3 , ) + tuple ( arrays [ 0 ] . shape ) out = numpy . zeros ( outshape , dtype ) except AttributeError : raise TypeError ( 'First element in arrays does ' 'not have .shape attribute' ) else : out = numpy . asanyarray ( out ) intl_combine . generic_combine ( method , arrays , out [ 0 ] , out [ 1 ] , out [ 2 ] , masks , zeros , scales , weights ) return out | Stack arrays using different methods . | 209 | 6 |
4,093 | def compute_fwhm_1d_simple ( Y , xc , X = None ) : return compute_fw_at_frac_max_1d_simple ( Y , xc , X = X , f = 0.5 ) | Compute the FWHM . | 53 | 7 |
4,094 | def compute_fw_at_frac_max_1d_simple ( Y , xc , X = None , f = 0.5 ) : yy = np . asarray ( Y ) if yy . ndim != 1 : raise ValueError ( 'array must be 1-d' ) if yy . size == 0 : raise ValueError ( 'array is empty' ) if X is None : xx = np . arange ( yy . shape [ 0 ] ) else : xx = X xpix = coor_to_pix_1d ( xc - xx [ 0 ] ) try : peak = yy [ xpix ] except IndexError : raise ValueError ( 'peak is out of array' ) fwhm_x , _codex , _msgx = compute_fwhm_1d ( xx , yy - f * peak , xc , xpix ) return peak , fwhm_x | Compute the full width at fraction f of the maximum | 201 | 11 |
4,095 | def _fwhm_side_lineal ( uu , vv ) : res1 , = np . nonzero ( vv < 0 ) if len ( res1 ) == 0 : return 0 , 1 # error, no negative value else : # first value i2 = res1 [ 0 ] i1 = i2 - 1 dx = uu [ i2 ] - uu [ i1 ] dy = vv [ i2 ] - vv [ i1 ] r12 = uu [ i1 ] - vv [ i1 ] * dx / dy return r12 , 0 | Compute r12 using linear interpolation . | 126 | 9 |
4,096 | def get_ZPE ( viblist ) : if type ( viblist ) is str : l = ast . literal_eval ( viblist ) else : l = viblist l = [ float ( w ) for w in l ] ZPE = 0.5 * sum ( l ) * cm2ev return ( ZPE ) | Returns the zero point energy from a list of frequencies . | 68 | 11 |
4,097 | def auto_labels ( df ) : systems = list ( df . system ) facets = list ( df . facet ) systems_labels = [ w . replace ( '_' , '\ ' ) for w in systems ] systems_labels = [ sub ( w ) for w in systems_labels ] systems_labels = [ w . replace ( '}$$_{' , '' ) for w in systems_labels ] systems_labels = [ w . replace ( '$' , '' ) for w in systems_labels ] systems_labels = [ '$' + w + '$' for w in systems_labels ] facets_label = [ w . replace ( '_' , '\ ' ) for w in facets ] facets_label = [ '(' + w + ')' for w in facets_label ] labels = [ ] for i , sys in enumerate ( systems_labels ) : labels . append ( sys + facets_label [ i ] ) # labels = list(set(labels)) return ( labels ) | Transforms atomic system information into well - formatted labels . | 225 | 11 |
4,098 | def proton_hydroxide_free_energy ( temperature , pressure , pH ) : H2 = GasMolecule ( 'H2' ) H2O = GasMolecule ( 'H2O' ) G_H2 = H2 . get_free_energy ( temperature = temperature , pressure = pressure ) G_H2O = H2O . get_free_energy ( temperature = temperature ) G_H = ( 0.5 * G_H2 ) - ( ( R * temperature ) / ( z * F ) ) * ln10 * pH G_OH = G_H2O - G_H # Do not need Kw when water equilibrated return ( G_H , G_OH ) | Returns the Gibbs free energy of proton in bulk solution . | 157 | 12 |
4,099 | def get_FEC ( molecule_list , temperature , pressure , electronic_energy = 'Default' ) : if not temperature or not pressure : return ( 0 ) else : molecule_list = [ m for m in molecule_list if m != 'star' ] # print(molecule_list) FEC_sum = [ ] for molecule in molecule_list : if 'gas' in molecule : mol = GasMolecule ( molecule . replace ( 'gas' , '' ) ) if pressure == 'Default' : p = mol . pressure else : p = pressure if electronic_energy == 'Default' : ee = mol . electronic_energy else : ee = electronic_energy FEC = mol . get_free_energy ( temperature = temperature , pressure = p , electronic_energy = ee ) FEC_sum . append ( FEC ) if 'star' in molecule : FEC = Adsorbate ( molecule . replace ( 'star' , '' ) ) FEC = FEC . get_helmholtz_energy ( temperature = temperature ) FEC_sum . append ( FEC ) FEC_sum = sum ( FEC_sum ) return ( FEC_sum ) | Returns the Gibbs free energy corrections to be added to raw reaction energies . | 241 | 14 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.