pdb.hpp

/*
  This file is part of LOOS.
 
  LOOS (Lightweight Object-Oriented Structure library)
  Copyright (c) 2008, Tod D. Romo, Alan Grossfield
  Department of Biochemistry and Biophysics
  School of Medicine & Dentistry, University of Rochester
 
  This package (LOOS) is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation under version 3 of the License.
 
  This package is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
 
 
 
#if !defined(LOOS_PDB_HPP)
#define LOOS_PDB_HPP
 
 
 
 
#include <iostream>
#include <fstream>
#include <stdexcept>
#include <vector>
#include <map>
 
#include <loos_defs.hpp>
#include <AtomicGroup.hpp>
#include <exceptions.hpp>
#include <pdb_remarks.hpp>
#include <cryst.hpp>
#include <utils.hpp>
#include <utils_structural.hpp>
 
 
 
namespace loos {
 
 
    class PDB : public AtomicGroup {
    public:
        PDB() : _max_index(0), _show_charge(false), _auto_ter(true), _has_cryst(false),
                strictness_policy(false), _missing_q(false), _missing_b(false),
                _missing_segid(false), _fname("<not set>") { }
        virtual ~PDB() {}
      
        explicit PDB(const std::string& fname) 
            : _max_index(0), _show_charge(false), _auto_ter(true),
              _has_cryst(false), strictness_policy(false),
              _missing_q(false), _missing_b(false), _missing_segid(false),
              _fname(fname)
        {
            std::ifstream ifs(fname.c_str());
            if (!ifs)
                throw(FileOpenError(fname));
            read(ifs);
        }
      
        explicit PDB(std::istream& ifs) 
            : _max_index(0), _show_charge(false), _auto_ter(true),
              _has_cryst(false), strictness_policy(false),
              _missing_q(false), _missing_b(false), _missing_segid(false),              
              _fname("stream")
        {
            read(ifs);
        }
      
        static pAtomicGroup create(const std::string& fname) {
            return(pAtomicGroup(new PDB(fname)));
        }
 
        virtual PDB* clone(void) const;
 
        PDB copy(void) const;
 
 
        static PDB fromAtomicGroup(const AtomicGroup&);
 
        void showCharge(bool b);
 
 
        bool showCharge(void) const;
        bool strict(void) const;
        bool autoTerminate(void) const;
 
        void strict(const bool b);
 
 
        void autoTerminate(bool b);
 
        Remarks& remarks(void);
        void remarks(const Remarks&);
 
        const UnitCell& unitCell(void);
        void unitCell(const UnitCell&);
 
        friend std::ostream& operator<<(std::ostream&, const PDB&);
 
        std::string asString() const;
 
        void read(std::istream& is);
 
    private:
        class ComparePatoms {
            bool operator()(const pAtom& a, const pAtom& b) { return(a->id() < b->id()); }
        };
 
 
        PDB(const AtomicGroup& grp) : AtomicGroup(grp), _show_charge(false), _auto_ter(true), _has_cryst(false) { }
 
        bool emptyString(const std::string&);
 
    bool isMissingOccupancies() const { return(_missing_q); }
    bool isMissingBFactors() const { return(_missing_b); }
    bool isMissingSegids() const { return(_missing_segid); }
    bool isMissingFields() const { return(_missing_q || _missing_b || _missing_segid); }
 
 
        // These will modify the PDB upon a successful parse...
        void parseRemark(const std::string&);
        void parseAtomRecord(const std::string&);
        void parseConectRecord(const std::string&);
        void parseCryst1Record(const std::string&);
 
        // Convert an Atom to a string representation in PDB format...
        std::string atomAsString(const pAtom p) const;
 
#if !defined(SWIG)
        friend std::ostream& FormatConectRecords(std::ostream&, const PDB&);
#endif
 
        pAtom findAtom(const int i);
        void uniqueBonds();
 
    private:
        uint _max_index;
        bool _show_charge;
        bool _auto_ter;
        bool _has_cryst;
        bool strictness_policy;
        bool _missing_q, _missing_b, _missing_segid;
        std::string _fname;
        Remarks _remarks;
        UnitCell cell;
        std::map<int, pAtom> _atomid_to_patom;
    };
 
}
 
#endif