msfiddle 0.1.0__py3-none-any.whl

msfiddle/utils/msms_utils.py

@@ -0,0 +1,312 @@
+import numpy as np
+import re
+from tqdm import tqdm
+
+from rdkit import Chem
+# ignore the warning
+from rdkit import RDLogger 
+RDLogger.DisableLog('rdApp.*')
+from rdkit.Chem import AllChem
+from rdkit.Chem.rdMolDescriptors import CalcMolFormula
+
+from .mol_utils import ATOMS_WEIGHT, monoisotopic_mass_calculator
+
+MSLEVEL_MAP = {
+	'MS2': 2,
+	'MS1': 1, 
+	'2': 2,
+	'1': 1,
+}
+# this is the superset of spectra keys in our data
+mgf_key_order = ['title', 'precursor_type', 'precursor_mz', 
+				'molmass', 'ms_level', 'ionmode', 
+				'source_instrument', 'instrument_type', 'collision_energy', 
+				'smiles', 'inchi_key']
+
+def sdf2mgf(path, prefix): 
+	'''mgf format
+	[{
+		'params': {
+			'title': prefix_<index>, 
+			'precursor_type': <precursor_type (e.g. [M+NH4]+ and [M+H]+)>, 
+			'precursor_mz': <precursor m/z>,
+			'molmass': <isotopic mass>, 
+			'ms_level': <ms_level>, 
+			'ionmode': <POSITIVE|NEGATIVE>, 
+			'source_instrument': <source_instrument>,
+			'instrument_type': <instrument_type>, 
+			'collision_energy': <collision energe>, 
+			'smiles': <smiles>, 
+			'inchi_key': <inchi_key>, 
+		},
+		'm/z array': mz_array,
+		'intensity array': intensity_array
+	}, ...]
+	'''
+	supp = Chem.SDMolSupplier(path)
+	print('Read {} data from {}'.format(len(supp), path))
+
+	spectra = []
+	for idx, mol in enumerate(tqdm(supp)): 
+		if mol == None or \
+			not mol.HasProp('MASS SPECTRAL PEAKS') or \
+			not mol.HasProp('PRECURSOR TYPE') or \
+			not mol.HasProp('PRECURSOR M/Z') or \
+			not mol.HasProp('SPECTRUM TYPE') or \
+			not mol.HasProp('COLLISION ENERGY') or \
+			not mol.HasProp('ION MODE'): 
+			continue
+		
+		mz_array = []
+		intensity_array = []
+		raw_ms = mol.GetProp('MASS SPECTRAL PEAKS').split('\n')
+		for line in raw_ms:
+			mz_array.append(float(line.split()[0]))
+			intensity_array.append(float(line.split()[1]))
+		mz_array = np.array(mz_array)
+		intensity_array = np.array(intensity_array)
+
+		inchi_key = 'Unknown' if not mol.HasProp('INCHIKEY') else mol.GetProp('INCHIKEY')
+		instrument = 'Unknown' if not mol.HasProp('INSTRUMENT') else mol.GetProp('INSTRUMENT')
+		spectrum = {
+			'params': {
+				'title': prefix+'_'+str(idx), 
+				'precursor_type': mol.GetProp('PRECURSOR TYPE'),
+				'precursor_mz': mol.GetProp('PRECURSOR M/Z'),
+				'molmass': mol.GetProp('EXACT MASS'),
+				'ms_level': mol.GetProp('SPECTRUM TYPE'), 
+				'ionmode': mol.GetProp('ION MODE'), 
+				'source_instrument': instrument,
+				'instrument_type': mol.GetProp('INSTRUMENT TYPE'), 
+				'collision_energy': mol.GetProp('COLLISION ENERGY'), 
+				'smiles': Chem.MolToSmiles(mol, isomericSmiles=True), 
+				'inchi_key': inchi_key, 
+			},
+			'm/z array': mz_array,
+			'intensity array': intensity_array
+		} 
+		spectra.append(spectrum)
+	return spectra
+
+def filter_spec(spectra, config, type2charge): 
+	clean_spectra = []
+	smiles_list = []
+
+	records = {'instrument_type': [], 'instrument': [], 'ms_level': [], 
+			'atom_type': [], 'precursor_type': [], 'peak_num': [],
+			'max_mz': [], 'invalud_formula': [], 'ppm_tolerance': [], 
+			'invalid_intensity_array': []}
+	for idx, spectrum in enumerate(tqdm(spectra)): 
+		smiles = spectrum['params']['smiles'] 
+		mol = Chem.AddHs(Chem.MolFromSmiles(smiles))
+		if mol == None: continue
+
+		# Unify the smiles format
+		smiles = Chem.MolToSmiles(mol, isomericSmiles=False, canonical=True)
+		spectrum['params']['smiles'] = smiles
+
+		# Filter by instrument type
+		if 'instrument_type' in config.keys(): 
+			instrument_type = spectrum['params']['instrument_type']
+			if instrument_type not in config['instrument_type']: 
+				records['instrument_type'].append(spectrum['params']['title'])
+				continue
+
+		# Filter by instrument (MoNA contains too many intrument names to filter out)
+		if 'instrument' in config.keys(): 
+			instrument = spectrum['params']['source_instrument']
+			if instrument not in config['instrument']: 
+				records['instrument'].append(spectrum['params']['title'])
+				continue
+
+		# Filter by mslevel
+		if 'ms_level' in config.keys(): 
+			mslevel = spectrum['params']['ms_level']
+			if mslevel != config['ms_level']: 
+				records['ms_level'].append(spectrum['params']['title'])
+				continue
+
+		# Filter by atom number and atom type 
+		if len(mol.GetAtoms()) > config['max_atom_num'] or len(mol.GetAtoms()) < config['min_atom_num']: continue
+		is_compound_countain_rare_atom = False 
+		for atom in mol.GetAtoms(): 
+			if atom.GetSymbol() not in config['atom_type']:
+				is_compound_countain_rare_atom = True
+				break
+		if is_compound_countain_rare_atom: 
+			records['atom_type'].append(spectrum['params']['title'])
+			continue
+
+		# Filter by precursor type
+		precursor_type = spectrum['params']['precursor_type']
+		if precursor_type not in config['precursor_type']:
+			records['precursor_type'].append(spectrum['params']['title'])
+			continue
+
+		# Filt by peak number
+		if len(spectrum['m/z array']) < config['min_peak_num']: 
+			records['peak_num'].append(spectrum['params']['title'])
+			continue
+
+		# Filter by max m/z
+		if np.max(spectrum['m/z array']) < config['min_mz'] or np.max(spectrum['m/z array']) > config['max_mz']: 
+			records['max_mz'].append(spectrum['params']['title'])
+			continue
+
+		# Filter by ppm (mass error)
+		if 'ppm_tolerance' in config.keys(): 
+			f = CalcMolFormula(mol)
+			# try: 
+			# 	f = Formula(f)
+			# except: # invalud formula
+			# 	records['invalud_formula'].append(spectrum['params']['title'])
+			# 	continue
+			molmass = monoisotopic_mass_calculator(f, 'f')
+			theo_mz = precursor_mz_calculator(precursor_type, molmass)
+			ppm = abs(theo_mz - float(spectrum['params']['precursor_mz'])) / theo_mz * 10**6
+			
+			if ppm > config['ppm_tolerance']: 
+				records['ppm_tolerance'].append(spectrum['params']['title'])
+				continue
+			
+		# Remove the invalid spectra
+		if spectrum['intensity array'].max() == spectrum['intensity array'].min(): 
+			records['invalid_intensity_array'].append(spectrum['params']['title'])
+			continue
+
+		spectrum['params']['theoretical_precursor_mz'] = theo_mz
+		spectrum['params']['ppm'] = ppm
+		spectrum['params']['simulated_precursor_mz'] = simulate_experimental_mz(theo_mz, config['ppm_tolerance'])
+		spectrum['params']['charge'] = type2charge[precursor_type] # add charge
+		clean_spectra.append(spectrum)
+		smiles_list.append(smiles)
+
+	print('Filtering records: ')
+	for k, v in records.items():
+		print('\t{}: {}'.format(k, len(v)))
+
+	return clean_spectra, smiles_list
+
+def simulate_experimental_mz(theoretical_mz, relative_mass_tolerance_ppm):
+	"""
+	Simulate experimental precursor m/z value by shifting the theoretical value 
+	within a Gaussian distribution of mass deviations.
+
+	:param theoretical_mz: Theoretical precursor m/z value.
+	:param relative_mass_tolerance_ppm: Relative mass tolerance in parts per million (ppm).
+	:return: Simulated experimental precursor m/z value.
+	"""
+	
+	# Calculate the standard deviation of the Gaussian distribution as 1/3 of the relative mass tolerance
+	std_dev = (relative_mass_tolerance_ppm / 1e6 * theoretical_mz) / 3
+	
+	# Randomly sample a mass deviation from the Gaussian distribution
+	mass_deviation = np.random.normal(0, std_dev)
+	
+	# Shift the theoretical m/z value by the sampled mass deviation to simulate the experimental value
+	experimental_mz = theoretical_mz + mass_deviation
+	
+	return experimental_mz
+
+def ce2nce(ce, precursor_mz, charge):
+	charge_factor = {1: 1, 2: 0.9, 3: 0.85, 4: 0.8, 5: 0.75, 6: 0.75, 7: 0.75, 8: 0.75}
+	return ce * 500 * charge_factor[charge] / precursor_mz
+
+def precursor_mz_calculator(precursor_type, mass): 
+	if precursor_type == '[M+H]+': 
+		return mass + ATOMS_WEIGHT['H']
+	elif precursor_type == '[M+2H]2+':
+		return (mass + 2 * ATOMS_WEIGHT['H']) / 2
+	elif precursor_type == '[M+Na]+': 
+		return mass + ATOMS_WEIGHT['Na']
+	elif precursor_type == '[M-H]-':
+		return mass - ATOMS_WEIGHT['H']
+	elif precursor_type == '[M+H-H2O]+' or precursor_type == '[M-H2O+H]+': 
+		return mass + ATOMS_WEIGHT['H'] - (ATOMS_WEIGHT['H'] * 2 + ATOMS_WEIGHT['O'])
+	elif precursor_type == '[2M+H]+': 
+		return 2 * mass + ATOMS_WEIGHT['H']
+	elif precursor_type == '[2M-H]-':
+		return 2 * mass - ATOMS_WEIGHT['H']
+	elif precursor_type == '[M+H-2H2O]+':
+		return mass + ATOMS_WEIGHT['H'] - 2 * (ATOMS_WEIGHT['H'] * 2 + ATOMS_WEIGHT['O'])
+	elif precursor_type == '[M+H-NH3]+': 
+		return mass + ATOMS_WEIGHT['H'] - (ATOMS_WEIGHT['N'] + ATOMS_WEIGHT['H'] * 3)
+	elif precursor_type == '[M+H+NH3]+' or precursor_type == '[M+NH4]+':
+		return mass + ATOMS_WEIGHT['H'] + (ATOMS_WEIGHT['N'] + ATOMS_WEIGHT['H'] * 3)
+	elif precursor_type == '[M+H-CH2O2]+':
+		return mass + ATOMS_WEIGHT['H'] - (ATOMS_WEIGHT['C'] + ATOMS_WEIGHT['H'] * 2 + ATOMS_WEIGHT['O'] * 2)
+	elif precursor_type == '[M+H-CH4O2]+':
+		return mass + ATOMS_WEIGHT['H'] - (ATOMS_WEIGHT['C'] + ATOMS_WEIGHT['H'] * 4 + ATOMS_WEIGHT['O'] * 2)
+	elif precursor_type == '[M-H-CO2]-' or precursor_type == '[M-CHO2]-':
+		return mass - ATOMS_WEIGHT['H'] - (ATOMS_WEIGHT['C'] + ATOMS_WEIGHT['O'] * 2)
+	elif precursor_type == '[M-H-H2O]-':
+		return mass - ATOMS_WEIGHT['H'] - (ATOMS_WEIGHT['H'] * 2 + ATOMS_WEIGHT['O'])
+	else: 
+		raise ValueError('Unsupported precursor type: {}'.format(precursor_type))
+
+def mass_calculator(precursor_type, precursor_mz): 
+	if precursor_type == '[M+H]+':
+		return precursor_mz - ATOMS_WEIGHT['H']
+	elif precursor_type == '[M+2H]2+':
+		return (precursor_mz * 2 - 2 * ATOMS_WEIGHT['H'])
+	elif precursor_type == '[M+Na]+':
+		return precursor_mz - ATOMS_WEIGHT['Na']
+	elif precursor_type == '[M-H]-':
+		return precursor_mz + ATOMS_WEIGHT['H']
+	elif precursor_type == '[M+H-H2O]+' or precursor_type == '[M-H2O+H]+':
+		return precursor_mz - ATOMS_WEIGHT['H'] + (ATOMS_WEIGHT['H'] * 2 + ATOMS_WEIGHT['O'])
+	elif precursor_type == '[2M+H]+':
+		return (precursor_mz - ATOMS_WEIGHT['H']) / 2
+	elif precursor_type == '[2M-H]-':
+		return (precursor_mz + ATOMS_WEIGHT['H']) / 2
+	elif precursor_type == '[M+H-2H2O]+':
+		return precursor_mz - ATOMS_WEIGHT['H'] + 2 * (ATOMS_WEIGHT['H'] * 2 + ATOMS_WEIGHT['O'])
+	elif precursor_type == '[M+H-NH3]+':
+		return precursor_mz - ATOMS_WEIGHT['H'] + (ATOMS_WEIGHT['N'] + ATOMS_WEIGHT['H'] * 3)
+	elif precursor_type == '[M+H+NH3]+' or precursor_type == '[M+NH4]+':
+		return precursor_mz - ATOMS_WEIGHT['H'] - (ATOMS_WEIGHT['N'] + ATOMS_WEIGHT['H'] * 3)
+	elif precursor_type == '[M+H-CH2O2]+':
+		return precursor_mz - ATOMS_WEIGHT['H'] + (ATOMS_WEIGHT['C'] + ATOMS_WEIGHT['H'] * 2 + ATOMS_WEIGHT['O'] * 2)
+	elif precursor_type == '[M+H-CH4O2]+':
+		return precursor_mz - ATOMS_WEIGHT['H'] + (ATOMS_WEIGHT['C'] + ATOMS_WEIGHT['H'] * 4 + ATOMS_WEIGHT['O'] * 2)
+	elif precursor_type == '[M-H-CO2]-' or precursor_type == '[M-CHO2]-':
+		return precursor_mz + ATOMS_WEIGHT['H'] + (ATOMS_WEIGHT['C'] + ATOMS_WEIGHT['O'] * 2)
+	elif precursor_type == '[M-H-H2O]-':
+		return precursor_mz + ATOMS_WEIGHT['H'] + (ATOMS_WEIGHT['H'] * 2 + ATOMS_WEIGHT['O'])
+	else:
+		raise ValueError('Unsupported precursor type: {}'.format(precursor_type))
+
+if __name__ == '__main__':
+	# test sdf2mgf
+	spectra = sdf2mgf('../data/origin/Agilent_Combined.sdf', 'agilent_combine')
+	print('Number of spectra: {}'.format(len(spectra)))
+	for spec in spectra: 
+		if spec['params']['precursor_type'] == '[M-H]-':
+			print(spec)
+			break
+
+	# test filter_spec
+	config = {
+		'instrument_type': 'ESI-QTOF',
+		'instrument': ['Unknown'],
+		'ms_level': '2',
+		'atom_type': ['C', 'O', 'N', 'H', 'P', 'S', 'F', 'Cl', 'B', 'Br', 'I', 'Na', 'K'],
+		'precursor_type': ['[M+H]+', '[M-H]-'],
+		'min_mz': 50,
+		'max_mz': 1500,
+		'min_peak_num': 5,
+		'max_atom_num': 300,
+		'min_atom_num': 10,
+		'ppm_tolerance': 10
+	}
+	type2charge = {
+		'[M+H]+': 1,
+		'[M-H]-': -1
+	}
+	clean_spectra, smiles_list = filter_spec(spectra, config, type2charge)
+	print('Number of clean spectra: {}'.format(len(clean_spectra)))
+	print('Number of smiles: {}'.format(len(smiles_list)))
+	for spec in clean_spectra: 
+		if spec['params']['precursor_type'] == '[M-H]-':
+			print(spec)
+			break

