• RE: distance constraint from fixed cofactor to substrate (ligand to be docked)

    Dear Hector,

    I will send you a download link when the release is out.

    Best regards,

    Ilenia

     

  • RE: distance constraint from fixed cofactor to substrate (ligand to be docked)

    Dear Hector,

    First of all, apologies for the inconvenience this is causing you. We appreciate the time you are spending on it and we really value your feedback.


    One of the developers on our side fixed the bug you reported and it will be available with the upcoming November release. I hope that's not too long for you to be considered as an option.

    The fix still requires the atom to be accessed directly from the protein and to be unique. You can perhaps identify it by using other information than the label (e.g. coordinates).

    Let me know if there is anything else I can help with.

    Thank you very much again for all your feedback.

    Best regards,
    Ilenia

  • RE: distance constraint from fixed cofactor to substrate (ligand to be docked)

    Dear Hector,

    Thank you for your post.

    I did look at my output files, and indeed, those generated with the CSD Python API look similar to yours. The protein module currently treats cofactors as ligand molecules and therefore when the constraint is written out to the api_gold.conf file it will call the wrong atom indices. 

    I've informed the developers team and they will be working on a fix for this issue.

    In the meantime, could you use this rather suboptimal solution?

    • Access the right atom index with the command:

    >>>cofactor_atom = protein.atom('H4N')

    As before there must be a unique instance of this label for it to work.

    • Edit the api_gold.conf file to replace the word "ligand" with "protein"

    e.g. in my case change: 

    constraint distance ligand 5081 ligand 33 3.5000 1.5000 5.0000 off

    to 

    constraint distance protein 5081 ligand 33 3.5000 1.5000 5.0000 off

    I hope this helps.

    Best regards,

    Ilenia

     

  • RE: distance constraint from fixed cofactor to substrate (ligand to be docked)

    Dear Hector,

    Thank you for letting us know. I hope you now have a working setup to perform your docking calculation with GOLD.

    Best regards,

    Ilenia

  • RE: distance constraint from fixed cofactor to substrate (ligand to be docked)

    Dear Hector,

    The way you are setting up a distance constraint looks correct to me. The only thing I'd suggest is to make sure you are calling the right atom label. Please find below a code snippet where I accessed the same atom but in two different ways (from the protein or from the binding site) and the atom label was different, too. This is due to the fact that new objects are created:

    from ccdc.docking import Docker
    from ccdc.io import MoleculeReader
    from ccdc.protein import Protein

    docker = Docker()
    settings = docker.settings
    protein_file = 'protein.mol2'
    settings.add_protein_file(protein_file)

    ligand_file = 'ligand.mol2'
    settings.add_ligand_file(ligand_file,10)

    protein = settings.proteins[0]

    settings.fitness_function = 'plp'
    settings.autoscale = 10.
    settings.output_directory = 'output'
    settings.output_file = 'docked_ligands.mol2'

    settings.binding_site = settings.BindingSiteFromPoint(protein, (15.672, -6.014, 18.132), 10.0)
    print settings.binding_site.ligands[0].identifier, protein.ligands[0].identifier
    #option 1
    #cofactor_atom = [a for a in settings.binding_site.ligands[0].atoms if a.label=="H4N"][0]
    #option 2
    cofactor_atom = [a for a in protein.ligands[0].atoms if a.label=="H23"][0]

    ### distance constraint
    ligand_atom = [a for a in MoleculeReader(ligand_file)[0].atoms if a.label=="C32"][0]
    settings.add_constraint(settings.DistanceConstraint(cofactor_atom, ligand_atom))

    results = docker.dock()

     

    I hope it helps.

    Best regards,

    Ilenia

  • RE: Differing results between mogul and API

    Hi Dave,

    Sorry for the delay in getting back to you, but I've just seen this post.

    There are a few things to clarify here.

    1) CSD data

    The CSD Python API, by default, uses the November release of the database, but is is possible to add multiple libraries to the calculation (e.g. the CSD updates) if you want to. 

    To have consistent results I've changed the Mogul settings in Mercury from CSD-System --> Mogul Settings... where in the Include library column I've selected only CSD 5.37.

    2) Standardisation of aromatic and delocalised bonds

    It is important to standardise your input molecule according to CSD conventions. Mogul does it automatically, while in the API you need two additional lines of code:

     

     

    -------------------------------------------------------------------------------------------------------------------------------------

    from ccdc.io import MoleculeReader
    from ccdc.conformer import GeometryAnalyser

    mol = MoleculeReader('test2_3d_opt.sdf')[0]
    mol.standardise_aromatic_bonds()
    mol.standardise_delocalised_bonds()

    geometry_analysed_mol = engine.analyse_molecule(mol)

    for b in geometry_analysed_mol.analysed_bonds:
        print b.atom_labels , b.atom_indices , b.value , b.mean , b.median , b.z_score , b.generalised , b.nhits

    -------------------------------------------------------------------------------------------------------------------------------------

    I hope that helps.

    Best wishes,

    Ilenia

     

     

  • RE: Finding structures that contain two molecules that are different in protonation state only

    Hi Marko,

    I've recently tackled a similar problem, but I was only interested in two-component structures in the CSD. The approach I followed made use of the SubstructureSearch functionality and is summarised below:

    1. Search the CSD to find all two-components structures that are organic and have 3D coordinates, and store resulting refcodes in a .gcd file for future usage
    2. Split each entry in its heaviest component and smallest component
    3. Create and save a Substructure Screen of all heaviest components (please note that this functionality will be available with the November release of the CSD Python API, but it helped to speed up the search)
    4. Create a dictionary of the smallest components (key: CSD identifier, value: Molecule object of the component). A Substructure Screen can be used here, too.
    5. Perform the substructure search:
      1. Start by using the heaviest component as a query
      2. Loop over all the “heavy_hits” and check that the smallest component is the same as the one in the query. Used the dictionary created above in this step.

    N.B. I check that query and hit have the same number of heavy atoms. However, it’s likely that you get false positives, as in same cases query and hit differ in stereochemistry rather than in the number of hydrogen atoms.

    I hope that helps.

    Regards,

    Ilenia