bcl/example/descriptor/example_descriptor_molecule_complexity.cpp at master · BCLCommons/bcl · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
// (c) Copyright BCL @ Vanderbilt University 2014
// (c) BCL Homepage: http://www.meilerlab.org/bclcommons
// (c) BCL Code Repository: https://github.com/BCLCommons/bcl
// (c)
// (c) The BioChemical Library (BCL) was originally developed by contributing members of the Meiler Lab @ Vanderbilt University.
// (c)
// (c) The BCL is now made available as an open-source software package distributed under the permissive MIT license,
// (c) developed and maintained by the Meiler Lab at Vanderbilt University and contributing members of the BCL Commons.
// (c)
// (c) External code contributions to the BCL are welcome. Please visit the BCL Commons GitHub page for information on how you can contribute.
// (c)
// (c) This file is part of the BCL software suite and is made available under the MIT license.
// (c)

// include example header
#include "example.h"
// include the header of the class which this example is for
#include "descriptor/bcl_descriptor_molecule_complexity.h"

// includes from bcl - sorted alphabetically
#include "chemistry/bcl_chemistry_fragment_ensemble.h"
#include "io/bcl_io_file.h"

// external includes - sorted alphabetically

namespace bcl
{
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  //!
  //! @example example_descriptor_molecule_complexity.cpp
  //!
  //! @author geanesar, mendenjl
  //! @date Dec 29, 2014
  //! @remarks status complete
  //! @remarks reviewed by nobody on
  //!
  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  class ExampleDescriptorMoleculeComplexity :
    public ExampleInterface
  {
  public:

    ExampleDescriptorMoleculeComplexity *Clone() const
    {
      return new ExampleDescriptorMoleculeComplexity( *this);
    }

  /////////////////
  // data access //
  /////////////////

    //! @brief returns class name
    //! @return the class name as const ref std::string
    const std::string &GetClassIdentifier() const
    {
      return GetStaticClassName( *this);
    }

    int Run() const
    {
    //////////////////////////////////
    // construction and destruction //
    //////////////////////////////////

      // default constructor
      descriptor::MoleculeComplexity complexity;

      // copy constructor
      descriptor::MoleculeComplexity complexity_copy( complexity);

      // Clone/destruction
      util::ShPtr< descriptor::MoleculeComplexity> copy( util::CloneToShPtr( complexity));

    /////////////////
    // data access //
    /////////////////

      BCL_ExampleCheck( complexity.GetAlias(), "MoleculeComplexity");

      BCL_ExampleCheck( complexity.GetString(), "MoleculeComplexity");

    ///////////////
    // operators //
    ///////////////

      storage::Map< std::string, float> filenames_to_expected_complexity;

      // files names with expected maximum distances calculated using pymol
      filenames_to_expected_complexity[ "diazepam.sdf"] = 0.77;
      filenames_to_expected_complexity[ "taxol.sdf"] = 4.68;
      filenames_to_expected_complexity[ "hexane.sdf"] = 0.05;

      for
      (
        storage::Map< std::string, float>::const_iterator
        itr_files( filenames_to_expected_complexity.Begin()),
        itr_files_end( filenames_to_expected_complexity.End());
        itr_files != itr_files_end;
        ++itr_files
      )
      {
        // create input stream for reading a smallmolecule ensemble
        io::IFStream input;
        BCL_ExampleMustOpenInputFile( input, AddExampleInputPathToFilename( e_Chemistry, itr_files->first));
        // read in ensemble
        chemistry::FragmentEnsemble ensemble( input);
        // close stream
        io::File::CloseClearFStream( input);

        const chemistry::FragmentComplete &mol( *ensemble.Begin());

        BCL_ExampleIndirectCheckWithinAbsTolerance
        (
          complexity( mol)( 0),
          float( itr_files->second),
          0.01,
          "Calculating the complexity of molecules in " + itr_files->first
        );
      }

    //////////////////////
    // input and output //
    //////////////////////

      BCL_ExampleIndirectCheck
      (
        TestBCLObjectIOForSymmetry( complexity, complexity_copy),
        true,
        "MoleculeComplexity I/O"
      );

    //////////////////////
    // helper functions //
    //////////////////////

      return 0;
    } // Run

    static const ExampleClass::EnumType s_Instance;

  }; //end ExampleDescriptorMoleculeComplexity

  const ExampleClass::EnumType ExampleDescriptorMoleculeComplexity::s_Instance
  (
    GetExamples().AddEnum( ExampleDescriptorMoleculeComplexity())
  );

} // namespace bcl