Merge branch 'develop' into trunk

include/cif++/Cif++.hpp

@@ -792,7 +792,7 @@ class Row
 	}
 	}
 
 
 	void assign(const std::vector<Item> &values);
 	void assign(const std::vector<Item> &values);
-	void assign(std::string_view name, const std::string &value, bool updateLinked);
+	void assign(std::string_view name, const std::string &value, bool updateLinked, bool validate = true);
 
 
 	bool operator==(const Row &rhs) const
 	bool operator==(const Row &rhs) const
 	{
 	{
@@ -814,7 +814,7 @@ class Row
 	friend std::ostream &operator<<(std::ostream &os, const Row &row);
 	friend std::ostream &operator<<(std::ostream &os, const Row &row);
 
 
   private:
   private:
-	void assign(size_t column, const std::string &value, bool updateLinked);
+	void assign(size_t column, const std::string &value, bool updateLinked, bool validate = true);
 	void assign(const Item &i, bool updateLinked);
 	void assign(const Item &i, bool updateLinked);
 
 
 	static void swap(size_t column, ItemRow *a, ItemRow *b);
 	static void swap(size_t column, ItemRow *a, ItemRow *b);
@@ -2152,6 +2152,7 @@ class Category
 	std::vector<ItemColumn> mColumns;
 	std::vector<ItemColumn> mColumns;
 	ItemRow *mHead;
 	ItemRow *mHead;
 	ItemRow *mTail;
 	ItemRow *mTail;
+	size_t mLastUniqueNr = 0;
 	class CatIndex *mIndex;
 	class CatIndex *mIndex;
 
 
 	std::vector<Linked> mParentLinks, mChildLinks;
 	std::vector<Linked> mParentLinks, mChildLinks;

include/cif++/Structure.hpp

@@ -60,30 +60,101 @@ class File;
 
 
 class Atom
 class Atom
 {
 {
+  private:
+
+	struct AtomImpl : public std::enable_shared_from_this<AtomImpl>
+	{
+		AtomImpl(cif::Datablock &db, const std::string &id, cif::Row row);
+
+		// constructor for a symmetry copy of an atom
+		AtomImpl(const AtomImpl &impl, const Point &loc, const std::string &sym_op);
+
+		AtomImpl(const AtomImpl &i) = default;
+
+		void prefetch();
+
+		int compare(const AtomImpl &b) const;
+
+		bool getAnisoU(float anisou[6]) const;
+
+		void moveTo(const Point &p);
+
+		const Compound &comp() const;
+
+		const std::string get_property(const std::string_view name) const;
+		void set_property(const std::string_view name, const std::string &value);
+
+		const cif::Datablock &mDb;
+		std::string mID;
+		AtomType mType;
+
+		std::string mAtomID;
+		std::string mCompID;
+		std::string mAsymID;
+		int mSeqID;
+		std::string mAltID;
+		std::string mAuthSeqID;
+
+		Point mLocation;
+		int mRefcount;
+		cif::Row mRow;
+
+		mutable std::vector<std::tuple<std::string,cif::detail::ItemReference>> mCachedRefs;
+
+		mutable const Compound *mCompound = nullptr;
+
+		bool mSymmetryCopy = false;
+		bool mClone = false;
+
+		std::string mSymmetryOperator = "1_555";
+	};
+
   public:
   public:
-	Atom();
-	Atom(struct AtomImpl *impl);
-	Atom(const Atom &rhs);
+
+	Atom() {}
+
+	Atom(std::shared_ptr<AtomImpl> impl)
+		: mImpl(impl) {}
+
+	Atom(const Atom &rhs)
+		: mImpl(rhs.mImpl) {}
 
 
 	Atom(cif::Datablock &db, cif::Row &row);
 	Atom(cif::Datablock &db, cif::Row &row);
 
 
 	// a special constructor to create symmetry copies
 	// a special constructor to create symmetry copies
 	Atom(const Atom &rhs, const Point &symmmetry_location, const std::string &symmetry_operation);
 	Atom(const Atom &rhs, const Point &symmmetry_location, const std::string &symmetry_operation);
 
 
-	~Atom();
-
-	explicit operator bool() const { return mImpl_ != nullptr; }
+	explicit operator bool() const { return (bool)mImpl; }
 
 
 	// return a copy of this atom, with data copied instead of referenced
 	// return a copy of this atom, with data copied instead of referenced
-	Atom clone() const;
+	Atom clone() const
+	{
+		auto copy = std::make_shared<AtomImpl>(*mImpl);
+		copy->mClone = true;
+		return Atom(copy);
+	}
+
+	Atom &operator=(const Atom &rhs) = default;
 
 
-	Atom &operator=(const Atom &rhs);
+	template <typename T>
+	T get_property(const std::string_view name) const;
+
+	void set_property(const std::string_view name, const std::string &value)
+	{
+		mImpl->set_property(name, value);
+	}
+
+	template <typename T, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
+	void property(const std::string_view name, const T &value)
+	{
+		set_property(name, std::to_string(value));
+	}
 
 
-	const std::string &id() const;
-	AtomType type() const;
+	const std::string &id() const			{ return mImpl->mID; }
+	AtomType type() const					{ return mImpl->mType; }
 
 
-	Point location() const;
-	void location(Point p);
+	Point location() const					{ return mImpl->mLocation; }
+	void location(Point p)					{ mImpl->moveTo(p); }
 
 
 	/// \brief Translate the position of this atom by \a t
 	/// \brief Translate the position of this atom by \a t
 	void translate(Point t);
 	void translate(Point t);
@@ -91,47 +162,40 @@ class Atom
 	/// \brief Rotate the position of this atom by \a q
 	/// \brief Rotate the position of this atom by \a q
 	void rotate(Quaternion q);
 	void rotate(Quaternion q);
 
 
+	/// \brief Translate and rotate the position of this atom by \a t and \a q
+	void translateAndRotate(Point t, Quaternion q);
+
+	/// \brief Translate, rotate and translate again the coordinates this atom by \a t1 , \a q and \a t2
+	void translateRotateAndTranslate(Point t1, Quaternion q, Point t2);
+
 	// for direct access to underlying data, be careful!
 	// for direct access to underlying data, be careful!
-	const cif::Row getRow() const;
+	const cif::Row getRow() const			{ return mImpl->mRow; }
 	const cif::Row getRowAniso() const;
 	const cif::Row getRowAniso() const;
 
 
-	// Atom symmetryCopy(const Point& d, const clipper::RTop_orth& rt);
-	bool isSymmetryCopy() const;
-	std::string symmetry() const;
-	// const clipper::RTop_orth& symop() const;
+	bool isSymmetryCopy() const				{ return mImpl->mSymmetryCopy; }
+	std::string symmetry() const			{ return mImpl->mSymmetryOperator; }
 
 
-	const Compound &comp() const;
-	bool isWater() const;
+	const Compound &comp() const			{ return mImpl->comp(); }
+	bool isWater() const					{ return mImpl->mCompID == "HOH" or mImpl->mCompID == "H2O" or mImpl->mCompID == "WAT"; }
 	int charge() const;
 	int charge() const;
 
 
 	float uIso() const;
 	float uIso() const;
-	bool getAnisoU(float anisou[6]) const;
+	bool getAnisoU(float anisou[6]) const	{ return mImpl->getAnisoU(anisou); }
 	float occupancy() const;
 	float occupancy() const;
 
 
-	template <typename T>
-	T property(const std::string_view name) const;
-
-	void property(const std::string_view name, const std::string &value);
-
-	template <typename T, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
-	void property(const std::string_view name, const T &value)
-	{
-		property(name, std::to_string(value));
-	}
-
 	// specifications
 	// specifications
-	const std::string& labelAtomID() const		{ return mAtomID; }
-	const std::string& labelCompID() const		{ return mCompID; }
-	const std::string& labelAsymID() const		{ return mAsymID; }
+	const std::string& labelAtomID() const		{ return mImpl->mAtomID; }
+	const std::string& labelCompID() const		{ return mImpl->mCompID; }
+	const std::string& labelAsymID() const		{ return mImpl->mAsymID; }
 	std::string labelEntityID() const;
 	std::string labelEntityID() const;
-	int labelSeqID() const						{ return mSeqID; }
-	const std::string& labelAltID() const		{ return mAltID; }
-	bool isAlternate() const					{ return not mAltID.empty(); }
+	int labelSeqID() const						{ return mImpl->mSeqID; }
+	const std::string& labelAltID() const		{ return mImpl->mAltID; }
+	bool isAlternate() const					{ return not mImpl->mAltID.empty(); }
 
 
 	std::string authAtomID() const;
 	std::string authAtomID() const;
 	std::string authCompID() const;
 	std::string authCompID() const;
 	std::string authAsymID() const;
 	std::string authAsymID() const;
-	const std::string& authSeqID() const		{ return mAuthSeqID; }
+	const std::string& authSeqID() const		{ return mImpl->mAuthSeqID; }
 	std::string pdbxAuthInsCode() const;
 	std::string pdbxAuthInsCode() const;
 	std::string pdbxAuthAltID() const;
 	std::string pdbxAuthAltID() const;
 
 
@@ -140,13 +204,6 @@ class Atom
 
 
 	bool operator==(const Atom &rhs) const;
 	bool operator==(const Atom &rhs) const;
 
 
-	// // get clipper format Atom
-	// clipper::Atom toClipper() const;
-
-	// Radius calculation based on integrating the density until perc of electrons is found
-	void calculateRadius(float resHigh, float resLow, float perc);
-	float radius() const;
-
 	// access data in compound for this atom
 	// access data in compound for this atom
 
 
 	// convenience routine
 	// convenience routine
@@ -158,16 +215,10 @@ class Atom
 
 
 	void swap(Atom &b)
 	void swap(Atom &b)
 	{
 	{
-		std::swap(mImpl_, b.mImpl_);
-		std::swap(mAtomID, b.mAtomID);
-		std::swap(mCompID, b.mCompID);
-		std::swap(mAsymID, b.mAsymID);
-		std::swap(mSeqID, b.mSeqID);
-		std::swap(mAltID, b.mAltID);
-		std::swap(mAuthSeqID, b.mAuthSeqID);
+		std::swap(mImpl, b.mImpl);
 	}
 	}
 
 
-	int compare(const Atom &b) const;
+	int compare(const Atom &b) const		{ return mImpl->compare(*b.mImpl); }
 
 
 	bool operator<(const Atom &rhs) const
 	bool operator<(const Atom &rhs) const
 	{
 	{
@@ -178,21 +229,30 @@ class Atom
 
 
   private:
   private:
 	friend class Structure;
 	friend class Structure;
+
 	void setID(int id);
 	void setID(int id);
 
 
-	AtomImpl *impl();
-	const AtomImpl *impl() const;
+	std::shared_ptr<AtomImpl> mImpl;
+};
+
+template <>
+inline std::string Atom::get_property<std::string>(const std::string_view name) const
+{
+	return mImpl->get_property(name);
+}
 
 
-	struct AtomImpl *mImpl_;
+template <>
+inline int Atom::get_property<int>(const std::string_view name) const
+{
+	auto v = mImpl->get_property(name);
+	return v.empty() ? 0 : stoi(v);
+}
 
 
-	// cached values
-	std::string mAtomID;
-	std::string mCompID;
-	std::string mAsymID;
-	int mSeqID;
-	std::string mAltID;
-	std::string mAuthSeqID;
-};
+template <>
+inline float Atom::get_property<float>(const std::string_view name) const
+{
+	return stof(mImpl->get_property(name));
+}
 
 
 inline void swap(mmcif::Atom &a, mmcif::Atom &b)
 inline void swap(mmcif::Atom &a, mmcif::Atom &b)
 {
 {
@@ -216,19 +276,16 @@ typedef std::vector<Atom> AtomView;
 class Residue
 class Residue
 {
 {
   public:
   public:
-	// constructors should be private, but that's not possible for now (needed in emplace)
-
-	// constructor for waters
+	// constructor
 	Residue(const Structure &structure, const std::string &compoundID,
 	Residue(const Structure &structure, const std::string &compoundID,
-		const std::string &asymID, const std::string &authSeqID);
-
-	// constructor for a residue without a sequence number
-	Residue(const Structure &structure, const std::string &compoundID,
-		const std::string &asymID);
-
-	// constructor for a residue with a sequence number
-	Residue(const Structure &structure, const std::string &compoundID,
-		const std::string &asymID, int seqID, const std::string &authSeqID);
+		const std::string &asymID, int seqID = 0, const std::string &authSeqID = {})
+		: mStructure(&structure)
+		, mCompoundID(compoundID)
+		, mAsymID(asymID)
+		, mSeqID(seqID)
+		, mAuthSeqID(authSeqID)
+	{
+	}
 
 
 	Residue(const Residue &rhs) = delete;
 	Residue(const Residue &rhs) = delete;
 	Residue &operator=(const Residue &rhs) = delete;
 	Residue &operator=(const Residue &rhs) = delete;
@@ -552,6 +609,12 @@ class Structure
 	/// \brief Rotate the coordinates of all atoms in the structure by \a q
 	/// \brief Rotate the coordinates of all atoms in the structure by \a q
 	void rotate(Quaternion t);
 	void rotate(Quaternion t);
 
 
+	/// \brief Translate and rotate the coordinates of all atoms in the structure by \a t and \a q
+	void translateAndRotate(Point t, Quaternion q);
+
+	/// \brief Translate, rotate and translate again the coordinates of all atoms in the structure by \a t1 , \a q and \a t2
+	void translateRotateAndTranslate(Point t1, Quaternion q, Point t2);
+
 	const std::vector<Residue> &getNonPolymers() const { return mNonPolymers; }
 	const std::vector<Residue> &getNonPolymers() const { return mNonPolymers; }
 	const std::vector<Residue> &getBranchResidues() const { return mBranchResidues; }
 	const std::vector<Residue> &getBranchResidues() const { return mBranchResidues; }
 
 

src/BondMap.cpp

@@ -180,7 +180,10 @@ bool CompoundBondMap::bonded(const std::string &compoundID, const std::string &a
 
 
 	auto compound = mmcif::CompoundFactory::instance().create(compoundID);
 	auto compound = mmcif::CompoundFactory::instance().create(compoundID);
 	if (not compound)
 	if (not compound)
-		std::cerr << "Missing compound bond info for " << compoundID << std::endl;
+	{
+		if (cif::VERBOSE >= 0)
+			std::cerr << "Missing compound bond info for " << compoundID << std::endl;
+	}
 	else
 	else
 	{
 	{
 		for (auto &atom : compound->bonds())
 		for (auto &atom : compound->bonds())
@@ -308,7 +311,7 @@ BondMap::BondMap(const Structure &p)
 	{
 	{
 		if (c == "HOH" or c == "H2O" or c == "WAT")
 		if (c == "HOH" or c == "H2O" or c == "WAT")
 		{
 		{
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "skipping water in bond map calculation" << std::endl;
 				std::cerr << "skipping water in bond map calculation" << std::endl;
 			continue;
 			continue;
 		}
 		}

src/Cif2PDB.cpp

@@ -753,7 +753,8 @@ class Ff : public FBase
             }
             }
             catch (const std::exception& ex)
             catch (const std::exception& ex)
             {
             {
-                std::cerr << "Failed to write '" << s << "' as a double, this indicates an error in the code for writing PDB files" << std::endl;
+				if (cif::VERBOSE >= 0)
+	                std::cerr << "Failed to write '" << s << "' as a double, this indicates an error in the code for writing PDB files" << std::endl;
                 os << s;
                 os << s;
             }
             }
         }
         }
@@ -2329,7 +2330,8 @@ void WriteRemark200(std::ostream& pdbFile, Datablock& db)
 	}
 	}
 	catch (const std::exception& ex)
 	catch (const std::exception& ex)
 	{
 	{
-		std::cerr << ex.what() << std::endl;
+		if (cif::VERBOSE >= 0)
+			std::cerr << ex.what() << std::endl;
 	}
 	}
 }
 }
 
 
@@ -2390,7 +2392,8 @@ void WriteRemark280(std::ostream& pdbFile, Datablock& db)
 	}
 	}
 	catch (const std::exception& ex)
 	catch (const std::exception& ex)
 	{
 	{
-		std::cerr << ex.what() << std::endl;
+		if (cif::VERBOSE >= 0)
+			std::cerr << ex.what() << std::endl;
 	}
 	}
 }
 }
 
 

src/CifParser.cpp

@@ -288,7 +288,7 @@ SacParser::CIFToken SacParser::getNextToken()
 					mState = eStateTextField + 1;
 					mState = eStateTextField + 1;
 				else if (ch == kEOF)
 				else if (ch == kEOF)
 					error("unterminated textfield");
 					error("unterminated textfield");
-				else if (not isAnyPrint(ch))
+				else if (not isAnyPrint(ch) and cif::VERBOSE >= 0)
 					//					error("invalid character in text field '" + string({ static_cast<char>(ch) }) + "' (" + to_string((int)ch) + ")");
 					//					error("invalid character in text field '" + string({ static_cast<char>(ch) }) + "' (" + to_string((int)ch) + ")");
 					std::cerr << "invalid character in text field '" << std::string({static_cast<char>(ch)}) << "' (" << ch << ") line: " << mLineNr << std::endl;
 					std::cerr << "invalid character in text field '" << std::string({static_cast<char>(ch)}) << "' (" << ch << ") line: " << mLineNr << std::endl;
 				break;
 				break;
@@ -1220,7 +1220,7 @@ void DictParser::linkItems()
 	{
 	{
 		for (auto &iv : cv.mItemValidators)
 		for (auto &iv : cv.mItemValidators)
 		{
 		{
-			if (iv.mType == nullptr)
+			if (iv.mType == nullptr and cif::VERBOSE >= 0)
 				std::cerr << "Missing item_type for " << iv.mTag << std::endl;
 				std::cerr << "Missing item_type for " << iv.mTag << std::endl;
 		}
 		}
 	}
 	}
@@ -1255,7 +1255,8 @@ void DictParser::loadDictionary()
 	}
 	}
 	catch (const std::exception &)
 	catch (const std::exception &)
 	{
 	{
-		std::cerr << "Error parsing dictionary" << std::endl;
+		if (cif::VERBOSE >= 0)
+			std::cerr << "Error parsing dictionary" << std::endl;
 		throw;
 		throw;
 	}
 	}
 
 

