/// \brief TODOCUMENT
///
/// Things for investigation:
///  * raw/final score from alignment
///  * expected raw/final score
///  * top categorised reasons by raw score
///  * repeat for varying scan_stride (can just be called by nmnf fn)
alignment_scan_comparison check_scan_on_final_alignment::do_check(const alignment     &arg_alignment,  ///< TODOCUMENT
                                                                  const protein       &arg_protein_a,  ///< TODOCUMENT
                                                                  const protein       &arg_protein_b,  ///< TODOCUMENT
                                                                  const quad_criteria &arg_criteria,   ///< TODOCUMENT
                                                                  const scan_stride   &arg_scan_stride ///< TODOCUMENT
                                                                  ) const {
	const auto aln_range = irange( 0_z, arg_alignment.length() );
	cerr << "SHOULD THE RANGE BE 7.0 RATHER THAN SQRT(40.0)????\n";
	return accumulate(
		cross( aln_range, aln_range ),
		alignment_scan_comparison{},
		[&] (alignment_scan_comparison x, const size_size_tpl &y) {
			const size_t aln_from_ctr   = get<0>( y );
			const size_t aln_to_ctr     = get<1>( y );
			const bool   from_alns_both = has_both_positions_of_index( arg_alignment, aln_from_ctr );
			const bool   to_alns_both   = has_both_positions_of_index( arg_alignment, aln_to_ctr   );

			if ( from_alns_both && to_alns_both ) {

				const auto a_from     = get_a_position_of_index( arg_alignment, aln_from_ctr );
				const auto b_from     = get_b_position_of_index( arg_alignment, aln_from_ctr );
				const auto a_to       = get_a_position_of_index( arg_alignment, aln_to_ctr   );
				const auto b_to       = get_b_position_of_index( arg_alignment, aln_to_ctr   );
				const bool a_included = difference( a_from, a_to ) > NUM_EXCLUDED_ON_SIDES;
				const bool b_included = difference( b_from, b_to ) > NUM_EXCLUDED_ON_SIDES;

				if ( a_included && b_included ) {
					const auto the_distance = distance_between_points(
						view_vector_of_residue_pair(
							arg_protein_a.get_residue_ref_of_index( a_from ),
							arg_protein_a.get_residue_ref_of_index( a_to   )
						),
						view_vector_of_residue_pair(
							arg_protein_b.get_residue_ref_of_index( b_from ),
							arg_protein_b.get_residue_ref_of_index( b_to   )
						)
					);
//					const auto score       = ( the_distance >= 7.0 ) ? 0.0 : ( 1.0 - the_distance / 7.0 );
					const auto score       = ( the_distance >= sqrt( 40.0 ) ) ? 0.0 : ( 1.0 - the_distance / 7.0 );
					if ( score > 0.0 ) {
						const auto scan_result = quad_and_rep_criteria_result_of(
							arg_protein_a,
							arg_protein_b,
							arg_criteria,
							arg_scan_stride,
							numeric_cast<index_type>( a_from ),
							numeric_cast<index_type>( a_to   ),
							numeric_cast<index_type>( b_from ),
							numeric_cast<index_type>( b_to   )
						);
						x += make_pair( scan_result, score );
					}
				}
			}

			return x;
		}
	);
}
			/// \brief Get the (wrapped) difference between the two pairs' to_residue psi angles
			inline angle_type to_psi_angle_difference(const size_size_pair &arg_indices_a, ///< The indices of the from/to residues in the first  protein
			                                          const size_size_pair &arg_indices_b, ///< The indices of the from/to residues in the second protein
			                                          const protein        &arg_protein_a, ///< The first  protein
			                                          const protein        &arg_protein_b  ///< The second protein
			                                          ) {
				const residue    &to_a_res = arg_protein_a.get_residue_ref_of_index( arg_indices_a.second );
				const residue    &to_b_res = arg_protein_b.get_residue_ref_of_index( arg_indices_b.second );
				const angle_type &to_psi_a = geom::make_angle_from_radians<angle_base_type>( angle_in_radians( to_a_res.get_psi_angle() ) );
				const angle_type &to_psi_b = geom::make_angle_from_radians<angle_base_type>( angle_in_radians( to_b_res.get_psi_angle() ) );
				return wrapped_difference( to_psi_a, to_psi_b );
			}
			/// \brief Get the (wrapped) difference between the two pairs' from_residue psi angles
			inline angle_type from_psi_angle_difference(const size_size_pair &arg_indices_a, ///< The indices of the from/to residues in the first  protein
			                                            const size_size_pair &arg_indices_b, ///< The indices of the from/to residues in the second protein
			                                            const protein        &arg_protein_a, ///< The first  protein
			                                            const protein        &arg_protein_b  ///< The second protein
			                                            ) {
				const residue &from_a_res = arg_protein_a.get_residue_ref_of_index( arg_indices_a.first );
				const residue &from_b_res = arg_protein_b.get_residue_ref_of_index( arg_indices_b.first );
				const auto     from_psi_a = geom::convert_angle_type<angle_base_type>( from_a_res.get_psi_angle() );
				const auto     from_psi_b = geom::convert_angle_type<angle_base_type>( from_b_res.get_psi_angle() );
				return wrapped_difference( from_psi_a, from_psi_b );
			}
