def columns(data_url, list_of_variables): df = pd.read_pickle(data_url) # Reads pickle as strings out_list = [[] for i in range(len(list_of_variables)) ] # Initiate list of lists, with as many lists as variables. counter = 0 for i in list_of_variables: out_list[counter].append(support.str_to_float(df[i].tolist())) counter = counter + 1 return out_list
def access_data(cell_key, variable): df = pd.read_pickle((database.as_posix() + "/" + cell_key)) output = support.str_to_float( df[variable].tolist() ) #Extracts the wanted variable "variable" from the dataframe, converts it to a string and returns it. return output
def incremental_cycle_charge_discharge( df ): # Adds incremental cycle, charge and discharge from current signs. cycle = [] # Initiate variable cycle_nr = 0 # Cycle counter that will be written to cycle variable discharge_incr = [] # Initiate variable charge_incr = [] # Initiate variable dis_char_cycle = False # Used to define if cycling begins with discharge or charge, uses that to define if cycle starts with discharge or charge. char_dis_cycle = False # Used to define if cycling begins with discharge or charge, uses that to define if cycle starts with discharge or charge. started = False # Used to define if cycling has started current_float = support.str_to_float( df['current'].tolist()) # Extracting incremental current as float for i in range(0, len(current_float)): # Read dataframe line for line #--------------------------------- # Cycle variable: if current_float[i] < 0 and current_float[ i - 1] > 0 and started == False: # New discharge, and current is turned on for first time started = True dis_char_cycle = True if current_float[i] > 0 and current_float[ i - 1] < 0 and started == False: # New charge, and current is turned on for first time started = True char_dis_cycle = True if current_float[i] < 0 and current_float[ i - 1] > 0 and started == True: # New discharge, and new cycle cycle_nr = cycle_nr + 1 if current_float[i] > 0 and current_float[ i - 1] < 0 and started == True: # New charge, and new cycle cycle_nr = cycle_nr + 1 cycle.append(cycle_nr) # --------------------------------- # Discharge and charge variables: if not 'cap_incr' in df.columns: # Used for e.g. linear sweep voltammetry, where there is no capacity values. Skip/add zero. discharge_incr.append(0) charge_incr.append(0) continue if current_float[i] == 0: # If current is zero, capacity will be zero discharge_incr.append(0) charge_incr.append(0) if current_float[i] < 0: # Negative current means discharge discharge_incr.append(df['cap_incr'][i]) charge_incr.append(0) if current_float[i] > 0: discharge_incr.append(0) charge_incr.append(df['cap_incr'][i]) # --------------------------------- df['cycle'], df['discharge_incr'], df['charge_incr'] = [ cycle, discharge_incr, charge_incr ] # Add them as new columns to dataframe. return df
def specific_capacity_incremental(df, char_mass): discharge_incr_float = support.str_to_float(df['discharge_incr'].tolist( )) # Extracting incremental discharge as float discharge_incr_spec = np.divide( discharge_incr_float, float(char_mass) / 1000) # Divide by mass in grams to obtain specific capacity. charge_incr_float = support.str_to_float(df['charge_incr'].tolist( )) # Extracting incremental discharge as float charge_incr_spec = np.divide( charge_incr_float, float(char_mass) / 1000) # Divide by mass in grams to obtain specific capacity. cap_incr_float = support.str_to_float( df['cap_incr'].tolist()) # Extracting incremental discharge as float cap_incr_spec = np.divide( cap_incr_float, float(char_mass) / 1000) # Divide by mass in grams to obtain specific capacity. # Adding new columns where zero is replaced by Nan, for line plotting discharge_incr_spec_nonzero = discharge_incr_spec.copy() charge_incr_spec_nonzero = charge_incr_spec.copy() cap_incr_spec_nonzero = cap_incr_spec.copy() discharge_incr_spec_nonzero[discharge_incr_spec_nonzero == 0] = 'nan' charge_incr_spec_nonzero[charge_incr_spec_nonzero == 0] = 'nan' cap_incr_spec_nonzero[cap_incr_spec_nonzero == 0] = 'nan' df['discharge_incr_spec'], df['charge_incr_spec'], df['cap_incr_spec'] = [ discharge_incr_spec, charge_incr_spec, cap_incr_spec ] # Add them as new columns. df['discharge_incr_spec_nonzero'], df['charge_incr_spec_nonzero'], df[ 'cap_incr_spec_nonzero'] = [ discharge_incr_spec_nonzero, charge_incr_spec_nonzero, cap_incr_spec_nonzero ] return df
def add_cycle_incr( df ): # Was used on Lanhe-files, but replaced with add_from_currents function. discharge_incr_float = support.str_to_float(df['discharge_incr'].tolist( )) # Extracting incremental discharge as float charge_incr_float = support.str_to_float( df['charge_incr'].tolist()) # Extracting incremental charge as float cycle = [] # Initiates cycle variable (incremental cycle) cycle_nr = 0 # Cycle counter that will be written to cycle variable dis_char_cycle = False # Used to define if cycling begins with discharge or charge, uses that to define if cycle starts with discharge or charge. char_dis_cycle = False # Used to define if cycling begins with discharge or charge, uses that to define if cycle starts with discharge or charge. started = False # Used to define if cycling has started for i in range(0, len(discharge_incr_float)): if discharge_incr_float[i] != 0 and discharge_incr_float[ i - 1] == 0 and started == False: # New discharge and starting with discharge dis_char_cycle = True started = True if charge_incr_float[i] != 0 and charge_incr_float[ i - 1] == 0 and started == False: # New charge and starting with charge char_dis_cycle = True started = True if discharge_incr_float[i] != 0 and discharge_incr_float[ i - 1] == 0 and dis_char_cycle == True: # New discharge, which (might) define new cycle. cycle_nr = cycle_nr + 1 # New cycle if charge_incr_float[i] != 0 and charge_incr_float[ i - 1] == 0 and char_dis_cycle == True: # New charge, which (might) define new cycle. cycle_nr = cycle_nr + 1 # New cycle cycle.append(cycle_nr) df['cycle'] = cycle # Add cycle variable as new column in dataframe. return df
def change_specific_capacity_incremental_no_OCV(df): discharge_incr_spec_original = support.str_to_float( df['discharge_incr_spec'].tolist() ) # Extracting incremental discharge as float charge_incr_spec_original = support.str_to_float( df['charge_incr_spec'].tolist( )) # Extracting incremental discharge as float cap_incr_spec_original = support.str_to_float(df['cap_incr_spec'].tolist( )) # Extracting incremental discharge as float discharge_incr_spec_nonzero_original = support.str_to_float( df['discharge_incr_spec_nonzero'].tolist() ) # Extracting incremental discharge as float charge_incr_spec_nonzero_original = support.str_to_float( df['charge_incr_spec_nonzero'].tolist() ) # Extracting incremental discharge as float cap_incr_spec_nonzero_original = support.str_to_float( df['cap_incr_spec_nonzero'].tolist() ) # Extracting incremental discharge as float discharge_incr_spec = [] charge_incr_spec = [] cap_incr_spec = [] discharge_incr_spec_nonzero = [] charge_incr_spec_nonzero = [] cap_incr_spec_nonzero = [] for i in range(0, len(df['potential'])): if df['current'][i] == '0.000000000000000E+000': discharge_incr_spec.append('nan') charge_incr_spec.append('nan') cap_incr_spec.append('nan') discharge_incr_spec_nonzero.append('nan') charge_incr_spec_nonzero.append('nan') cap_incr_spec_nonzero.append('nan') else: discharge_incr_spec.append(discharge_incr_spec_original[i]) charge_incr_spec.append(charge_incr_spec_original[i]) cap_incr_spec.append(cap_incr_spec_original[i]) discharge_incr_spec_nonzero.append( discharge_incr_spec_nonzero_original[i]) charge_incr_spec_nonzero.append( charge_incr_spec_nonzero_original[i]) cap_incr_spec_nonzero.append(cap_incr_spec_nonzero_original[i]) df['discharge_incr_spec'], df['charge_incr_spec'], df['cap_incr_spec'], df[ 'discharge_incr_spec_nonzero'], df['charge_incr_spec_nonzero'], df[ 'cap_incr_spec_nonzero'] = discharge_incr_spec, charge_incr_spec, cap_incr_spec, discharge_incr_spec_nonzero, charge_incr_spec_nonzero, cap_incr_spec_nonzero return df
def specific_capacity_cycle(df, char_mass): cycle_incr_float = support.str_to_float( df['cycle'].tolist()) # Extracting incremental cycle number as float discharge_incr_float = support.str_to_float(df['discharge_incr'].tolist( )) # Extracting incremental discharge as float charge_incr_float = support.str_to_float(df['charge_incr'].tolist( )) # Extracting incremental discharge as float current_incr_float = support.str_to_float( df['current'].tolist()) # Extracting incremental current as float. # df = df.astype(float) # Converts all dataframe values to float last_cycle = int( cycle_incr_float[-1] ) # Extracts last element of cycle column (last cycle nr) and converts to int. cycles = list( range(last_cycle)) # Makes list of cycles, from 0 to last cycle nr. discharge_spec = [] # Initiates variable charge_spec = [] # Initiates variable current_spec = [] for i in range(0, len(cycle_incr_float)): if cycle_incr_float[i] == 0 and discharge_incr_float[ i] == 0 and charge_incr_float[i] == 0: # Ignores rest step. continue if i == len( cycle_incr_float ) - 1: # If iteration has reached the second last row of df, add last value to charge and discharge. if not (discharge_incr_float[-1] == 0): # Adding only if not zero. discharge_spec.append(discharge_incr_float[-1] / float(char_mass) * 1000) if not (charge_incr_float[-1] == 0): # Adding only if not zero. charge_spec.append(charge_incr_float[-1] / float(char_mass) * 1000) current_spec.append(current_incr_float[-1] / float(char_mass) * 1000) continue # Iteration is finished, and should not go to if condition below. if discharge_incr_float[i] != 0 and discharge_incr_float[ i + 1] == 0: # Finds where the discharge ends. if discharge_incr_float[i] < discharge_incr_float[ i - 1]: # Sometimes last value before changing to (dis)charge is transitioning to 0, use second last value instead. discharge_spec.append(discharge_incr_float[i - 1] / float(char_mass) * 1000) # Adding specific discharge/gram current_spec.append( current_incr_float[i - 1] / float(char_mass) * 1000 ) # Adds current for discharge, assumes same on charge. else: discharge_spec.append(discharge_incr_float[i] / float(char_mass) * 1000) # Adding specific discharge/gram current_spec.append( current_incr_float[i] / float(char_mass) * 1000 ) # Adds current for discharge, assumes same on charge. if charge_incr_float[i] != 0 and charge_incr_float[ i + 1] == 0: # Finds where the charge ends. if charge_incr_float[i] < charge_incr_float[ i - 1]: # Sometimes last value before changing to (dis)charge is transitioning to 0, use second last value instead. charge_spec.append(charge_incr_float[i - 1] / float(char_mass) * 1000) # Adding specific charge/gram else: charge_spec.append(charge_incr_float[i] / float(char_mass) * 1000) # Adding specific charge/gram discharge_spec, charge_spec, cycles, current_spec = support.remove_last( discharge_spec, charge_spec, cycles, current_spec, target=min(len(discharge_spec), len(charge_spec), len(cycles))) if (len(discharge_spec) != len(charge_spec) or len(discharge_spec) != len(cycles)): sys.exit( "Error: Unequal lengths of discharge_spec/charge_spec/cycle_nr!") discharge_spec, charge_spec, cycles, current_spec = support.fill_none( discharge_spec, charge_spec, cycles, current_spec, target=len(cycle_incr_float)) # Fill rest of column with 'None' df['discharge_spec'], df['charge_spec'], df['cycle_nr'], df[ 'current_spec'] = [discharge_spec, charge_spec, cycles, current_spec] # Add them as new columns. return df
def multiply_scalar(df, new_variable_name, from_variable, scalar): #df[new_variable_name] = df[from_variable].mul(scalar) df[new_variable_name] = [ i * scalar for i in support.str_to_float(df[from_variable].tolist()) ] # Multiplying each element in list that contains float numbers of column in df. return df