tools.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 "config.hpp"

#include <string>
#include <vector>
#include <map>
#include <tuple>
#include <memory>
#include <iostream>

#if defined(__INTEL_COMPILER)
 #include <malloc.h>
#else
 #include <mm_malloc.h>
#endif

#if defined(__INTEL_COMPILER)
  #define ASSUME_ALIGNED(c) __assume_aligned( (c), DC_MEM_ALIGNMENT)
#else
  #define ASSUME_ALIGNED(c) (c) = (float*) __builtin_assume_aligned( (c), DC_MEM_ALIGNMENT)
#endif

namespace Clustering {
namespace Tools {
  using Neighbor = std::pair<std::size_t, float>;
  using Neighborhood = std::map<std::size_t, Clustering::Tools::Neighbor>;
  void
  write_pops(std::string fname, std::vector<std::size_t> pops, std::string header_comment,
             std::map<std::string,float> stringMap);
  void
  write_fes(std::string fname, std::vector<float> fes, std::string header_comment,
            std::map<std::string,float> stringMap);
  std::vector<std::size_t>
  read_clustered_trajectory(std::string filename);
  void
  write_clustered_trajectory(std::string filename, std::vector<std::size_t> traj,
                             std::string header_comment, std::map<std::string,float> stringMap);
  template <typename NUM>
  std::vector<NUM>
  read_single_column(std::string filename);
  template <typename NUM>
  void
  write_single_column(std::string filename, std::vector<NUM> dat,
                      std::string header_comment, bool with_scientific_format=false);
  template <typename KEY, typename VAL>
  void
  write_map(std::string filename, std::map<KEY, VAL> mapping,
            std::string header_comment, bool val_then_key=false);
  std::vector<float>
  read_free_energies(std::string filename);
  std::vector<std::size_t>
  read_concat_limits(std::string filename);
  std::pair<Neighborhood, Neighborhood>
  read_neighborhood(const std::string fname);
  void
  write_neighborhood(const std::string fname,
                     const Neighborhood& nh,
                     const Neighborhood& nh_high_dens,
                     std::string header_comment,
                     std::map<std::string,float> stringMap);
  std::map<std::size_t, std::size_t>
  microstate_populations(std::vector<std::size_t> traj);
  template <typename NUM>
  std::tuple<NUM*, std::size_t, std::size_t>
  read_coords(std::string filename,
              std::vector<std::size_t> usecols = std::vector<std::size_t>());
  template <typename NUM>
  void
  free_coords(NUM* coords);
  template <typename NUM>
  std::vector<NUM>
  dim1_sorted_coords(const NUM* coords
                   , std::size_t n_rows
                   , std::size_t n_cols);
  template <typename NUM>
  std::vector<NUM>
  boxlimits(const std::vector<NUM>& xs
          , std::size_t boxsize
          , std::size_t n_rows
          , std::size_t n_cols);
  template <typename NUM>
  std::pair<std::size_t, std::size_t>
  min_max_box(const std::vector<NUM>& limits
            , NUM val
            , NUM radius);
  unsigned int
  min_multiplicator(unsigned int orig
                  , unsigned int mult);
  std::string
  stringprintf(const std::string& str, ...);
  template <typename NUM>
  NUM
  string_to_num(const std::string &s);
  template <typename T>
  std::vector<T>
  unique_elements(std::vector<T> xs);
  void
  check_concat_limits(std::vector<std::size_t> concat_limits,
                      std::size_t n_frames);
  void
  read_comments(std::string filename, std::map<std::string,float> &stringMap);
  float
  read_next_float(std::ifstream &ifs);
  void
  append_commentsMap(std::string &header_comment, std::map<std::string,float> &stringMap);
} // end namespace 'Tools'
} // end namespace 'Clustering'

// template implementations
#include "tools.hxx"