msfiddle/utils/pkl_utils.py

@@ -0,0 +1,372 @@
+import numpy as np
+import re
+from decimal import Decimal
+from tqdm import tqdm
+import pandas as pd
+import random
+import copy
+
+from rdkit import Chem
+# ignore the warning
+from rdkit import RDLogger 
+RDLogger.DisableLog('rdApp.*')
+from rdkit.Chem import AllChem
+from rdkit.Chem.rdMolDescriptors import CalcMolFormula
+
+from .mol_utils import monoisotopic_mass_calculator, formula_to_dict, formula_to_vector, dict_to_formula, ATOMS_INDEX
+
+# ------------------------ Main Functions ------------------------
+
+def spec2arr(spectra, encoder): 
+    '''data format
+    [
+        {'title': <str>, 'formula': <numpy array>, 'env': <numpy array>, 'spec': <numpy array>}, 
+        {'title': <str>, 'formula': <numpy array>, 'env': <numpy array>, 'spec': <numpy array>}, 
+        ....
+    ]
+    '''
+    data = []
+    bad_data = []
+    for idx, spectrum in enumerate(tqdm(spectra)): 
+        data_item = spec2arr_single(spectrum, encoder)
+        if data_item != None: 
+            data.append(data_item)
+        else:
+            bad_data.append(spectrum['params']['title'])
+
+    return data, bad_data
+
+def spec2pair(data, bad_title, encoder): 
+    # Extract df of spectra index and smiles
+    df = {'index': [], 'smiles': []}
+    
+    for idx, data_item in enumerate(tqdm(data)): 
+        if data_item['title'] in bad_title: continue
+        
+        df['index'].append(idx)
+        df['smiles'].append(data_item['smiles'])
+    df = pd.DataFrame(df)
+    
+    # Extract positive pairs
+    print('Extracting positive and negative pairs...')
+    positive_pairs, negative_pairs = generate_pairs(df)
+
+    # Ensure balanced samples
+    num_samples = min(len(positive_pairs), len(negative_pairs))
+    sampled_positive_pairs = random.sample(positive_pairs, num_samples)
+    sampled_negative_pairs = random.sample(negative_pairs, num_samples)
+
+    # Convert pairs to dataframe
+    data_pairs = {'idx1': [], 'idx2': [], 'label': []}
+    for idx1, idx2 in sampled_positive_pairs:
+        data_pairs['idx1'].append(idx1)
+        data_pairs['idx2'].append(idx2)
+        data_pairs['label'].append(1)
+    for idx1, idx2 in sampled_negative_pairs:
+        data_pairs['idx1'].append(idx1)
+        data_pairs['idx2'].append(idx2)
+        data_pairs['label'].append(0)
+
+    return data_pairs
+
+# ------------------------ Helper Functions ------------------------
+
+def generate_pairs(df):
+    df_group = df.groupby('smiles')
+    groups = list(df_group.groups.values())
+
+    positive_pairs = set()
+    negative_pairs = set()
+
+    for _, row in tqdm(df.iterrows(), total=len(df)): 
+        group = df_group.get_group(row['smiles']) 
+
+        # Positive pair (from the same group)
+        if len(group) > 1:
+            positive_pair_candidates = list(set(group.index) - {row.name})
+            positive_pair = random.sample(positive_pair_candidates, 1)[0]
+            positive_pairs.add(tuple(sorted((row.name, positive_pair))))
+
+        # Negative pair (from a different group)
+        other_groups = [g for g in groups if row.name not in g]
+        if other_groups:
+            random_group = random.choice(other_groups)
+            negative_pair = random.choice(random_group)
+            negative_pairs.add(tuple(sorted((row.name, negative_pair))))
+
+    return positive_pairs, negative_pairs
+
+def spec2arr_single(spectrum, encoder): 
+    # convert molecular object to formula string
+    mol = Chem.MolFromSmiles(spectrum['params']['smiles'])
+    mol = Chem.AddHs(mol)
+    try: 
+        formula = CalcMolFormula(mol) # formula string
+    except: 
+        print('Failed to convert smiles to formula: {}'.format(spectrum['params']['smiles']))
+        return None
+    
+    charge = int(encoder['type2charge'][spectrum['params']['precursor_type']])
+
+    # spec array
+    good_spec, mz_array, int_array, spec_arr = generate_ms(x=spectrum['m/z array'], 
+                                        y=spectrum['intensity array'], 
+                                        precursor_mz=float(spectrum['params']['theoretical_precursor_mz']), 
+                                        resolution=encoder['resolution'], 
+                                        max_mz=encoder['max_mz'], 
+                                        charge=charge)
+    if not good_spec: 
+        print('Failed to generate mass spectra: {}'.format(spectrum['params']['title']))
+        return None # invalid spectra
+
+    # env array
+    adjust_formula, adjust_precursor_type = melt_neutral_precursor(formula, spectrum['params']['precursor_type'])
+    ce, nce = parse_collision_energy(ce_str=spectrum['params']['collision_energy'], 
+                            precursor_mz=float(spectrum['params']['theoretical_precursor_mz']), 
+                            charge=abs(charge))
+    if ce == None and nce == None: 
+        print('Failed to parse collision energy: \"{}\"'.format(spectrum['params']['collision_energy']))
+        return None # can not process '30-50 eV'
+    env_arr = np.array([float(spectrum['params']['theoretical_precursor_mz']), 
+                        nce, 
+                        encoder['precursor_type'][adjust_precursor_type]]) 
+    
+    # mass
+    # iso_mass = monoisotopic_mass_calculator(mol, mode='mol')
+    iso_mass = monoisotopic_mass_calculator(adjust_formula, mode='f')
+    
+    # formula array
+    formula_vec = formula_to_vector(adjust_formula)
+    f_arr = np.array(formula_vec)
+    
+    return {'title': spectrum['params']['title'], 
+            'smiles': spectrum['params']['smiles'],
+            'formula': f_arr.astype(np.float32), 
+            'mass': iso_mass, 
+            'charge': charge, 
+            'spec': spec_arr.astype(np.float32), 
+            'env': env_arr.astype(np.float32),
+            'mz': mz_array,
+            'intensity': int_array}
+
+def generate_ms(x, y, precursor_mz, resolution=1, max_mz=1500, charge=1): 
+    '''
+    Input:  x   [float list denotes the x-coordinate of peaks]
+            y   [float list denotes the y-coordinate of peaks]
+            precursor_mz    [float denotes the parent ion]
+            resolution      [float denotes the resolution of spectra]
+            max_mz          [integer denotes the maximum m/z value of spectra]
+            charge          [float denotes the charge of spectra]
+    Return: ms  [numpy array denotes the mass spectra]
+    '''
+    assert len(x) == len(y), 'The length of x and y should be the same.'
+
+    x, y = remove_precursor_isotopic_peaks(x, y, precursor_mz, charge, tolerance=resolution/10)
+    x = np.array(x)
+    y = np.array(y)
+    if len(x) == 0 or y.max() - y.min() == 0: 
+        return False, None, None, None
+
+    # (1) Smooth the MS/MS (no benefit)
+    # y = np.sqrt(y)
+    # (2) Sharpen the MS/MS
+    # y = y ** 2
+
+    # Prepare parameters using Decimal for precision
+    resolution = Decimal(str(resolution))
+    max_mz = Decimal(str(max_mz))
+    
+    # Initialize mass spectra vector with zeros
+    intensity_val = np.zeros(int(max_mz // resolution))
+    mz_val = np.zeros(int(max_mz // resolution)) # Save the max delta m/z falling this bin
+    
+    # Convert x, y to indices and accumulate in the mass spectra vector
+    for mz, intensity in zip(x, y): 
+        idx = int(round(Decimal(str(mz)) // resolution))
+        
+        intensity_val[idx] += intensity # Accumulate the intensity in the bin
+        if intensity_val[idx] < intensity: # Update the max delta m/z falling this bin
+            mz_val[idx] = mz
+            
+    # Normalize to 0-1 range
+    intensity_val = (intensity_val - intensity_val.min()) / (intensity_val.max() - intensity_val.min())
+
+    # Stack the arrays horizontally
+    stacked_ms = np.column_stack((intensity_val, mz_val))
+
+    return True, x, y, stacked_ms
+
+def remove_precursor_isotopic_peaks(x, y, precursor_mz, charge, tolerance=0.1):
+    # Calculate the spacing between isotopic peaks
+    spacing = 1 / abs(charge)
+    
+    # Generate theoretical isotopic peaks
+    max_isotopes = 5  # Typically, we consider up to 5 isotopic peaks for large molecules
+    theoretical_isotopic_peaks = [precursor_mz - i * spacing for i in range(max_isotopes)]
+    
+    # Identify isotopic peaks
+    isotopic_peaks = []
+    for value in x:
+        for theoretical_peak in theoretical_isotopic_peaks:
+            if abs(value - theoretical_peak) <= tolerance:
+                isotopic_peaks.append(value)
+                break
+    
+    # Remove isotopic peaks from x and y
+    filtered_x = []
+    filtered_y = []
+    for xi, yi in zip(x, y):
+        if xi not in isotopic_peaks:
+            filtered_x.append(xi)
+            filtered_y.append(yi)
+    
+    return filtered_x, filtered_y
+
+def parse_collision_energy(ce_str, precursor_mz, charge=1): 
+    # ratio constants for NCE
+    # charge = int(charge.lstrip('+').lstrip('-'))
+    charge_factor = {1: 1, 2: 0.9, 3: 0.85, 4: 0.8, 5: 0.75, 6: 0.75, 7: 0.75, 8: 0.75}
+
+    ce = None
+    nce = None
+    
+    # match collision energy (eV)
+    matches_ev = {
+        # NIST20
+        r"^[\d]+[.]?[\d]*$": lambda x: float(x), 
+        r"^[\d]+[.]?[\d]*[ ]?eV$": lambda x: float(x.rstrip(" eV")), 
+        r"^[\d]+[.]?[\d]*[ ]?ev$": lambda x: float(x.rstrip(" ev")), 
+        r"^[\d]+[.]?[\d]*[ ]?v$": lambda x: float(x.rstrip(" v")), 
+        r"^[\d]+[.]?[\d]*[ ]?V$": lambda x: float(x.rstrip(" V")), 
+        r"^NCE=[\d]+[.]?[\d]*% [\d]+[.]?[\d]*eV$": lambda x: float(x.split()[1].rstrip("eV")),
+        r"^nce=[\d]+[.]?[\d]*% [\d]+[.]?[\d]*ev$": lambda x: float(x.split()[1].rstrip("ev")),
+        # MassBank
+        r"^[\d]+[.]?[\d]*[ ]?V$": lambda x: float(x.rstrip(" V")), 
+        r"^hcd[\d]+[.]?[\d]*$": lambda x: float(x.lstrip('hcd')), 
+        r"^[\d]+HCD$": lambda x: float(x.rstrip("HCD")), # 35HCD
+    }
+    for k, v in matches_ev.items(): 
+        if re.match(k, ce_str): 
+            ce = v(ce_str)
+            break
+    # match collision energy (NCE)
+    matches_nce = {
+        # MassBank
+        r"^[\d]+[.]?[\d]*[ ]?[%]? \(nominal\)$": lambda x: float(x.rstrip('% (nominal)')), 
+        r"^[\d]+[.]?[\d]*[ ]?nce$": lambda x: float(x.rstrip(' nce')), 
+        r"^[\d]+[.]?[\d]*[ ]?\(nce\)$": lambda x: float(x.rstrip(' (nce)')), 
+        r"^NCE=[\d]+\%$": lambda x: float(x.lstrip('NCE=').rstrip('%')), 
+        r"^[\d]+[.]?[\d]*\([Nn][Cc][Ee]\)$": lambda x: float(x.split('(')[0]), # 90(NCE)
+        r"^HCD \(NCE [\d]+[.]?[\d]*%\)$": lambda x: float(x.split(' ')[-1].rstrip('%)')), # HCD (NCE 40%)
+        # CASMI
+        r"^[\d]+[.]?[\d]*[ ]?\(nominal\)$": lambda x: float(x.rstrip("(nominal)").rstrip(' ')), 
+    }
+    for k, v in matches_nce.items(): 
+        if re.match(k, ce_str): 
+            nce = v(ce_str) * 0.01
+            break
+    
+    # unknown collision energy
+    if ce_str == 'Unknown': 
+        ce = 40
+
+    if nce == None and ce != None: 
+        nce = ce * 500 * charge_factor[charge] / precursor_mz
+    elif ce == None and nce != None:
+        ce = nce * precursor_mz / (500 * charge_factor[charge])
+    else:
+        # raise Exception('Collision energy parse error: {}'.format(ce_str))
+        return None, None
+    return ce, nce
+
+def melt_neutral_precursor(formula, precursor_type): 
+    precursor_type = unify_precursor_type(precursor_type)
+
+    neutrue_list = ['H2O', 'NH3', 'CO2', 'CH4O2', 'CH2O2']
+    neutrue_counts = {}
+
+    # Step 1: Get the count of neutral losses/adducts
+    for neutrue in neutrue_list:
+        if neutrue in precursor_type:
+            pattern = r'([-+]?\d*)\b' + neutrue + r'\b'
+            matches = re.findall(pattern, precursor_type)
+            if matches: 
+                count = matches[0]
+                if count == '+': count = 1
+                elif count == '-': count = -1
+                else: 
+                    try: 
+                        count = int(count)
+                    except Exception as e:
+                        print('Get the count of neutral losses/adducts', e)
+                        print(precursor_type, neutrue, matches, count)
+                neutrue_counts[neutrue] = count
+                break # only one neutral adduct is allowed
+                
+    # Step 2: Remove neutral losses/adducts from the precursor type string
+    pattern = r'([-+]?\d*)(?:' + '|'.join(neutrue_list) + ')' + r'\b'
+    adjust_precursor_type = re.sub(pattern, '', precursor_type)
+
+    # Step 3: Add neutral losses/adducts to formula
+    f_dict = formula_to_dict(formula)
+    for neutrue, count in neutrue_counts.items():
+        n_dict = formula_to_dict(neutrue)
+        for k, v in n_dict.items():
+            if k in f_dict.keys():
+                try: 
+                    f_dict[k] += int(v) * count
+                except Exception as e:
+                    print('Add neutral losses/adducts to formula', e)
+                    print(f_dict, int(v) * count)
+            else:
+                f_dict[k] = int(v) * count
+    adjust_formula = dict_to_formula(f_dict)
+
+    return adjust_formula, adjust_precursor_type
+
+def unify_precursor_type(precursor_type): 
+    # +1+-neutrue
+    # '[M+H-H2O]+', '[M-H2O+H]+', '[M+H-2H2O]+', '[M+H-NH3]+', '[M+H+NH3]+', '[M+NH4]+', '[M+H-CH2O2]+', '[M+H-CH4O2]+'
+    # -1+-neutrue
+    # '[M-H-CO2]-', '[M-CHO2]-', '[M-H-H2O]-'
+    if precursor_type == '[M+NH4]+': return '[M+H+NH3]+'
+    elif precursor_type == '[M-CHO2]-': return '[M-H-CO2]-'
+    elif precursor_type == '[M-H2O+H]+': return '[M+H-H2O]+'
+    else: return precursor_type
+    
+
+
+if __name__ == '__main__':
+    # melt_neutral_precursor
+    formula = 'C12H14O2'
+    precursor_type = '[M+H-CH2O2]+'
+    adjust_formula, adjust_precursor_type = melt_neutral_precursor(formula, precursor_type)
+    print(adjust_formula, adjust_precursor_type)
+    print(formula_to_vector(adjust_formula))
+
+    # generate_ms
+    x = [128.0511, 128.0553, 129.0544, 129.0585, 130.0665, 130.0725]
+    y = [102.5, 2.3, 10.99, 1., 999., 22.68]
+    precursor_mz = 130.06564948176495
+    print('origin mz', x)
+    print('origin intensity', y)
+    resolution = 0.2
+    max_mz = 1500
+    charge = 1
+    good_ms, mz, intensity, ms = generate_ms(x, y, precursor_mz, resolution, max_mz, charge)
+    print(good_ms, ms)
+    print('mz', mz)
+    print('intensity', intensity)
+
+    x = [1447.98, 279.24, 695.48, 1446.97, 415.23, 29.69, 1446.89]
+    y = [1., 0.02231055, 0.02118375, 0.01257913, 0.01197476, 0.00163897, 0.]
+    precursor_mz = 1448.97222710619
+    print('origin mz', x)
+    print('origin intensity', y)
+    resolution = 1.
+    max_mz = 1500
+    charge = -1
+    good_ms, mz, intensity, ms = generate_ms(x, y, precursor_mz, resolution, max_mz, charge)
+    print(good_ms, ms)
+    print('mz', mz)
+    print('intensity', intensity)