Sure, sorry...

This is the function that is visible from python and the one that the
python code calls:

static PyObject * IMFind (PyObject *self, PyObject *args, PyObject
*kwargs) {

        //Array for the detection of the parameters coming from Python
        static char *kwlist[] =
{"shareInt","root","prefix","lowerLimit",NULL};
        //Root protein code
        char *root;
        //Pefix for the output file
        char *prefix;
        //Incoming Python object
        PyObject *shareIntPy;
        //Number of proteins at level two from the root, that will appear in
the iMotifs' proteins
        int *pSize = new int;
        //Maximum number of common interactors
        int *max = new int;
        //Set relating each protein (integer) with their interactors...
        set<unsigned int>** shareInt;
        //Lower limit for iMotif search
        int lowLim;
        //Vector for the seed iMotifs from an specific threshold
        vector<iMotif> IMseed;
        //Vector of all the working iMotifs during the identification process
        vector<iMotif> IMarray;

        //Receiving data from python
        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Ossi", kwlist,
&shareIntPy, &root, &prefix,&lowLim)) {
                cerr << "Error in parameter transference from python to iMotif 
C++
module"<<endl;
                return Py_BuildValue("");
        }

        //The position of the name in the vector corresponds to the number by
which it is represented
        //Here we take the info coming from python and transform it
into a vector (will allow us to work with numbers instead of
        // strings) and shareInt which is an array of sets (form
std::set)
        vector<string> translator = string2int
(shareIntPy,root,shareInt,pSize,max);

        //Loop for iMotif search at threshold thr till the specified lower
limit
        for (int thr = *max; thr >= lowLim; thr--) {
                cout << "Checking threshold " << thr << endl;

                //Specifying the output file name
                stringstream filename;
                filename << prefix << "." << thr;

                //Getting the seed iMotifs for this threshold
                IMseed = getSeedIM(shareInt,*pSize,thr);

                //Adding the new seeds (if any) to those obtained from previous
rounds...
                if (!IMseed.size()) {
                        IMseed.clear();
                        vector<iMotif>().swap(IMseed); //This is how I try to 
free them
now, size & capacity gets to 0, but the
                                                       // memory is
not freed...
                } else {
                        
IMarray.insert(IMarray.end(),IMseed.begin(),IMseed.end());
                        IMseed.clear();
                        vector<iMotif>().swap(IMseed);
                }

                //Fuse those iMotifs sharing thr interactors
                // It also deletes the IMarray before giving it the
new data in the same way as I use here for IMseed
                processIMVector(IMarray,thr);
                writeIMVector(IMarray,translator,filename.str());

        }

        return Py_BuildValue("");
}

The object iMotif used here is composed by 2 sets and 3 strings just
like this: (the access is done by setters and getters)

class iMotif {
private:
        //Set of the proteins that shares the iMotif with the root
        set<unsigned int> proteins;
        //Set of the proteins to which the iMotifs interacts
        set<unsigned int> interactors;
        //iMotifs interactors signature
        string MD5Interactor;
        //iMotifs proteins signature
        string MD5Proteins;
        //Real MD5 according to the sequences names
        string signature;
...
}
and I specified the destructor as:
iMotif::~iMotif() {

        this->proteins.clear();
        set<unsigned int>().swap(this->proteins);

        this->interactors.clear();
        set<unsigned int>().swap(this->proteins);

}

The call to the function from python goes like this:

iMotifs.IMFind(shareInt=intersections_dict,
root=options.protein_problem, prefix=prefixOutFile, lowerLimit=1);

where intersections_dict is a dictionary and options.protein_problem
and prefixOutFile are strings. There is nothing to return from C++ to
python, the result is directly printed into several files.

Thanks,
J
--
http://mail.python.org/mailman/listinfo/python-list

Reply via email to