- renaming header files

- atomByID now returns an empty atom
- operator bool for Atom

include/cif++/AtomShape.h → include/cif++/AtomShape.hpp

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "cif++/Structure.h"
+#include "cif++/Structure.hpp"
 
 namespace mmcif
 {

include/cif++/AtomType.h → include/cif++/AtomType.hpp

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <boost/math/quaternion.hpp>
 

include/cif++/BondMap.h → include/cif++/BondMap.hpp

@@ -4,7 +4,7 @@
 
 #include <unordered_map>
 
-#include "cif++/Structure.h"
+#include "cif++/Structure.hpp"
 
 namespace mmcif
 {

include/cif++/Cif++.h → include/cif++/Cif++.hpp

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <regex>
 #include <iostream>
@@ -12,7 +12,7 @@
 #include <boost/lexical_cast.hpp>
 #include <boost/any.hpp>
 
-#include "cif++/CifUtils.h"
+#include "cif++/CifUtils.hpp"
 
 /*
 	Simple C++ interface to CIF files.

include/cif++/Cif2PDB.h → include/cif++/Cif2PDB.hpp

 #pragma once
 
-#include "cif++/Cif++.h"
+#include "cif++/Cif++.hpp"
 
 void WritePDBFile(std::ostream& pdbFile, cif::File& cifFile);
 

include/cif++/CifParser.h → include/cif++/CifParser.hpp

 // CIF Parser
 
-#include "cif++/Cif++.h"
+#include "cif++/Cif++.hpp"
 
 #include <stack>
 

include/cif++/CifUtils.h → include/cif++/CifUtils.hpp

@@ -6,7 +6,7 @@
 #include <set>
 #include <cassert>
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 struct rsrc_imp
 {

include/cif++/CifValidator.h → include/cif++/CifValidator.hpp

 // cif parsing library
 
-#include "cif++/Cif++.h"
+#include "cif++/Cif++.hpp"
 
 //// the std regex of gcc is crashing....
 // #include <boost/regex.hpp>

include/cif++/Compound.h → include/cif++/Compound.hpp

@@ -7,8 +7,8 @@
 #include <vector>
 #include <map>
 
-#include "cif++/AtomType.h"
-#include "cif++/Cif++.h"
+#include "cif++/AtomType.hpp"
+#include "cif++/Cif++.hpp"
 
 namespace mmcif
 {

include/cif++/DistanceMap.h → include/cif++/DistanceMap.hpp

@@ -6,7 +6,7 @@
 
 #include <clipper/clipper.h>
 
-#include "cif++/Structure.h"
+#include "cif++/Structure.hpp"
 
 namespace mmcif
 {

include/cif++/FixDMC.hpp

+// --------------------------------------------------------------------
+
+#pragma once
+
+namespace mmcif
+{
+
+class Structure;
+
+/// \brief Add missing backbone atoms
+///
+/// \param structure	The structure that should be fixed
+/// \param simplified	Use a simplified algorithm
+
+void CreateMissingBackboneAtoms(Structure& structure, bool simplified);
+
+
+}
\ No newline at end of file

include/cif++/MapMaker.h → include/cif++/MapMaker.hpp

@@ -2,7 +2,7 @@
 
 #include <clipper/clipper.h>
 
-#include "cif++/Structure.h"
+#include "cif++/Structure.hpp"
 
 namespace mmcif
 {

include/cif++/PDB2Cif.h → include/cif++/PDB2Cif.hpp

 #pragma once
 
-#include "cif++/Cif++.h"
+#include "cif++/Cif++.hpp"
 
 // --------------------------------------------------------------------
 

include/cif++/PDB2CifRemark3.h → include/cif++/PDB2CifRemark3.hpp

 #pragma once
 
-#include "cif++/PDB2Cif.h"
+#include "cif++/PDB2Cif.hpp"
 
 // --------------------------------------------------------------------
 

include/cif++/Point.h → include/cif++/Point.hpp

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <boost/math/quaternion.hpp>
 

include/cif++/ResolutionCalculator.h → include/cif++/ResolutionCalculator.hpp

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "cif++/ResolutionCalculator.h"
+#include "cif++/ResolutionCalculator.hpp"
 
 #include <clipper/clipper.h>
 

include/cif++/Statistics.h → include/cif++/Statistics.hpp

@@ -5,9 +5,9 @@
 
 #pragma once
 
-#include "cif++/MapMaker.h"
-#include "cif++/DistanceMap.h"
-#include "cif++/BondMap.h"
+#include "cif++/MapMaker.hpp"
+#include "cif++/DistanceMap.hpp"
+#include "cif++/BondMap.hpp"
 
 namespace mmcif
 {

include/cif++/Structure.h → include/cif++/Structure.hpp

@@ -10,10 +10,10 @@
 
 #include <clipper/core/coords.h>
 
-#include "cif++/AtomType.h"
-#include "cif++/Point.h"
-#include "cif++/Compound.h"
-#include "cif++/Cif++.h"
+#include "cif++/AtomType.hpp"
+#include "cif++/Point.hpp"
+#include "cif++/Compound.hpp"
+#include "cif++/Cif++.hpp"
 
 /*
 	To modify a structure, you will have to use actions.
@@ -44,11 +44,14 @@ class Atom
 {
   public:
 //	Atom(const structure& s, const std::string& id);
+	Atom();
 	Atom(struct AtomImpl* impl);
 	Atom(const Atom& rhs);
 
 	~Atom();
-	
+
+	explicit operator bool() const			{ return mImpl_ != nullptr;	}
+
 	// return a copy of this atom, with data copied instead of referenced
 	Atom clone() const;
 	
@@ -85,6 +88,7 @@ class Atom
 	std::string labelAsymID() const;
 	int labelSeqID() const;
 	std::string labelAltID() const;
+	bool isAlternate() const;
 	
 	std::string authAtomID() const;
 	std::string authCompID() const;
@@ -113,13 +117,13 @@ class Atom
 	// convenience routine
 	bool isBackBone() const
 	{
-		return labelAtomID() == "N" or labelAtomID() == "O" or
-			labelAtomID() == "C" or labelAtomID() == "CA";
+		auto atomID = labelAtomID();
+		return atomID == "N" or atomID == "O" or atomID == "C" or atomID == "CA";
 	}
 	
 	void swap(Atom& b)
 	{
-		std::swap(mImpl, b.mImpl);
+		std::swap(mImpl_, b.mImpl_);
 	}
 
 	int compare(const Atom& b) const;
@@ -128,7 +132,10 @@ class Atom
 	friend class Structure;
 	void setID(int id);
 
- 	struct AtomImpl*			mImpl;
+	AtomImpl*			impl();
+	const AtomImpl*		impl() const;
+
+ 	struct AtomImpl*	mImpl_;
 };
 
 inline void swap(mmcif::Atom& a, mmcif::Atom& b)
@@ -196,7 +203,9 @@ class Residue
 	const Structure& structure() const		{ return *mStructure; }
 
 	bool empty() const						{ return mStructure == nullptr; }
-	
+
+	bool hasAlternateAtoms() const;
+
 	// some routines for 3d work
 	std::tuple<Point,float> centerAndRadius() const;
 
@@ -247,6 +256,9 @@ class Monomer : public Residue
 	/// \brief Returns true if the four atoms C, CA, N and O are present
 	bool isComplete() const;
 
+	/// \brief Returns true if any of the backbone atoms has an alternate
+	bool hasAlternateBackboneAtoms() const;
+
 	Atom CAlpha() const		{ return atomByID("CA"); }
 	Atom C() const			{ return atomByID("C"); }
 	Atom N() const			{ return atomByID("N"); }
@@ -364,6 +376,8 @@ class Structure
 	AtomView waters() const;
 	
 	const std::list<Polymer>& polymers() const				{ return mPolymers; }
+	std::list<Polymer>& polymers()							{ return mPolymers; }
+
 	const std::vector<Residue>& nonPolymers() const			{ return mNonPolymers; }
 
 	Atom getAtomByID(std::string id) const;

include/cif++/Symmetry.h → include/cif++/Symmetry.hpp

@@ -2,7 +2,7 @@
 
 #pragma once
 
-#include "cif++/Structure.h"
+#include "cif++/Structure.hpp"
 
 namespace mmcif
 {

include/cif++/TlsParser.h → include/cif++/TlsParser.hpp

@@ -28,7 +28,7 @@
 #include <string>
 #include <tuple>
 
-#include "cif++/Cif++.h"
+#include "cif++/Cif++.hpp"
 
 namespace cif
 {

src/AtomShape.cpp

@@ -3,9 +3,9 @@
 #include <thread>
 #include <mutex>
 
-#include "cif++/Structure.h"
-#include "cif++/AtomShape.h"
-#include "cif++/Point.h"
+#include "cif++/Structure.hpp"
+#include "cif++/AtomShape.hpp"
+#include "cif++/Point.hpp"
 
 #include <newuoa.h>
 

src/AtomType.cpp

 // Lib for working with structures as contained in mmCIF and PDB files
 
-#include "cif++/AtomType.h"
-#include "cif++/Cif++.h"
+#include "cif++/AtomType.hpp"
+#include "cif++/Cif++.hpp"
 
 using namespace std;
 

src/BondMap.cpp

 // copyright
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
-#include "cif++/Cif++.h"
-#include "cif++/BondMap.h"
-#include "cif++/Compound.h"
-#include "cif++/CifUtils.h"
+#include "cif++/Cif++.hpp"
+#include "cif++/BondMap.hpp"
+#include "cif++/Compound.hpp"
+#include "cif++/CifUtils.hpp"
 
 using namespace std;
 

src/Cif++.cpp

@@ -24,10 +24,10 @@ namespace fs = boost::filesystem;
 #include <boost/iostreams/filter/gzip.hpp>
 #include <boost/logic/tribool.hpp>
 
-#include "cif++/Cif++.h"
-#include "cif++/CifParser.h"
-#include "cif++/CifValidator.h"
-#include "cif++/CifUtils.h"
+#include "cif++/Cif++.hpp"
+#include "cif++/CifParser.hpp"
+#include "cif++/CifValidator.hpp"
+#include "cif++/CifUtils.hpp"
 
 using namespace std;
 namespace ba = boost::algorithm;

src/Cif2PDB.cpp

-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <map>
 #include <set>
@@ -13,9 +13,9 @@
 #include <boost/iostreams/concepts.hpp>    // output_filter
 #include <boost/iostreams/operations.hpp>  // put
 
-#include "cif++/Cif2PDB.h"
-#include "cif++/AtomType.h"
-#include "cif++/Compound.h"
+#include "cif++/Cif2PDB.hpp"
+#include "cif++/AtomType.hpp"
+#include "cif++/Compound.hpp"
 
 using namespace std;
 namespace ba = boost::algorithm;

src/CifParser.cpp

@@ -4,9 +4,9 @@
 
 #include <boost/algorithm/string.hpp>
 
-#include "cif++/Cif++.h"
-#include "cif++/CifParser.h"
-#include "cif++/CifValidator.h"
+#include "cif++/Cif++.hpp"
+#include "cif++/CifParser.hpp"
+#include "cif++/CifValidator.hpp"
 
 using namespace std;
 namespace ba = boost::algorithm;

src/CifUtils.cpp

 // CIF parser
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <tuple>
 #include <iostream>
@@ -21,7 +21,7 @@
 #include <boost/timer/timer.hpp>
 #endif
 
-#include "cif++/CifUtils.h"
+#include "cif++/CifUtils.hpp"
 
 using namespace std;
 namespace ba = boost::algorithm;

src/CifValidator.cpp

@@ -6,9 +6,9 @@
 #include <boost/regex.hpp>
 // #include <regex>
 
-#include "cif++/Cif++.h"
-#include "cif++/CifParser.h"
-#include "cif++/CifValidator.h"
+#include "cif++/Cif++.hpp"
+#include "cif++/CifParser.hpp"
+#include "cif++/CifValidator.hpp"
 
 using namespace std;
 namespace ba = boost::algorithm;

src/Compound.cpp

 // Lib for working with structures as contained in mmCIF and PDB files
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <map>
 #include <numeric>
@@ -16,10 +16,10 @@ namespace fs = std::filesystem;
 namespace fs = boost::filesystem;
 #endif
 
-#include "cif++/Cif++.h"
-#include "cif++/Point.h"
-#include "cif++/Compound.h"
-#include "cif++/CifUtils.h"
+#include "cif++/Cif++.hpp"
+#include "cif++/Point.hpp"
+#include "cif++/Compound.hpp"
+#include "cif++/CifUtils.hpp"
 
 using namespace std;
 namespace ba = boost::algorithm;

src/DistanceMap.cpp

 // copyright
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <atomic>
 #include <mutex>
 
-#include "cif++/DistanceMap.h"
-#include "cif++/CifUtils.h"
+#include "cif++/DistanceMap.hpp"
+#include "cif++/CifUtils.hpp"
 
 using namespace std;
 

src/FixDMC.cpp

+// --------------------------------------------------------------------
+
+#include <set>
+
+#include <cif++/Structure.h>
+
+namespace mmcif
+{
+
+void addC(Monomer& mon)
+{
+
+}
+
+void addCA(Monomer& mon)
+{
+
+}
+
+void addN(Monomer& mon)
+{
+
+}
+
+void addO(Monomer& mon)
+{
+
+}
+
+void CreateMissingBackboneAtoms(Structure& structure, bool simplified)
+{
+	for (auto& poly: structure.polymers())
+	{
+		for (auto& mon: poly)
+		{
+			if (mon.isComplete() or mon.hasAlternateBackboneAtoms())
+				continue;
+			
+			std::set<std::string> missing;
+			if (not mon.hasAtomWithID("C"))		missing.insert("C");
+			if (not mon.hasAtomWithID("CA"))	missing.insert("CA");
+			if (not mon.hasAtomWithID("N"))		missing.insert("N");
+			if (not mon.hasAtomWithID("O"))		missing.insert("O");
+
+			switch (missing.size())
+			{
+				case 1:
+					if (missing.count("O"))
+						addO(mon);
+					else if (missing.count("N"))
+						addN(mon);
+					else if (missing.count("CA"))
+						addCA(mon);
+					else if (missing.count("C"))
+						addC(mon);
+					break;
+			}
+		}
+	}
+}
+
+}
\ No newline at end of file

src/MapMaker.cpp

-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <iomanip>
 #include <fstream>
@@ -21,9 +21,9 @@ namespace fs = boost::filesystem;
 #include <clipper/clipper-contrib.h>
 #include <clipper/clipper-ccp4.h>
 
-#include "cif++/Cif++.h"
-#include "cif++/MapMaker.h"
-#include "cif++/ResolutionCalculator.h"
+#include "cif++/Cif++.hpp"
+#include "cif++/MapMaker.hpp"
+#include "cif++/ResolutionCalculator.hpp"
 
 using namespace std;
 namespace io = boost::iostreams;

src/PDB2Cif.cpp

-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <map>
 #include <set>
@@ -11,11 +11,11 @@
 
 #include <clipper/core/spacegroup.h>
 
-#include "cif++/PDB2Cif.h"
-#include "cif++/AtomType.h"
-#include "cif++/Compound.h"
-#include "cif++/PDB2CifRemark3.h"
-#include "cif++/CifUtils.h"
+#include "cif++/PDB2Cif.hpp"
+#include "cif++/AtomType.hpp"
+#include "cif++/Compound.hpp"
+#include "cif++/PDB2CifRemark3.hpp"
+#include "cif++/CifUtils.hpp"
 
 using namespace std;
 namespace ba = boost::algorithm;

src/PDB2CifRemark3.cpp

-#include "cif++/Config.h"
-#include "cif++/Cif++.h"
+#include "cif++/Config.hpp"
+#include "cif++/Cif++.hpp"
 
 #include <map>
 #include <set>
@@ -9,10 +9,10 @@
 #include <boost/format.hpp>
 // #include <boost/numeric/ublas/matrix.hpp>
 
-#include "cif++/AtomType.h"
-#include "cif++/Compound.h"
-#include "cif++/PDB2CifRemark3.h"
-#include "cif++/CifUtils.h"
+#include "cif++/AtomType.hpp"
+#include "cif++/Compound.hpp"
+#include "cif++/PDB2CifRemark3.hpp"
+#include "cif++/CifUtils.hpp"
 
 using namespace std;
 namespace ba = boost::algorithm;

src/Point.cpp

@@ -3,7 +3,7 @@
 #include <random>
 #include <valarray>
 
-#include "cif++/Point.h"
+#include "cif++/Point.hpp"
 
 using namespace std;
 

src/ResolutionCalculator.cpp

 // --------------------------------------------------------------------
 
-#include "cif++/ResolutionCalculator.h"
+#include "cif++/ResolutionCalculator.hpp"
 
-#include "cif++/Point.h"
+#include "cif++/Point.hpp"
 
 using namespace std;
 

src/Secondary.cpp

@@ -5,7 +5,7 @@
 
 // Calculate DSSP-like secondary structure information
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <numeric>
 #include <iomanip>
@@ -13,8 +13,8 @@
 
 #include <boost/algorithm/string.hpp>
 
-#include "cif++/Structure.h"
-#include "cif++/Secondary.h"
+#include "cif++/Structure.hpp"
+#include "cif++/Secondary.hpp"
 
 namespace ba = boost::algorithm;
 

src/Statistics.cpp

@@ -3,14 +3,14 @@
    Date: maandag 04 juni, 2018
 */
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <fstream>
 #include <numeric>
 
-#include "cif++/Structure.h"
-#include "cif++/AtomShape.h"
-#include "cif++/Statistics.h"
+#include "cif++/Structure.hpp"
+#include "cif++/AtomShape.hpp"
+#include "cif++/Statistics.hpp"
 
 using namespace std;
 

src/Structure.cpp

 // Lib for working with structures as contained in file and PDB files
 
-#include "cif++/Structure.h"
+#include "cif++/Structure.hpp"
 
 #include <numeric>
 #include <fstream>
@@ -19,10 +19,10 @@ namespace fs = boost::filesystem;
 #include <boost/iostreams/filter/gzip.hpp>
 #include <boost/format.hpp>
 
-#include "cif++/PDB2Cif.h"
-#include "cif++/CifParser.h"
-#include "cif++/Cif2PDB.h"
-#include "cif++/AtomShape.h"
+#include "cif++/PDB2Cif.hpp"
+#include "cif++/CifParser.hpp"
+#include "cif++/Cif2PDB.hpp"
+#include "cif++/AtomShape.hpp"
 
 using namespace std;
 
@@ -317,7 +317,7 @@ struct AtomImpl
 		mLocation = p;
 	}
 	
-	const Compound& comp()
+	const Compound& comp() const
 	{
 		if (mCompound == nullptr)
 		{
@@ -346,7 +346,7 @@ struct AtomImpl
 		return mRadius;
 	}
 
-	const string& property(const string& name)
+	const string& property(const string& name) const
 	{
 		static string kEmptyString;
 		
@@ -391,9 +391,9 @@ struct AtomImpl
 	Point				mLocation;
 	int					mRefcount;
 	cif::Row			mRow;
-	const Compound*		mCompound;
+	mutable const Compound*		mCompound;
 	float				mRadius = nan("4");
-	map<string,string>	mCachedProperties;
+	mutable map<string,string>	mCachedProperties;
 	
 	bool				mSymmetryCopy = false;
 	bool				mClone = false;
@@ -408,38 +408,58 @@ struct AtomImpl
 //{
 //}
 //
+
+Atom::Atom()
+	: mImpl_(nullptr)
+{
+}
+
 Atom::Atom(AtomImpl* impl)
-	: mImpl(impl)
+	: mImpl_(impl)
+{
+}
+
+AtomImpl* Atom::impl()
+{
+	if (mImpl_ == nullptr)
+		throw std::runtime_error("atom is not set");
+	return mImpl_;
+}
+
+const AtomImpl* Atom::impl() const
 {
+	if (mImpl_ == nullptr)
+		throw std::runtime_error("atom is not set");
+	return mImpl_;
 }
 
 Atom Atom::clone() const
 {
-	return Atom(new AtomImpl(*mImpl));
+	return Atom(mImpl_ ? new AtomImpl(*mImpl_) : nullptr);
 }
 
 Atom::Atom(const Atom& rhs)
-	: mImpl(rhs.mImpl)
+	: mImpl_(rhs.mImpl_)
 {
-	if (mImpl)
-		mImpl->reference();
+	if (mImpl_)
+		mImpl_->reference();
 }
 
 Atom::~Atom()
 {
-	if (mImpl)
-		mImpl->release();
+	if (mImpl_)
+		mImpl_->release();
 }
 
 Atom& Atom::operator=(const Atom& rhs)
 {
 	if (this != &rhs)
 	{
-		if (mImpl)
-			mImpl->release();
-		mImpl = rhs.mImpl;
-		if (mImpl)
-			mImpl->reference();
+		if (mImpl_)
+			mImpl_->release();
+		mImpl_ = rhs.mImpl_;
+		if (mImpl_)
+			mImpl_->reference();
 	}
 
 	return *this;
@@ -448,30 +468,30 @@ Atom& Atom::operator=(const Atom& rhs)
 template<>
 string Atom::property<string>(const string& name) const
 {
-	return mImpl->property(name);
+	return impl()->property(name);
 }
 
 template<>
 int Atom::property<int>(const string& name) const
 {
-	auto v = mImpl->property(name);
+	auto v = impl()->property(name);
 	return v.empty() ? 0 : stoi(v);
 }
 
 template<>
 float Atom::property<float>(const string& name) const
 {
-	return stof(mImpl->property(name));
+	return stof(impl()->property(name));
 }
 
 const string& Atom::id() const
 {
-	return mImpl->mID;
+	return impl()->mID;
 }
 
 AtomType Atom::type() const
 {
-	return mImpl->mType;
+	return impl()->mType;
 }
 
 int Atom::charge() const
@@ -483,8 +503,8 @@ string Atom::energyType() const
 {
 	string result;
 	
-	if (mImpl and mImpl->mCompound)
-		result = mImpl->mCompound->getAtomByID(mImpl->mAtomID).typeEnergy;
+	if (impl() and impl()->mCompound)
+		result = impl()->mCompound->getAtomByID(impl()->mAtomID).typeEnergy;
 	
 	return result;
 }
@@ -505,7 +525,7 @@ float Atom::uIso() const
 
 bool Atom::getAnisoU(float anisou[6]) const
 {
-	return mImpl->getAnisoU(anisou);
+	return impl()->getAnisoU(anisou);
 }
 
 float Atom::occupancy() const
@@ -515,27 +535,32 @@ float Atom::occupancy() const
 
 string Atom::labelAtomID() const
 {
-	return mImpl->mAtomID;
+	return impl()->mAtomID;
 }
 
 string Atom::labelCompID() const
 {
-	return mImpl->mCompID;
+	return impl()->mCompID;
 }
 
 string Atom::labelAsymID() const
 {
-	return mImpl->mAsymID;
+	return impl()->mAsymID;
 }
 
 string Atom::labelAltID() const
 {
-	return mImpl->mAltID;
+	return impl()->mAltID;
+}
+
+bool Atom::isAlternate() const
+{
+	return not impl()->mAltID.empty();
 }
 
 int Atom::labelSeqID() const
 {
-	return mImpl->mSeqID;
+	return impl()->mSeqID;
 }
 
 string Atom::authAsymID() const
@@ -570,7 +595,7 @@ string Atom::authSeqID() const
 
 string Atom::labelID() const
 {
-	return property<string>("label_comp_id") + '_' + mImpl->mAsymID + '_' + to_string(mImpl->mSeqID) + ':' + mImpl->mAtomID;
+	return property<string>("label_comp_id") + '_' + impl()->mAsymID + '_' + to_string(impl()->mSeqID) + ':' + impl()->mAtomID;
 }
 
 string Atom::pdbID() const
@@ -584,78 +609,78 @@ string Atom::pdbID() const
 
 Point Atom::location() const
 {
-	return mImpl->mLocation;
+	return impl()->mLocation;
 }
 
 void Atom::location(Point p)
 {
-	mImpl->moveTo(p);
+	impl()->moveTo(p);
 }
 
 Atom Atom::symmetryCopy(const Point& d, const clipper::RTop_orth& rt)
 {
-	return Atom(new AtomImpl(*mImpl, d, rt));
+	return Atom(new AtomImpl(*impl(), d, rt));
 }
 
 bool Atom::isSymmetryCopy() const
 {
-	return mImpl->mSymmetryCopy;
+	return impl()->mSymmetryCopy;
 }
 
 string Atom::symmetry() const
 {
-	return clipper::Symop(mImpl->mRTop).format() + "\n" + mImpl->mRTop.format();
+	return clipper::Symop(impl()->mRTop).format() + "\n" + impl()->mRTop.format();
 }
 
 const clipper::RTop_orth& Atom::symop() const
 {
-	return mImpl->mRTop;
+	return impl()->mRTop;
 }
 
 const Compound& Atom::comp() const
 {
-	return mImpl->comp();
+	return impl()->comp();
 }
 
 bool Atom::isWater() const
 {
-	return mImpl->isWater();
+	return impl()->isWater();
 }
 
 bool Atom::operator==(const Atom& rhs) const
 {
-	return mImpl == rhs.mImpl or
-		(&mImpl->mFile == &rhs.mImpl->mFile and mImpl->mID == rhs.mImpl->mID); 	
+	return impl() == rhs.impl() or
+		(&impl()->mFile == &rhs.impl()->mFile and impl()->mID == rhs.impl()->mID); 	
 }
 
 clipper::Atom Atom::toClipper() const
 {
-	return mImpl->toClipper();
+	return impl()->toClipper();
 }
 
 void Atom::calculateRadius(float resHigh, float resLow, float perc)
 {
 	AtomShape shape(*this, resHigh, resLow, false);
-	mImpl->mRadius = shape.radius();
+	impl()->mRadius = shape.radius();
 
 	// verbose
 	if (cif::VERBOSE > 1)
-		cout << "Calculated radius for " << AtomTypeTraits(mImpl->mType).name() << " with charge " << charge() << " is " << mImpl->mRadius << endl;
+		cout << "Calculated radius for " << AtomTypeTraits(impl()->mType).name() << " with charge " << charge() << " is " << impl()->mRadius << endl;
 }
 
 float Atom::radius() const
 {
-	return mImpl->mRadius;
+	return impl()->mRadius;
 }
 
 int Atom::compare(const Atom& b) const
 {
-	return mImpl == b.mImpl ? 0 : mImpl->compare(*b.mImpl);
+	return impl() == b.impl() ? 0 : impl()->compare(*b.impl());
 }
 
 void Atom::setID(int id)
 {
-	mImpl->mID = to_string(id);
+	impl()->mID = to_string(id);
 }
 
 // --------------------------------------------------------------------
@@ -805,13 +830,21 @@ const AtomView& Residue::atoms() const
 
 Atom Residue::atomByID(const string& atomID) const
 {
+	Atom result;
+
 	for (auto& a: mAtoms)
 	{
 		if (a.labelAtomID() == atomID)
-			return a;
+		{
+			result = a;
+			break;
+		}
 	}
-	
-	throw runtime_error("Atom with atom_id " + atomID + " not found in residue " + mAsymID + ':' + to_string(mSeqID));
+
+	if (not result and cif::VERBOSE)
+		std::cerr << "Atom with atom_id " << atomID << " not found in residue " << mAsymID << ':' << mSeqID << std::endl;
+
+	return result;
 }
 
 // Residue is a single entity if the atoms for the asym with mAsymID is equal
@@ -877,6 +910,11 @@ tuple<Point,float> Residue::centerAndRadius() const
 	return make_tuple(center, radius);
 }
 
+bool Residue::hasAlternateAtoms() const
+{
+	return std::find_if(mAtoms.begin(), mAtoms.end(), [](const Atom& atom) { return atom.isAlternate(); }) != mAtoms.end();
+}
+
 // --------------------------------------------------------------------
 // monomer
 
@@ -1137,6 +1175,24 @@ bool Monomer::isComplete() const
 	return seen == 15;
 }
 
+bool Monomer::hasAlternateBackboneAtoms() const
+{
+	bool result;
+	for (auto& a: mAtoms)
+	{
+		if (not a.isAlternate())
+			continue;
+
+		auto atomID = a.labelAtomID();
+		if (atomID == "CA" or atomID == "C" or atomID == "N" or atomID == "O")
+		{
+			result = true;
+			break;
+		}
+	}
+	return result;
+}
+
 float Monomer::chiralVolume() const
 {
 	float result = 0;
@@ -1939,7 +1995,7 @@ void Structure::swapAtoms(Atom& a1, Atom& a2)
 	auto l2 = r2.front()["label_atom_id"];
 	l1.swap(l2);
 	
-	a1.mImpl->swapAtomLabels(*a2.mImpl);
+	a1.impl()->swapAtomLabels(*a2.impl());
 
 	auto l3 = r1.front()["auth_atom_id"];
 	auto l4 = r2.front()["auth_atom_id"];

src/Symmetry.cpp

 // copyright
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <atomic>
 #include <mutex>
 
-#include "cif++/Symmetry.h"
-#include "cif++/CifUtils.h"
+#include "cif++/Symmetry.hpp"
+#include "cif++/CifUtils.hpp"
 
 using namespace std;
 

src/TlsParser.cpp

@@ -24,7 +24,7 @@
 	SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
-#include "cif++/Config.h"
+#include "cif++/Config.hpp"
 
 #include <termios.h>
 #include <sys/ioctl.h>
@@ -35,9 +35,9 @@
 #include <boost/program_options.hpp>
 #include <boost/algorithm/string.hpp>
 
-#include "cif++/CifUtils.h"
-#include "cif++/Structure.h"
-#include "cif++/TlsParser.h"
+#include "cif++/CifUtils.hpp"
+#include "cif++/Structure.hpp"
+#include "cif++/TlsParser.hpp"
 
 using namespace std;
 namespace po = boost::program_options;

test/unit-test.cpp

 #define BOOST_TEST_MODULE LibCifPP_Test
 #include <boost/test/included/unit_test.hpp>
 
-#include "cif++/DistanceMap.h"
+#include "cif++/DistanceMap.hpp"
 
 // --------------------------------------------------------------------