src/CifUtils.cpp

@@ -1237,7 +1237,7 @@ std::filesystem::path gDataDir;
 
 
 void addDataDirectory(std::filesystem::path dataDir)
 void addDataDirectory(std::filesystem::path dataDir)
 {
 {
-	if (VERBOSE and not fs::exists(dataDir))
+	if (VERBOSE > 0 and not fs::exists(dataDir))
 		std::cerr << "The specified data directory " << dataDir << " does not exist" << std::endl;
 		std::cerr << "The specified data directory " << dataDir << " does not exist" << std::endl;
 	gDataDir = dataDir;
 	gDataDir = dataDir;
 }
 }

src/CifValidator.cpp

@@ -354,7 +354,7 @@ void Validator::reportError(const std::string &msg, bool fatal) const
 {
 {
 	if (mStrict or fatal)
 	if (mStrict or fatal)
 		throw ValidationError(msg);
 		throw ValidationError(msg);
-	else if (VERBOSE)
+	else if (VERBOSE > 0)
 		std::cerr << msg << std::endl;
 		std::cerr << msg << std::endl;
 }
 }
 
 

src/Compound.cpp

@@ -193,7 +193,7 @@ Compound::Compound(cif::Datablock &db, const std::string &id, const std::string
 			bond.type = BondType::delo;
 			bond.type = BondType::delo;
 		else
 		else
 		{
 		{
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "Unimplemented chem_comp_bond.type " << btype << " in " << id << std::endl;
 				std::cerr << "Unimplemented chem_comp_bond.type " << btype << " in " << id << std::endl;
 			bond.type = BondType::sing;
 			bond.type = BondType::sing;
 		}
 		}
@@ -520,7 +520,7 @@ Compound *CCDCompoundFactoryImpl::create(const std::string &id)
 		}
 		}
 	}
 	}
 
 