/// \brief TODOCUMENT
///
/// Provide functions that allow this function to be expressed slightly more tightly
quad_criteria_result check_scan_on_final_alignment::rep_quad_criteria_result_of(const protein            &arg_query_protein,    ///< TODOCUMENT
                                                                                const protein            &arg_index_protein,    ///< TODOCUMENT
                                                                                const quad_criteria      &arg_criteria,         ///< TODOCUMENT
                                                                                const scan_stride        &arg_scan_stride,      ///< TODOCUMENT
                                                                                const index_type         &arg_query_from_index, ///< TODOCUMENT
                                                                                const index_type         &arg_query_to_index,   ///< TODOCUMENT
                                                                                const index_type         &arg_index_from_index, ///< TODOCUMENT
                                                                                const index_type         &arg_index_to_index    ///< TODOCUMENT
                                                                                ) {
	const auto from_rep_indices = get_from_rep_of_indices( arg_scan_stride, arg_query_from_index, arg_index_from_index );
	const auto to_rep_indices   = get_to_rep_of_indices  ( arg_scan_stride, arg_query_to_index,   arg_index_to_index   );

	if ( ! from_rep_indices || ! to_rep_indices ) {
		return quad_criteria_result::HAS_NO_REP;
	}

	const auto query_from_rep_index = from_rep_indices->first;
	const auto query_to_rep_index   = to_rep_indices->first;
	const auto index_from_rep_index = from_rep_indices->second;
	const auto index_to_rep_index   = to_rep_indices->second;
	const auto query_res_pair       = make_multi_struc_res_rep_pair(
		arg_query_protein.get_residue_ref_of_index( get_index_of_rep_index( arg_scan_stride.get_query_from_strider(), query_from_rep_index ) ),
		arg_query_protein.get_residue_ref_of_index( get_index_of_rep_index( arg_scan_stride.get_query_to_strider  (), query_to_rep_index   ) ),
		0,
		query_from_rep_index,
		query_to_rep_index
	);
	const auto index_res_pair       = make_multi_struc_res_rep_pair(
		arg_index_protein.get_residue_ref_of_index( get_index_of_rep_index( arg_scan_stride.get_index_from_strider(), index_from_rep_index ) ),
		arg_index_protein.get_residue_ref_of_index( get_index_of_rep_index( arg_scan_stride.get_index_to_strider  (), index_to_rep_index   ) ),
		0,
		index_from_rep_index,
		index_to_rep_index
	);
	const auto result               = criteria_result_of( arg_criteria, query_res_pair, index_res_pair );
//	if ( result != quad_criteria_result::PASS && result != quad_criteria_result::QUERY_FAILS_SINGLE_CHECKS && result != quad_criteria_result::INDEX_FAILS_SINGLE_CHECKS ) {
//		quad_criteria_result::PASS;
		cerr << "Quad: [("  << setw(  2 ) << right << arg_query_from_index
		     << ","         << setw(  2 ) << right << arg_index_from_index
		     << ")->("      << setw(  2 ) << right << arg_query_to_index
		     << ","         << setw(  2 ) << right << arg_index_to_index
		     << ")], Rep[(" << setw(  2 ) << right << query_from_rep_index
		     << ","         << setw(  2 ) << right << index_from_rep_index
		     << ")->("      << setw(  2 ) << right << query_to_rep_index
		     << ","         << setw(  2 ) << right << index_to_rep_index
		     << ")]="       << setw( 25 ) << right << result
//		     << ",A/"                              << query_res_pair
//		     << ",B/"                              << index_res_pair
		     << "\n";
//	}

	return result;
}
/// \brief TODOCUMENT
void cath::test::dssp_wolf_file_test_suite_fixture::check_pdb_and_dssp_built_protein(const string &arg_example_id ///< TODOCUMENT
                                                                                     ) {
	ostringstream build_prot_warn_stream;
	const auto the_pdb_file               = read_pdb_file (  pdb_file_of_example_id( arg_example_id ) );
	const auto the_dssp_file              = read_dssp_file( dssp_file_of_example_id( arg_example_id ) );
	const auto pdb_prot                   = build_protein_of_pdb( the_pdb_file, reference_wrapper<ostream>{ build_prot_warn_stream } );
	const auto num_non_null_dssp_residues = get_num_non_null_residues( the_dssp_file );
	const auto num_pdb_residues           = pdb_prot.get_length();
	BOOST_CHECK_EQUAL( build_prot_warn_stream.str(), "" );

	ostringstream test_ss;
	const log_to_ostream_guard the_guard{ test_ss };

	const protein      combi_prot_with_all_pdb_residues   = protein_from_dssp_and_pdb(the_dssp_file, the_pdb_file, dssp_skip_policy::DONT_SKIP__BREAK_ANGLES );
	const protein      combi_prot_with_dssp_only_residues = protein_from_dssp_and_pdb(the_dssp_file, the_pdb_file, dssp_skip_policy::SKIP__BREAK_ANGLES      );

	BOOST_REQUIRE_EQUAL( num_non_null_dssp_residues, combi_prot_with_dssp_only_residues.get_length() );
	BOOST_REQUIRE_EQUAL( num_pdb_residues,           combi_prot_with_all_pdb_residues.get_length()   );

	// Compare the combi's residues with the DSSP residues
	//( this requires two counters to handle skipping null DSSP residues)
	size_t combi_residue_ctr = 0;
	for (const residue dssp_residue : the_dssp_file) {

		// If this is a null DSSP residue then just move onto the next one
		if ( is_null_residue(dssp_residue) ) {
			continue;
		}
		const residue built_residue = combi_prot_with_dssp_only_residues.get_residue_ref_of_index( combi_residue_ctr );
		BOOST_CHECK_EQUAL( dssp_residue.get_pdb_residue_id(),   built_residue.get_pdb_residue_id()   );
		BOOST_CHECK_EQUAL( dssp_residue.get_sec_struc_number(), built_residue.get_sec_struc_number() );
		BOOST_CHECK_EQUAL( dssp_residue.get_sec_struc_type(),   built_residue.get_sec_struc_type()   );
//		cerr << dssp_residue  << endl;
//		cerr << built_residue << endl;
//		cerr << endl;
		++combi_residue_ctr;
	}

	for (size_t pdb_residue_ctr = 0; pdb_residue_ctr < num_pdb_residues; ++pdb_residue_ctr) {
		const pdb_residue the_pdb_residue = the_pdb_file.get_residue_cref_of_index__backbone_unchecked(pdb_residue_ctr);
		const residue     built_residue   = combi_prot_with_all_pdb_residues.get_residue_ref_of_index( pdb_residue_ctr );
		BOOST_CHECK_EQUAL( the_pdb_residue.get_residue_id(),                               built_residue.get_pdb_residue_id()     );
		BOOST_CHECK_EQUAL( get_carbon_alpha_coord( the_pdb_residue ),                      built_residue.get_carbon_alpha_coord() );
		BOOST_CHECK_EQUAL( get_or_predict_carbon_beta_coord_of_residue( the_pdb_residue ), built_residue.get_carbon_beta_coord()  );
//		cerr << pdb_residue   << endl;
//		cerr << built_residue << endl;
//		cerr << endl;
	}
}
			/// \brief Calculate the squared distance between the views of the two residue pairs
			///
			/// Each view is the location of the to_residue's carbon-beta atom as seen from
			/// the coordinate frame of the from_residue
			inline double squared_distance(const size_size_pair &arg_indices_a, ///< The indices of the from/to residues in the first  protein
			                               const size_size_pair &arg_indices_b, ///< The indices of the from/to residues in the second protein
			                               const protein        &arg_protein_a, ///< The first  protein
			                               const protein        &arg_protein_b  ///< The second protein
			                               ) {
				const residue    &from_a_res = arg_protein_a.get_residue_ref_of_index( arg_indices_a.first  );
				const residue    &to_a_res   = arg_protein_a.get_residue_ref_of_index( arg_indices_a.second );
				const residue    &from_b_res = arg_protein_b.get_residue_ref_of_index( arg_indices_b.first  );
				const residue    &to_b_res   = arg_protein_b.get_residue_ref_of_index( arg_indices_b.second );

				const geom::coord view_a     = view_vector_of_residue_pair( from_a_res, to_a_res );
				const geom::coord view_b     = view_vector_of_residue_pair( from_b_res, to_b_res );

				return squared_distance_between_points( view_a, view_b );
			}
			void add_structure_to_store(T                         &arg_store,           ///< TODOCUMENT
			                            const index_type          &arg_structure_index, ///< TODOCUMENT
			                            const protein             &arg_protein,         ///< TODOCUMENT
			                            const scan_policy<KPs...> &arg_scan_policy,     ///< TODOCUMENT
			                            const scan_role           &arg_scan_role        ///< TODOCUMENT
			                            ) {
				const auto &the_keyer        = arg_scan_policy.get_keyer();
//				BOOST_LOG_TRIVIAL( warning ) << "Keyer is : " << the_keyer;
				const auto  roled_stride     = roled_scan_stride{ arg_scan_role, arg_scan_policy.get_scan_stride() };
				const auto  num_residues     = debug_unwarned_numeric_cast<index_type>( arg_protein.get_length() );
				const auto  from_rep_strider = get_this_from_strider( roled_stride );
				const auto  to_rep_strider   = get_this_to_strider  ( roled_stride );
				for (const auto &from_rep_index : get_rep_indices_range( from_rep_strider, num_residues ) ) {
//					 BOOST_LOG_TRIVIAL( warning ) << "\tFrom rep " << from_rep_index;
					for (const auto &to_rep_index : get_rep_indices_range( to_rep_strider, num_residues ) ) {

						if ( from_rep_index != to_rep_index ) {
							const auto the_res_pair = make_multi_struc_res_rep_pair(
								arg_protein.get_residue_ref_of_index( get_index_of_rep_index( from_rep_strider, from_rep_index ) ),
								arg_protein.get_residue_ref_of_index( get_index_of_rep_index( to_rep_strider,   to_rep_index   ) ),
								arg_structure_index,
								from_rep_index,
								to_rep_index
							);
//							BOOST_LOG_TRIVIAL( warning ) << "\t\tTo rep " << to_rep_index << " - the rep : " << the_res_pair;
							arg_store.push_back_entry_to_cell( the_keyer.make_key( the_res_pair ), the_res_pair );
						}
					}
				}
			}
			/// \brief Calculate the view_frame of the pair
			///        (ie the coordinate frame of the to_residue's atoms in terms of the coordinate from of the from_residue's atoms)
			inline cath::geom::rotation view_frame(const protein &arg_protein,    ///< The protein containing the two residues
			                                       const size_t  &arg_from_index, ///< The index of the from_residue
			                                       const size_t  &arg_to_index    ///< The index of the to_residue
			                                       ) {
				return view_frame(
					arg_protein.get_residue_ref_of_index( arg_from_index ),
					arg_protein.get_residue_ref_of_index( arg_to_index   )
				);
			}
