density_clustering.hpp

Go to the documentation of this file.

/*
Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
All rights reserved.

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice,
   this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#pragma once

#include <vector>
#include <map>
#include <set>
#include <array>
#include <utility>
#include <string>

#include <boost/program_options.hpp>

#include "tools.hpp"
namespace Clustering {
  namespace Density {
    using FreeEnergy = std::pair<std::size_t, float>;
    using Neighbor = Clustering::Tools::Neighbor;
    using Neighborhood = Clustering::Tools::Neighborhood;
    using Box = std::array<int, 2>;
    constexpr int BOX_DIFF[9][2] = {{-1, 1}, { 0, 1}, { 1, 1}
                                  , {-1, 0}, { 0, 0}, { 1, 0}
                                  , {-1,-1}, { 0,-1}, { 1,-1}};
    const int N_NEIGHBOR_BOXES = 9;
//    //! encodes box differences in 3D, i.e. if you are at
//    //! the center box, the 27 different tuples hold the steppings
//    //! to the 27 spacial neighbors (including the center box itself).
//    constexpr int BOX_DIFF[27][3] = {{-1, 1,-1}, { 0, 1,-1}, { 1, 1,-1}
//                                   , {-1, 0,-1}, { 0, 0,-1}, { 1, 0,-1}
//                                   , {-1,-1,-1}, { 0,-1,-1}, { 1,-1,-1}
//                                   , {-1, 1, 0}, { 0, 1, 0}, { 1, 1, 0}
//                                   , {-1, 0, 0}, { 0, 0, 0}, { 1, 0, 0}
//                                   , {-1,-1, 0}, { 0,-1, 0}, { 1,-1, 0}
//                                   , {-1, 1, 1}, { 0, 1, 1}, { 1, 1, 1}
//                                   , {-1, 0, 1}, { 0, 0, 1}, { 1, 0, 1}
//                                   , {-1,-1, 1}, { 0,-1, 1}, { 1,-1, 1}};
//    //! number of neigbor boxes in cubic 3D grid (including center box).
//    const int N_NEIGHBOR_BOXES = 27;
    struct BoxGrid {
      std::vector<int> n_boxes;
      std::vector<Box> assigned_box;
      std::map<Box, std::vector<int>> boxes;
    };
    constexpr Box
    neighbor_box(const Box center, const int i_neighbor);
    BoxGrid
    compute_box_grid(const float* coords,
                     const std::size_t n_rows,
                     const std::size_t n_cols,
                     const float radius);
    bool
    is_valid_box(const Box box,
                 const BoxGrid& grid);
    std::vector<std::size_t>
    calculate_populations(const float* coords,
                          const std::size_t n_rows,
                          const std::size_t n_cols,
                          const float radius);
    std::map<float, std::vector<std::size_t>>
    calculate_populations(const float* coords,
                          const std::size_t n_rows,
                          const std::size_t n_cols,
                          const std::vector<float> radii);
    std::vector<float>
    calculate_free_energies(const std::vector<std::size_t>& pops);
    std::vector<FreeEnergy>
    sorted_free_energies(const std::vector<float>& fe);
    std::tuple<Neighborhood, Neighborhood>
    nearest_neighbors(const float* coords,
                      const std::size_t n_rows,
                      const std::size_t n_cols,
                      const std::vector<float>& free_energy);
    void
    screening_log(const double sigma2
                , const std::size_t first_frame_above_threshold
                , const std::vector<FreeEnergy>& fe_sorted);
    std::tuple<std::vector<std::size_t>
             , std::size_t
             , double
             , std::vector<FreeEnergy>
             , std::set<std::size_t>
             , std::size_t>
    prepare_initial_clustering(const std::vector<float>& free_energy
                             , const Neighborhood& nh
                             , const float free_energy_threshold
                             , const std::size_t n_rows
                             , const std::vector<std::size_t> initial_clusters);
    std::vector<std::size_t>
    normalized_cluster_names(std::size_t first_frame_above_threshold
                           , std::vector<std::size_t> clustering
                           , std::vector<FreeEnergy>& fe_sorted);
    bool
    lump_initial_clusters(const std::set<std::size_t>& local_nh
                        , std::size_t& distinct_name
                        , std::vector<std::size_t>& clustering
                        , const std::vector<FreeEnergy>& fe_sorted
                        , std::size_t first_frame_above_threshold);
    std::set<std::size_t>
    high_density_neighborhood(const float* coords,
                              const std::size_t n_cols,
                              const std::vector<FreeEnergy>& sorted_fe,
                              const std::size_t i_frame,
                              const std::size_t limit,
                              const float max_dist);
    double
    compute_sigma2(const Neighborhood& nh);
    bool
    compare2DVector(const std::pair<std::size_t,std::size_t>& p1,
                    const std::pair<std::size_t,std::size_t>& p2);
    bool
    has2digits(float val);
    std::vector<std::size_t>
    sorted_cluster_names (std::vector<std::size_t> clustering);
    std::vector<std::size_t>
    assign_low_density_frames(const std::vector<std::size_t>& initial_clustering,
                              const Neighborhood& nh_high_dens,
                              const std::vector<float>& free_energy);
    void
    main(boost::program_options::variables_map args);
  } // end namespace Density
} // end namespace Clustering