-	if (result == nullptr and cif::VERBOSE)
+	if (result == nullptr and cif::VERBOSE > 0)
 		std::cerr << "Could not locate compound " << id << " in the CCD components file" << std::endl;
 		std::cerr << "Could not locate compound " << id << " in the CCD components file" << std::endl;
 
 
 	return result;
 	return result;
@@ -645,13 +645,13 @@ CompoundFactory::CompoundFactory()
 	auto ccd = cif::loadResource("components.cif");
 	auto ccd = cif::loadResource("components.cif");
 	if (ccd)
 	if (ccd)
 		mImpl.reset(new CCDCompoundFactoryImpl(mImpl));
 		mImpl.reset(new CCDCompoundFactoryImpl(mImpl));
-	else if (cif::VERBOSE)
+	else if (cif::VERBOSE > 0)
 		std::cerr << "CCD components.cif file was not found" << std::endl;
 		std::cerr << "CCD components.cif file was not found" << std::endl;
 
 
 	const char *clibd_mon = getenv("CLIBD_MON");
 	const char *clibd_mon = getenv("CLIBD_MON");
 	if (clibd_mon != nullptr and fs::is_directory(clibd_mon))
 	if (clibd_mon != nullptr and fs::is_directory(clibd_mon))
 		mImpl.reset(new CCP4CompoundFactoryImpl(clibd_mon));
 		mImpl.reset(new CCP4CompoundFactoryImpl(clibd_mon));
