It appears that all of the time is spent evaluating the harmonic when
the number of particles in large (say 1000). This makes sense as the
code was designed more for Frank's case where there are only a few
proteins of each type (and so the only quadratic steps were computing
all pairs between the particles representing a pair of proteins in the
LowestRefinedPairScore).
One option would be to use a ClosePairsScoreState and change the
connectivity restraint to get its pairs from that. Then the
connectivity restraint would only search through edges defined by
pairs in a PairContainer and then you can fill that however you want.
If you are lazy, then you just use an AllPairsPairContainer and
replicate the current behavior (module particle refiners, which would
have to be worked in another way). Comments?
On Jan 27, 2009, at 7:20 PM, Keren Lasker wrote:
just for the records,
Ben suggested compiling with release=true, which reduced the running
time to ~7 seconds.
I still think we should consider a faster implementation. Maybe use
geometric hashing to query close particles in space.
On Jan 26, 2009, at 9:43 PM, Keren Lasker wrote:
hi all,
I am writing a test case for adding hierarchy support in DOMINO,
and it seems that the connectivity restraint works incredibly
sssllllooowww between two proteins each of ~100 residues.
i=0
ub = IMP.core.HarmonicUpperBound(1.0, 0.1)
ss= IMP.core.DistancePairScore(ub)
r= IMP.core.ConnectivityRestraint(ss)
ps = IMP.Particles()
ps_refined=[]
for j in xrange(2):
ps.append(self.particles[i+j])
for e in ps_refined:
r.add_particles(e)
beg = time.time()
r.evaluate(None)
end = time.time()
dt = end - beg
print 'connectivity restraint calculation took %9.6f Seconds' % (dt)
The evaluate function takes ~20 seconds.
am I missing something here? is there a faster implementation using
some external library ?