/// \brief TODOCUMENT
void cath::test::dssp_wolf_file_test_suite_fixture::compare_residue_frames_from_pdb_vs_wolf(const string &arg_example_id ///< TODOCUMENT
                                                                                            ) {
	ostringstream build_prot_warn_stream;
	const wolf_file            the_wolf_file     = read_wolf(     wolf_file_of_example_id( arg_example_id ) );
	const pdb                  the_pdb_file      = read_pdb_file(  pdb_file_of_example_id( arg_example_id ) );
	const protein              pdb_prot          = build_protein_of_pdb( the_pdb_file, reference_wrapper<ostream>{ build_prot_warn_stream });
	const wolf_file::size_type num_wolf_residues = the_wolf_file.get_num_residues();
	const size_t   num_pdb_residues  = pdb_prot.get_length();

	BOOST_CHECK_EQUAL( build_prot_warn_stream.str(), "" );

	BOOST_REQUIRE_EQUAL(num_pdb_residues, num_wolf_residues);

	doub_angle_vec angles_between_frame_pairs;
	for (size_t residue_ctr = 0; residue_ctr < num_pdb_residues; ++residue_ctr) {
		const residue &wolf_residue     = the_wolf_file.get_residue_of_index( residue_ctr );
		const residue &pdb_prot_residue = pdb_prot.get_residue_ref_of_index( residue_ctr );

		BOOST_REQUIRE_EQUAL( pdb_prot_residue.get_pdb_residue_id(), wolf_residue.get_pdb_residue_id() );

		const rotation   raw_wolf_frame   = wolf_residue.get_frame();
		const rotation   wolf_frame       = tidy_copy(raw_wolf_frame, 0.001);
		const rotation   pdb_frame        = pdb_prot_residue.get_frame();
		const doub_angle the_angle        = angle_between_rotations( wolf_frame, pdb_frame );
		angles_between_frame_pairs.push_back( the_angle );
	}

	BOOST_REQUIRE_GT( angles_between_frame_pairs.size(), 0_z );

	// Sort the list of angles in ascending order
	sort( angles_between_frame_pairs );

	// Check that around 95% of the way through the list of angles, the values are still
	// less than 3 degrees (in radians)
	const size_t ninety_fifth_perc_index = numeric_cast<size_t>(
		round( 0.95 * numeric_cast<double>( angles_between_frame_pairs.size() ) )
	);
	BOOST_CHECK_LT(
		angles_between_frame_pairs[ ninety_fifth_perc_index ],
		make_angle_from_degrees<double>( 3.0 )
	);
}
/// \brief Private static method that implements the process of building the views from proteins
coord_vec_vec view_cache::build_views(const protein &arg_protein ///< The protein which the view_cache should be built to represent
                                      ) {
	// Grab the number of residues and prepare the views accordingly
	const size_t num_residues = arg_protein.get_length();
	coord_vec_vec new_views( num_residues );
	for (coord_vec &view_of : new_views) {
		view_of.reserve( num_residues );
	}

	// Loop over the all from-versus-to residue pairs and add the resulting views
	for (const size_t &from_res_ctr : irange( 0_z, num_residues ) ) {
		for (const size_t &to_res_ctr : irange( 0_z, num_residues ) ) {
			coord_vec &view_of_from = new_views[ from_res_ctr ];
			view_of_from.push_back( view_vector_of_residue_pair(
				arg_protein.get_residue_ref_of_index( from_res_ctr ),
				arg_protein.get_residue_ref_of_index( to_res_ctr   )
			) );
		}
	}
	return new_views;
}
/// \brief TODOCUMENT
pair<str_vec, str_vec> check_scan_on_final_alignment::get_rep_name_lists(const protein           &arg_protein,          ///< TODOCUMENT
                                                                         const roled_scan_stride &arg_roled_scan_stride ///< TODOCUMENT
                                                                         ) const {
//	const auto        &num_residues  = arg_protein.get_length();
	const auto rep_list_indices      = get_rep_index_lists( arg_roled_scan_stride, numeric_cast<index_type>( arg_protein.get_length() ) );
	const auto residue_name_of_index = [&] (const index_type &x) { return get_pdb_residue_name_string( arg_protein.get_residue_ref_of_index( x ) ); };
	return make_pair(
		transform_build<str_vec>( rep_list_indices.first,  residue_name_of_index ),
		transform_build<str_vec>( rep_list_indices.second, residue_name_of_index )
	);
}
			void dense_add_structure_to_store(T                         &arg_store,           ///< TODOCUMENT
			                                  const index_type          &arg_structure_index, ///< TODOCUMENT
			                                  const protein             &arg_protein,         ///< TODOCUMENT
			                                  const scan_policy<KPs...> &arg_scan_policy,     ///< TODOCUMENT
			                                  const scan_role           &arg_scan_role        ///< TODOCUMENT
			                                  ) {
				const auto &the_criteria     = arg_scan_policy.get_criteria();
				const auto &the_keyer        = arg_scan_policy.get_keyer();
//				BOOST_LOG_TRIVIAL( warning ) << "Keyer is : " << the_keyer;
				const auto  roled_stride     = roled_scan_stride{ arg_scan_role, arg_scan_policy.get_scan_stride() };
				const auto  num_residues     = debug_unwarned_numeric_cast<index_type>( arg_protein.get_length() );
				const auto  from_rep_strider = get_this_from_strider( roled_stride );
				const auto  to_rep_strider   = get_this_to_strider  ( roled_stride );
				for (const auto &from_rep_index : get_rep_indices_range( from_rep_strider, num_residues ) ) {
//					BOOST_LOG_TRIVIAL( warning ) << "\tFrom rep " << from_rep_index;
					for (const auto &to_rep_index : get_rep_indices_range( to_rep_strider, num_residues ) ) {
//						BOOST_LOG_TRIVIAL( warning ) << "\t\tTo rep " << to_rep_index;
						if ( from_rep_index != to_rep_index ) {
							const auto the_res_pair = make_multi_struc_res_rep_pair(
								arg_protein.get_residue_ref_of_index( get_index_of_rep_index( from_rep_strider, from_rep_index ) ),
								arg_protein.get_residue_ref_of_index( get_index_of_rep_index( to_rep_strider, to_rep_index )   ),
								arg_structure_index,
								from_rep_index,
								to_rep_index
							);
//							BOOST_LOG_TRIVIAL( warning ) << "\t\tMade multi_struc_res_rep_pair : " << the_res_pair;
//							const auto the_key    = the_keyer.make_key       ( the_res_pair );
//							BOOST_LOG_TRIVIAL( warning ) << "\t\tThe actual key itself is      : " << output_key(the_key );

							const auto close_keys = the_keyer.make_close_keys( the_res_pair, the_criteria );
//							BOOST_LOG_TRIVIAL( warning ) << "\t\t\t(from_phi : "
//							                             << the_res_pair.get_res_pair_core().get_from_phi_angle()
//							                             << ") There are "
//							                             << boost::distance( common::cross( close_keys ) )
//							                             << " keys close to "
//							                             << output_key( the_keyer.make_key( the_res_pair ) );

//							BOOST_LOG_TRIVIAL( warning ) << "\t\tRange 0 : \"" << boost::algorithm::join ( std::get<0>( close_keys ) | boost::adaptors::transformed( [](const uint8_t &x) { return std::to_string( static_cast<size_t>( x) ); } ) , "\", \"") << "\"";
//							BOOST_LOG_TRIVIAL( warning ) << "\t\tRange 1 : \"" << boost::algorithm::join ( std::get<1>( close_keys ) | boost::adaptors::transformed( [](const uint8_t &x) { return std::to_string( static_cast<size_t>( x) ); } ) , "\", \"") << "\"";
//							BOOST_LOG_TRIVIAL( warning ) << "\t\tRange 2 : \"" << boost::algorithm::join ( std::get<2>( close_keys ) | boost::adaptors::transformed( [](const uint8_t &x) { return std::to_string( static_cast<size_t>( x) ); } ) , "\", \"") << "\"";
//							BOOST_LOG_TRIVIAL( warning ) << "\t\tRange 3 : \"" << boost::algorithm::join ( std::get<3>( close_keys ) | boost::adaptors::transformed( [](const uint8_t &x) { return std::to_string( static_cast<size_t>( x) ); } ) , "\", \"") << "\"";
//							BOOST_LOG_TRIVIAL( warning ) << "\t\tRange 4 : \"" << boost::algorithm::join ( std::get<4>( close_keys ) | common::lexical_casted<std::string>() , "\", \"") << "\"";
//							BOOST_LOG_TRIVIAL( warning ) << "\t\tRange 5 : \"" << boost::algorithm::join ( std::get<5>( close_keys ) | common::lexical_casted<std::string>() , "\", \"") << "\"";
//							BOOST_LOG_TRIVIAL( warning ) << "\t\tRange 6 : \"" << boost::algorithm::join ( std::get<6>( close_keys ) | common::lexical_casted<std::string>() , "\", \"") << "\"";
//							BOOST_LOG_TRIVIAL( warning ) << "\t\tRange 7 : \"" << boost::algorithm::join ( std::get<7>( close_keys ) | common::lexical_casted<std::string>() , "\", \"") << "\"";

//							KEYER_PARTS: tuple<
//								res_pair_phi_psi_angle_keyer_part<res_pair_from_phi_keyer_part_spec>,
//								res_pair_phi_psi_angle_keyer_part<res_pair_from_psi_keyer_part_spec>,
//								res_pair_phi_psi_angle_keyer_part<res_pair_to_phi_keyer_part_spec>,
//								res_pair_phi_psi_angle_keyer_part<res_pair_to_psi_keyer_part_spec>,
//								res_pair_index_dirn_keyer_part,
//								res_pair_view_axis_keyer_part<res_pair_view_x_keyer_part_spec>,
//								res_pair_view_axis_keyer_part<res_pair_view_y_keyer_part_spec>,
//								res_pair_view_axis_keyer_part<res_pair_view_z_keyer_part_spec>
//							>
//							KEY: tuple<unsigned char, unsigned char, unsigned char, unsigned char, res_pair_dirn, short, short, short>
//							CLOSE_KEYS: tuple<
//								joined_range<const integer_range<unsigned char>, const integer_range<unsigned char> >,
//								joined_range<const integer_range<unsigned char>, const integer_range<unsigned char> >,
//								joined_range<const integer_range<unsigned char>, const integer_range<unsigned char> >,
//								joined_range<const integer_range<unsigned char>, const integer_range<unsigned char> >,
//								array<res_pair_dirn, 1u>,
//								integer_range<short int>,
//								integer_range<short int>,
//								integer_range<short int>
//							>;
//							ELEMENT_OF_CLOSE_KEYS: tuple<unsigned char, unsigned char, unsigned char, unsigned char, const res_pair_dirn &, short, short, short>

//							const bool contains_key = common::contains( common::cross( close_keys ), the_keyer.make_key( the_res_pair ) );
//							if ( contains_key ) {
//								BOOST_LOG_TRIVIAL( warning ) << "\t\t\tDoes contain the central key";
//							}
//							else {
//								BOOST_LOG_TRIVIAL( warning ) << "\t\t\t***** Doesn't contain the central key";
//							}

//							size_t counter = 0;
							for (const auto &x : common::cross( close_keys ) ) {
//								if ( ! contains_key ) {
//									BOOST_LOG_TRIVIAL( warning ) << "\t\t\t\t[" << counter << "] : Adding entry for close key " << output_key( x );
//								}
								arg_store.push_back_entry_to_cell( x, the_res_pair );
//								++counter;
							}
						}
					}
				}
				arg_store.summarize();
			}