-	else if (cif::VERBOSE)
+	else if (cif::VERBOSE > 0)
 		std::cerr << "CCP4 monomers library not found, CLIBD_MON is not defined" << std::endl;
 		std::cerr << "CCP4 monomers library not found, CLIBD_MON is not defined" << std::endl;
 
 
 }
 }
@@ -695,7 +695,8 @@ void CompoundFactory::setDefaultDictionary(const std::filesystem::path &inDictFi
 	}
 	}
 	catch (const std::exception &)
 	catch (const std::exception &)
 	{
 	{
-		std::cerr << "Error loading dictionary " << inDictFile << std::endl;
+		if (cif::VERBOSE >= 0)
+			std::cerr << "Error loading dictionary " << inDictFile << std::endl;
 		throw;
 		throw;
 	}
 	}
 }
 }
@@ -715,7 +716,8 @@ void CompoundFactory::pushDictionary(const std::filesystem::path &inDictFile)
 	}
 	}
 	catch (const std::exception &)
 	catch (const std::exception &)
 	{
 	{
-		std::cerr << "Error loading dictionary " << inDictFile << std::endl;
+		if (cif::VERBOSE >= 0)
+			std::cerr << "Error loading dictionary " << inDictFile << std::endl;
 		throw;
 		throw;
 	}
 	}
 }
 }

