def evaluate_molecule(molecule_id, project_id, depth_total, depth_last_match): from fragmentation.models import FragMolSample, FragAnnotationDB m = model_from_cache(Molecule, molecule_id) p = model_from_cache(SampleAnnotationProject, project_id) # check if sample exist with the same mass project_frag_sample = cache.get_or_set('project_frag_sample_' + str(p.id), p.frag_sample) fm_search_ids = [] ms1 = cache.get('project_ms1_not_init_' + str(project_id)) am = AdductManager(ion_charge=p.frag_sample.ion_charge) adducts_mass = np.array(am.adducts.mass).reshape((1, -1)) mass_exact = m.mass_exact() # + settings.PROTON_MASS diff_mass = abs(ms1[1].reshape((-1, 1)) - mass_exact - adducts_mass) mass_tol = mass_exact * float(p.frag_compare_conf.ppm_tolerance) * 10**-6 test = np.where(diff_mass <= mass_tol) # fm_search_ids = [(mol_id, adduct), ...] fm_search_ids = [(ms1[0][pos_idx], am.adducts.index[adduct_idx]) for pos_idx, adduct_idx in zip(test[0], test[1])] adducts = [am.adducts.index[adduct_idx] for adduct_idx in set(test[1])] p.add_process() tsk = evaluate_molecule_2.apply_async(args=[ m.id, fm_search_ids, adducts, project_id, depth_total, depth_last_match ], queue=settings.CELERY_RUN_QUEUE) p.close_process() return 0
def run_reaction_molecule(reactants_id, reaction_id, project_id, depth_total, depth_last_match): from metabolization.models import Reaction, ReactProcess from django.db.models import Count p = model_from_cache(SampleAnnotationProject, project_id) r = model_from_cache(Reaction, reaction_id) reactants_count = len(reactants_id) reactants_uniq_count = len(set(reactants_id)) if reactants_count == r.reactants_number: reactants = Molecule.objects\ .filter(id__in = reactants_id) rp_search = ReactProcess.objects\ .annotate(reactants_count=Count('reactants'))\ .filter( reaction = r, reactants_count = reactants_uniq_count) for m in reactants: rp_search = rp_search.filter(reactants__id=m.id) if rp_search.count() > 0: rp = rp_search.first() rp.wait_run_end() else: rp = ReactProcess.objects.create(reaction=r) for m_id in reactants_id: rp.reactants.add(Molecule.objects.get(id=m_id)) rp.save() rp.run_reaction().refresh_from_db() try: p.react_processes.add(rp) p.save() except: pass mols_ids = [m.id for m in rp.products.all()] grp_tsk = group( load_molecule.s(m_id, project_id, depth_total, depth_last_match) for m_id in mols_ids) p.add_process(len(mols_ids)) grp_tsk() # if missing 2nd reactant, react with each molecule that has already match elif reactants_count == 1 and r.reactants_number == 2: mols_ids = [m.id for m in p.molecules_init_and_matching()] grp_tsk = group(\ run_reaction_molecule.s(\ [reactants_id [0], m_id], r.id, project_id, depth_total, depth_last_match ) \ for m_id in mols_ids ) p.add_process(len(mols_ids)) grp_tsk() p.close_process() return 0
def load_molecule(molecule_id, project_id, depth_total, depth_last_match): p = model_from_cache(SampleAnnotationProject, project_id) molecules_ids = cache.get('project_molecules_all_' + str(project_id)) if not molecule_id in molecules_ids: molecules_ids.append(molecule_id) m = model_from_cache(Molecule, molecule_id) try: p.molecules.add(m) p.save() added = True cache.set('project_molecules_all_' + str(p.id), molecules_ids, None) except: added = False if added: p.add_process() tsk = evaluate_molecule.apply_async( args=[molecule_id, project_id, depth_total, depth_last_match], queue=settings.CELERY_RUN_QUEUE) p.close_process() return 0
def evaluate_molecule(molecule_id, project_id, depth_total, depth_last_match): from fragmentation.models import FragMolSample, FragAnnotationDB m = model_from_cache(Molecule, molecule_id) p = model_from_cache(SampleAnnotationProject, project_id) # check if sample exist with the same mass project_frag_sample = cache.get_or_set('project_frag_sample_' + str(p.id), p.frag_sample) fm_search_ids = [] #for mass_exact in m.mass_exact_isotopes(): #mass_exact += 1.007 #for mass_exact in [m.mass_exact()]: mass_exact = m.mass_exact() + settings.PROTON_MASS mass_var = float(p.frag_compare_conf.ppm_tolerance) * 10**-6 mass_window = (mass_exact * (1 - mass_var), mass_exact * (1 + mass_var)) ms1 = cache.get('project_ms1_not_init_' + str(project_id)) pos_id_min, pos_id_max = (np.searchsorted(ms1[1], mw) for mw in mass_window) fm_search_ids = ms1[0][pos_id_min:pos_id_max] p.add_process() tsk = evaluate_molecule_2.apply_async( args=[m.id, fm_search_ids, project_id, depth_total, depth_last_match], queue=settings.CELERY_RUN_QUEUE) p.close_process() return 0
def evaluate_molecule_2(molecule_id, fm_search_ids, adducts, project_id, depth_total, depth_last_match): from fragmentation.models import FragMolSample, FragAnnotationCompare from fragmentation.modules import FragSim, FragCompare m = model_from_cache(Molecule, molecule_id) p = model_from_cache(SampleAnnotationProject, project_id) # If mass match, frag molecule and check if frag match match = False if len(fm_search_ids) > 0: # fm_search_ids can be = 0 for ghost metabolites ### Fragmentation fsim = FragSim(p.frag_sim_conf) fmsim = {} for adduct in adducts: fmsim[adduct] = fsim.frag_molecule( m, adduct, ion_charge=p.frag_sample.ion_charge) ### Compare with each sample of same mass fcomp = FragCompare(p.frag_compare_conf) for fmsample_id, adduct in fm_search_ids: fmsample = FragMolSample.objects.get(id=fmsample_id) fac_search = FragAnnotationCompare.objects.filter( project=p, frag_mol_sample=fmsample, molecule=m) if fac_search.count() == 0: fac = FragAnnotationCompare.objects.create( project=p, frag_mol_sample=fmsample, molecule=m) fmcomp = fcomp.compare_frag_mols([fmsim[adduct], fmsample]) fac.frag_mol_compare = fmcomp fac.save() match = fmcomp.match # Metabolize molecule under conditions if ( (depth_total + 1) < p.depth_total ) \ and ( match or (depth_last_match < p.depth_last_match) ): depth_total += 1 if match: depth_last_match = 0 else: depth_last_match += 1 p.add_process() tsk = run_reactions_molecule.apply_async( args=[molecule_id, project_id, depth_total, depth_last_match], queue=settings.CELERY_RUN_QUEUE) p.close_process() return 0
def run_reactions_molecule(molecule_id, project_id, depth_total, depth_last_match): m = model_from_cache(Molecule, molecule_id) p = model_from_cache(SampleAnnotationProject, project_id) grp_tsk = group(\ run_reaction_molecule.s([molecule_id], r.id, project_id, depth_total, depth_last_match) \ for r in p.reactions_conf.reactions.all() ) p.add_process(p.reactions_conf.reactions.count()) grp_tsk() p.close_process() return 0
def finish_run(project_id): project = model_from_cache(Project, project_id) queue = settings.CELERY_LOG_QUEUE log_project.s(project_id, { "message": "run finished" }).apply_async(queue=queue) project.finish_run()
def evaluate_molecule(molecule_id, project_id, depth_total, depth_last_match): from fragmentation.models import FragMolSample, FragAnnotationDB molecule = model_from_cache(Molecule, molecule_id) project = SampleAnnotationProject.objects.get(id=project_id) if project.is_stopped(): project.close_process() return "project stopped" log_message = { "task": "evaluate_molecule", "opts": { "molecule_id": molecule_id, "smiles": molecule.smiles(), }, } # check if sample exist with the same mass fm_search_ids = [] ms1 = cache.get("project_ms1_not_init_" + str(project_id)) am = AdductManager(ion_charge=project.frag_sample.ion_charge) adducts_mass = np.array(am.adducts.mass).reshape((1, -1)) mass_exact = molecule.mass_exact() # + settings.PROTON_MASS diff_mass = abs(ms1[1].reshape((-1, 1)) - mass_exact - adducts_mass) mass_tol = mass_exact * float( project.frag_compare_conf.ppm_tolerance) * 10**-6 test = np.where(diff_mass <= mass_tol) # fm_search_ids = [(mol_id, adduct), ...] fm_search_ids = [(ms1[0][pos_idx], am.adducts.index[adduct_idx]) for pos_idx, adduct_idx in zip(test[0], test[1])] adducts = [am.adducts.index[adduct_idx] for adduct_idx in set(test[1])] log_message["opts"].update({ "fm_search_ids": fm_search_ids, "adducts": adducts }) log_to_file(project_id, log_message) project.add_process() tsk = evaluate_molecule_2.apply_async( kwargs={ "molecule_id": molecule.id, "fm_search_ids": fm_search_ids, "adducts": adducts, "project_id": project_id, "depth_total": depth_total, "depth_last_match": depth_last_match, }, queue=settings.CELERY_RUN_QUEUE, ) project.close_process() return 0
def load_molecule(molecule_id, project_id, depth_total, depth_last_match): project = SampleAnnotationProject.objects.get(id=project_id) if project.is_stopped(): project.close_process() return "project stopped" molecules_ids = cache.get("project_molecules_all_" + str(project_id)) if not molecule_id in molecules_ids: molecules_ids.append(molecule_id) molecule = model_from_cache(Molecule, molecule_id) try: project.molecules.add(molecule) project.save() added = True cache.set("project_molecules_all_" + str(project_id), molecules_ids, None) except: added = False if added: project.add_process() tsk = evaluate_molecule.apply_async( kwargs={ "molecule_id": molecule_id, "project_id": project_id, "depth_total": depth_total, "depth_last_match": depth_last_match, }, queue=settings.CELERY_RUN_QUEUE, ) project.close_process() return 0
def run_reaction_molecule(reactants_id, reaction_id, project_id, depth_total, depth_last_match): from metabolization.models import Reaction, ReactProcess from django.db.models import Count project = SampleAnnotationProject.objects.get(id=project_id) if project.is_stopped(): project.close_process() return "project stopped" reaction = model_from_cache(Reaction, reaction_id) log_message = { "task": "run_reaction_molecule", "opts": { "reaction_id": reaction_id, "smarts": reaction.smarts, "reaction_name": reaction.name, }, } reactants_count = len(reactants_id) reactants_uniq_count = len(set(reactants_id)) if reactants_count == reaction.reactants_number: reactants = Molecule.objects.filter(id__in=reactants_id) log_message["opts"].update( {"reactants": {r.id: r.smiles() for r in reactants.all()}}) rp_search = ReactProcess.objects.annotate( reactants_count=Count("reactants")).filter( reaction=reaction, reactants_count=reactants_uniq_count) for m in reactants: rp_search = rp_search.filter(reactants__id=m.id) if rp_search.count() > 0: log_message.update({"message": "reaction already processed"}) rp = rp_search.first() rp.wait_run_end() else: rp = ReactProcess.objects.create(reaction=reaction) for m_id in reactants_id: rp.reactants.add(Molecule.objects.get(id=m_id)) # reactants_smiles = rp.save() rp.run_reaction().refresh_from_db() try: project.react_processes.add(rp) project.save() except: pass log_message["opts"].update( {"products": {r.id: r.smiles() for r in rp.products.all()}}) log_to_file(project_id, log_message) mols_ids = [m.id for m in rp.products.all()] grp_tsk = group( load_molecule.s( m_id, project_id=project_id, depth_total=depth_total, depth_last_match=depth_last_match, ) for m_id in mols_ids) project.add_process(len(mols_ids)) grp_tsk() # if missing 2nd reactant, react with each molecule that has already match elif reactants_count == 1 and reaction.reactants_number == 2: mols_ids = [m.id for m in project.molecules_init_and_matching()] grp_tsk = group( run_reaction_molecule.s( reactants_id=[reactants_id[0], m_id], reaction_id=reaction.id, project_id=project_id, depth_total=depth_total, depth_last_match=depth_last_match, ) for m_id in mols_ids) project.add_process(len(mols_ids)) grp_tsk() project.close_process() return 0
def evaluate_molecule_2(molecule_id, fm_search_ids, adducts, project_id, depth_total, depth_last_match): from fragmentation.models import FragMolSample, FragAnnotationCompare from fragmentation.modules import FragSim, FragCompare molecule = model_from_cache(Molecule, molecule_id) project = SampleAnnotationProject.objects.get(id=project_id) if project.is_stopped(): project.close_process() return "project stopped" fmsamples = [(FragMolSample.objects.get(id=fmsample_id), adduct) for fmsample_id, adduct in fm_search_ids] ion_ids = [(str(fms.ion_id), adduct) for fms, adduct in fmsamples] log_message = { "task": "evaluate_molecule_2", "opts": { "molecule_id": molecule_id, "smiles": molecule.smiles(), "fm_search_ids": fm_search_ids, "ion_ids": ion_ids, "adducts": adducts, }, } # If mass match, frag molecule and check if frag match match = False if len(fm_search_ids) > 0: # fm_search_ids can be = 0 for ghost metabolites ### Fragmentation fsim = FragSim(project.frag_sim_conf) fmsim = {} for adduct in adducts: fmsim[adduct] = fsim.frag_molecule( molecule, adduct, ion_charge=project.frag_sample.ion_charge) ### Compare with each sample of same mass fcomp = FragCompare(project.frag_compare_conf) for fmsample_id, adduct in fm_search_ids: fmsample = FragMolSample.objects.get(id=fmsample_id) fac_search = FragAnnotationCompare.objects.filter( project=project, frag_mol_sample=fmsample, molecule=molecule) if fac_search.count() == 0: fac = FragAnnotationCompare.objects.create( project=project, frag_mol_sample=fmsample, molecule=molecule) fmcomp = fcomp.compare_frag_mols([fmsim[adduct], fmsample]) fac.frag_mol_compare = fmcomp fac.save() match = fmcomp.match log_message["opts"].update({ "match": str(match), "cosine": fmcomp.cosine }) log_to_file(project_id, log_message) # Metabolize molecule under conditions if ((depth_total + 1) < project.depth_total) and ( match or (depth_last_match < project.depth_last_match)): depth_total += 1 if match: depth_last_match = 0 else: depth_last_match += 1 project.add_process() tsk = run_reactions_molecule.apply_async( args=[molecule_id, project_id, depth_total, depth_last_match], queue=settings.CELERY_RUN_QUEUE, ) project.close_process() return 0
def finish_run(project_id): p = model_from_cache(Project, project_id) p.finish_run()
def log_project(project_id, data): project = model_from_cache(Project, project_id) project.log_to_file(data)