Index: kernel/test/pair_scores/test_transform.py =================================================================== --- kernel/test/pair_scores/test_transform.py (revision 0) +++ kernel/test/pair_scores/test_transform.py (revision 0) @@ -0,0 +1,96 @@ +import unittest +import IMP.utils +import IMP.test, IMP + +class DistanceTests(IMP.test.TestCase): + """Test the symmetry restraint""" + def test_symmetry(self): + """Test the transform pair score basics""" + IMP.set_log_level(IMP.VERBOSE) + m= IMP.Model() + p0= IMP.Particle() + m.add_particle(p0) + d0= IMP.XYZDecorator.create(p0) + p1= IMP.Particle() + m.add_particle(p1) + d1= IMP.XYZDecorator.create(p1) + tps= IMP.TransformedDistancePairScore(IMP.Harmonic(0,1)) + tps.set_translation(0,1,0) + tps.set_rotation(1, 0, 0, + 0, 1, 0, + 0, 0, 1) + d0.set_coordinates(IMP.Vector3D(2,3,4)) + d1.set_coordinates(IMP.Vector3D(2,2,4)) + self.assertEqual(tps.evaluate(p0, p1, None), 0) + self.assert_(tps.evaluate(p1, p0, None) != 0) + tps.set_center(10,13,4) + self.assertEqual(tps.evaluate(p0, p1, None), 0) + self.assert_(tps.evaluate(p1, p0, None) != 0) + tps.set_center(0,0,0) + print "test rotation" + tps.set_rotation(0, 0,-1, + 0, 1, 0, + 1, 0, 0) + d1.set_coordinates(IMP.Vector3D(4, 2, -2)) + self.assertEqual(tps.evaluate(p0, p1, None), 0) + self.assert_(tps.evaluate(p1, p0, None) != 0) + tps.set_translation(0,0,0) + tps.set_rotation(0,-1, 0, + 1, 0, 0, + 0, 0, 1) + d0.set_coordinates(IMP.Vector3D(0,1,0)) + d1.set_coordinates(IMP.Vector3D(1,1,0)) + # clear derivs + print "test derivs" + m.evaluate(True) + tps.evaluate(p0, p1, IMP.DerivativeAccumulator(1)) + print d0.get_coordinate_derivative(0) + print d0.get_coordinate_derivative(1) + print d0.get_coordinate_derivative(2) + print d1.get_coordinate_derivative(0) + print d1.get_coordinate_derivative(1) + print d1.get_coordinate_derivative(2) + self.assert_(d0.get_coordinate_derivative(0) > 0) + self.assert_(d0.get_coordinate_derivative(1) == 0) + self.assert_(d0.get_coordinate_derivative(2) == 0) + self.assert_(d1.get_coordinate_derivative(1) > 0) + self.assert_(d1.get_coordinate_derivative(0) == 0) + self.assert_(d1.get_coordinate_derivative(2) == 0) + def test_symmetry2(self): + """Test the transform pair score optimization""" + IMP.set_log_level(IMP.VERBOSE) + m= IMP.Model() + p0= IMP.Particle() + m.add_particle(p0) + d0= IMP.XYZDecorator.create(p0) + p1= IMP.Particle() + m.add_particle(p1) + d1= IMP.XYZDecorator.create(p1) + d0.set_coordinates(IMP.Vector3D(2,3,4)) + d1.set_coordinates(IMP.Vector3D(20,20,40)) + d0.set_coordinates_are_optimized(True) + d1.set_coordinates_are_optimized(True) + tps= IMP.TransformedDistancePairScore(IMP.Harmonic(0,1)) + tps.set_translation(0,1,0) + tps.set_rotation(1, 0, 0, + 0, 0,-1, + 0, 1, 0) + pr= IMP.PairListRestraint(tps) + pr.add_particle_pair(IMP.ParticlePair(p0, p1)) + m.add_restraint(pr) + cg= IMP.ConjugateGradients() + cg.set_model(m) + cg.optimize(100) + d0.show() + d1.show() + vt= IMP.Vector3D(d1.get_vector()*IMP.Vector3D(1,0,0)+0, + d1.get_vector()*IMP.Vector3D(0,0,-1)+1, + d1.get_vector()*IMP.Vector3D(0,1,0)+0) + print "trans" + print str(vt[0]) + " " + str(vt[1])+" " + str(vt[2]) + self.assertEqual(vt[0], d0.get_coordinate(0)) + self.assertEqual(vt[1], d0.get_coordinate(1)) + self.assertEqual(vt[2], d0.get_coordinate(2)) + +if __name__ == '__main__': + unittest.main() Index: kernel/include/IMP/singleton_scores/DistanceToSingletonScore.h =================================================================== --- kernel/include/IMP/singleton_scores/DistanceToSingletonScore.h (revision 620) +++ kernel/include/IMP/singleton_scores/DistanceToSingletonScore.h (working copy) @@ -31,6 +31,7 @@ virtual void show(std::ostream &out=std::cout) const; }; + } // namespace IMP #endif /* __IMP_DISTANCE_TO_SINGLETON_SCORE_H */ Index: kernel/include/IMP/decorators/XYZDecorator.h =================================================================== --- kernel/include/IMP/decorators/XYZDecorator.h (revision 620) +++ kernel/include/IMP/decorators/XYZDecorator.h (working copy) @@ -71,6 +71,13 @@ DerivativeAccumulator &d) { get_particle()->add_to_derivative(get_coordinate_key(i), v, d); } + //! Add something to the derivative of the coordinates + void add_to_coordinates_derivative(const Vector3D& v, + DerivativeAccumulator &d) { + add_to_coordinate_derivative(0, v[0], d); + add_to_coordinate_derivative(1, v[1], d); + add_to_coordinate_derivative(2, v[2], d); + } //! Get whether the coordinates are optimized /** \return true only if all of them are optimized. */ Index: kernel/include/IMP/pair_scores/SConscript =================================================================== --- kernel/include/IMP/pair_scores/SConscript (revision 620) +++ kernel/include/IMP/pair_scores/SConscript (working copy) @@ -2,7 +2,8 @@ Import('env') files = ['DistancePairScore.h', 'SphereDistancePairScore.h', - 'RefineOncePairScore.h', 'TypedPairScore.h'] + 'RefineOncePairScore.h', 'TypedPairScore.h', + 'TransformedDistancePairScore.h'] # Install the include files: includedir = os.path.join(env['includedir'], 'IMP', 'pair_scores') Index: kernel/include/IMP/pair_scores/DistancePairScore.h =================================================================== --- kernel/include/IMP/pair_scores/DistancePairScore.h (revision 620) +++ kernel/include/IMP/pair_scores/DistancePairScore.h (working copy) @@ -29,20 +29,6 @@ virtual void show(std::ostream &out=std::cout) const; }; -namespace internal -{ - -//! An internal helper function for evaluating distance potentials -/** The function applies f to scale*(distance-offset). - */ -Float evaluate_distance_pair_score(Particle *a, Particle *b, - DerivativeAccumulator *da, - UnaryFunction *f, - Float offset, - Float scale); - -} // namespace internal - } // namespace IMP #endif /* __IMP_DISTANCE_PAIR_SCORE_H */ Index: kernel/include/IMP/pair_scores/TransformedDistancePairScore.h =================================================================== --- kernel/include/IMP/pair_scores/TransformedDistancePairScore.h (revision 0) +++ kernel/include/IMP/pair_scores/TransformedDistancePairScore.h (revision 0) @@ -0,0 +1,52 @@ +/** + * \file TransformedDistancePairScore.h + * \brief A Score on the distance between a pair of particles. + * + * Copyright 2007-8 Sali Lab. All rights reserved. + */ + +#ifndef __IMP_TRADISTANCE_PAIR_SCORE_H +#define __IMP_TRADISTANCE_PAIR_SCORE_H + +#include "../PairScore.h" +#include "../UnaryFunction.h" +#include "../Pointer.h" +#include "../Vector3D.h" + +namespace IMP +{ + +/** + \brief Apply a function to the distance between two particles + after transforming the first + + Apply a transform to the second particle and then apply the unary + function to the distance between the transformed particle and the + second. This can be used to implement symmetry restraints. + + The second particle, x, is transformed as R*(x-center)+ translation+center + + \ingroup pairscore + */ +class IMPDLLEXPORT TransformedDistancePairScore : public PairScore +{ + Pointer f_; + Vector3D tc_, c_; + Vector3D r_[3], ri_[3]; + public: + TransformedDistancePairScore(UnaryFunction *f); + virtual ~TransformedDistancePairScore(){} + virtual Float evaluate(Particle *a, Particle *b, + DerivativeAccumulator *da); + virtual void show(std::ostream &out=std::cout) const; + + void set_rotation(float r00, float r01, float r02, + float r10, float r11, float r12, + float r20, float r21, float r22); + void set_translation(float t0, float t1, float t2); + void set_center(float t0, float t1, float t2); +}; + +} // namespace IMP + +#endif /* __IMP_TRADISTANCE_PAIR_SCORE_H */ Index: kernel/include/IMP/internal/SConscript =================================================================== --- kernel/include/IMP/internal/SConscript (revision 620) +++ kernel/include/IMP/internal/SConscript (working copy) @@ -5,7 +5,8 @@ 'ref_counting.h', 'ObjectContainer.h', 'ParticleGrid.h', 'kernel_version_info.h', 'constants.h', 'units.h', 'utility.h', 'bbox_nbl_helpers.h', - 'ArrayOnAttributesHelper.h', 'Unit.h', 'ExponentialNumber.h'] + 'ArrayOnAttributesHelper.h', 'Unit.h', 'ExponentialNumber.h', + 'evaluate_distance_pair_score.h'] # Install the include files: includedir = os.path.join(env['includedir'], 'IMP', 'internal') Index: kernel/include/IMP/internal/units.h =================================================================== --- kernel/include/IMP/internal/units.h (revision 620) +++ kernel/include/IMP/internal/units.h (working copy) @@ -119,6 +119,8 @@ typedef Multiply::type, Centimeter>::type CubicCentimeter; typedef Divide::type GramPerCubicCentimeter; +typedef Shift::type NanoSecond; +typedef Shift::type FemtoSecond; Index: kernel/include/IMP/internal/evaluate_distance_pair_score.h =================================================================== --- kernel/include/IMP/internal/evaluate_distance_pair_score.h (revision 0) +++ kernel/include/IMP/internal/evaluate_distance_pair_score.h (revision 0) @@ -0,0 +1,76 @@ +/** + * \file evaluate_distance_pair_score.h + * \brief A Score on the distance between a pair of particles. + * + * Copyright 2007-8 Sali Lab. All rights reserved. + */ + +#ifndef IMP_EVALUTE_DISTANCE_PAIR_SCORE_H +#define IMP_EVALUTE_DISTANCE_PAIR_SCORE_H + +#include "../Vector3D.h" + +namespace IMP +{ + +namespace internal +{ + +template +Float evaluate_distance_pair_score(W0 d0, W1 d1, + DerivativeAccumulator *da, + UnaryFunction *f, + SD sd) +{ + static const Float MIN_DISTANCE = .00001; + IMP_CHECK_OBJECT(f); + //IMP_CHECK_OBJECT(a); + //IMP_CHECK_OBJECT(b); + + Float d2 = 0; + Vector3D delta; + Float score; + + /*IMP_IF_CHECK(CHEAP) { + XYZDecorator::cast(a); + XYZDecorator::cast(b); + }*/ + + //XYZDecorator d0(a); + //XYZDecorator d1(b); + for (int i = 0; i < 3; ++i) { + delta[i] = d0.get_coordinate(i) - d1.get_coordinate(i); + d2 += square(delta[i]); + } + + Float distance = std::sqrt(d2); + + Float shifted_distance = sd(distance); //scale*(distance - offset); + + // if needed, calculate the partial derivatives of the scores with respect + // to the particle attributes + // avoid division by zero if the distance is too small + if (da && distance >= MIN_DISTANCE) { + Float deriv; + + score = f->evaluate_deriv(shifted_distance, deriv); + + Vector3D d= delta/distance *deriv; + //for (int i = 0; i < 3; ++i) { + // Float d = delta[i] / distance * deriv; + d0.add_to_coordinates_derivative(d, *da); + d1.add_to_coordinates_derivative(-d, *da); + //} + } else { + // calculate the score based on the distance feature + score = f->evaluate(shifted_distance); + } + + return score; +} + +} // namespace internal + +} // IMP + +#endif Index: kernel/include/IMP/Vector3D.h =================================================================== --- kernel/include/IMP/Vector3D.h (revision 620) +++ kernel/include/IMP/Vector3D.h (working copy) @@ -65,6 +65,20 @@ operator[](2) * s); } + //! product with scalar + Vector3D operator/(Float s) const { + return Vector3D(operator[](0) / s, + operator[](1) / s, + operator[](2) / s); + } + + //! negation + Vector3D operator-() const { + return Vector3D(-operator[](0), + -operator[](1), + -operator[](2)); + } + //! \return the vector product of two vectors. /** \param[in] vec2 The other vector to use in the product. */ @@ -106,7 +120,7 @@ operator[](2) + o[2]); } - void show(std::ostream &out) const { + void show(std::ostream &out=std::cout) const { out << "(" << operator[](0) << ", " << operator[](1) << ", " << operator[](2) << ")"; } Index: kernel/include/IMP.h =================================================================== --- kernel/include/IMP.h (revision 620) +++ kernel/include/IMP.h (working copy) @@ -60,6 +60,7 @@ #include "IMP/pair_scores/SphereDistancePairScore.h" #include "IMP/pair_scores/RefineOncePairScore.h" #include "IMP/pair_scores/TypedPairScore.h" +#include "IMP/pair_scores/TransformedDistancePairScore.h" #include "IMP/singleton_scores/DistanceToSingletonScore.h" #include "IMP/singleton_scores/AttributeSingletonScore.h" #include "IMP/triplet_scores/AngleTripletScore.h" Index: kernel/src/singleton_scores/DistanceToSingletonScore.cpp =================================================================== --- kernel/src/singleton_scores/DistanceToSingletonScore.cpp (revision 620) +++ kernel/src/singleton_scores/DistanceToSingletonScore.cpp (working copy) @@ -8,60 +8,19 @@ #include "IMP/singleton_scores/DistanceToSingletonScore.h" #include "IMP/decorators/XYZDecorator.h" #include "IMP/UnaryFunction.h" +#include "IMP/internal/evaluate_distance_pair_score.h" +#include namespace IMP { -namespace internal -{ +struct StaticD { + Vector3D v_; + StaticD(Vector3D v): v_(v){} + Float get_coordinate(unsigned int i) {return v_[i];} + void add_to_coordinates_derivative(Vector3D, DerivativeAccumulator){} +}; -static const Float MIN_DISTANCE = .00001; -Float evaluate_distance_to_singleton_score(const Vector3D &v, - Particle *b, - DerivativeAccumulator *da, - UnaryFunction *f, - Float offset, - Float scale) -{ - IMP_CHECK_OBJECT(f); - IMP_CHECK_OBJECT(b); - - Float d2 = 0, delta[3]; - Float score; - - XYZDecorator d1 = XYZDecorator::cast(b); - - for (int i = 0; i < 3; ++i) { - delta[i] = v[i] - d1.get_coordinate(i); - d2 += square(delta[i]); - } - - Float distance = std::sqrt(d2); - - Float shifted_distance = scale*(distance - offset); - - // if needed, calculate the partial derivatives of the scores with respect - // to the particle attributes - // avoid division by zero if the distance is too small - if (da && distance >= MIN_DISTANCE) { - Float deriv; - - score = f->evaluate_deriv(shifted_distance, deriv); - - for (int i = 0; i < 3; ++i) { - Float d = delta[i] / distance * deriv; - d1.add_to_coordinate_derivative(i, -d, *da); - } - } else { - // calculate the score based on the distance feature - score = f->evaluate(shifted_distance); - } - - return score; -} - -} // namespace internal - DistanceToSingletonScore::DistanceToSingletonScore(UnaryFunction *f, const Vector3D &v): f_(f), pt_(v){} @@ -69,8 +28,9 @@ Float DistanceToSingletonScore::evaluate(Particle *b, DerivativeAccumulator *da) { - return internal::evaluate_distance_to_singleton_score(pt_,b, da, - f_.get(), 0,1); + return internal::evaluate_distance_pair_score(XYZDecorator(b), + StaticD(pt_), da, + f_.get(), boost::lambda::_1); } void DistanceToSingletonScore::show(std::ostream &out) const Index: kernel/src/restraints/BondDecoratorRestraint.cpp =================================================================== --- kernel/src/restraints/BondDecoratorRestraint.cpp (revision 620) +++ kernel/src/restraints/BondDecoratorRestraint.cpp (working copy) @@ -11,6 +11,9 @@ #include "IMP/score_states/BondDecoratorListScoreState.h" #include "IMP/decorators/bond_decorators.h" #include "IMP/pair_scores/DistancePairScore.h" +#include "IMP/internal/evaluate_distance_pair_score.h" +#include "IMP/decorators/XYZDecorator.h" +#include namespace IMP { @@ -47,11 +50,11 @@ } if (pa && pb) { sum+= - internal::evaluate_distance_pair_score(pa, - pb, + internal::evaluate_distance_pair_score(XYZDecorator(pa), + XYZDecorator(pb), accum, f_.get(), - l, s); + s*(boost::lambda::_1-l)); } } return sum; Index: kernel/src/pair_scores/DistancePairScore.cpp =================================================================== --- kernel/src/pair_scores/DistancePairScore.cpp (revision 620) +++ kernel/src/pair_scores/DistancePairScore.cpp (working copy) @@ -8,72 +8,26 @@ #include "IMP/pair_scores/DistancePairScore.h" #include "IMP/decorators/XYZDecorator.h" #include "IMP/UnaryFunction.h" +#include "IMP/internal/evaluate_distance_pair_score.h" +#include namespace IMP { -namespace internal -{ +DistancePairScore::DistancePairScore(UnaryFunction *f): f_(f){} -static const Float MIN_DISTANCE = .00001; -Float evaluate_distance_pair_score(Particle *a, Particle *b, - DerivativeAccumulator *da, - UnaryFunction *f, - Float offset, - Float scale) +struct Identity { - IMP_CHECK_OBJECT(f); - IMP_CHECK_OBJECT(a); - IMP_CHECK_OBJECT(b); + Float operator()(Float t) const {return t;} +}; - Float d2 = 0, delta[3]; - Float score; - - IMP_IF_CHECK(CHEAP) { - XYZDecorator::cast(a); - XYZDecorator::cast(b); - } - - XYZDecorator d0(a); - XYZDecorator d1(b); - for (int i = 0; i < 3; ++i) { - delta[i] = d0.get_coordinate(i) - d1.get_coordinate(i); - d2 += square(delta[i]); - } - - Float distance = std::sqrt(d2); - - Float shifted_distance = scale*(distance - offset); - - // if needed, calculate the partial derivatives of the scores with respect - // to the particle attributes - // avoid division by zero if the distance is too small - if (da && distance >= MIN_DISTANCE) { - Float deriv; - - score = f->evaluate_deriv(shifted_distance, deriv); - - for (int i = 0; i < 3; ++i) { - Float d = delta[i] / distance * deriv; - d0.add_to_coordinate_derivative(i, d, *da); - d1.add_to_coordinate_derivative(i, -d, *da); - } - } else { - // calculate the score based on the distance feature - score = f->evaluate(shifted_distance); - } - - return score; -} - -} // namespace internal - -DistancePairScore::DistancePairScore(UnaryFunction *f): f_(f){} - Float DistancePairScore::evaluate(Particle *a, Particle *b, DerivativeAccumulator *da) { - return internal::evaluate_distance_pair_score(a,b, da, f_.get(), 0,1); + return internal::evaluate_distance_pair_score(XYZDecorator(a), + XYZDecorator(b), + da, f_.get(), + boost::lambda::_1); } void DistancePairScore::show(std::ostream &out) const Index: kernel/src/pair_scores/SConscript =================================================================== --- kernel/src/pair_scores/SConscript (revision 620) +++ kernel/src/pair_scores/SConscript (working copy) @@ -1,7 +1,8 @@ Import('env') files = ['DistancePairScore.cpp', 'SphereDistancePairScore.cpp', - 'RefineOncePairScore.cpp', 'TypedPairScore.cpp'] + 'RefineOncePairScore.cpp', 'TypedPairScore.cpp', + 'TransformedDistancePairScore.cpp'] files = [File(x) for x in files] Return('files') Index: kernel/src/pair_scores/TransformedDistancePairScore.cpp =================================================================== --- kernel/src/pair_scores/TransformedDistancePairScore.cpp (revision 0) +++ kernel/src/pair_scores/TransformedDistancePairScore.cpp (revision 0) @@ -0,0 +1,140 @@ +/** + * \file TransformedDistancePairScore.cpp + * \brief A Score on the distance between a pair of particles. + * + * Copyright 2007-8 Sali Lab. All rights reserved. + */ + +#include "IMP/pair_scores/TransformedDistancePairScore.h" +#include "IMP/decorators/XYZDecorator.h" +#include "IMP/UnaryFunction.h" +#include "IMP/decorators/XYZDecorator.h" +#include "IMP/internal/evaluate_distance_pair_score.h" +#include + + +namespace IMP +{ + +static void inverse(float r00, float r01, float r02, + float r10, float r11, float r12, + float r20, float r21, float r22, + Vector3D *inv) { + Float t4 = r00*r11; + Float t6 = r00*r12; + Float t8 = r01*r10; + Float t10 = r02*r10; + Float t12 = r01*r20; + Float t14 = r02*r20; + Float t17i = (t4*r22-t6*r21-t8*r22+t10*r21+t12*r12-t14*r11); + IMP_check(t17i != 0, "Singular matrix", ValueException); + Float t17= 1.0/t17i; + inv[0][0] = (r11*r22-r12*r21)*t17; + inv[0][1] = -(r01*r22-r02*r21)*t17; + inv[0][2] = (r01*r12-r02*r11)*t17; + inv[1][0] = -(r10*r22-r12*r20)*t17; + inv[1][1] = (r00*r22-t14)*t17; + inv[1][2] = -(t6-t10)*t17; + inv[2][0] = (r10*r21-r11*r20)*t17; + inv[2][1] = -(r00*r21-t12)*t17; + inv[2][2] = (t4-t8)*t17; +} + +TransformedDistancePairScore +::TransformedDistancePairScore(UnaryFunction *f): f_(f), + tc_(0,0,0), + c_(0,0,0) +{ + set_rotation(1,0,0, + 0,1,0, + 0,0,1); +} + + +/* + Compute R(x-c)+tc and the reverse + dt= R(d-c)+tc-> Rt(dt-tc)+c + */ +struct TransformParticle +{ + const Vector3D *r_, *ri_; + const Vector3D &tc_; + const Vector3D &c_; + XYZDecorator d_; + TransformParticle(const Vector3D *r, + const Vector3D *ri, + const Vector3D &tc, + const Vector3D &c, + Particle *p): r_(r), ri_(ri), + tc_(tc), c_(c), d_(p){} + + Float get_coordinate(unsigned int i) const { + return (d_.get_vector()-c_)*r_[i] + tc_[i]; + } + + void add_to_coordinates_derivative(const Vector3D& f, + DerivativeAccumulator &da) { + Vector3D r(f*ri_[0], + f*ri_[1], + f*ri_[2]); + d_.add_to_coordinates_derivative(r, da); + } +}; + +Float TransformedDistancePairScore::evaluate(Particle *a, Particle *b, + DerivativeAccumulator *da) +{ + TransformParticle tb(r_,ri_, tc_,c_,b); + IMP_LOG(VERBOSE, "Transformed particle is " + << tb.get_coordinate(0) << " " << tb.get_coordinate(1) + << " " << tb.get_coordinate(2) << std::endl); + return internal::evaluate_distance_pair_score(XYZDecorator(a), + tb, + da, f_.get(), + boost::lambda::_1); +} + + +void TransformedDistancePairScore::set_rotation(float r00, float r01, float r02, + float r10, float r11, float r12, + float r20, float r21, float r22) +{ + // do in two steps in case inverse throws an exception + Vector3D v[3]; + inverse(r00, r01, r02, + r10, r11, r12, + r20, r21, r22, + v); + r_[0]= Vector3D(r00, r01, r02); + r_[1]= Vector3D(r10, r11, r12); + r_[2]= Vector3D(r20, r21, r22); + ri_[0]= v[0]; + ri_[1]= v[1]; + ri_[2]= v[2]; + IMP_LOG(VERBOSE, "Rotation is \n" << r_[0] << "\n" << r_[1] << "\n" + << r_[2] << "\nand inverse is \n" + << ri_[0] << "\n" << ri_[1] << "\n" + << ri_[2] << std::endl); +} + +void TransformedDistancePairScore::set_translation(float t0, float t1, float t2) +{ + tc_= Vector3D(t0, t1, t2) + c_; +} + + +void TransformedDistancePairScore::set_center(float t0, float t1, float t2) +{ + tc_= tc_-c_; + c_= Vector3D(t0, t1, t2); + tc_= tc_+c_; +} + + +void TransformedDistancePairScore::show(std::ostream &out) const +{ + out << "TransformedDistancePairScore using "; + f_->show(out); +} + +} // namespace IMP Index: kernel/src/pair_scores/SphereDistancePairScore.cpp =================================================================== --- kernel/src/pair_scores/SphereDistancePairScore.cpp (revision 620) +++ kernel/src/pair_scores/SphereDistancePairScore.cpp (working copy) @@ -8,6 +8,9 @@ #include "IMP/pair_scores/SphereDistancePairScore.h" #include "IMP/UnaryFunction.h" #include "IMP/pair_scores/DistancePairScore.h" +#include "IMP/decorators/XYZDecorator.h" +#include "IMP/internal/evaluate_distance_pair_score.h" +#include "boost/lambda/lambda.hpp" namespace IMP { @@ -18,6 +21,13 @@ { } +struct Shift +{ + Float s_; + Shift(Float s): s_(s){} + Float operator()(Float t) const {return t-s_;} +}; + Float SphereDistancePairScore::evaluate(Particle *a, Particle *b, DerivativeAccumulator *da) { @@ -29,8 +39,10 @@ ValueException); Float ra = a->get_value(radius_); Float rb = b->get_value(radius_); - return internal::evaluate_distance_pair_score(a,b, da, f_.get(), - ra+rb, 1); + return internal::evaluate_distance_pair_score(XYZDecorator(a), + XYZDecorator(b), + da, f_.get(), + boost::lambda::_1-(ra+rb)); } void SphereDistancePairScore::show(std::ostream &out) const Index: kernel/pyext/IMP.i =================================================================== --- kernel/pyext/IMP.i (revision 620) +++ kernel/pyext/IMP.i (working copy) @@ -81,6 +81,9 @@ %pythonprepend DistancePairScore::DistancePairScore %{ args[0].thisown=0 %} + %pythonprepend TransformedDistancePairScore::TransformedDistancePairScore %{ + args[0].thisown=0 + %} %pythonprepend BondCoverPairScore::BondCoverPairScore %{ args[0].thisown=0 %} @@ -216,6 +219,7 @@ %include "IMP/pair_scores/RefineOncePairScore.h" %include "IMP/pair_scores/SphereDistancePairScore.h" %include "IMP/pair_scores/TypedPairScore.h" +%include "IMP/pair_scores/TransformedDistancePairScore.h" %include "IMP/particle_refiners/BondCoverParticleRefiner.h" %include "IMP/particle_refiners/ChildrenParticleRefiner.h" %include "IMP/singleton_scores/DistanceToSingletonScore.h"