src/PDB2CifRemark3.cpp

@@ -1320,7 +1320,7 @@ bool Remark3Parser::parse(const std::string& expMethod, PDBRecord* r, cif::Datab
 
 
 	if (line != "REFINEMENT.")
 	if (line != "REFINEMENT.")
 	{
 	{
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 			std::cerr << "Unexpected data in REMARK 3" << std::endl;
 			std::cerr << "Unexpected data in REMARK 3" << std::endl;
 		return false;
 		return false;
 	}
 	}
@@ -1332,7 +1332,7 @@ bool Remark3Parser::parse(const std::string& expMethod, PDBRecord* r, cif::Datab
 
 
 	if (not std::regex_match(line, m, rxp))
 	if (not std::regex_match(line, m, rxp))
 	{
 	{
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 			std::cerr << "Expected valid PROGRAM line in REMARK 3" << std::endl;
 			std::cerr << "Expected valid PROGRAM line in REMARK 3" << std::endl;
 		return false;
 		return false;
 	}
 	}
@@ -1367,8 +1367,9 @@ bool Remark3Parser::parse(const std::string& expMethod, PDBRecord* r, cif::Datab
 		}
 		}
 		catch(const std::exception& e)
 		catch(const std::exception& e)
 		{
 		{
-			std::cerr << "Error parsing REMARK 3 with " << parser->program() << std::endl
-					  << e.what() << '\n';
+			if (cif::VERBOSE >= 0)
+				std::cerr << "Error parsing REMARK 3 with " << parser->program() << std::endl
+						  << e.what() << '\n';
 			score = 0;
 			score = 0;
 		}
 		}
 
 
@@ -1411,7 +1412,7 @@ bool Remark3Parser::parse(const std::string& expMethod, PDBRecord* r, cif::Datab
 			tryParser(new TNT_Remark3Parser(program, expMethod, r, db));
 			tryParser(new TNT_Remark3Parser(program, expMethod, r, db));
 		else if (ba::starts_with(program, "X-PLOR"))
 		else if (ba::starts_with(program, "X-PLOR"))
 			tryParser(new XPLOR_Remark3Parser(program, expMethod, r, db));
 			tryParser(new XPLOR_Remark3Parser(program, expMethod, r, db));
-		else if (cif::VERBOSE)
+		else if (cif::VERBOSE > 0)
 			std::cerr << "Skipping unknown program (" << program << ") in REMARK 3" << std::endl;
 			std::cerr << "Skipping unknown program (" << program << ") in REMARK 3" << std::endl;
 	}
 	}
 
 
