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