main page namespaces classes files
CPSP home

src/cpsp/HPThreadingOptions.hh

Go to the documentation of this file.

/*
 *  Main authors:
 *     Martin Mann http://www.bioinf.uni-freiburg.de/~mmann/
 *
 *  Contributing authors:
 *     Sebastian Will http://www.bioinf.uni-freiburg.de/~will/
 *
 *  Copyright:
 *     Martin Mann, 2007
 *
 *  This file is part of the CPSP-tools package:
 *     http://www.bioinf.uni-freiburg.de/sw/cpsp/
 *
 *  See the file "LICENSE" for information on usage and
 *  redistribution of this file, and for a
 *     DISCLAIMER OF ALL WARRANTIES.
 *
 */

#ifndef THREADINGOPTIONS_HH_
#define THREADINGOPTIONS_HH_

#include "cpsp/Exception.hh"
#include <biu/OptionParser.hh>
#include <string>
#include <map>
#include <biu/LatticeDescriptor.hh>
#include <biu/LatticeFrame.hh>
#include "cpsp/HCoreDatabase.hh"

namespace cpsp
{

    class HPThreadingOptions
    {
    public:
        
        enum CORESELECTS { FIRST, ALL_BEST, ALL };          // steuert kernauswahl
    
    private:
    
        void initAllowedArguments(biu::OptionMap & allowedArgs,
                                            std::string &infoText ) const;
        std::string*            sequence;
        
        const biu::LatticeDescriptor*   latDescr;
        
        biu::LatticeFrame*      lattice;
        
        CORESELECTS             coreSelection;
            
        int                     minE, maxE;
        
        unsigned int            maxSols;
        
        std::vector<unsigned int>   hullLvl;
        
        unsigned int            maxPCoreDistance;
        
        HCoreDatabase*          coreDB;
        
        enum SeqFeatures{ P_SINGLET, H_SINGLET };
        
        typedef std::map< int, std::vector <unsigned int> > FeatureMap;
        
        FeatureMap  seqFeatureMap;
        
        bool        onlyCountingStructures;
        
        bool        verboseOutput;
        
        unsigned int    minEvenOddHs;
        
        unsigned int    contactsInSeq;

        bool useSymmetryBreaking;
        
        bool useNoDDS;
        
        bool normalizeStructures;
        
    public:
        HPThreadingOptions(int argc, char** argv) 
            throw(cpsp::Exception);
        HPThreadingOptions();
        
        virtual ~HPThreadingOptions();
        
        


        const std::string* const 
        getSequence() const { return sequence; }
        unsigned int setSequence(const std::string &seq) throw(cpsp::Exception);

        const bool
        getUseSymmetryBreaking() const { return useSymmetryBreaking; }
        void setUseSymmetryBreaking(bool val) { useSymmetryBreaking = val; }
        
        const bool
        getUseNoDDS() const { return useNoDDS; }
        void setUseNoDDS(bool val) { useNoDDS = val; }
        
        const biu::LatticeFrame* const 
        getLattice() const { return lattice; }
        void setLattice(biu::LatticeFrame* lat) { lattice = lat; latDescr = lat->getDescriptor();}
        
        const CORESELECTS 
        getCoreSelection() const { return coreSelection; }
        void setCoreSelection(CORESELECTS cs) { coreSelection = cs; }
        
        const int 
        getMinimalEnergy() const { return minE; }
        void setMinimalEnergy(int val) { minE = val; }
        
        const int 
        getMaximalEnergy() const { return maxE; }
        void setMaximalEnergy(int val) { maxE = val;}
        
        const unsigned int 
        getMaximalSolutions() const { return maxSols; }
        void setMaximalSolutions(unsigned int val) { maxSols = val; }
        
        const std::vector<unsigned int> *const 
        getHullLevel() const { 
            return &hullLvl; 
        }
        
        const unsigned int 
        getMaxPCoreDistance() const { 
            return maxPCoreDistance; 
        }
        
        void 
        setLatticeFrameSize(const unsigned int newFrameSize) {
            assert(lattice != NULL);
            lattice->setFrameSize(newFrameSize);
        }
        
        HCoreDatabase* 
        getHCoreDB(void) { return coreDB; }
        void setHCoreDB(HCoreDatabase* db) {assert(db!=NULL); coreDB = db; }
        
        unsigned int 
        getNumOfPSinglets(void) { 
            return seqFeatureMap[P_SINGLET].size(); 
        }

        unsigned int 
        getNumOfHSinglets(void) { 
            return seqFeatureMap[H_SINGLET].size(); 
        }
        
        std::vector <unsigned int>& 
        getPSinglets(void) { 
            return seqFeatureMap[P_SINGLET];
        }

        std::vector <unsigned int>& 
        getHSinglets(void) { 
            return seqFeatureMap[H_SINGLET];
        }
        
        bool 
        countingMode(void) { return onlyCountingStructures; }
        bool countingMode(bool newVal) { onlyCountingStructures = newVal; return onlyCountingStructures; }
        
        bool 
        verboseOut(void) { return verboseOutput; }
        bool verboseOut(bool newVal) { verboseOutput = newVal; return verboseOutput; }
        
        unsigned int 
        getMinEvenOddHs(void) { return minEvenOddHs; }
        
        unsigned int
        getContactsInSequence(void) { return contactsInSeq; }
        
        void 
        setNormalizeStructures( const bool val ) { normalizeStructures = val; }
        const bool
        getNormalizeStructures( void ) const { return normalizeStructures; }
        
    };

} // namespace cpsp

#endif /*THREADINGOPTIONS_HH_*/