Hi all,

I am currently implementing a restraint in C++ with the goal of providing similar functionality as the fuzzyRestraint in pmi/restraints/proteomics with better efficiency.

I have come up with the following design (see code excerpts bellow):

A pure virtual base FuzzyRestraint class that implements the interface.

Several child classes that inherit from that and perform the fuzzy logic calculation (ie OR, AND, NOT).

For example, given two restraints r1,r2, I could instantiate a FuzzyOr r3=r1|r2;

My issue is the following: whenever I chain more that two operands (for example r=r1|r2|r3|r4), I get a segfault in the do_get_inputs. I believe this is due to the class containing pointers, but I didn't specify a copy constructor, assignment operator, and destructor to handle these operations without corrupting my memory/loosing information.

I know if I was writing standard c++ that's what i'd have to do, but I admit that I am a bit lost when it comes to IMP due to the entanglement with python and automatic memory management.

So my question is:

1/ Do you agree that my issue comes from that shallow copy ?

2/ Is there a functionality in IMP to handle such a case ?

Thanks,

sam hanot

class IMPPMIEXPORT FuzzyRestraint;
class IMPPMIEXPORT FuzzyOr;
class IMPPMIEXPORT FuzzyRestraint : public Restraint {
public:
FuzzyRestraint(Model *m, std::string name) : Restraint(m, name) {}
virtual double unprotected_evaluate(DerivativeAccumulator *) const = 0;
virtual ModelObjectsTemp do_get_inputs() const = 0;
FuzzyOr *operator|(FuzzyRestraint *r);
IMP_OBJECT_METHODS(FuzzyRestraint);
};

class IMPPMIEXPORT FuzzyOr : public FuzzyRestraint {
FuzzyRestraint *r1_;
FuzzyRestraint *r2_;

public:
FuzzyOr(Model *m, FuzzyRestraint *r1, FuzzyRestraint *r2)
      : FuzzyRestraint(m, "FuzzyOr %1%"), r1_(r1), r2_(r2) {
    std::cerr << "Creating FuzzyOr from " << r1_->get_name() << " (" << r1_
              << ") " << r2_->get_name() << " (" << r2_ << ") "
              << ": " << get_name() << '\n';
}
virtual double unprotected_evaluate(DerivativeAccumulator *) const
      IMP_OVERRIDE {
    Model *m(get_model());
    double const a(r1_->unprotected_evaluate(nullptr));
    double const b(r2_->unprotected_evaluate(nullptr));
    return exp(-a) + exp(-b) - exp(-a - b);
}
virtual ModelObjectsTemp do_get_inputs() const IMP_OVERRIDE {
    ModelObjectsTemp ret(r1_->get_inputs());
    ModelObjectsTemp const tmp(r2_->get_inputs());
    ret.insert(ret.end(), tmp.begin(), tmp.end());
    return ret;
}
IMP_OBJECT_METHODS(FuzzyOr);
};

FuzzyOr *FuzzyRestraint::operator|(FuzzyRestraint *r) {
IMP_NEW(IMP::pmi::FuzzyOr, ret, (get_model(), this, r));
return ret.release();
}