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
|
// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
#include <BALL/CONCEPT/classTest.h>
#include <BALLTestConfig.h>
///////////////////////////
#include <BALL/STRUCTURE/sdGenerator.h>
#include <BALL/QSAR/ringPerceptionProcessor.h>
#include <BALL/STRUCTURE/ringAnalyser.h>
#include <BALL/FORMAT/MOLFile.h>
#include <BALL/FORMAT/PDBFile.h>
///////////////////////////
START_TEST(SDGenerator)
/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
using namespace BALL;
using namespace std;
PRECISION(0.001)
SDGenerator* sdg;
CHECK(SDGenerator())
sdg = new SDGenerator;
TEST_NOT_EQUAL(sdg, 0)
RESULT
CHECK(~SDGenerator())
delete sdg;
RESULT
SDGenerator sdg_2;
System molecule_sys;
PDBFile infile(BALL_TEST_DATA_PATH(input_SDGenerator_test.pdb));
infile >> molecule_sys;
infile.close();
CHECK((pair<Atom*, Atom*> getNeighbours(vector<Atom*>& ring, Atom*& atom)))
vector<Atom*> ring;
for (AtomIterator atom_it = molecule_sys.beginAtom(); atom_it != molecule_sys.endAtom(); atom_it++)
{
ring.push_back(&*atom_it);
}
pair<Atom*, Atom*> neighbours = sdg_2.getNeighbours(ring, ring[1]);
TEST_EQUAL(neighbours.first, ring[0])
TEST_EQUAL(neighbours.second, ring[2])
RESULT
for (AtomIterator atom_it = molecule_sys.beginAtom(); atom_it != molecule_sys.endAtom(); atom_it++)
{
atom_it -> setProperty(SDGenerator::IN_RING);
}
// get the "smallest set of smallest rings" (SSSR)
vector<vector<Atom*> > sssr;
// call the implementation of Figueras algorithm
RingPerceptionProcessor getRings;
getRings.RingPerceptionProcessor::calculateSSSR(sssr, molecule_sys);
vector<vector<Atom*> > unseq_ringsys = sssr;
RingAnalyser ra;
CHECK(vector<vector<Atom*> sequenceRings(vector<vector<Atom*> >& ringsystem))
vector<vector<Atom*> > seq_ringsys;
ra.sequenceRings(sssr, seq_ringsys);
for (Size i = 0; i != seq_ringsys[0].size(); i++)
{
if(i > 0 && i < seq_ringsys[0].size())
{
if(seq_ringsys[0][i-1] == sdg_2.getNeighbours(seq_ringsys[0], seq_ringsys[0][i]).first)
{
TEST_EQUAL(seq_ringsys[0][i-1], sdg_2.getNeighbours(seq_ringsys[0], seq_ringsys[0][i]).first)
}
else if(seq_ringsys[0][i-1] == sdg_2.getNeighbours(seq_ringsys[0], seq_ringsys[0][i]).second)
{
TEST_EQUAL(seq_ringsys[0][i-1], sdg_2.getNeighbours(seq_ringsys[0], seq_ringsys[0][i]).second)
}
else if(seq_ringsys[0][i+1] = sdg_2.getNeighbours(seq_ringsys[0], seq_ringsys[0][i]).first)
{
TEST_EQUAL(seq_ringsys[0][i+1], sdg_2.getNeighbours(seq_ringsys[0], seq_ringsys[0][i]).first)
}
else
{ //if none of the previous cases was true, this one must be, otherwise sequenceRings() has failed
TEST_EQUAL(seq_ringsys[0][i+1], sdg_2.getNeighbours(seq_ringsys[0], seq_ringsys[0][i]).second)
}
}
}
RESULT
System molecule_sys_2;
PDBFile infile_2(BALL_TEST_DATA_PATH(input_SDGenerator_test_2a.pdb));
infile_2 >> molecule_sys_2;
infile.close();
System molecule_sys_3;
PDBFile infile_3(BALL_TEST_DATA_PATH(input_SDGenerator_test_2b.pdb));
infile_3 >> molecule_sys_3;
infile_3.close();
CHECK(void generateSD(System& molecule_sys))
sdg_2.generateSD(molecule_sys_2);
vector<Atom*> mol_1;
vector<Atom*> mol_2;
AtomIterator atom_it_1;
AtomIterator atom_it_2;
for (atom_it_1 = molecule_sys_3.beginAtom(); atom_it_1 != molecule_sys_3.endAtom(); atom_it_1++)
{
for (atom_it_2 = molecule_sys_2.beginAtom(); atom_it_2 != molecule_sys_2.endAtom(); atom_it_2++)
{
if(atom_it_1 -> getName() == atom_it_2 -> getName())
{
TEST_REAL_EQUAL(atom_it_1 -> getPosition()[1], atom_it_2 -> getPosition()[1]);
}
}
}
RESULT
END_TEST
|