@@ -1420,7 +1421,8 @@ bool Remark3Parser::parse(const std::string& expMethod, PDBRecord* r, cif::Datab
 	bool guessProgram = scores.empty() or scores.front().score < 0.9f;;
 	bool guessProgram = scores.empty() or scores.front().score < 0.9f;;
 	if (guessProgram)
 	if (guessProgram)
 	{
 	{
-		std::cerr << "Unknown or untrusted program in REMARK 3, trying all parsers to see if there is a match" << std::endl;
+		if (cif::VERBOSE >= 0)
+			std::cerr << "Unknown or untrusted program in REMARK 3, trying all parsers to see if there is a match" << std::endl;
 		
 		
 		tryParser(new BUSTER_TNT_Remark3Parser("BUSTER-TNT", expMethod, r, db));
 		tryParser(new BUSTER_TNT_Remark3Parser("BUSTER-TNT", expMethod, r, db));
 		tryParser(new CNS_Remark3Parser("CNS", expMethod, r, db));
 		tryParser(new CNS_Remark3Parser("CNS", expMethod, r, db));
@@ -1444,7 +1446,7 @@ bool Remark3Parser::parse(const std::string& expMethod, PDBRecord* r, cif::Datab
 
 
 		auto& best = scores.front();
 		auto& best = scores.front();
 
 
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 			std::cerr << "Choosing " << best.parser->program() << " version '" << best.parser->version() << "' as refinement program. Score = " << best.score << std::endl;
 			std::cerr << "Choosing " << best.parser->program() << " version '" << best.parser->version() << "' as refinement program. Score = " << best.score << std::endl;
 
 
 		auto& software = db["software"];
 		auto& software = db["software"];

src/Secondary.cpp

@@ -1240,7 +1240,7 @@ void DSSPImpl::calculateSecondaryStructure()
 		auto r1 = findRes(asym1, seq1);
 		auto r1 = findRes(asym1, seq1);
 		if (r1 == mResidues.end())
 		if (r1 == mResidues.end())
 		{
 		{
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "Missing (incomplete?) residue for SS bond when trying to find " << asym1 << '/' << seq1 << std::endl;
 				std::cerr << "Missing (incomplete?) residue for SS bond when trying to find " << asym1 << '/' << seq1 << std::endl;
 			continue;
 			continue;
 			// throw std::runtime_error("Invalid file, missing residue for SS bond");
 			// throw std::runtime_error("Invalid file, missing residue for SS bond");
@@ -1249,7 +1249,7 @@ void DSSPImpl::calculateSecondaryStructure()
 		auto r2 = findRes(asym2, seq2);
 		auto r2 = findRes(asym2, seq2);
 		if (r2 == mResidues.end())
 		if (r2 == mResidues.end())
 		{
 		{
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "Missing (incomplete?) residue for SS bond when trying to find " << asym2 << '/' << seq2 << std::endl;
 				std::cerr << "Missing (incomplete?) residue for SS bond when trying to find " << asym2 << '/' << seq2 << std::endl;
 			continue;
 			continue;
 			// throw std::runtime_error("Invalid file, missing residue for SS bond");
 			// throw std::runtime_error("Invalid file, missing residue for SS bond");
@@ -1300,7 +1300,7 @@ void DSSPImpl::calculateSecondaryStructure()
 	{
 	{
 		if (a == b)
 		if (a == b)
 		{
 		{
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "In the SS bonds list, the residue " << a->mM << " is bonded to itself" << std::endl;
 				std::cerr << "In the SS bonds list, the residue " << a->mM << " is bonded to itself" << std::endl;
 			continue;
 			continue;
 		}
 		}
@@ -1483,7 +1483,7 @@ SecondaryStructureType DSSP::operator()(const std::string &inAsymID, int inSeqID
 		{ return r.mM.asymID() == inAsymID and r.mM.seqID() == inSeqID; });
 		{ return r.mM.asymID() == inAsymID and r.mM.seqID() == inSeqID; });
 	if (i != mImpl->mResidues.end())
 	if (i != mImpl->mResidues.end())
 		result = i->mSecondaryStructure;
 		result = i->mSecondaryStructure;
-	else if (cif::VERBOSE)
+	else if (cif::VERBOSE > 0)
 		std::cerr << "Could not find secondary structure for " << inAsymID << ':' << inSeqID << std::endl;
 		std::cerr << "Could not find secondary structure for " << inAsymID << ':' << inSeqID << std::endl;
 	return result;
 	return result;
 }
 }
@@ -1501,7 +1501,7 @@ double DSSP::accessibility(const std::string &inAsymID, int inSeqID) const
 		{ return r.mM.asymID() == inAsymID and r.mM.seqID() == inSeqID; });
 		{ return r.mM.asymID() == inAsymID and r.mM.seqID() == inSeqID; });
 	if (i != mImpl->mResidues.end())
 	if (i != mImpl->mResidues.end())
 		result = i->mSecondaryStructure;
 		result = i->mSecondaryStructure;
-	else if (cif::VERBOSE)
+	else if (cif::VERBOSE > 0)
 		std::cerr << "Could not find secondary structure for " << inAsymID << ':' << inSeqID << std::endl;
 		std::cerr << "Could not find secondary structure for " << inAsymID << ':' << inSeqID << std::endl;
 	return result;
 	return result;
 }
 }
@@ -1526,7 +1526,7 @@ bool DSSP::isAlphaHelixEndBeforeStart(const std::string &inAsymID, int inSeqID)
 
 
 	if (i != mImpl->mResidues.end() and i + 1 != mImpl->mResidues.end())
 	if (i != mImpl->mResidues.end() and i + 1 != mImpl->mResidues.end())
 		result = i->GetHelixFlag(HelixType::rh_alpha) == Helix::End and (i + 1)->GetHelixFlag(HelixType::rh_alpha) == Helix::Start;
 		result = i->GetHelixFlag(HelixType::rh_alpha) == Helix::End and (i + 1)->GetHelixFlag(HelixType::rh_alpha) == Helix::Start;
-	else if (cif::VERBOSE)
+	else if (cif::VERBOSE > 0)
 		std::cerr << "Could not find secondary structure for " << inAsymID << ':' << inSeqID << std::endl;
 		std::cerr << "Could not find secondary structure for " << inAsymID << ':' << inSeqID << std::endl;
 
 
 	return result;
 	return result;

src/TlsParser.cpp

@@ -248,7 +248,7 @@ struct TLSSelectionNot : public TLSSelection
 		for (auto& r: residues)
 		for (auto& r: residues)
 			r.selected = not r.selected;
 			r.selected = not r.selected;
 
 
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 		{
 		{
 			std::cout << std::string(indentLevel * 2, ' ') << "NOT" << std::endl;
 			std::cout << std::string(indentLevel * 2, ' ') << "NOT" << std::endl;
 			DumpSelection(residues, indentLevel);
 			DumpSelection(residues, indentLevel);
@@ -267,7 +267,7 @@ struct TLSSelectionAll : public TLSSelection
 		for (auto& r: residues)
 		for (auto& r: residues)
 			r.selected = true;
 			r.selected = true;
 
 
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 		{
 		{
 			std::cout << std::string(indentLevel * 2, ' ') << "ALL" << std::endl;
 			std::cout << std::string(indentLevel * 2, ' ') << "ALL" << std::endl;
 			DumpSelection(residues, indentLevel);
 			DumpSelection(residues, indentLevel);
@@ -287,7 +287,7 @@ struct TLSSelectionChain : public TLSSelectionAll
 		for (auto& r: residues)
 		for (auto& r: residues)
 			r.selected = allChains or r.chainID == m_chain;
 			r.selected = allChains or r.chainID == m_chain;
 
 
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 		{
 		{
 			std::cout << std::string(indentLevel * 2, ' ') << "CHAIN " << m_chain << std::endl;
 			std::cout << std::string(indentLevel * 2, ' ') << "CHAIN " << m_chain << std::endl;
 			DumpSelection(residues, indentLevel);
 			DumpSelection(residues, indentLevel);
@@ -307,7 +307,7 @@ struct TLSSelectionResID : public TLSSelectionAll
 		for (auto& r: residues)
 		for (auto& r: residues)
 			r.selected = r.seqNr == m_seq_nr and r.iCode == m_icode;
 			r.selected = r.seqNr == m_seq_nr and r.iCode == m_icode;
 
 
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 		{
 		{
 			std::cout << std::string(indentLevel * 2, ' ') << "ResID " << m_seq_nr << (m_icode ? std::string { m_icode} : "") << std::endl;
 			std::cout << std::string(indentLevel * 2, ' ') << "ResID " << m_seq_nr << (m_icode ? std::string { m_icode} : "") << std::endl;
 			DumpSelection(residues, indentLevel);
 			DumpSelection(residues, indentLevel);
@@ -331,7 +331,7 @@ struct TLSSelectionRangeSeq : public TLSSelectionAll
 						  (r.seqNr <= m_last or m_last == kResidueNrWildcard));
 						  (r.seqNr <= m_last or m_last == kResidueNrWildcard));
 		}
 		}
 
 
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 		{
 		{
 			std::cout << std::string(indentLevel * 2, ' ') << "Range " << m_first << ':' << m_last << std::endl;
 			std::cout << std::string(indentLevel * 2, ' ') << "Range " << m_first << ':' << m_last << std::endl;
 			DumpSelection(residues, indentLevel);
 			DumpSelection(residues, indentLevel);
@@ -374,7 +374,7 @@ struct TLSSelectionRangeID : public TLSSelectionAll
 			}
 			}
 		}
 		}
 
 
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 		{
 		{
 			std::cout << std::string(indentLevel * 2, ' ') << "Through " << m_first << ':' << m_last << std::endl;
 			std::cout << std::string(indentLevel * 2, ' ') << "Through " << m_first << ':' << m_last << std::endl;
 			DumpSelection(residues, indentLevel);
 			DumpSelection(residues, indentLevel);
@@ -407,7 +407,7 @@ struct TLSSelectionUnion : public TLSSelection
 		for (auto ai = a.begin(), bi = b.begin(), ri = residues.begin(); ri != residues.end(); ++ai, ++bi, ++ri)
 		for (auto ai = a.begin(), bi = b.begin(), ri = residues.begin(); ri != residues.end(); ++ai, ++bi, ++ri)
 			ri->selected = ai->selected or bi->selected;
 			ri->selected = ai->selected or bi->selected;
 
 
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 		{
 		{
 			std::cout << std::string(indentLevel * 2, ' ') << "Union" << std::endl;
 			std::cout << std::string(indentLevel * 2, ' ') << "Union" << std::endl;
 			DumpSelection(residues, indentLevel);
 			DumpSelection(residues, indentLevel);
@@ -440,7 +440,7 @@ struct TLSSelectionIntersection : public TLSSelection
 		for (auto ai = a.begin(), bi = b.begin(), ri = residues.begin(); ri != residues.end(); ++ai, ++bi, ++ri)
 		for (auto ai = a.begin(), bi = b.begin(), ri = residues.begin(); ri != residues.end(); ++ai, ++bi, ++ri)
 			ri->selected = ai->selected and bi->selected;
 			ri->selected = ai->selected and bi->selected;
 
 
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 		{
 		{
 			std::cout << std::string(indentLevel * 2, ' ') << "Intersection" << std::endl;
 			std::cout << std::string(indentLevel * 2, ' ') << "Intersection" << std::endl;
 			DumpSelection(residues, indentLevel);
 			DumpSelection(residues, indentLevel);
@@ -462,7 +462,7 @@ struct TLSSelectionByName : public TLSSelectionAll
 		for (auto& r: residues)
 		for (auto& r: residues)
 			r.selected = r.name == m_name;
 			r.selected = r.name == m_name;
 
 
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 		{
 		{
 			std::cout << std::string(indentLevel * 2, ' ') << "Name " << m_name << std::endl;
 			std::cout << std::string(indentLevel * 2, ' ') << "Name " << m_name << std::endl;
 			DumpSelection(residues, indentLevel);
 			DumpSelection(residues, indentLevel);
@@ -488,7 +488,7 @@ struct TLSSelectionByElement : public TLSSelectionAll
 		for (auto& r: residues)
 		for (auto& r: residues)
 			r.selected = iequals(r.name, m_element);
 			r.selected = iequals(r.name, m_element);
 
 
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 		{
 		{
 			std::cout << std::string(indentLevel * 2, ' ') << "Element " << m_element << std::endl;
 			std::cout << std::string(indentLevel * 2, ' ') << "Element " << m_element << std::endl;
 			DumpSelection(residues, indentLevel);
 			DumpSelection(residues, indentLevel);
@@ -890,7 +890,7 @@ TLSSelectionPtr TLSSelectionParserImplPhenix::Parse()
 
 
 	Match(pt_EOLN);
 	Match(pt_EOLN);
 	
 	
-	if (extraParenthesis)
+	if (extraParenthesis and cif::VERBOSE > 0)
 		std::cerr << "WARNING: too many closing parenthesis in TLS selection statement" << std::endl;
 		std::cerr << "WARNING: too many closing parenthesis in TLS selection statement" << std::endl;
 	
 	
 	return result;
 	return result;
@@ -931,7 +931,7 @@ TLSSelectionPtr TLSSelectionParserImplPhenix::ParseFactor()
 		case '(':
 		case '(':
 			Match('(');
 			Match('(');
 			result = ParseAtomSelection();
 			result = ParseAtomSelection();
-			if (m_lookahead == pt_EOLN)
+			if (m_lookahead == pt_EOLN and cif::VERBOSE > 0)
 				std::cerr << "WARNING: missing closing parenthesis in TLS selection statement" << std::endl;
 				std::cerr << "WARNING: missing closing parenthesis in TLS selection statement" << std::endl;
 			else
 			else
 				Match(')');
 				Match(')');
@@ -1033,7 +1033,7 @@ TLSSelectionPtr TLSSelectionParserImplPhenix::ParseFactor()
 					result.reset(new TLSSelectionRangeID(from, to, icode_from, icode_to));
 					result.reset(new TLSSelectionRangeID(from, to, icode_from, icode_to));
 				else
 				else
 				{
 				{
-					if (cif::VERBOSE and (icode_from or icode_to))
+					if (cif::VERBOSE > 0 and (icode_from or icode_to))
 						std::cerr << "Warning, ignoring insertion codes" << std::endl;
 						std::cerr << "Warning, ignoring insertion codes" << std::endl;
 					
 					
 					result.reset(new TLSSelectionRangeSeq(from, to));
 					result.reset(new TLSSelectionRangeSeq(from, to));
@@ -1231,7 +1231,8 @@ TLSSelectionPtr TLSSelectionParserImplBuster::ParseGroup()
 				std::tie(chain2, seqNr2) = ParseAtom();
 				std::tie(chain2, seqNr2) = ParseAtom();
 				if (chain1 != chain2)
 				if (chain1 != chain2)
 				{
 				{
-					std::cerr << "Warning, ranges over multiple chains detected" << std::endl;
+					if (cif::VERBOSE > 0)
+						std::cerr << "Warning, ranges over multiple chains detected" << std::endl;
 					
 					
 					TLSSelectionPtr sc1(new TLSSelectionChain(chain1));
 					TLSSelectionPtr sc1(new TLSSelectionChain(chain1));
 					TLSSelectionPtr sr1(new TLSSelectionRangeSeq(seqNr1, kResidueNrWildcard));
 					TLSSelectionPtr sr1(new TLSSelectionRangeSeq(seqNr1, kResidueNrWildcard));
@@ -1289,7 +1290,7 @@ std::tuple<std::string,int> TLSSelectionParserImplBuster::ParseAtom()
 			Match(':');
 			Match(':');
 			std::string atom = m_value_s;
 			std::string atom = m_value_s;
 			
 			
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "Warning: ignoring atom ID '" << atom << "' in TLS selection" << std::endl;
 				std::cerr << "Warning: ignoring atom ID '" << atom << "' in TLS selection" << std::endl;
 			
 			
 			Match(bt_IDENT);
 			Match(bt_IDENT);
@@ -1810,7 +1811,8 @@ class TLSSelectionParser
 		}
 		}
 		catch (const std::exception& ex)
 		catch (const std::exception& ex)
 		{
 		{
-			std::cerr << "ParseError: " << ex.what() << std::endl;
+			if (cif::VERBOSE >= 0)
+				std::cerr << "ParseError: " << ex.what() << std::endl;
 		}
 		}
 		
 		
 		return result;
 		return result;
@@ -1834,14 +1836,14 @@ TLSSelectionPtr ParseSelectionDetails(const std::string& program, const std::str
 
 
 		if (not result)
 		if (not result)
 		{
 		{
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "Falling back to old BUSTER" << std::endl;
 				std::cerr << "Falling back to old BUSTER" << std::endl;
 			result = busterOld.Parse(selection);
 			result = busterOld.Parse(selection);
 		}
 		}
 		
 		
 		if (not result)
 		if (not result)
 		{
 		{
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "Falling back to PHENIX" << std::endl;
 				std::cerr << "Falling back to PHENIX" << std::endl;
 			result = phenix.Parse(selection);
 			result = phenix.Parse(selection);
 		}
 		}
@@ -1852,35 +1854,35 @@ TLSSelectionPtr ParseSelectionDetails(const std::string& program, const std::str
 
 
 		if (not result)
 		if (not result)
 		{
 		{
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "Falling back to BUSTER" << std::endl;
 				std::cerr << "Falling back to BUSTER" << std::endl;
 			result = buster.Parse(selection);
 			result = buster.Parse(selection);
 		}
 		}
 
 
 		if (not result)
 		if (not result)
 		{
 		{
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "Falling back to old BUSTER" << std::endl;
 				std::cerr << "Falling back to old BUSTER" << std::endl;
 			result = busterOld.Parse(selection);
 			result = busterOld.Parse(selection);
 		}
 		}
 	}
 	}
 	else
 	else
 	{
 	{
-		if (cif::VERBOSE)
+		if (cif::VERBOSE > 0)
 			std::cerr << "No known program specified, trying PHENIX" << std::endl;
 			std::cerr << "No known program specified, trying PHENIX" << std::endl;
 
 
 		result = phenix.Parse(selection);
 		result = phenix.Parse(selection);
 
 
 		if (not result)
 		if (not result)
 		{
 		{
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "Falling back to BUSTER" << std::endl;
 				std::cerr << "Falling back to BUSTER" << std::endl;
 			result = buster.Parse(selection);
 			result = buster.Parse(selection);
 		}
 		}
 
 
 		if (not result)
 		if (not result)
 		{
 		{
-			if (cif::VERBOSE)
+			if (cif::VERBOSE > 0)
 				std::cerr << "Falling back to old BUSTER" << std::endl;
 				std::cerr << "Falling back to old BUSTER" << std::endl;
 			result = busterOld.Parse(selection);
 			result = busterOld.Parse(selection);
 		}
 		}

test/structure-test.cpp

@@ -179,3 +179,23 @@ _struct_asym.details                       ?
 				<< structure.getFile().data() << std::endl;
 				<< structure.getFile().data() << std::endl;
 	}
 	}
 }
 }
+
+// // --------------------------------------------------------------------
+
+// BOOST_AUTO_TEST_CASE(test_load_1)
+// {
+// 	mmcif::File cf(gTestDir / "5v3g.cif.gz");
+// 	mmcif::Structure s(cf);
+
+// 	for (auto &poly : s.polymers())
+// 	{
+// 		std::cout << std::string(80, '=') << std::endl;
+// 		for (auto &res : poly)
+// 		{
+// 			std::cout << res << std::endl;
+
+// 			for (auto &atom : res.atoms())
+// 				std::cout << "  " << atom << std::endl;
+// 		}
+// 	}
+// }