├── src
    ├── coords_file
    │   ├── xdrfile
    │   │   ├── CMakeLists.txt
    │   │   ├── xdrfile_xtc.h
    │   │   ├── xdrfile_trr.h
    │   │   ├── xdrfile_xtc.c
    │   │   ├── trr2xtc.c
    │   │   ├── xdrfile_c_test.c
    │   │   └── xdrfile_trr.c
    │   ├── CMakeLists.txt
    │   ├── coords_file.hpp
    │   └── coords_file.cpp
    ├── create_header_hpp.sh
    ├── make_version.sh
    ├── density_clustering_cuda_kernels.hpp
    ├── logger.cpp
    ├── lts_cuda_kernels.cuh
    ├── logger.hpp
    ├── density_clustering_opencl.hpp
    ├── state_filter.hpp
    ├── density_clustering_cuda.hpp
    ├── network_builder.hpp
    ├── density_clustering_common.hpp
    ├── noise.hpp
    ├── coring.hpp
    ├── density_clustering_mpi.hpp
    ├── density_clustering_common.cpp
    ├── density_clustering_opencl.cpp
    ├── mpp.hpp
    ├── density_clustering_cuda_kernels.cu
    ├── tools.hpp
    ├── tools.hxx
    ├── tools.cpp
    ├── density_clustering.hpp
    ├── noise.cpp
    ├── state_filter.cpp
    └── coring.cpp
├── config.hpp.cmake.in
├── generate_header.py
├── LICENSE.txt
├── bash_completion_clustering.sh
├── FindOpenCL.cmake
├── CMakeLists.txt
└── README.md


/src/coords_file/xdrfile/CMakeLists.txt:
--------------------------------------------------------------------------------
1 | 
2 | add_library(xdrfile xdrfile.c xdrfile_xtc.c)
3 | 
4 | 


--------------------------------------------------------------------------------
/config.hpp.cmake.in:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | #define DC_MEM_ALIGNMENT @DC_MEM_ALIGNMENT@
4 | 
5 | //@USE_MPI@
6 | //@USE_OPENCL@
7 | 
8 | 


--------------------------------------------------------------------------------
/generate_header.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | import sys
 4 | import os
 5 | 
 6 | fh_in = open(sys.argv[1], 'r')
 7 | fh_out = open(sys.argv[2], 'w')
 8 | 
 9 | for line in fh_in:
10 |   fh_out.write(r'"' + line[:-1] + r'\n"' + "\n")
11 | 
12 | fh_in.close()
13 | fh_out.close()
14 | 
15 | 


--------------------------------------------------------------------------------
/src/create_header_hpp.sh:
--------------------------------------------------------------------------------
 1 | 
 2 | if [ -f embedded_cytoscape.hpp ]; then
 3 |   cp embedded_cytoscape.hpp embedded_cytoscape.hpp.bak
 4 | fi
 5 | 
 6 | echo "#pragma once" > embedded_cytoscape.hpp
 7 | echo "namespace Clustering {" >> embedded_cytoscape.hpp
 8 | echo "namespace Network {" >> embedded_cytoscape.hpp
 9 | echo "unsigned char viewer_header[] = {" >> embedded_cytoscape.hpp
10 | 
11 | xxd -i header.html | sed s/unsigned.*// >> embedded_cytoscape.hpp
12 | 
13 | echo 'const char* viewer_footer = "}); }); </script> </body> </html>";' >> embedded_cytoscape.hpp
14 | 
15 | echo '} // end namespace Network' >> embedded_cytoscape.hpp
16 | echo '} // end namespace Clustering' >> embedded_cytoscape.hpp
17 | 
18 | 


--------------------------------------------------------------------------------
/src/make_version.sh:
--------------------------------------------------------------------------------
 1 | 
 2 | v_dir=$1
 3 | 
 4 | if [ ! -d $v_dir ]; then
 5 |   echo "$v_dir does not exist. will create it."
 6 |   mkdir $v_dir
 7 | fi
 8 | 
 9 | cp -r clustering.cpp\
10 |       CMakeLists.txt\
11 |       config.hpp.cmake.in\
12 |       density_clustering.cpp\
13 |       density_clustering.hpp\
14 |       density_clustering_mpi.cpp\
15 |       density_clustering_mpi.hpp\
16 |       density_clustering_common.hpp\
17 |       density_clustering_common.cpp\
18 |       FindOpenCL.cmake\
19 |       cl.hpp\
20 |       density_clustering_opencl.hpp\
21 |       density_clustering_opencl.cpp\
22 |       pops.cl\
23 |       generate_header.py\
24 |       logger.cpp\
25 |       logger.hpp\
26 |       mpp.cpp\
27 |       mpp.hpp\
28 |       network_builder.cpp\
29 |       network_builder.hpp\
30 |       README.md\
31 |       state_filter.cpp\
32 |       state_filter.hpp\
33 |       tools.cpp\
34 |       tools.hpp\
35 |       tools.hxx\
36 |       coring.cpp\
37 |       coring.hpp\
38 |       noise.cpp\
39 |       noise.hpp\
40 |       embedded_cytoscape.hpp\
41 |       doc\
42 |       doxygen.config\
43 |       coords_file\
44 |       $v_dir/
45 | 
46 | tar cf $v_dir.tar $v_dir/
47 | gzip $v_dir.tar
48 | 
49 | 


--------------------------------------------------------------------------------
/src/coords_file/xdrfile/xdrfile_xtc.h:
--------------------------------------------------------------------------------
 1 | /* -*- mode: c; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- 
 2 |  *
 3 |  * $Id: xdrfile_xtc.h,v 1.5 2009/05/18 09:06:38 spoel Exp $
 4 |  *
 5 |  * Copyright (c) Erik Lindahl, David van der Spoel 2003,2004.
 6 |  * Coordinate compression (c) by Frans van Hoesel. 
 7 |  *
 8 |  * This program is free software; you can redistribute it and/or
 9 |  * modify it under the terms of the GNU Lesser General Public License
10 |  * as published by the Free Software Foundation; either version 3
11 |  * of the License, or (at your option) any later version.
12 |  */
13 | 
14 | #ifndef _xdrfile_xtc_h
15 | #define _xdrfile_xtc_h
16 | 
17 | #ifdef CPLUSPLUS
18 | extern "C" {
19 | #endif
20 | 
21 | #include "xdrfile.h"
22 |   
23 |   /* All functions return exdrOK if succesfull. 
24 |    * (error codes defined in xdrfile.h).
25 |    */  
26 |    
27 |   /* This function returns the number of atoms in the xtc file in *natoms */
28 |   extern int read_xtc_natoms(const char *fn,int *natoms);
29 |   
30 |   /* Read one frame of an open xtc file */
31 |   extern int read_xtc(XDRFILE *xd,int natoms,int *step,float *time,
32 | 		      matrix box,rvec *x,float *prec);
33 |   
34 |   /* Write a frame to xtc file */
35 |   extern int write_xtc(XDRFILE *xd,
36 | 		       int natoms,int step,float time,
37 | 		       matrix box,rvec *x,float prec);
38 |   
39 | #ifdef CPLUSPLUS
40 | }
41 | #endif
42 | 
43 | #endif
44 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2015-2018, Florian Sittel (www.lettis.net)
 2 | Copyright (c) 2018-2019, Daniel Nagel
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice,
 9 |    this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | 


--------------------------------------------------------------------------------
/src/coords_file/xdrfile/xdrfile_trr.h:
--------------------------------------------------------------------------------
 1 | /* -*- mode: c; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- 
 2 |  *
 3 |  * $Id: xdrfile_trr.h,v 1.2 2009/05/18 09:06:38 spoel Exp $
 4 |  *
 5 |  * Copyright (c) Erik Lindahl, David van der Spoel 2003,2004.
 6 |  * Coordinate compression (c) by Frans van Hoesel. 
 7 |  *
 8 |  * This program is free software; you can redistribute it and/or
 9 |  * modify it under the terms of the GNU Lesser General Public License
10 |  * as published by the Free Software Foundation; either version 3
11 |  * of the License, or (at your option) any later version.
12 |  */
13 | 
14 | #ifndef _xdrfile_trr_h
15 | #define _xdrfile_trr_h
16 | 
17 | #ifdef CPLUSPLUS
18 | extern "C" {
19 | #endif
20 | 
21 | #include "xdrfile.h"
22 |   
23 |   /* All functions return exdrOK if succesfull. 
24 |    * (error codes defined in xdrfile.h).
25 |    */  
26 |    
27 |   /* This function returns the number of atoms in the xtc file in *natoms */
28 |   extern int read_trr_natoms(char *fn,int *natoms);
29 |   
30 |   /* Read one frame of an open xtc file. If either of x,v,f,box are
31 |      NULL the arrays will be read from the file but not used.  */
32 |   extern int read_trr(XDRFILE *xd,int natoms,int *step,float *t,float *lambda,
33 | 		      matrix box,rvec *x,rvec *v,rvec *f);
34 | 
35 |   /* Write a frame to xtc file */
36 |   extern int write_trr(XDRFILE *xd,int natoms,int step,float t,float lambda,
37 | 		       matrix box,rvec *x,rvec *v,rvec *f);
38 | 
39 |   
40 | #ifdef CPLUSPLUS
41 | }
42 | #endif
43 | 
44 | #endif
45 | 


--------------------------------------------------------------------------------
/src/coords_file/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2015, Florian Sittel (www.lettis.net)
 2 | # All rights reserved.
 3 | # 
 4 | # Redistribution and use in source and binary forms, with or without modification,
 5 | # are permitted provided that the following conditions are met:
 6 | # 
 7 | # 1. Redistributions of source code must retain the above copyright notice,
 8 | #    this list of conditions and the following disclaimer.
 9 | # 
10 | # 2. Redistributions in binary form must reproduce the above copyright notice,
11 | #    this list of conditions and the following disclaimer in the documentation
12 | #    and/or other materials provided with the distribution.
13 | # 
14 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
15 | # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 | # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
17 | # SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
18 | # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
19 | # OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 | # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
21 | # TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
22 | # EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 | 
24 | add_subdirectory(xdrfile)
25 | 
26 | add_library(coords_file coords_file.cpp)
27 | target_link_libraries(coords_file xdrfile)
28 | 
29 | 


--------------------------------------------------------------------------------
/src/density_clustering_cuda_kernels.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | //// hard-coded settings
 4 | 
 5 | // for pops
 6 | #define BSIZE_POPS 512
 7 | 
 8 | // for neighborhood search
 9 | #define BSIZE_NH 128
10 | 
11 | // for screening
12 | #define BSIZE_SCR 256
13 | 
14 | ////
15 | 
16 | 
17 | namespace Clustering {
18 | namespace Density {
19 | namespace CUDA {
20 | namespace Kernel {
21 | 
22 |   __global__ void
23 |   population_count(unsigned int offset
24 |                  , float* coords
25 |                  , unsigned int n_rows
26 |                  , unsigned int n_cols
27 |                  , float* radii2
28 |                  , unsigned int n_radii
29 |                  , unsigned int* pops
30 |                  , unsigned int i_from
31 |                  , unsigned int i_to);
32 | 
33 |   __global__ void
34 |   nearest_neighbor_search(unsigned int offset
35 |                         , float* coords
36 |                         , unsigned int n_rows
37 |                         , unsigned int n_cols
38 |                         , float* fe
39 |                         , unsigned int* nh_nhhd_ndx
40 |                         , float* nh_nhhd_dist
41 |                         , unsigned int i_from
42 |                         , unsigned int i_to);
43 | 
44 | 
45 |   __global__ void
46 |   screening(unsigned int offset
47 |           , float* sorted_coords
48 |           , unsigned int n_rows
49 |           , unsigned int n_cols
50 |           , float max_dist2
51 |           , unsigned int* clustering
52 |           , unsigned int i_from
53 |           , unsigned int i_to);
54 | 
55 | }}}} // end Clustering::Density::CUDA::Kernel
56 | 
57 | 


--------------------------------------------------------------------------------
/src/logger.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice,
 9 |    this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | */
25 | 
26 | #include "logger.hpp"
27 | 
28 | namespace Clustering {
29 |   bool verbose = false;
30 |   std::ostream devnull(0);
31 | 
32 |   std::ostream& logger(std::ostream& s) {
33 |     if (verbose) {
34 |       return s;
35 |     } else {
36 |       return devnull; 
37 |     }
38 |   }
39 | 
40 |   std::ostream& debug() {
41 |     std::cout << "DEBUG: ";
42 |     return std::cout;
43 |   }
44 | } // end namespace Clustering
45 | 
46 | 


--------------------------------------------------------------------------------
/src/lts_cuda_kernels.cuh:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <cuda.h>
 4 | 
 5 | /**
 6 |  * perform reduction (sum) on given values.
 7 |  * stores result to results-array at index i_result.
 8 |  *
 9 |  * implicit first reduction on call, so run with half the total range
10 |  *
11 |  * begin reduction at offset.
12 |  */
13 | template <unsigned int _BLOCKSIZE>
14 | __global__ void
15 | reduce_sum(unsigned int offset
16 |          , float* vals
17 |          , unsigned int n_vals
18 |          , float* results
19 |          , unsigned int i_result) {
20 |   __shared__ float sum_block[_BLOCKSIZE];
21 |   unsigned int stride;
22 |   unsigned int bid = blockIdx.x;
23 |   unsigned int tid = threadIdx.x;
24 |   unsigned int gid = bid*_BLOCKSIZE+tid;
25 |   unsigned int gid2 = gid + _BLOCKSIZE*gridDim.x;
26 |   // store probs locally for reduction
27 |   if (gid2 < n_vals) {
28 |     // initial double load and first reduction
29 |     sum_block[tid] = vals[gid+offset] + vals[gid2+offset];
30 |   } else if (gid < n_vals) {
31 |     sum_block[tid] = vals[gid+offset];
32 |   } else {
33 |     sum_block[tid] = 0.0f;
34 |   }
35 | //TODO ifdef to set intrinsic sync mode for specific architectures (e.g. Tesla K40)
36 | //  for (stride=_BLOCKSIZE/2; stride > 32; stride /= 2) {
37 | //    __syncthreads();
38 | //    if (tid < stride) {
39 | //      sum_block[tid] += sum_block[tid+stride];
40 | //    }
41 | //  }
42 | //  // unroll loop inside warp (intrinsic sync!)
43 | //  __syncthreads();
44 | //  if (tid < 32) {
45 | //    sum_block[tid] += sum_block[tid+32];
46 | //    sum_block[tid] += sum_block[tid+16];
47 | //    sum_block[tid] += sum_block[tid+8];
48 | //    sum_block[tid] += sum_block[tid+4];
49 | //    sum_block[tid] += sum_block[tid+2];
50 | //    sum_block[tid] += sum_block[tid+1];
51 | //  }
52 |   for (stride=_BLOCKSIZE/2; stride > 0; stride /= 2) {
53 |     __syncthreads();
54 |     if (tid < stride) {
55 |       sum_block[tid] += sum_block[tid+stride];
56 |     }
57 |   }
58 |   if (tid == 0) {
59 |     atomicAdd(&results[i_result], sum_block[0]);
60 |   }
61 | }
62 | 
63 | 


--------------------------------------------------------------------------------
/src/logger.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice,
 9 |    this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | */
25 | #pragma once
26 | 
27 | #include <iostream>
28 | /*! \file
29 |  * \brief Define global logger
30 |  */
31 | 
32 | /*!
33 |  * \brief functions related to verbose/output mode
34 |  *
35 |  * This namespace contains all functions related to the verbose mode.
36 |  */
37 | namespace Clustering {
38 |   //! global flag: use verbose output?
39 |   extern bool verbose;
40 |   //! fake-stream used as output if nothing should be printed to stdout/stderr.
41 |   extern std::ostream devnull;
42 |   //! logger, use like logger(std::cout) << ...;
43 |   //! will print to given stream if global 'verbose' is set to true.
44 |   std::ostream& logger(std::ostream& s);
45 |   //! print formatted debug output to std::cerr.
46 |   std::ostream& debug();
47 | } // end namespace Clustering
48 | 
49 | 


--------------------------------------------------------------------------------
/src/density_clustering_opencl.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice,
 9 |    this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | */
25 | #pragma once
26 | 
27 | #include "config.hpp"
28 | 
29 | #include <CL/cl.hpp>
30 | 
31 | #include <vector>
32 | #include <map>
33 | 
34 | 
35 | namespace Clustering {
36 | namespace Density {
37 | //! OpenCL implementations of compute intensive functions
38 | namespace OpenCL {
39 |   //! OpenCL implementation of
40 |   //! \link Clustering::Density::calculate_populations(const float* coords, const std::size_t n_rows, const std::size_t n_cols, std::vector<float> radii);
41 |   //!
42 |   //! **ATTENTION**: OpenCL support is unfinished and not expected to return sound results.
43 |   std::map<float, std::vector<std::size_t>>
44 |   calculate_populations(const float* coords, const std::size_t n_rows, const std::size_t n_cols, std::vector<float> radii);
45 | } // end namespace OpenCL
46 | } // end namespace Density
47 | } // end namespace Clustering
48 | 


--------------------------------------------------------------------------------
/src/state_filter.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2015, Florian Sittel (www.lettis.net)
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice,
 9 |    this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | */
25 | #pragma once
26 | 
27 | #include <boost/program_options.hpp>
28 | 
29 | namespace Clustering {
30 | //! functionality for filtering coordinates or order parameters (ASCII or GROMACS' .xtc) based on state trajectory.
31 | namespace Filter {
32 |   void
33 |   //! print with fixed precision and width
34 |   fixedprint(double num, std::size_t prec, std::size_t width);
35 |   /*!
36 |    *  controlling function and user interface for state filtering.
37 |    *
38 |    *  *parsed arguments*:
39 |    *    - **states**: input file with state trajectory
40 |    *    - **coords**: ASCII or .xtc file with coordinates or order parameters
41 |    *    - **output**: filtered coordinates
42 |    *    - **state**: selected state that should be filtered from full data set
43 |    */
44 |   void
45 |   main(boost::program_options::variables_map args);
46 | } // end namespace Filter
47 | } // end namespace Clustering
48 | 


--------------------------------------------------------------------------------
/src/density_clustering_cuda.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "config.hpp"
 4 | #include "density_clustering_common.hpp"
 5 | 
 6 | #include <map>
 7 | #include <vector>
 8 | 
 9 | namespace Clustering {
10 | namespace Density {
11 | namespace CUDA {
12 | 
13 |   void
14 |   check_error(std::string msg="");
15 | 
16 |   int
17 |   get_num_gpus();
18 | 
19 |   using Neighborhood = Clustering::Tools::Neighborhood;
20 | 
21 |   Pops
22 |   calculate_populations_partial(const float* coords
23 |                               , const std::vector<float>& sorted_coords
24 |                               , const std::vector<float>& blimits
25 |                               , std::size_t n_rows
26 |                               , std::size_t n_cols
27 |                               , std::vector<float> radii
28 |                               , std::size_t i_from
29 |                               , std::size_t i_to
30 |                               , int i_gpu);
31 |   
32 |   Pops
33 |   calculate_populations(const float* coords
34 |                       , const std::size_t n_rows
35 |                       , const std::size_t n_cols
36 |                       , std::vector<float> radii);
37 | 
38 |   std::tuple<Neighborhood, Neighborhood>
39 |   nearest_neighbors(const float* coords,
40 |                     const std::size_t n_rows,
41 |                     const std::size_t n_cols,
42 |                     const std::vector<float>& free_energy);
43 | 
44 |   std::vector<std::size_t>
45 |   sanitize_state_names(std::vector<std::size_t> clustering);
46 | 
47 |   std::vector<std::size_t>
48 |   screening(const std::vector<float>& free_energy
49 |           , const Neighborhood& nh
50 |           , const float free_energy_threshold
51 |           , const float* coords
52 |           , const std::size_t n_rows
53 |           , const std::size_t n_cols
54 |           , const std::vector<std::size_t> initial_clusters);
55 | 
56 |   std::set<std::size_t>
57 |   high_density_neighborhood(const float* coords,
58 |                             const std::size_t n_cols,
59 |                             const std::vector<FreeEnergy>& sorted_fe,
60 |                             const std::size_t i_frame,
61 |                             const std::size_t limit,
62 |                             const float max_dist);
63 | 
64 | }}} // end Clustering::Density::CUDA
65 | 
66 | 


--------------------------------------------------------------------------------
/src/network_builder.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice,
 9 |    this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | */
25 | #pragma once
26 | 
27 | #include <map>
28 | #include <iostream>
29 | 
30 | #include <boost/program_options.hpp>
31 | /*! \file
32 |  * \brief Network Builder
33 |  *
34 |  * \sa \link Clustering::NetworkBuilder
35 |  */
36 | namespace Clustering {
37 |   /*!
38 |    * \brief functions for network creation from free energy screening
39 |    *
40 |    * This module finds local minimas in the free energy landscape. Therefore,
41 |    * it build a network from the previously determined clusters.
42 |    */
43 |   namespace NetworkBuilder {
44 |     /*!
45 |      * controlling function and user interface for network creation
46 |      *
47 |      * \param min min. free energy to take into account
48 |      * \param max max. free energy to take into account
49 |      * \param step free energy stepping
50 |      * \param basename basic input file format
51 |      * \param minpop min. population per microstate, discard states with lower population
52 |      * \param network-html generate an html representation of the network
53 |      */
54 |     void
55 |     main(boost::program_options::variables_map args);
56 |   } // end namespace Clustering
57 | } // end namespace NetworkBuilder
58 | 
59 | 


--------------------------------------------------------------------------------
/src/density_clustering_common.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice,
 9 |    this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | */
25 | #pragma once
26 | 
27 | #include "config.hpp"
28 | #include "density_clustering.hpp"
29 | 
30 | /*! \file
31 |  * this module holds common implementations for both, single-node and MPI code.
32 |  * it is used for functions that are too similar for both versions and have
33 |  * only slight variations that can be implemented by 'ifdef'-guards.
34 |  */
35 | 
36 | namespace Clustering {
37 | namespace Density {
38 |     //              radius  ->   pops
39 |     typedef std::map<float, std::vector<std::size_t>> Pops;
40 | 
41 |     //! returns state trajectory for clusters given by a free energy threshold.
42 |     //! frames with a local free energy estimate higher than the given threshold
43 |     //! will not be clustered and remain in 'state 0'.
44 |     std::vector<std::size_t>
45 |     screening(const std::vector<float>& free_energy
46 |             , const Neighborhood& nh
47 |             , const float free_energy_threshold
48 |             , const float* coords
49 |             , const std::size_t n_rows
50 |             , const std::size_t n_cols
51 |             , const std::vector<std::size_t> initial_clusters
52 | #ifdef DC_USE_MPI
53 |             , const int mpi_n_nodes
54 |             , const int mpi_node_id
55 | #endif
56 |                                );
57 | }} // end namespace Clustering::Density
58 | 
59 | 


--------------------------------------------------------------------------------
/src/coords_file/coords_file.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2015, Florian Sittel (www.lettis.net)
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice,
 9 |    this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | */
25 | #pragma once
26 | 
27 | #include <vector>
28 | #include <string>
29 | #include <fstream>
30 | #include <sstream>
31 | #include <memory>
32 | 
33 | extern "C" {
34 |   // use xdrfile library to read/write xtc and trr files from gromacs
35 |   #include "xdrfile/xdrfile.h"
36 |   #include "xdrfile/xdrfile_xtc.h"
37 |   #include "xdrfile/xdrfile_trr.h"
38 | }
39 | 
40 | namespace CoordsFile {
41 | 
42 | class Handler {
43 |  public:
44 |   virtual std::vector<float> next() = 0;
45 |   virtual void write(std::vector<float> row) = 0;
46 |   virtual bool eof() = 0;
47 | };
48 | 
49 | class AsciiHandler : public Handler {
50 |  public:
51 |   AsciiHandler(std::string fname, std::string mode);
52 |   std::vector<float> next();
53 |   void write(std::vector<float> row);
54 |   bool eof();
55 |  protected:
56 |   std::ifstream _ifs;
57 |   std::ofstream _ofs;
58 |   bool _eof;
59 |   std::string _mode;
60 | };
61 | 
62 | class XtcHandler : public Handler {
63 |  public:
64 |   XtcHandler(std::string fname, std::string mode);
65 |   ~XtcHandler();
66 |   std::vector<float> next();
67 |   void write(std::vector<float> row);
68 |   bool eof();
69 |  protected:
70 |   bool _eof;
71 |   std::string _mode;
72 |   int _natoms;
73 |   int _nrow;
74 |   XDRFILE* _xdr;
75 |   rvec* _coord_buf;
76 | };
77 | 
78 | typedef std::unique_ptr<Handler> FilePointer;
79 | 
80 | template <typename T> std::vector<T>
81 | split(std::string s);
82 | 
83 | FilePointer
84 | open(std::string fname, std::string mode);
85 | 
86 | } // end namespace 'CoordsFile'
87 | 
88 | 


--------------------------------------------------------------------------------
/bash_completion_clustering.sh:
--------------------------------------------------------------------------------
 1 | # add completion for clustering
 2 | _clustering() 
 3 | {
 4 |     local cur prev opts
 5 |     COMPREPLY=()
 6 |     cur="${COMP_WORDS[COMP_CWORD]}"
 7 |     prev="${COMP_WORDS[COMP_CWORD-1]}"
 8 |     mode="${COMP_WORDS[1]}"
 9 |     # opts for single file argument
10 |     # nopts for no options
11 |     # fopts for no autocompleion option (for numbers)
12 |     
13 |     # mode completion
14 |     if [[ ${prev} == "clustering" ]]; then
15 |         nopts="density network mpp coring noise filter stats"
16 |     else
17 |         # mode specific completion
18 |         case "${mode}" in
19 |             density)
20 |                 opts="--file --output --input --population --free-energy --free-energy-input --nearest-neighbors --nearest-neighbors-input" 
21 |                 nopts="--help --nthreads --verbose"
22 |                 fopts="--radius --radii --threshold-screening"
23 |                 ;;
24 |             network)
25 |                 opts="--minpop --basename --output"
26 |                 nopts="--help --network-html --verbose"
27 |                 fopts="--min --max --step"
28 |                 ;;
29 |             mpp)
30 |                 opts="--states --free-energy-input --concat-limits --tprob --output" 
31 |                 nopts="--help --verbose"
32 |                 fopts="--lagtime --qmin-from --qmin-to --qmin-step --concat-nframes --nthreads"
33 |                 ;;
34 |             coring)
35 |                 opts="--states --windows --output --distrubtion --cores--concat-limits" 
36 |                 nopts="--help --verbose --iterative"
37 |                 fopts="--concat-nframes"
38 |                 ;;
39 |             noise)
40 |                 opts="--states --output --basename --cores --concat-limits" 
41 |                 nopts="--help --verbose"
42 |                 fopts="--concat-nframes --cmin" 
43 |                 ;;
44 |             filter)
45 |                 opts="--states --coords --output"
46 |                 nopts="--help --verbose"
47 |                 fopts="--selected-states --every-nth --nRandom" 
48 |                 ;;
49 |             stats)
50 |                 opts="--states --concat-limits" 
51 |                 nopts="--help"
52 |                 fopts="--concat-nframes" 
53 |                 ;;
54 |             *)
55 |                 ;;
56 |         esac
57 |     fi
58 |     # if opts was parsed
59 |     if [[ " ${opts} " == *" ${prev} "* ]]; then
60 |         COMPREPLY=( $(compgen -f -- ${cur}) )
61 |     # if fopts was parse, no completion is returned
62 |     elif [[ " ${fopts} " == *" ${prev} "* ]]; then
63 |         COMPREPLY=()
64 |     # complete one of the given options
65 |     elif [[ "${opts} ${nopts} ${fopts}" == *"${cur}"* ]]; then
66 |         COMPREPLY=( $(compgen -W "${opts} ${nopts} ${fopts}" -- ${cur}) )
67 |     # return fallback file-directory completion
68 |     else
69 |         COMPREPLY=( $(compgen -df -- ${cur}) )    
70 |     fi
71 | 	return 0
72 | }
73 | complete -o filenames -F _clustering clustering
74 | 
75 | 


--------------------------------------------------------------------------------
/src/coords_file/xdrfile/xdrfile_xtc.c:
--------------------------------------------------------------------------------
  1 | /* -*- mode: c; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- 
  2 |  *
  3 |  * $Id: xdrfile_xtc.c,v 1.5 2009/05/18 09:06:38 spoel Exp $
  4 |  *
  5 |  * Copyright (c) Erik Lindahl, David van der Spoel 2003,2004.
  6 |  * Coordinate compression (c) by Frans van Hoesel. 
  7 |  *
  8 |  * This program is free software; you can redistribute it and/or
  9 |  * modify it under the terms of the GNU Lesser General Public License
 10 |  * as published by the Free Software Foundation; either version 3
 11 |  * of the License, or (at your option) any later version.
 12 |  */
 13 |  
 14 | #include <stdlib.h>
 15 | #include "xdrfile.h"
 16 | #include "xdrfile_xtc.h"
 17 | 	
 18 | #define MAGIC 1995
 19 | 
 20 | enum { FALSE, TRUE };
 21 | 
 22 | static int xtc_header(XDRFILE *xd,int *natoms,int *step,float *time,mybool bRead)
 23 | {
 24 | 	int result,magic,n=1;
 25 | 	
 26 | 	/* Note: read is same as write. He he he */
 27 | 	magic  = MAGIC;
 28 | 	if ((result = xdrfile_write_int(&magic,n,xd)) != n)
 29 | 		{
 30 | 			if (bRead)
 31 | 				return exdrENDOFFILE;
 32 | 			else
 33 | 				return exdrINT;
 34 | 		}
 35 | 	if (magic != MAGIC)
 36 | 		return exdrMAGIC;
 37 | 	if ((result = xdrfile_write_int(natoms,n,xd)) != n)
 38 | 		return exdrINT;
 39 | 	if ((result = xdrfile_write_int(step,n,xd)) != n)
 40 | 		return exdrINT;
 41 | 	if ((result = xdrfile_write_float(time,n,xd)) != n)
 42 | 		return exdrFLOAT;
 43 | 	
 44 | 	return exdrOK;
 45 | }
 46 | 
 47 | static int xtc_coord(XDRFILE *xd,int *natoms,matrix box,rvec *x,float *prec,
 48 | 					 mybool bRead)
 49 | {
 50 | 	int i,j,result;
 51 |     
 52 | 	/* box */
 53 | 	result = xdrfile_read_float(box[0],DIM*DIM,xd);
 54 | 	if (DIM*DIM != result)
 55 | 		return exdrFLOAT;
 56 | 	else 
 57 | 		{
 58 | 			if (bRead)
 59 | 				{
 60 | 					result = xdrfile_decompress_coord_float(x[0],natoms,prec,xd); 
 61 | 					if (result != *natoms)
 62 | 						return exdr3DX;
 63 | 				}
 64 | 			else
 65 | 				{
 66 | 					result = xdrfile_compress_coord_float(x[0],*natoms,*prec,xd); 
 67 | 					if (result != *natoms)
 68 | 						return exdr3DX;
 69 | 				}
 70 | 		}
 71 | 	return exdrOK;
 72 | }
 73 | 
 74 | int read_xtc_natoms(const char *fn,int *natoms)
 75 | {
 76 | 	XDRFILE *xd;
 77 | 	int step,result;
 78 | 	float time;
 79 | 	
 80 | 	xd = xdrfile_open(fn,"r");
 81 | 	if (NULL == xd)
 82 | 		return exdrFILENOTFOUND;
 83 | 	result = xtc_header(xd,natoms,&step,&time,TRUE);
 84 | 	xdrfile_close(xd);
 85 | 	
 86 | 	return result;
 87 | }
 88 | 
 89 | int read_xtc(XDRFILE *xd,
 90 | 			 int natoms,int *step,float *time,
 91 | 			 matrix box,rvec *x,float *prec)
 92 | /* Read subsequent frames */
 93 | {
 94 | 	int result;
 95 |   
 96 | 	if ((result = xtc_header(xd,&natoms,step,time,TRUE)) != exdrOK)
 97 | 		return result;
 98 | 	  
 99 | 	if ((result = xtc_coord(xd,&natoms,box,x,prec,1)) != exdrOK)
100 | 		return result;
101 |   
102 | 	return exdrOK;
103 | }
104 | 
105 | int write_xtc(XDRFILE *xd,
106 | 			  int natoms,int step,float time,
107 | 			  matrix box,rvec *x,float prec)
108 | /* Write a frame to xtc file */
109 | {
110 | 	int result;
111 |   
112 | 	if ((result = xtc_header(xd,&natoms,&step,&time,FALSE)) != exdrOK)
113 | 		return result;
114 | 
115 | 	if ((result = xtc_coord(xd,&natoms,box,x,&prec,0)) != exdrOK)
116 | 		return result;
117 |   
118 | 	return exdrOK;
119 | }
120 | 


--------------------------------------------------------------------------------
/src/noise.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice,
 9 |    this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | */
25 | #pragma once
26 | 
27 | #include <list>
28 | #include <map>
29 | 
30 | #include <boost/program_options.hpp>
31 | /*! \file
32 |  * \brief Noise Assignment
33 |  *
34 |  * \sa \link Clustering::Noise
35 |  */
36 | namespace Clustering {
37 |   /*!
38 |    * \brief functions related to noise assignment
39 |    *
40 |    * This module contains all function for identifying and dynamically
41 |    * reassigning noise. The underlaying principal is to assign low populated
42 |    * regions dynamically to the previous state, to improve the meta-stability
43 |    * of the resulting states.
44 |    * In Nagel19 it was shown that this works better than coring in case of low
45 |    * dimensional input. I.e., if the input is not homogeniously distributed in
46 |    * the input coordinates.
47 |    */
48 |   namespace Noise {
49 |     //! map for sorting clusters by population
50 |     typedef std::map<int,unsigned int> CounterClustMap;
51 | 
52 |     /*!
53 |      * \brief controlling function and user interface for noise assignment
54 |      *
55 |      * \param states single column file with state information.
56 |      * \param basename basename used in 'clustering network' (def.: 'clust.').
57 |      * \param cmin population threshold in percent below which an geometrically
58 |      *            isolated cluster gets assigned as noise.
59 |      * \param concat-nframes no. of frames per trajectory.
60 |      * \param concat-limits length of concated trajectories.
61 |      * \param output file name to store resulting trajectory.
62 |      * \param cores file name to store resulting cores.
63 |      * \return void
64 |      * \note This code needs to be executed from the same directory as clustering
65 |      *       density
66 |      * \warning This function is still in beta.
67 |      */
68 |     void
69 |     main(boost::program_options::variables_map args);
70 |   } // end namespace Noise
71 | } // end namespace Clustering
72 | 
73 | 


--------------------------------------------------------------------------------
/FindOpenCL.cmake:
--------------------------------------------------------------------------------
 1 | # - Try to find OpenCL
 2 | # This module tries to find an OpenCL implementation on your system. It supports
 3 | # AMD / ATI, Apple and NVIDIA implementations, but should work, too.
 4 | #
 5 | # To set manually the paths, define these environment variables:
 6 | # OpenCL_INCPATH    - Include path (e.g. OpenCL_INCPATH=/opt/cuda/4.0/cuda/include)
 7 | # OpenCL_LIBPATH    - Library path (e.h. OpenCL_LIBPATH=/usr/lib64/nvidia)
 8 | #
 9 | # Once done this will define
10 | #  OPENCL_FOUND        - system has OpenCL
11 | #  OPENCL_INCLUDE_DIRS  - the OpenCL include directory
12 | #  OPENCL_LIBRARIES    - link these to use OpenCL
13 | #
14 | # WIN32 should work, but is untested
15 | 
16 | FIND_PACKAGE(PackageHandleStandardArgs)
17 | 
18 | SET (OPENCL_VERSION_STRING "0.1.0")
19 | SET (OPENCL_VERSION_MAJOR 0)
20 | SET (OPENCL_VERSION_MINOR 1)
21 | SET (OPENCL_VERSION_PATCH 0)
22 | 
23 | IF (APPLE)
24 | 
25 | 	FIND_LIBRARY(OPENCL_LIBRARIES OpenCL DOC "OpenCL lib for OSX")
26 | 	FIND_PATH(OPENCL_INCLUDE_DIRS OpenCL/cl.h DOC "Include for OpenCL on OSX")
27 | 	FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS OpenCL/cl.hpp DOC "Include for OpenCL CPP bindings on OSX")
28 | 
29 | ELSE (APPLE)
30 | 
31 | 	IF (WIN32)
32 | 
33 | 		FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h)
34 | 		FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp)
35 | 
36 | 		# The AMD SDK currently installs both x86 and x86_64 libraries
37 | 		# This is only a hack to find out architecture
38 | 		IF( ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64" )
39 | 			SET(OPENCL_LIB_DIR "$ENV{ATISTREAMSDKROOT}/lib/x86_64")
40 | 		ELSE (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64")
41 | 			SET(OPENCL_LIB_DIR "$ENV{ATISTREAMSDKROOT}/lib/x86")
42 | 		ENDIF( ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64" )
43 | 		FIND_LIBRARY(OPENCL_LIBRARIES OpenCL.lib PATHS ${OPENCL_LIB_DIR} ENV OpenCL_LIBPATH)
44 | 
45 | 		GET_FILENAME_COMPONENT(_OPENCL_INC_CAND ${OPENCL_LIB_DIR}/../../include ABSOLUTE)
46 | 
47 | 		# On Win32 search relative to the library
48 | 		FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h PATHS "${_OPENCL_INC_CAND}" ENV OpenCL_INCPATH)
49 | 		FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS "${_OPENCL_INC_CAND}" ENV OpenCL_INCPATH)
50 | 
51 | 	ELSE (WIN32)
52 | 
53 | 		# Unix style platforms
54 | 		FIND_LIBRARY(OPENCL_LIBRARIES OpenCL
55 | 			PATHS ENV LD_LIBRARY_PATH ENV OpenCL_LIBPATH
56 | 		)
57 | 
58 | 		GET_FILENAME_COMPONENT(OPENCL_LIB_DIR ${OPENCL_LIBRARIES} PATH)
59 | 		GET_FILENAME_COMPONENT(_OPENCL_INC_CAND ${OPENCL_LIB_DIR}/../../include ABSOLUTE)
60 | 
61 | 		# The AMD SDK currently does not place its headers
62 | 		# in /usr/include, therefore also search relative
63 | 		# to the library
64 | 		FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h PATHS ${_OPENCL_INC_CAND} "/usr/local/cuda/include" "/opt/AMDAPP/include" ENV OpenCL_INCPATH)
65 | 		FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS ${_OPENCL_INC_CAND} "/usr/local/cuda/include" "/opt/AMDAPP/include" ENV OpenCL_INCPATH)
66 | 
67 | 	ENDIF (WIN32)
68 | 
69 | ENDIF (APPLE)
70 | 
71 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(OpenCL DEFAULT_MSG OPENCL_LIBRARIES OPENCL_INCLUDE_DIRS)
72 | 
73 | IF(_OPENCL_CPP_INCLUDE_DIRS)
74 | 	SET( OPENCL_HAS_CPP_BINDINGS TRUE )
75 | 	LIST( APPEND OPENCL_INCLUDE_DIRS ${_OPENCL_CPP_INCLUDE_DIRS} )
76 | 	# This is often the same, so clean up
77 | 	LIST( REMOVE_DUPLICATES OPENCL_INCLUDE_DIRS )
78 | ENDIF(_OPENCL_CPP_INCLUDE_DIRS)
79 | 
80 | MARK_AS_ADVANCED(
81 |   OPENCL_INCLUDE_DIRS
82 | )
83 | 
84 | 


--------------------------------------------------------------------------------
/src/coring.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice,
 9 |    this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | */
25 | #pragma once
26 | 
27 | #include <list>
28 | #include <map>
29 | 
30 | #include <boost/program_options.hpp>
31 | /*! \file
32 |  * \brief Dynamical Coring
33 |  *
34 |  * \sa \link Clustering::Coring
35 |  */
36 | 
37 | namespace Clustering {
38 |   /*!
39 |    * \brief functions related to dynamical coring
40 |    *
41 |    * This module contains all functions for finding the optimal coring time and
42 |    * dynamical coring. The underlaying principal is to define dynamical cores.
43 |    * In contrast to geometrical cores, this algorithm scales linear with the
44 |    * the number of frames. The idea is to require after a transition to stay
45 |    * at least for a certain time (coring time) in the new state, otherwise
46 |    * the transition is identified as intrastate fluctuation and the frames are
47 |    * are assigned to the previous state. A more in detail discussion can be
48 |    * found in Nagel19.
49 |    */
50 |   namespace Coring {
51 |     //! store the waiting time distribution for each state with time vs count.
52 |     typedef std::map<std::size_t, float> WTDMap;
53 | 
54 |     /*!
55 |      * \brief compute the waiting time distribution for single state
56 |      *
57 |      * \param streaks array with all wainting times
58 |      */    
59 |     WTDMap
60 |     compute_wtd(std::list<std::size_t> streaks);
61 | 
62 |     /*!
63 |      * \brief controlling function and user interface for boundary corrections
64 |      *
65 |      * \param states single column file with state information.
66 |      * \param windows double column file with states and their coring time
67 |      * \param distribution generate and write waiting time distributions to file.
68 |      * \param output file name to store resulting trajectory.
69 |      * \param concat-nframes no. of frames per trajectory.
70 |      * \param concat-limits length of concated trajectories.
71 |      * \param cores file name to store resulting cores.
72 |      * \return void
73 |      */
74 |     void
75 |     main(boost::program_options::variables_map args);
76 |   } // end namespace Coring
77 | } // end namespace Clustering
78 | 
79 | 


--------------------------------------------------------------------------------
/src/density_clustering_mpi.hpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without modification,
 6 | are permitted provided that the following conditions are met:
 7 | 
 8 | 1. Redistributions of source code must retain the above copyright notice,
 9 |    this list of conditions and the following disclaimer.
10 | 
11 | 2. Redistributions in binary form must reproduce the above copyright notice,
12 |    this list of conditions and the following disclaimer in the documentation
13 |    and/or other materials provided with the distribution.
14 | 
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 | */
25 | #pragma once
26 | 
27 | #include "config.hpp"
28 | #include "density_clustering.hpp"
29 | 
30 | #include <vector>
31 | 
32 | #include <boost/program_options.hpp>
33 | 
34 | namespace Clustering {
35 | namespace Density {
36 | //! MPI implementations of compute intensive functions.
37 | namespace MPI {
38 |   //! identify MPI process 0 as main process
39 |   const int MAIN_PROCESS = 0;
40 |   //! MPI implementation of
41 |   //! \link Clustering::Density::calculate_populations(const float* coords, const std::size_t n_rows, const std::size_t n_cols, const float radius)
42 |   std::vector<std::size_t>
43 |   calculate_populations(const float* coords,
44 |                         const std::size_t n_rows,
45 |                         const std::size_t n_cols,
46 |                         const float radius,
47 |                         const int mpi_n_nodes,
48 |                         const int mpi_node_id);
49 |   //! MPI implementation of
50 |   //! \link Clustering::Density::calculate_populations(const float* coords, const std::size_t n_rows, const std::size_t n_cols, const std::vector<float> radii)
51 |   std::map<float, std::vector<std::size_t>>
52 |   calculate_populations(const float* coords,
53 |                         const std::size_t n_rows,
54 |                         const std::size_t n_cols,
55 |                         std::vector<float> radii,
56 |                         const int mpi_n_nodes,
57 |                         const int mpi_node_id);
58 |   //! MPI implementation of
59 |   //! \link Clustering::Density::nearest_neighbors
60 |   std::tuple<Neighborhood, Neighborhood>
61 |   nearest_neighbors(const float* coords,
62 |                     const std::size_t n_rows,
63 |                     const std::size_t n_cols,
64 |                     const std::vector<float>& free_energy,
65 |                     const int mpi_n_nodes,
66 |                     const int mpi_node_id);
67 |   //! MPI implementation of
68 |   //! \link Clustering::Density::high_density_neighborhood
69 |   std::set<std::size_t>
70 |   high_density_neighborhood(const float* coords,
71 |                             const std::size_t n_cols,
72 |                             const std::vector<FreeEnergy>& sorted_fe,
73 |                             const std::size_t i_frame,
74 |                             const std::size_t limit,
75 |                             const float max_dist,
76 |                             const int mpi_n_nodes,
77 |                             const int mpi_node_id);
78 |   //! MPI implementation of
79 |   //! \link Clustering::Density::main
80 |   void
81 |   main(boost::program_options::variables_map args);
82 | } // end namespace MPI
83 | } // end namespace Density
84 | } // end namespace Clustering
85 | 
86 | 


--------------------------------------------------------------------------------
/src/coords_file/coords_file.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2015, Florian Sittel (www.lettis.net)
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without modification,
  6 | are permitted provided that the following conditions are met:
  7 | 
  8 | 1. Redistributions of source code must retain the above copyright notice,
  9 |    this list of conditions and the following disclaimer.
 10 | 
 11 | 2. Redistributions in binary form must reproduce the above copyright notice,
 12 |    this list of conditions and the following disclaimer in the documentation
 13 |    and/or other materials provided with the distribution.
 14 | 
 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 24 | */
 25 | #include "coords_file.hpp"
 26 | 
 27 | #include <iostream>
 28 | 
 29 | namespace CoordsFile {
 30 | 
 31 | template <typename T>
 32 | std::vector<T>
 33 | split(std::string s) {
 34 |   std::vector<T> v;
 35 |   std::istringstream iss(s);
 36 |   while(iss.good()) {
 37 |     T buf;
 38 |     iss >> buf;
 39 |     v.push_back(buf);
 40 |   }
 41 |   return v;
 42 | }
 43 | 
 44 | //// ASCII handler
 45 | 
 46 | AsciiHandler::AsciiHandler(std::string fname, std::string mode)
 47 |   : _eof(false)
 48 |   , _mode(mode) {
 49 |   if (mode == "r") {
 50 |     this->_ifs.open(fname);
 51 |   } else if (mode == "w") {
 52 |     this->_ofs.open(fname);
 53 |   } else {
 54 |     std::cerr << "unknown mode: " << mode << std::endl;
 55 |     exit(EXIT_FAILURE);
 56 |   }
 57 | }
 58 | 
 59 | std::vector<float>
 60 | AsciiHandler::next() {
 61 |   if (_ifs.is_open() && _ifs.good()) {
 62 |     std::string s;
 63 |     std::getline(_ifs, s);
 64 |     if (_ifs.good()) {
 65 |       if (s == "") {
 66 |         // skip empty lines
 67 |         return this->next();
 68 |       } else {
 69 |         return split<float>(s);
 70 |       }
 71 |     }
 72 |   }
 73 |   _eof = true;
 74 |   return {};
 75 | }
 76 | 
 77 | void
 78 | AsciiHandler::write(std::vector<float> row) {
 79 |   if (_ofs.is_open() && _ofs.good()) {
 80 |     for (float f: row) {
 81 |       _ofs << " " << f;
 82 |     }
 83 |     _ofs << std::endl;
 84 |   }
 85 | }
 86 | 
 87 | bool
 88 | AsciiHandler::eof() {
 89 |   return _eof;
 90 | }
 91 | 
 92 | 
 93 | //// XTC handler
 94 | 
 95 | XtcHandler::XtcHandler(std::string fname, std::string mode)
 96 |   : _eof(false)
 97 |   , _mode(mode)
 98 |   , _nrow(0) {
 99 |   if (_mode == "r") {
100 |     read_xtc_natoms(fname.c_str(), &_natoms);
101 |     _coord_buf = static_cast<rvec*>(calloc(_natoms, sizeof(_coord_buf[0])));
102 |   }
103 |   _xdr = xdrfile_open(fname.c_str(), mode.c_str());
104 | }
105 | 
106 | XtcHandler::~XtcHandler() {
107 |   xdrfile_close(_xdr);
108 |   if (_mode == "r") {
109 |     free(_coord_buf);
110 |   }
111 | }
112 | 
113 | std::vector<float>
114 | XtcHandler::next() {
115 |   if (_mode == "r") {
116 |     int step;
117 |     float time_step;
118 |     float prec;
119 |     matrix box;
120 |     int err = read_xtc(_xdr, _natoms, &step, &time_step, box, _coord_buf, &prec);
121 |     if (err == exdrOK) {
122 |       std::vector<float> v(_natoms*3);
123 |       for (int i=0; i < _natoms; ++i) {
124 |         v[3*i]   = _coord_buf[i][0];
125 |         v[3*i+1] = _coord_buf[i][1];
126 |         v[3*i+2] = _coord_buf[i][2];
127 |       }
128 |       return v;
129 |     }
130 |   }
131 |   _eof = true;
132 |   return {};
133 | }
134 | 
135 | void
136 | XtcHandler::write(std::vector<float> row) {
137 |   if (_mode == "w") {
138 |     float fake_box_matrix[3][3] = {{0,0,0}, {0,0,0}, {0,0,0}};
139 |     int natoms = row.size() / 3;
140 |     rvec* x = static_cast<rvec*>(calloc(natoms, sizeof(rvec)));
141 |     for (int i=0; i < natoms; ++i) {
142 |       x[i][0] = row[3*i];
143 |       x[i][1] = row[3*i+1];
144 |       x[i][2] = row[3*i+2];
145 |     }
146 |     write_xtc(_xdr, natoms, _nrow, _nrow*1.0f, fake_box_matrix, x, 1000.0f);
147 |     free(x);
148 |     ++_nrow;
149 |   }
150 | }
151 | 
152 | bool
153 | XtcHandler::eof() {
154 |   return _eof;
155 | }
156 | 
157 | 
158 | //// unifying interface
159 | 
160 | FilePointer
161 | open(std::string fname, std::string mode) {
162 |   if ((fname.size() > 4)
163 |    && (fname.compare(fname.size()-4, 4, ".xtc") == 0)) {
164 |     return FilePointer(new XtcHandler(fname, mode));
165 |   } else {
166 |     return FilePointer(new AsciiHandler(fname, mode));
167 |   }
168 | }
169 | 
170 | } // end namespace 'CoordsFile'
171 | 
172 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
  1 | # Copyright (c) 2015, Florian Sittel (www.lettis.net)
  2 | # All rights reserved.
  3 | # 
  4 | # Redistribution and use in source and binary forms, with or without modification,
  5 | # are permitted provided that the following conditions are met:
  6 | # 
  7 | # 1. Redistributions of source code must retain the above copyright notice,
  8 | #    this list of conditions and the following disclaimer.
  9 | # 
 10 | # 2. Redistributions in binary form must reproduce the above copyright notice,
 11 | #    this list of conditions and the following disclaimer in the documentation
 12 | #    and/or other materials provided with the distribution.
 13 | # 
 14 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 15 | # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 16 | # OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 17 | # SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 18 | # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 19 | # OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 20 | # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 21 | # TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 22 | # EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 23 | 
 24 | cmake_minimum_required (VERSION 2.8)
 25 | project (clustering) 
 26 | 
 27 | # do we want static libraries?
 28 | # When STATIC_LINKING is set, cmake looks for libraries called *.a.
 29 | if(STATIC_LINKING)
 30 |   set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
 31 | endif(STATIC_LINKING)
 32 | 
 33 | # Gnu compiler setup
 34 | if (${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
 35 |   message("using Gnu compiler")
 36 |   # use C++ 2011 standard
 37 |   set (CMAKE_CXX_FLAGS "-std=c++11")
 38 |   # profiling
 39 |   #set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -pg")
 40 |   # optimization
 41 |   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
 42 |   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftree-vectorize")
 43 |   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math")
 44 |   # parallelization
 45 |   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
 46 |   # warnings
 47 |   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 48 |   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra")
 49 |   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-pragmas")
 50 |   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wmissing-declarations")
 51 |   set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-gpu-targets")
 52 | 
 53 |   if (NATIVE_COMPILATION)
 54 |     message("native compilation: this code will ONLY run on THIS machine")
 55 |     set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
 56 |   endif()
 57 |   set (DC_MEM_ALIGNMENT 32)
 58 |   if (CPU_ACCELERATION)
 59 |     if (${CPU_ACCELERATION} STREQUAL "SSE2")
 60 |       message("using SSE2")
 61 |       set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse2")
 62 |       set (DC_MEM_ALIGNMENT 16)
 63 | 
 64 |     elseif (${CPU_ACCELERATION} STREQUAL "SSE4_1")
 65 |       message("using SSE4_1")
 66 |       set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.1")
 67 |       set (DC_MEM_ALIGNMENT 16)
 68 | 
 69 |     elseif (${CPU_ACCELERATION} STREQUAL "SSE4_2")
 70 |       message("using SSE4_2")
 71 |       set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.2")
 72 |       set (DC_MEM_ALIGNMENT 16)
 73 | 
 74 |     elseif (${CPU_ACCELERATION} STREQUAL "AVX")
 75 |       message("using AVX")
 76 |       set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
 77 |       set (DC_MEM_ALIGNMENT 32)
 78 |     else()
 79 |       message(SEND_ERROR "unknown instruction set: ${CPU_ACCELERATION}")
 80 |     endif()
 81 |   else()
 82 |     message("using standard CPU acceleration with memory aligned at ${DC_MEM_ALIGNMENT} bytes")
 83 |   endif()
 84 | else()
 85 |   message(SEND_ERROR "currently no other compiler than the GCC is supported. sorry.")
 86 | endif()
 87 | 
 88 | configure_file(config.hpp.cmake.in ${CMAKE_BINARY_DIR}/generated/config.hpp)
 89 | include_directories(${CMAKE_BINARY_DIR}/generated/)
 90 | 
 91 | find_package (Boost 1.49 COMPONENTS program_options system filesystem REQUIRED)
 92 | include_directories (${Boost_INCLUDE_DIR})
 93 | 
 94 | add_subdirectory(src/coords_file)
 95 | 
 96 | 
 97 | set(CLUSTERING_SRCS src/clustering.cpp
 98 |                     src/density_clustering.cpp
 99 |                     src/density_clustering_common.cpp
100 |                     src/mpp.cpp
101 |                     src/network_builder.cpp
102 |                     src/state_filter.cpp
103 |                     src/coring.cpp
104 |                     src/noise.cpp
105 |                     src/tools.cpp
106 |                     src/logger.cpp)
107 | 
108 | set(CLUSTERING_LIBS ${Boost_LIBRARIES} coords_file)
109 | 
110 | if(${USE_CUDA})
111 |   message(STATUS "using CUDA")
112 |   find_package(CUDA REQUIRED)
113 |   set(CUDA_PROPAGATE_HOST_FLAGS OFF)
114 |   set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-std=c++11;-O3;-DVERBOSE;-Xcompiler -fopenmp")
115 |   set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-arch=compute_30")
116 |   # debugging
117 |   #set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-g -G")
118 | 
119 |   set (CLUSTERING_SRCS ${CLUSTERING_SRCS}
120 |                        src/density_clustering_cuda.cu
121 |                        src/density_clustering_cuda_kernels.cu)
122 | 
123 |   set (CLUSTERING_LIBS ${CLUSTERING_LIBS} ${CUDA_LIBRARIES})
124 |   include_directories (${CUDA_INCLUDE_DIRS})
125 |   add_definitions(-DUSE_CUDA)
126 | endif()
127 | 
128 | 
129 | set (PROGNAME clustering)
130 | 
131 | 
132 | if (${USE_CUDA})
133 |   #  set (PROGNAME ${PROGNAME}.cuda)
134 |   cuda_add_executable(${PROGNAME} ${CLUSTERING_SRCS})
135 | else()
136 |   add_executable(${PROGNAME} ${CLUSTERING_SRCS})
137 | endif()
138 | 
139 | target_link_libraries(${PROGNAME} ${CLUSTERING_LIBS})
140 | 
141 | 
142 | # set -static, when STATIC_LINKING is TRUE and set LINK_SEARCH_END_STATIC
143 | # to remove the additional -bdynamic from the linker line.
144 | if(STATIC_LINKING)
145 |     set(CMAKE_EXE_LINKER_FLAGS "-static")
146 |     set_target_properties(${PROGNAME} PROPERTIES LINK_SEARCH_END_STATIC 1)
147 | endif(STATIC_LINKING)
148 | 
149 | 
150 | install(TARGETS ${PROGNAME} RUNTIME DESTINATION .)
151 | 
152 | # create source-doc with doxygen
153 | add_custom_target(doc
154 |                   WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
155 |                   COMMAND doxygen doxygen.config)
156 | 
157 | 


--------------------------------------------------------------------------------
/src/density_clustering_common.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without modification,
  6 | are permitted provided that the following conditions are met:
  7 | 
  8 | 1. Redistributions of source code must retain the above copyright notice,
  9 |    this list of conditions and the following disclaimer.
 10 | 
 11 | 2. Redistributions in binary form must reproduce the above copyright notice,
 12 |    this list of conditions and the following disclaimer in the documentation
 13 |    and/or other materials provided with the distribution.
 14 | 
 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 24 | */
 25 | 
 26 | #include "logger.hpp"
 27 | #include "density_clustering_common.hpp"
 28 | #include <iomanip>
 29 | 
 30 | #ifdef DC_USE_MPI
 31 |   #include "density_clustering_mpi.hpp"
 32 | #endif
 33 | 
 34 | namespace Clustering {
 35 | namespace Density {
 36 | 
 37 |   std::vector<std::size_t>
 38 |   screening(const std::vector<float>& free_energy
 39 |           , const Neighborhood& nh
 40 |           , const float free_energy_threshold
 41 |           , const float* coords
 42 |           , const std::size_t n_rows
 43 |           , const std::size_t n_cols
 44 |           , const std::vector<std::size_t> initial_clusters
 45 | #ifdef DC_USE_MPI
 46 |           , const int mpi_n_nodes
 47 |           , const int mpi_node_id
 48 | #endif
 49 |                             ) {
 50 | #ifdef DC_USE_MPI
 51 |     using namespace Clustering::Density::MPI;
 52 | #endif
 53 |     std::vector<std::size_t> clustering;
 54 |     std::size_t first_frame_above_threshold;
 55 |     double sigma2;
 56 |     std::vector<FreeEnergy> fe_sorted;
 57 |     std::set<std::size_t> visited_frames;
 58 |     std::size_t distinct_name;
 59 |     // data preparation
 60 |     std::tie(clustering
 61 |            , first_frame_above_threshold
 62 |            , sigma2
 63 |            , fe_sorted
 64 |            , visited_frames
 65 |            , distinct_name) = prepare_initial_clustering(free_energy
 66 |                                                        , nh
 67 |                                                        , free_energy_threshold
 68 |                                                        , n_rows
 69 |                                                        , initial_clusters);
 70 |     Clustering::logger(std::cout) << "    " << std::setw(6)
 71 |                                   << Clustering::Tools::stringprintf("%.2f", free_energy_threshold)
 72 |                                   << " " << std::setw(9)
 73 |                                   << Clustering::Tools::stringprintf("%i", first_frame_above_threshold)
 74 |                                   << std::endl;
 75 | #ifdef DC_USE_MPI
 76 |     if (mpi_node_id == MAIN_PROCESS) {
 77 | #endif
 78 |       screening_log(sigma2
 79 |                   , first_frame_above_threshold
 80 |                   , fe_sorted);
 81 | #ifdef DC_USE_MPI
 82 |     }
 83 | #endif
 84 |     // indices inside this loop are in order of sorted(!) free energies
 85 |     bool neighboring_clusters_merged = false;
 86 |     //TODO: this while loop shouldn't be necessary, resp.
 87 |     //      will always finish trivially after 2 runs, since nothing will
 88 |     //      happen as all frames will have been visitied...
 89 |     while ( ! neighboring_clusters_merged) {
 90 |       neighboring_clusters_merged = true;
 91 | #ifdef DC_USE_MPI
 92 |       if (mpi_node_id == MAIN_PROCESS) {
 93 | #endif
 94 | //        logger(std::cout) << "initial merge iteration" << std::endl;
 95 | #ifdef DC_USE_MPI
 96 |       }
 97 | #endif
 98 |       for (std::size_t i=0; i < first_frame_above_threshold; ++i) {
 99 |         if (visited_frames.count(i) == 0) {
100 |           visited_frames.insert(i);
101 |           // all frames/clusters in local neighborhood should be merged ...
102 | #ifdef DC_USE_MPI
103 |           using hdn_mpi = Clustering::Density::MPI::high_density_neighborhood;
104 |           std::set<std::size_t> local_nh = hdn_mpi(coords,
105 |                                                    n_cols,
106 |                                                    fe_sorted,
107 |                                                    i,
108 |                                                    first_frame_above_threshold,
109 |                                                    4*sigma2,
110 |                                                    mpi_n_nodes,
111 |                                                    mpi_node_id);
112 | #else
113 |           //TODO use box-assisted search on
114 |           //     fe_sorted coords for 'high_density_neighborhood'
115 |           std::set<std::size_t> local_nh = high_density_neighborhood(coords,
116 |                                                                      n_cols,
117 |                                                                      fe_sorted,
118 |                                                                      i,
119 |                                                                      first_frame_above_threshold,
120 |                                                                      4*sigma2);
121 | #endif
122 |           neighboring_clusters_merged = lump_initial_clusters(local_nh
123 |                                                             , distinct_name
124 |                                                             , clustering
125 |                                                             , fe_sorted
126 |                                                             , first_frame_above_threshold)
127 |                                      && neighboring_clusters_merged;
128 |         }
129 |       } // end for
130 |     } // end while
131 |     return normalized_cluster_names(first_frame_above_threshold
132 |                                   , clustering
133 |                                   , fe_sorted);
134 |   }
135 | 
136 | } // end namespace Density
137 | } // end namespace Clustering
138 | 
139 | 


--------------------------------------------------------------------------------
/src/density_clustering_opencl.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without modification,
  6 | are permitted provided that the following conditions are met:
  7 | 
  8 | 1. Redistributions of source code must retain the above copyright notice,
  9 |    this list of conditions and the following disclaimer.
 10 | 
 11 | 2. Redistributions in binary form must reproduce the above copyright notice,
 12 |    this list of conditions and the following disclaimer in the documentation
 13 |    and/or other materials provided with the distribution.
 14 | 
 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 24 | */
 25 | 
 26 | #define __CL_ENABLE_EXCEPTIONS
 27 | 
 28 | #include "density_clustering_opencl.hpp"
 29 | 
 30 | #include <iostream>
 31 | 
 32 | namespace Clustering {
 33 | namespace Density {
 34 | namespace OpenCL {
 35 | 
 36 |   std::map<float, std::vector<std::size_t>>
 37 |   calculate_populations(const float* coords,
 38 |                         const std::size_t n_rows,
 39 |                         const std::size_t n_cols,
 40 |                         std::vector<float> radii) {
 41 |     unsigned int uint_n_rows = (unsigned int) n_rows;
 42 |     unsigned int uint_n_cols = (unsigned int) n_cols;
 43 |     try {
 44 |       std::vector<cl::Platform> platforms;
 45 |       cl::Platform::get(&platforms);
 46 |       cl_context_properties cps[3] = {
 47 |         CL_CONTEXT_PLATFORM,
 48 |         (cl_context_properties) (platforms[0])(),
 49 |         0
 50 |       };
 51 |       cl::Context context(CL_DEVICE_TYPE_GPU, cps);
 52 |       std::vector<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>();
 53 |       std::vector<cl::CommandQueue> queues;
 54 |       for (cl::Device dev: devices) {
 55 |         queues.push_back(cl::CommandQueue(context, dev));
 56 |       }
 57 |       std::size_t n_queues = queues.size();
 58 |       // compute needed/avail mem sizes
 59 |       std::size_t n_bytes_per_row;
 60 |       std::size_t n_bytes_global_mem;
 61 |       n_bytes_per_row = n_cols * sizeof(float);
 62 |       n_bytes_global_mem = devices[0].getInfo<CL_DEVICE_GLOBAL_MEM_SIZE>();
 63 |       // do devices have enough memory for full data set?
 64 |       if (n_bytes_per_row * n_rows + (sizeof(unsigned int)*n_rows) > n_bytes_global_mem) {
 65 |         // TODO compute in chunks
 66 |         std::cerr << "error: not enough memory on device for full data set.\n"
 67 |                   << "       will support memory-size independet computation in a later release.\n"
 68 |                   << "       please check for updates." << std::endl;
 69 |         exit(EXIT_FAILURE);
 70 |       }
 71 |       // create buffers and copy data to device(s)
 72 |       cl::Buffer buf_coords = cl::Buffer(context, CL_MEM_READ_ONLY, n_rows*n_cols*sizeof(float));
 73 |       std::vector<cl::Buffer> buf_pops(n_queues);
 74 |       for (int iq=0; iq < n_queues; ++iq) {
 75 |         queues[iq].enqueueWriteBuffer(buf_coords, CL_TRUE, 0, n_rows*n_cols*sizeof(float), coords);
 76 |         buf_pops[iq] = cl::Buffer(context, CL_MEM_WRITE_ONLY, n_rows*sizeof(unsigned int));
 77 |       }
 78 | //TODO: fix
 79 |       // load kernel source
 80 | //      std::string kernel_src =
 81 | //        #include "kernel/pops.h"
 82 | //      ;
 83 |       cl::Program::Sources src(1, {kernel_src.c_str(), kernel_src.length()+1});
 84 |       cl::Program prog = cl::Program(context, src);
 85 |       int err = prog.build(devices);
 86 |       if (err != CL_SUCCESS) {
 87 |         std::cerr << "error during kernel compilation" << std::endl;
 88 |         std::cerr << prog.getBuildInfo<CL_PROGRAM_BUILD_LOG>(devices[0]) << std::endl;
 89 |         exit(EXIT_FAILURE);
 90 |       }
 91 |       // initialize pops for every queue to zero
 92 |       cl::Kernel krnl_init_pops(prog, "init_pops");
 93 |       for (int iq=0; iq < n_queues; ++iq) {
 94 |         krnl_init_pops.setArg(0, buf_pops[iq]);
 95 |         cl::NDRange full_global_range(n_rows);
 96 |         cl::Event event;
 97 |         queues[iq].enqueueNDRangeKernel(krnl_init_pops, cl::NullRange, full_global_range, cl::NullRange, NULL, &event);
 98 |         // very short and simple kernel: just do a blocking call
 99 |         event.wait();
100 |       }
101 |       cl::Kernel krnl_pops(prog, "pops");
102 |       // set kernel args
103 |       float rad2 = radii[0]*radii[0];
104 |       // TODO play with workgroup sizes
105 |       const unsigned int GLOBAL_SIZE = 1024;
106 |       const unsigned int WORKGROUP_SIZE = 128;
107 |       krnl_pops.setArg(2, sizeof(unsigned int), &uint_n_rows);
108 |       krnl_pops.setArg(3, sizeof(unsigned int), &uint_n_cols);
109 |       krnl_pops.setArg(4, buf_coords);
110 |       krnl_pops.setArg(5, sizeof(float), &rad2);
111 |       krnl_pops.setArg(7, sizeof(float)*WORKGROUP_SIZE*n_cols, NULL);
112 |       //// run kernel
113 |       // extend range to a size that is evenly divisible by the workgroup size.
114 |       // the kernel will ignore all workitems with index >= n_cols.
115 |       unsigned int range_length = n_rows;
116 |       while (range_length % WORKGROUP_SIZE != 0) {
117 |         ++range_length;
118 |       }
119 |       cl::NDRange global(GLOBAL_SIZE);
120 |       cl::NDRange local(WORKGROUP_SIZE);
121 |       // run pops kernel repeatedly, until the full range has been sampled
122 |       for (unsigned int i_block_ref=0; i_block_ref < range_length; i_block_ref += WORKGROUP_SIZE) {
123 |         krnl_pops.setArg(1, sizeof(unsigned int), &i_block_ref);
124 |         for (unsigned int i_block=0; i_block < range_length; i_block += n_queues*GLOBAL_SIZE) {
125 |           std::vector<cl::Event> events(n_queues);
126 |           for (unsigned int iq=0; iq < n_queues; ++iq) {
127 |             unsigned int q_block = i_block + iq*GLOBAL_SIZE;
128 |             krnl_pops.setArg(0, sizeof(unsigned int), &q_block);
129 |             krnl_pops.setArg(6, buf_pops[iq]);
130 |             queues[iq].enqueueNDRangeKernel(kernel, cl::NullRange, global, local, NULL, &events[iq]);
131 |           }
132 |           cl::Event::waitForEvents(events);
133 |         }
134 |       }
135 |       // retrieve results from all devices
136 |       std::vector<std::size_t> pops(n_rows, 0);
137 |       for (int iq=0; iq < n_queues; ++iq) {
138 |         std::vector<unsigned int> partial_pops(n_rows);
139 |         queues[iq].enqueueReadBuffer(buf_pops[iq], CL_TRUE, 0, n_rows*sizeof(unsigned int), partial_pops.data());
140 |         for (std::size_t i=0; i < n_rows; ++i) {
141 |           pops[i] += partial_pops[i];
142 |         }
143 |       }
144 |       return {{radii[0], pops}};
145 |     } catch(cl::Error error) {
146 |        std::cerr << "error in OpenCL call: " << error.what() << "(" << error.err() << ")" << std::endl;
147 |        exit(EXIT_FAILURE);
148 |     }
149 |   }
150 | 
151 | } // end namespace OpenCL
152 | } // end namespace Density
153 | } // end namespace Clustering
154 | 
155 | 


--------------------------------------------------------------------------------
/src/mpp.hpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without
  6 | modification, are permitted provided that the following conditions are met:
  7 | 
  8 | 1. Redistributions of source code must retain the above copyright notice, this
  9 | list of conditions and the following disclaimer.
 10 | 
 11 | 2. Redistributions in binary form must reproduce the above copyright notice,
 12 | this list of conditions and the following disclaimer in the documentation
 13 | and/or other materials provided with the distribution.
 14 | 
 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 16 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 17 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 18 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 19 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 20 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 21 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 22 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 23 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 24 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 25 | */
 26 | #pragma once
 27 | 
 28 | #include <vector>
 29 | #include <map>
 30 | #include <set>
 31 | #include <stdexcept>
 32 | #include <string>
 33 | 
 34 | #include <boost/program_options.hpp>
 35 | #include <boost/numeric/ublas/matrix_sparse.hpp>
 36 | #include <boost/numeric/ublas/io.hpp>
 37 | 
 38 | #include "tools.hpp"
 39 | /*! \file
 40 |  * \brief Most Probable Path Clustering
 41 |  *
 42 |  * \sa \link Clustering::MPP
 43 |  */
 44 | 
 45 | namespace Clustering {
 46 |   /*!
 47 |    * \brief functions related to "Most Probable Path"-clustering
 48 |    *
 49 |    * This module contains all function for dynamical clustering. In contrast to
 50 |    * density-based clustering, can it only be applied to previously clustered
 51 |    * trajectories. The idea is to create, based on a microstate input, a
 52 |    * coarse-grained model (macrostates).
 53 |    * The most probable path depends strongly on the selected timescale (mpp
 54 |    * time). If the input was dynamically cored, the mpp time needs to be
 55 |    * greater than the coring time.
 56 |    */
 57 |   namespace MPP {
 58 |     //! BOOST implementation of a sparse matrix for floats
 59 |     using SparseMatrixF = boost::numeric::ublas::mapped_matrix<float>;
 60 |     //! Neighborhood per frame
 61 |     using Neighborhood = Clustering::Tools::Neighborhood;
 62 |     //! read (row-normalized) transition matrix from file
 63 |     SparseMatrixF
 64 |     read_transition_probabilities(std::string fname);
 65 |     //! count transitions from one to the other cluster with certain lag
 66 |     //! and return as count matrix (row/col := from/to)
 67 |     SparseMatrixF
 68 |     transition_counts(std::vector<std::size_t> trajectory
 69 |                     , std::vector<std::size_t> concat_limits
 70 |                     , std::size_t n_lag_steps
 71 |                     , std::size_t i_max = 0);
 72 |     //! same as 'transition_counts', but with reweighting account for
 73 |     //! differently sized trajectory chunks (as given by concat_limits)
 74 |     SparseMatrixF
 75 |     weighted_transition_counts(std::vector<std::size_t> trajectory
 76 |                              , std::vector<std::size_t> concat_limits
 77 |                              , std::size_t n_lag_steps);
 78 |     //! compute transition matrix from counts by normalization of rows
 79 |     SparseMatrixF
 80 |     row_normalized_transition_probabilities(SparseMatrixF count_matrix
 81 |                                           , std::set<std::size_t> microstate_names);
 82 |     //! update transition matrix after lumping states into sinks
 83 |     SparseMatrixF
 84 |     updated_transition_probabilities(SparseMatrixF transition_matrix
 85 |                                    , std::map<std::size_t, std::size_t> sinks
 86 |                                    , std::map<std::size_t, std::size_t> pops);
 87 |     //! compute immediate future (i.e. without lag) of every state from highest probable transitions;
 88 |     //! exclude self-transitions.
 89 |     std::map<std::size_t, std::size_t>
 90 |     single_step_future_state(SparseMatrixF transition_matrix,
 91 |                              std::set<std::size_t> cluster_names,
 92 |                              float q_min,
 93 |                              std::map<std::size_t, float> min_free_energy);
 94 |     //! for every state, compute most probable path by following
 95 |     //! the 'future_state'-mapping recursively
 96 |     std::map<std::size_t, std::vector<std::size_t>>
 97 |     most_probable_path(std::map<std::size_t, std::size_t> future_state, std::set<std::size_t> cluster_names);
 98 |     //! compute cluster populations
 99 |     std::map<std::size_t, std::size_t>
100 |     microstate_populations(std::vector<std::size_t> clusters, std::set<std::size_t> cluster_names);
101 |     //! assign every state the lowest free energy value
102 |     //! of all of its frames.
103 |     std::map<std::size_t, float>
104 |     microstate_min_free_energy(const std::vector<std::size_t>& clustering,
105 |                                const std::vector<float>& free_energy);
106 |     //! compute path sinks, i.e. states of highest metastability,
107 |     //! and lowest free energy per path. these sinks will be states all other
108 |     //! states of the given path will be lumped into.
109 |     std::map<std::size_t, std::size_t>
110 |     path_sinks(std::vector<std::size_t> clusters,
111 |                std::map<std::size_t, std::vector<std::size_t>> mpp,
112 |                SparseMatrixF transition_matrix,
113 |                std::set<std::size_t> cluster_names,
114 |                float q_min,
115 |                std::vector<float> free_energy);
116 |     //! lump states based on path sinks and return new trajectory.
117 |     //! new microstates will have IDs of sinks.
118 |     std::vector<std::size_t>
119 |     lumped_trajectory(std::vector<std::size_t> trajectory,
120 |                       std::map<std::size_t, std::size_t> sinks);
121 |     //! run clustering for given Q_min value
122 |     std::tuple<std::vector<std::size_t>
123 |              , std::map<std::size_t, std::size_t>
124 |              , SparseMatrixF>
125 |     fixed_metastability_clustering(std::vector<std::size_t> initial_trajectory,
126 |                                    SparseMatrixF trans_prob,
127 |                                    float q_min,
128 |                                    std::vector<float> free_energy);
129 |     /*!
130 |      * \brief MPP clustering control function and user interface
131 |      *
132 |      * \param input input file with microstate trajectory
133 |      * \param basename name format for output files
134 |      * \param lagtime lag for transition estimation in units of frame numbers
135 |      * \param qmin-from lower limit for metastability (Q_min)
136 |      * \param qmin-to upper limit for metastability (Q_min)
137 |      * \param qmin-step stepping for metastability (Q_min)
138 |      * \param concat-nframes no. of frames per trajectory.
139 |      * \param concat-limits length of concated trajectories.
140 |      * \return void
141 |      * \note Lagtime should be greater than the coring time/ smallest
142 |      *       timescale.
143 |      */
144 |     void
145 |     main(boost::program_options::variables_map args);
146 |   } // end namespace Clustering::MPP
147 | } // end namespace Clustering
148 | 
149 | 


--------------------------------------------------------------------------------
/src/density_clustering_cuda_kernels.cu:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "density_clustering_cuda_kernels.hpp"
  3 | 
  4 | namespace Clustering {
  5 | namespace Density {
  6 | namespace CUDA {
  7 | namespace Kernel {
  8 | 
  9 |   __global__ void
 10 |   population_count(unsigned int offset
 11 |                  , float* coords
 12 |                  , unsigned int n_rows
 13 |                  , unsigned int n_cols
 14 |                  , float* radii2
 15 |                  , unsigned int n_radii
 16 |                  , unsigned int* pops
 17 |                  , unsigned int i_from
 18 |                  , unsigned int i_to) {
 19 |     extern __shared__ float smem[];
 20 |     unsigned int bid = blockIdx.x;
 21 |     unsigned int tid = threadIdx.x;
 22 |     unsigned int bsize = blockDim.x;
 23 |     unsigned int gid = bid * bsize + tid + i_from;
 24 |     // load frames for comparison into shared memory
 25 |     int comp_size = min(bsize, n_rows - offset);
 26 |     if (tid < comp_size) {
 27 |       for (unsigned int j=0; j < n_cols; ++j) {
 28 |         smem[tid*n_cols+j] = coords[(tid+offset)*n_cols+j];
 29 |       }
 30 |     }
 31 |     __syncthreads();
 32 |     // count neighbors
 33 |     if (gid < i_to) {
 34 |       unsigned int ref_id = tid+bsize;
 35 |       // load reference coordinates for re-use into shared memory
 36 |       for (unsigned int j=0; j < n_cols; ++j) {
 37 |         smem[ref_id*n_cols+j] = coords[gid*n_cols+j];
 38 |       }
 39 |       for (unsigned int r=0; r < n_radii; ++r) {
 40 |         unsigned int local_pop = 0;
 41 |         float rad2 = radii2[r];
 42 |         for (unsigned int i=0; i < comp_size; ++i) {
 43 |           float dist2 = 0.0f;
 44 |           for (unsigned int j=0; j < n_cols; ++j) {
 45 |             float c = smem[ref_id*n_cols+j] - smem[i*n_cols+j];
 46 |             dist2 = fma(c, c, dist2);
 47 |           }
 48 |           if (dist2 <= rad2) {
 49 |             ++local_pop;
 50 |           }
 51 |         }
 52 |         // update frame populations (per radius)
 53 |         pops[r*n_rows+gid] += local_pop;
 54 |       }
 55 |     }
 56 |   }
 57 | 
 58 |   __global__ void
 59 |   nearest_neighbor_search(unsigned int offset
 60 |                         , float* coords
 61 |                         , unsigned int n_rows
 62 |                         , unsigned int n_cols
 63 |                         , float* fe
 64 |                         , unsigned int* nh_nhhd_ndx
 65 |                         , float* nh_nhhd_dist
 66 |                         , unsigned int i_from
 67 |                         , unsigned int i_to) {
 68 |     // grid ids
 69 |     unsigned int bid = blockIdx.x;
 70 |     unsigned int tid = threadIdx.x;
 71 |     unsigned int bsize = blockDim.x;
 72 |     unsigned int gid = bid * bsize + tid + i_from;
 73 |     // free energy and local id for this frame
 74 |     float ref_fe;
 75 |     unsigned int ref_id;
 76 |     // shared memory for fast free energy / coordinate retrieval
 77 |     int comp_size = min(bsize, n_rows - offset);
 78 |     extern __shared__ float smem[];
 79 |     float* smem_fe = (float*) smem;
 80 |     float* smem_coords = (float*) &smem[comp_size];
 81 |     // load data of current block to compare with into shared memory 
 82 |     if (tid < comp_size) {
 83 |       for (unsigned int j=0; j < n_cols; ++j) {
 84 |         smem_coords[tid*n_cols+j] = coords[(tid+offset)*n_cols+j];
 85 |       }
 86 |       smem_fe[tid] = fe[tid+offset];
 87 |     }
 88 |     __syncthreads();
 89 |     if (gid < i_to) {
 90 |       ref_id = tid+bsize;
 91 |       // load reference coordinates for re-use into shared memory
 92 |       for (unsigned int j=0; j < n_cols; ++j) {
 93 |         smem_coords[ref_id*n_cols+j] = coords[gid*n_cols+j];
 94 |       }
 95 |       // reference free energy
 96 |       ref_fe = fe[gid];
 97 |       // load current best mindists for this frame into registers
 98 |       float nh_mindist = nh_nhhd_dist[gid];
 99 |       float nhhd_mindist = nh_nhhd_dist[gid+n_rows];
100 |       unsigned int nh_minndx = nh_nhhd_ndx[gid];
101 |       unsigned int nhhd_minndx = nh_nhhd_ndx[gid+n_rows];
102 |       // compare squared distances of reference
103 |       // to (other) frames in shared mem
104 |       for (unsigned int i=0; i < comp_size; ++i) {
105 |         float dist2=0.0f;
106 |         for (unsigned int j=0; j < n_cols; ++j) {
107 |           float c = smem_coords[ref_id*n_cols+j] - smem_coords[i*n_cols+j];
108 |           dist2 = fma(c, c, dist2);
109 |         }
110 |         // frame with min distance (i.e. nearest neighbor)
111 |         if ((nh_mindist == 0)
112 |          || (dist2 < nh_mindist && dist2 != 0)) {
113 |           nh_mindist = dist2;
114 |           nh_minndx = i+offset;
115 |         }
116 |         // frame with min distance and lower energy
117 |         if ((nhhd_mindist == 0 && smem_fe[i] < ref_fe)
118 |          || (dist2 < nhhd_mindist
119 |           && smem_fe[i] < ref_fe && dist2 != 0)) {
120 |           nhhd_mindist = dist2;
121 |           nhhd_minndx = i+offset;
122 |         }
123 |       }
124 |       // write results (ndx & dist) to global buffers
125 |       nh_nhhd_ndx[gid] = nh_minndx;
126 |       nh_nhhd_ndx[n_rows+gid] = nhhd_minndx;
127 |       nh_nhhd_dist[gid] = nh_mindist;
128 |       nh_nhhd_dist[n_rows+gid] = nhhd_mindist;
129 |     }
130 |   }
131 | 
132 |   __global__ void
133 |   screening(unsigned int offset
134 |           , float* sorted_coords
135 |           , unsigned int n_rows
136 |           , unsigned int n_cols
137 |           , float max_dist2
138 |           , unsigned int* clustering
139 |           , unsigned int i_from
140 |           , unsigned int i_to) {
141 |     // dynamic shared mem for ref coords
142 |     extern __shared__ float smem_coords[];
143 |     __shared__ unsigned int smem_states[BSIZE_SCR];
144 |     // thread dimensions
145 |     unsigned int bid = blockIdx.x;
146 |     unsigned int tid = threadIdx.x;
147 |     unsigned int bsize = blockDim.x;
148 |     unsigned int gid = bid * bsize + tid + i_from;
149 |     int comp_size = min(bsize, n_rows - offset);
150 |     if (tid < comp_size) {
151 |       // load reference coordinates to cache
152 |       for (unsigned int j=0; j < n_cols; ++j) {
153 |         smem_coords[tid*n_cols+j] = sorted_coords[(tid+offset)*n_cols+j];
154 |       }
155 |       // load reference state information to cache
156 |       smem_states[tid] = clustering[tid+offset];
157 |     }
158 |     __syncthreads();
159 |     if (gid < i_to) {
160 |       for (unsigned int j=0; j < n_cols; ++j) {
161 |         // load coordinates of current frame for re-use into shared memory
162 |         smem_coords[(tid+bsize)*n_cols+j] = sorted_coords[gid*n_cols+j];
163 |       }
164 |       // load previous state information to cache
165 |       unsigned int tmp_result = clustering[gid];
166 |       // compare current frame (tid) against reference block (k)
167 |       for (unsigned int k=0; k < comp_size; ++k) {
168 |         unsigned int tmp_state = smem_states[k];
169 |         if (tmp_state != tmp_result) {
170 |           float dist2 = 0.0f;
171 |           for (unsigned int j=0; j < n_cols; ++j) {
172 |             float c = smem_coords[(tid+bsize)*n_cols+j]
173 |                     - smem_coords[          k*n_cols+j];
174 |             dist2 = fma(c, c, dist2);
175 |           }
176 |           // update intermediate results
177 |           if (dist2 < max_dist2) {
178 |             tmp_result = min(tmp_state
179 |                            , tmp_result);
180 |             smem_states[k] = tmp_result;
181 |           }
182 |         }
183 |       }
184 |       clustering[gid] = tmp_result;
185 |     }
186 |     __syncthreads();
187 |     // update reference states
188 |     if (tid < comp_size) {
189 |       atomicMin(&clustering[tid+offset]
190 |               , smem_states[tid]);
191 |     }
192 |   }
193 | 
194 | }}}} // end Clustering::Density::CUDA::Kernel
195 | 
196 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | 
  2 | 
  3 | 
  4 | This software package provides extensive tools for fast, robust and stable
  5 | clustering of molecular dynamics trajectories.
  6 | The essential functions are:
  7 |   - density-based geometric clustering for microstate generation
  8 |   - dynamic clustering based on the Most-Probable-Path algorithm (MPP)
  9 |   - variable dynamic coring for boundary corrections
 10 |   - dynamic noise assignment.
 11 | 
 12 | Additionally, the package includes tools to efficiently filter original
 13 | coordinates or order parameters based on a discrete state definition
 14 | to identify representative structures and variables of clusters.
 15 | 
 16 | <!--
 17 | Computationally demanding functions are parallelized in a hybrid model using
 18 | OpenMP for SMP parallelization on a single node (multithreading)
 19 | and MPI over different cluster nodes. MPI support, however, is optional and
 20 | for a modern computer with a high number of fast cores or
 21 | even multiple CPUs, OpenMP parallelization is sufficiently fast.
 22 | -->
 23 | Computationally demanding functions are parallelized using CUDA or OpenMP.
 24 | 
 25 | # Documentation
 26 | All options are well documented and may be viewed by 'clustering -h'.
 27 | 
 28 | A documentation can be found on the project [page](https://moldyn.github.io/Clustering/docIndex.html), including an extensive [tutorial](https://moldyn.github.io/Clustering/docTutorial.html) which describes all technical
 29 | details in performing a complete clustering run from trajectory to markov state model.
 30 | 
 31 | The source code itself is additionally documented via doxygen. Run 'make doc' in
 32 | the build directory (see below for installation intructions) to compile the source
 33 | code documentation in html. Otherwise, it can be viewed [here](https://moldyn.github.io/Clustering/doxygen/index.html).
 34 | 
 35 | 
 36 | # Citations
 37 | The underlying methods are based on the following articles:
 38 |   - F. Sittel and G. Stock, *Robust Density-Based Clustering to Identify
 39 |     Metastable Conformational States of Proteins*,
 40 |     J. Chem. Theory Comput., 12, 2426; DOI: [10.1021/acs.jctc.5b01233](https://pubs.acs.org/doi/abs/10.1021/acs.jctc.5b01233)
 41 |   - A. Jain and G. Stock, *Hierarchical folding free energy landscape of HP35
 42 |     revealed by most probable path clustering*,
 43 |     J. of Phys. Chem. B, 118, 7750 - 7760, 2014; DOI: [10.1021/jp410398a](https://pubs.acs.org/doi/abs/10.1021/jp410398a)
 44 |   - D. Nagel, A. Weber, B. Lickert and G. Stock, *Dynamical coring of Markov state models*,
 45 |     J. Chem. Phys., 150, 094111, 2019; DOI: [10.1063/1.5081767](https://aip.scitation.org/doi/10.1063/1.5081767)
 46 | 
 47 | We kindly ask you to cite these articles if you use this software package for
 48 | published works.
 49 | 
 50 | 
 51 | # Licensing
 52 | This project was created by [lettis](http://www.lettis.net) and is currently maintained by [moldyn-nagel](https://github.com/moldyn-nagel).
 53 | 
 54 | Copyright (c) 2015-2019, [Florian Sittel](http://www.lettis.net) and Daniel Nagel
 55 | All rights reserved.
 56 | 
 57 | Redistribution and use in source and binary forms, with or without
 58 | modification, are permitted provided that the following conditions are met:
 59 | 
 60 | 1. Redistributions of source code must retain the above copyright notice,
 61 |    this list of conditions and the following disclaimer.
 62 | 
 63 | 2. Redistributions in binary form must reproduce the above copyright notice,
 64 |    this list of conditions and the following disclaimer in the documentation
 65 |    and/or other materials provided with the distribution.
 66 | 
 67 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 68 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 69 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 70 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 71 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 72 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 73 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 74 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 75 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 76 | 
 77 | 
 78 | # Installation
 79 | This package can be installed with conda via
 80 | ```
 81 | conda install moldyn-clustering -c conda-forge
 82 | ```
 83 | If conda is not available, it can be compiled as well.
 84 | 
 85 | # Compilation
 86 | ## Requirements
 87 |  required:
 88 |   -  **BOOST >= 1.49**
 89 |   -  **cmake >= 2.8**
 90 |   -  a **recent** C++ compiler (e.g. GNU g++ >= 4.9, must
 91 |      support C++11 standard)
 92 | 
 93 |  optional:
 94 |   - **CUDA >= 9.1**
 95 |   - doxygen (to build the API docs)
 96 | <!--  - MPI (for parallelized execution on clusters) -->
 97 | 
 98 | ## Quick-Start
 99 | 
100 | To quickly get a working (but possibly underperforming) binary
101 | 
102 |   - unpack the code ...
103 | ```
104 |     # tar xfz clustering_VERSION.tar.gz
105 | ```
106 |   - create a build folder inside the code directory ...
107 | ```
108 |     # cd clustering_VERSION
109 |     # mkdir build
110 | ```
111 |   - change to the build directory ...
112 | ```
113 |     # cd build
114 | ```
115 |   - ... and run cmake
116 | ```
117 |     # cmake .. -DCMAKE_INSTALL_PREFIX=/my/installation/path
118 | ```
119 |   - then compile and install the package to /my/installation/path (or any other
120 |     path you chose above) by invoking
121 | ```
122 |     # make
123 |     # make install 
124 | ```
125 | 
126 | If you want to have bash completion enabled, you need to add following line to your `.bashrc`
127 | ```bash
128 |    # in file .bashrc
129 |    source /my/installation/path/bash_completion_clustering.sh
130 | ```
131 | 
132 | ## Optimized Binaries and Custom Build Options
133 | 
134 | ### CUDA
135 | If you have an Nvidia graphic card it can be used to significantly speed up the
136 | *clustering density* method, by setting the following **cmake-option**:
137 | -DUSE_CUDA=1
138 | 
139 | ### Vectorization
140 | If you have a modern computer with vectorizing instruction sets (SSE2, SSE4_2,
141 | AVX, ...), set the following **cmake-option**: -DCPU_ACCELERATION=<OPTION>,
142 | where <OPTION> is one of
143 |   - SSE2
144 |   - SSE4_1
145 |   - SSE4_2
146 |   - AVX
147 | 
148 | It is important to select an option that is actually supported by your machine.
149 | Otherwise the program will produce erratic results, crash or not compile at all.
150 | On linux systems, you can check your computer's capabilities with
151 | ```
152 |     # cat /proc/cpuinfo
153 | ```
154 | Check in the *flags:*-block, if a certain instruction set is supported.
155 | If it is not listed, it is not supported.
156 | 
157 | ### Native Compilation
158 | To compile the code with '-march=native' option (specific to the GNU compiler),
159 | add '-DNATIVE_COMPILATION=ON' to your cmake-flags.
160 | Using this option, the GNU compiler will automatically use all available
161 | instruction sets for optimal performance (**attention**: you still
162 | need to set the vectorization option above, even if you use this option).
163 | 
164 | Unfortunately, the resulting binary will most likely run only on the computer
165 | it was compiled on - do **not** use this option if you want
166 | to distribute the binary, e.g. on a cluster.
167 | 
168 | <!--
169 | ### MPI
170 | For MPI support, build your binary with the additional cmake-flag -DDC_USE_MPI=ON.
171 | Invoke the *clustering_mpi* binary in the following way to run on several nodes with local multithreading via OpenMP:
172 | 
173 |      # /usr/bin/mpirun -n N_NODES -bind-to-core -bynode -cpus-per-proc N_THREADS_PER_NODE -report-bindings  \
174 |           clustering_mpi density -f COORDS_FILE -r RADIUS -p POPS_OUT -d FE_OUT -n N_THREADS_PER_NODE
175 | -->
176 | 
177 | 


--------------------------------------------------------------------------------
/src/tools.hpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without
  6 | modification, are permitted provided that the following conditions are met:
  7 | 
  8 | 1. Redistributions of source code must retain the above copyright notice, this
  9 | list of conditions and the following disclaimer.
 10 | 
 11 | 2. Redistributions in binary form must reproduce the above copyright notice,
 12 | this list of conditions and the following disclaimer in the documentation
 13 | and/or other materials provided with the distribution.
 14 | 
 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 16 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 17 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 18 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 19 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 20 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 21 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 22 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 23 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 24 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 25 | */
 26 | #pragma once
 27 | 
 28 | #include "config.hpp"
 29 | 
 30 | #include <string>
 31 | #include <vector>
 32 | #include <map>
 33 | #include <tuple>
 34 | #include <memory>
 35 | #include <iostream>
 36 | 
 37 | /// needed for aligned memory allocation for Xeon Phi, SSE or AVX
 38 | #if defined(__INTEL_COMPILER)
 39 |  #include <malloc.h>
 40 | #else
 41 |  #include <mm_malloc.h>
 42 | #endif
 43 | 
 44 | #if defined(__INTEL_COMPILER)
 45 |   #define ASSUME_ALIGNED(c) __assume_aligned( (c), DC_MEM_ALIGNMENT)
 46 | #else
 47 |   #define ASSUME_ALIGNED(c) (c) = (float*) __builtin_assume_aligned( (c), DC_MEM_ALIGNMENT)
 48 | #endif
 49 | /*! \file
 50 |  * \brief Tools mainly for IO and some other functions
 51 |  *
 52 |  * \sa \link Clustering::Tools
 53 |  */
 54 | 
 55 | namespace Clustering {
 56 | /*!
 57 |  * \brief additional tools used throughout the *clustering* package
 58 |  *
 59 |  * This module contains helper functions. Most of them are for reading or
 60 |  * writing files.
 61 |  */
 62 | namespace Tools {
 63 |   //! matches neighbor's frame id to distance
 64 |   using Neighbor = std::pair<std::size_t, float>;
 65 |   //! map frame id to neighbors
 66 |   using Neighborhood = std::map<std::size_t, Clustering::Tools::Neighbor>;
 67 |   //! write populations as column into given file
 68 |   void
 69 |   write_pops(std::string fname, std::vector<std::size_t> pops, std::string header_comment,
 70 |              std::map<std::string,float> stringMap);
 71 |   //! write free energies as column into given file
 72 |   void
 73 |   write_fes(std::string fname, std::vector<float> fes, std::string header_comment,
 74 |             std::map<std::string,float> stringMap);
 75 |   //! read states from trajectory (given as plain text file)
 76 |   std::vector<std::size_t>
 77 |   read_clustered_trajectory(std::string filename);
 78 |   //! write state trajectory into plain text file
 79 |   void
 80 |   write_clustered_trajectory(std::string filename, std::vector<std::size_t> traj,
 81 |                              std::string header_comment, std::map<std::string,float> stringMap);
 82 |   //! read single column of numbers from given file. number type (int, float, ...) given as template parameter
 83 |   template <typename NUM>
 84 |   std::vector<NUM>
 85 |   read_single_column(std::string filename);
 86 |   //! write single column of numbers to given file. number type (int, float, ...) given as template parameter
 87 |   template <typename NUM>
 88 |   void
 89 |   write_single_column(std::string filename, std::vector<NUM> dat,
 90 |                       std::string header_comment, bool with_scientific_format=false);
 91 |   //! write key-value map to plain text file with key as first and value as second column
 92 |   template <typename KEY, typename VAL>
 93 |   void
 94 |   write_map(std::string filename, std::map<KEY, VAL> mapping,
 95 |             std::string header_comment, bool val_then_key=false);
 96 |   //! read free energies from plain text file
 97 |   std::vector<float>
 98 |   read_free_energies(std::string filename);
 99 |   //! read conact limits
100 |   //! takes length of the single trajectories.
101 |   std::vector<std::size_t>
102 |   read_concat_limits(std::string filename);
103 |   //! read neighborhood info from plain text file
104 |   //! (two different neighborhoods: nearest neighbor (NN) and NN with higher density)
105 |   std::pair<Neighborhood, Neighborhood>
106 |   read_neighborhood(const std::string fname);
107 |   //! write neighborhood info to plain text file
108 |   //! (two different neighborhoods: nearest neighbor (NN) and NN with higher density)
109 |   void
110 |   write_neighborhood(const std::string fname,
111 |                      const Neighborhood& nh,
112 |                      const Neighborhood& nh_high_dens,
113 |                      std::string header_comment,
114 |                      std::map<std::string,float> stringMap);
115 |   //! compute microstate populations from clustered trajectory
116 |   std::map<std::size_t, std::size_t>
117 |   microstate_populations(std::vector<std::size_t> traj);
118 |   //! read coordinates from space-separated ASCII file.
119 |   //! will write data with precision of NUM-type into memory.
120 |   //! format: [row * n_cols + col]
121 |   //! return value: tuple of {data (unique_ptr<NUM> with custom deleter), n_rows (size_t), n_cols (size_t)}.
122 |   template <typename NUM>
123 |   std::tuple<NUM*, std::size_t, std::size_t>
124 |   read_coords(std::string filename,
125 |               std::vector<std::size_t> usecols = std::vector<std::size_t>());
126 |   //! free memory pointing to coordinates
127 |   template <typename NUM>
128 |   void
129 |   free_coords(NUM* coords);
130 |   //! return std::vector with coords sorted along first dimension.
131 |   //! uses row-based addressing (row*n_cols+col).
132 |   template <typename NUM>
133 |   std::vector<NUM>
134 |   dim1_sorted_coords(const NUM* coords
135 |                    , std::size_t n_rows
136 |                    , std::size_t n_cols);
137 |   //! separate into equally sized boxes and return min values of
138 |   //! first dimension for given box.
139 |   //! used for pruning in CUDA-accelerated code.
140 |   template <typename NUM>
141 |   std::vector<NUM>
142 |   boxlimits(const std::vector<NUM>& xs
143 |           , std::size_t boxsize
144 |           , std::size_t n_rows
145 |           , std::size_t n_cols);
146 |   //! return indices of min and max boxes around value for given radius.
147 |   template <typename NUM>
148 |   std::pair<std::size_t, std::size_t>
149 |   min_max_box(const std::vector<NUM>& limits
150 |             , NUM val
151 |             , NUM radius);
152 |   //! return minimum multiplicator to fulfill result * mult >= orig
153 |   unsigned int
154 |   min_multiplicator(unsigned int orig
155 |                   , unsigned int mult);
156 |   //! printf-version for std::string
157 |   std::string
158 |   stringprintf(const std::string& str, ...);
159 |   //! convert std::string to number of given template format
160 |   template <typename NUM>
161 |   NUM
162 |   string_to_num(const std::string &s);
163 |   //! return distinct elements of vector
164 |   template <typename T>
165 |   std::vector<T>
166 |   unique_elements(std::vector<T> xs);
167 |   //! check if concat limits were passed correctly
168 |   void
169 |   check_concat_limits(std::vector<std::size_t> concat_limits,
170 |                       std::size_t n_frames);
171 |   //! read comments of stringMap from file. Comments should start with #@
172 |   void
173 |   read_comments(std::string filename, std::map<std::string,float> &stringMap);
174 |   //! read the next float of ifstream
175 |   float
176 |   read_next_float(std::ifstream &ifs);
177 |   //! append commentsMap to header comment
178 |   void
179 |   append_commentsMap(std::string &header_comment, std::map<std::string,float> &stringMap);
180 | } // end namespace 'Tools'
181 | } // end namespace 'Clustering'
182 | 
183 | // template implementations
184 | #include "tools.hxx"
185 | 
186 | 


--------------------------------------------------------------------------------
/src/coords_file/xdrfile/trr2xtc.c:
--------------------------------------------------------------------------------
  1 | /* -*- mode: c; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- 
  2 |  *
  3 |  * $Id: trr2xtc.c,v 1.3 2009/05/18 09:06:38 spoel Exp $
  4 |  *
  5 |  * Copyright (c) Erik Lindahl, David van der Spoel 2003,2004.
  6 |  * Coordinate compression (c) by Frans van Hoesel. 
  7 |  *
  8 |  * This program is free software; you can redistribute it and/or
  9 |  * modify it under the terms of the GNU Lesser General Public License
 10 |  * as published by the Free Software Foundation; either version 3
 11 |  * of the License, or (at your option) any later version.
 12 |  */
 13 | 
 14 | #include <stdio.h>
 15 | #include <stdlib.h>
 16 | #include <string.h>
 17 | 
 18 | #include "xdrfile.h"
 19 | #include "xdrfile_trr.h"
 20 | #include "xdrfile_xtc.h"
 21 | 
 22 | 
 23 | /* This program tests reading and writing to XDR files */
 24 | 
 25 | static void _die(char *msg, int line, char *file) {
 26 | 	fprintf(stderr, "Fatal error: %s\n", msg);
 27 | 	fprintf(stderr, "Death occurred at %s, line %d\n", file, line);
 28 | 	exit(1);
 29 | }
 30 | #define die(msg) _die(msg,__LINE__,__FILE__)
 31 | 
 32 | static void _die_r(char *msg, int result, int line, char *file) {
 33 | 	fprintf(stderr, "Fatal error: %s\n", msg);
 34 | 	fprintf(stderr,"result = %d\n", result);
 35 | 	fprintf(stderr, "Death occurred at %s, line %d\n", file, line);
 36 | 	exit(1);
 37 | }
 38 | #define die_r(msg,res) _die_r(msg,res,__LINE__,__FILE__)
 39 | 
 40 | 
 41 | void ReadWrite(char *rfile, char *wfile, int in_xtcBool, int out_xtcBool, int in_trrBool, int out_trrBool)
 42 | {
 43 |   XDRFILE *xd_read, *xd_write;
 44 |   int result_xtc, result_trr;
 45 |   int natoms_xtc, natoms_trr;
 46 |   int step_xtc, step_trr;
 47 |   float time_xtc, time_trr;
 48 |   matrix box_xtc, box_trr;
 49 |   rvec *x_xtc, *x_trr, *v_trr, *f_trr;
 50 |   float prec_xtc = 1000.0;
 51 |   float lambda_trr = 0.0;
 52 |   
 53 |       
 54 |   xd_read = xdrfile_open(rfile, "r");
 55 |   if (NULL == xd_read)
 56 |     die("Opening xdrfile for reading");
 57 |   
 58 |   /* Test whether output file exists */
 59 |   if ((xd_write = xdrfile_open(wfile,"r")) != NULL) {
 60 |     xdrfile_close(xd_write);
 61 |     die("Output file exists.");
 62 |   }
 63 |   
 64 |   /* Output file does not exist. Now we can open it for writing */
 65 |   xd_write = xdrfile_open(wfile, "w");
 66 |   if (NULL == xd_write)
 67 |     die("Opening xdrfile for writing");
 68 |   
 69 |   
 70 |   /* .xtc -> .xtc */
 71 |   if(in_xtcBool && out_xtcBool)
 72 |     {
 73 |       result_xtc = read_xtc_natoms(rfile, &natoms_xtc);
 74 |       if (exdrOK != result_xtc)
 75 | 	die_r("read_xtc_natoms",result_xtc);
 76 |       
 77 |       x_xtc = calloc(natoms_xtc, sizeof(x_xtc[0]));
 78 | 
 79 |       while(1)
 80 | 	{
 81 | 	  result_xtc = read_xtc(xd_read, natoms_xtc, &step_xtc, &time_xtc,
 82 | 				box_xtc, x_xtc, &prec_xtc);
 83 | 	    
 84 | 	  if (result_xtc == 0) // if not reach the end of file, write it to the output.xtc file
 85 | 	    {
 86 | 	      if (exdrOK != result_xtc)
 87 | 		die_r("Reading xtc file", result_xtc);
 88 | 	      
 89 | 	      result_xtc = write_xtc(xd_write, natoms_xtc, step_xtc, time_xtc,
 90 | 				     box_xtc, x_xtc, prec_xtc);
 91 | 	      
 92 | 	      if (result_xtc != 0)
 93 | 		die_r("Writing xtc file", result_xtc);
 94 | 	    }
 95 | 	  else
 96 | 	    break;
 97 | 	}
 98 |     }
 99 |   
100 | 
101 |   /* .xtc -> .trr */
102 |   if(in_xtcBool && out_trrBool)
103 |     {
104 |       result_xtc = read_xtc_natoms(rfile, &natoms_xtc);
105 |       if (exdrOK != result_xtc)
106 | 	die_r("read_xtc_natoms",result_xtc);
107 |       
108 |       x_xtc = calloc(natoms_xtc, sizeof(x_xtc[0]));
109 |       
110 |       while(1)
111 | 	{
112 | 	  result_xtc = read_xtc(xd_read, natoms_xtc, &step_xtc, &time_xtc,
113 | 				box_xtc, x_xtc, &prec_xtc);
114 | 	  
115 | 	  if (result_xtc == 0) // if not reach the end of file, write it to the output.trr file
116 | 	    {
117 | 	      if (exdrOK != result_xtc)
118 | 		die_r("Reading xtc file", result_xtc);
119 | 	      
120 | 	      result_trr = write_trr(xd_write, natoms_xtc, step_xtc, time_xtc, lambda_trr,
121 | 				     box_xtc, x_xtc, NULL, NULL);
122 | 	      
123 | 	      if (0 != result_trr)
124 | 		die_r("Writing trr file",result_trr);
125 | 	      
126 | 	    }
127 | 	  else
128 | 	    break;
129 | 	}
130 |     }
131 |   
132 |   
133 |   /* .trr -> .trr */
134 |   if(in_trrBool && out_trrBool)
135 |     {
136 |       result_trr = read_trr_natoms(rfile, &natoms_trr);
137 |       
138 |       if (exdrOK != result_trr)
139 | 	die_r("read_trr_natoms",result_trr);
140 |       
141 |       x_trr = calloc(natoms_trr, sizeof(x_trr[0]));
142 |       v_trr = calloc(natoms_trr, sizeof(v_trr[0]));
143 |       f_trr = calloc(natoms_trr, sizeof(f_trr[0]));
144 |       
145 |       while (1)
146 | 	{
147 | 	  result_trr = read_trr(xd_read, natoms_trr, &step_trr, &time_trr, &lambda_trr,
148 | 				box_trr, x_trr, v_trr, f_trr);
149 | 	      
150 | 	  int ii_trr, jj_trr, x_ck=0, v_ck=0, f_ck=0;
151 | 	  int x_ck_bool=0, v_ck_bool=0, f_ck_bool=0;
152 | 	  
153 | 	  for (ii_trr = 0; ii_trr < natoms_trr; ii_trr++)
154 | 	    {
155 | 	      for(jj_trr = 0; jj_trr < DIM; jj_trr++)
156 | 		{
157 | 		  if (x_trr[ii_trr][jj_trr] == 0)
158 | 		    x_ck++;
159 | 		  if (v_trr[ii_trr][jj_trr] == 0)
160 | 		    v_ck++;
161 | 		  if (f_trr[ii_trr][jj_trr] == 0)
162 | 		    f_ck++;
163 | 		}
164 | 	    }
165 | 	  
166 | 	  if (x_ck == natoms_trr*DIM)
167 | 	    x_ck_bool = 1;
168 | 	  if (v_ck == natoms_trr*DIM)
169 | 	    v_ck_bool = 1;
170 | 	  if (f_ck == natoms_trr*DIM)
171 | 	    f_ck_bool = 1;
172 | 	      
173 | 	  if (result_trr == 0) // if not reach the end of file, write it to the output.trr file
174 | 	    {
175 | 	      if (exdrOK != result_trr)
176 | 		die_r("Reading trr file",result_trr);
177 | 	      
178 | 	      if(v_ck_bool && f_ck_bool)
179 | 		result_trr = write_trr(xd_write, natoms_trr, step_trr, time_trr, lambda_trr,
180 | 				       box_trr, x_trr, NULL, NULL);
181 | 	      else if(v_ck_bool)
182 | 		result_trr = write_trr(xd_write, natoms_trr, step_trr, time_trr, lambda_trr,
183 | 				       box_trr, x_trr, NULL, f_trr);
184 | 	      else if(f_ck_bool)
185 | 		result_trr = write_trr(xd_write, natoms_trr, step_trr, time_trr, lambda_trr,
186 | 				       box_trr, x_trr, v_trr, NULL);
187 | 	      else
188 | 		result_trr = write_trr(xd_write, natoms_trr, step_trr, time_trr, lambda_trr,
189 | 				       box_trr, x_trr, v_trr, f_trr);
190 | 	      
191 | 	      if (0 != result_trr)
192 | 		die_r("Writing trr file",result_trr);
193 | 	      
194 | 	    }
195 | 	  else
196 | 	    break;
197 | 	}
198 |     }
199 |   
200 |   
201 |   /* .trr -> .xtc */
202 |   if(in_trrBool && out_xtcBool)
203 |     {
204 |       result_trr = read_trr_natoms(rfile, &natoms_trr);
205 |       
206 |       if (exdrOK != result_trr)
207 | 	die_r("read_trr_natoms",result_trr);
208 |       
209 |       x_trr = calloc(natoms_trr, sizeof(x_trr[0]));
210 |       v_trr = calloc(natoms_trr, sizeof(v_trr[0]));
211 |       f_trr = calloc(natoms_trr, sizeof(f_trr[0]));
212 |       
213 |       while(1)
214 | 	{
215 | 	  result_trr = read_trr(xd_read, natoms_trr, &step_trr, &time_trr, &lambda_trr,
216 | 				box_trr, x_trr, v_trr, f_trr);
217 | 	  
218 | 	  if (result_trr == 0) // if not reach the end of file, write it to the output.trr file
219 | 	    {
220 | 	      if (exdrOK != result_trr)
221 | 		die_r("Reading trr file", result_trr);
222 | 	      
223 | 	      result_xtc = write_xtc(xd_write, natoms_trr, step_trr, time_trr,
224 | 				     box_trr, x_trr, prec_xtc);
225 | 	      
226 | 	      if (result_xtc != 0)
227 | 		die_r("Writing xtc file", result_xtc);
228 | 		}
229 | 	  else
230 | 	    break;
231 | 	}
232 |     }
233 |   
234 |   xdrfile_close(xd_read);
235 |   xdrfile_close(xd_write);
236 |   
237 | }
238 | 
239 | 
240 | 
241 | int main(int argc, char *argv[])
242 | {
243 |   int inFileBool = 0;
244 |   int outFileBool = 0;
245 |   int in_xtcBool = 0;
246 |   int out_xtcBool = 0;
247 |   int in_trrBool = 0;
248 |   int out_trrBool = 0;
249 |   char *rfile=NULL, *wfile=NULL;
250 |   
251 | 
252 |   if(argc != 5)
253 |     {
254 |       fprintf(stderr,"Usage: %s -i inFile -o outFile\n",argv[0]);
255 |       exit(1);
256 |     }
257 |   else
258 |     {
259 |       int ii = 1;
260 | 
261 |       while(ii < argc)
262 | 	{
263 | 	  if(strcmp(argv[ii], "-i") == 0)         // if (argv[ii] == "-i")
264 | 	    {
265 | 	      ii++;
266 | 	      inFileBool = 1;
267 | 	 
268 | 	      if(strstr(argv[ii], ".xtc") != NULL)
269 | 		{
270 | 		  in_xtcBool = 1;
271 | 		  in_trrBool = 0;
272 | 		}
273 | 	      if(strstr(argv[ii], ".trr") != NULL)
274 | 		{
275 | 		  in_trrBool = 1;
276 | 		  in_xtcBool = 0;
277 | 		}
278 | 
279 | 	      rfile = argv[ii];
280 | 	    }
281 | 
282 | 	  if(strcmp(argv[ii], "-o") == 0)
283 | 	    {
284 | 	      ii++;
285 | 	      outFileBool = 1;
286 | 	 
287 | 	      if(strstr(argv[ii], ".xtc") != NULL)
288 | 		{		
289 | 		  out_xtcBool = 1;
290 | 		  out_trrBool = 0;
291 | 		}
292 | 	      if(strstr(argv[ii], ".trr") != NULL)
293 | 		{
294 | 		  out_trrBool = 1;
295 | 		  out_xtcBool = 0;
296 | 		}
297 | 
298 | 	      wfile = argv[ii];
299 | 	    }
300 | 
301 | 	  ii++;
302 | 	}
303 |     }
304 | 
305 |   if(!inFileBool || !outFileBool)
306 |     {
307 |       perror("Usage : ./ReadWrite -i inFile -o outFile");
308 |       exit(1);
309 |     }
310 | 
311 |   ReadWrite(rfile, wfile, in_xtcBool, out_xtcBool, in_trrBool, out_trrBool);
312 |   
313 | 
314 |   return 0;
315 | }
316 | 


--------------------------------------------------------------------------------
/src/tools.hxx:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without modification,
  6 | are permitted provided that the following conditions are met:
  7 | 
  8 | 1. Redistributions of source code must retain the above copyright notice,
  9 |    this list of conditions and the following disclaimer.
 10 | 
 11 | 2. Redistributions in binary form must reproduce the above copyright notice,
 12 |    this list of conditions and the following disclaimer in the documentation
 13 |    and/or other materials provided with the distribution.
 14 | 
 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 24 | */
 25 | 
 26 | #include "tools.hpp"
 27 | #include "logger.hpp"
 28 | 
 29 | #include <iostream>
 30 | #include <fstream>
 31 | #include <sstream>
 32 | #include <iterator>
 33 | #include <map>
 34 | #include <algorithm>
 35 | 
 36 | namespace Clustering {
 37 | namespace Tools {
 38 | 
 39 | template <typename NUM>
 40 | std::tuple<NUM*, std::size_t, std::size_t>
 41 | read_coords(std::string filename, std::vector<std::size_t> usecols) {
 42 |   std::size_t n_rows=0;
 43 |   std::size_t n_cols=0;
 44 |   std::size_t n_cols_used=0;
 45 |   std::ifstream ifs(filename);
 46 |   Clustering::logger(std::cout) << "~~~ reading coordinates" << std::endl;
 47 |   if (ifs.fail()) {
 48 |     std::cerr << "error: cannot open file '" << filename << "'" << std::endl;
 49 |     exit(EXIT_FAILURE);
 50 |   }
 51 |   Clustering::logger(std::cout) << "    from file: " << filename << std::endl;
 52 |   {
 53 |     // determine n_cols
 54 |     std::string linebuf;
 55 |     while (linebuf.empty() && ifs.good()) {
 56 |       std::getline(ifs, linebuf);
 57 |     }
 58 |     std::stringstream ss(linebuf);
 59 |     n_cols = std::distance(std::istream_iterator<std::string>(ss),
 60 |                            std::istream_iterator<std::string>());
 61 |     // go back to beginning to read complete file
 62 |     ifs.seekg(0);
 63 |     // determine n_rows
 64 |     while (ifs.good()) {
 65 |       std::getline(ifs, linebuf);
 66 |       if ( ! linebuf.empty()) {
 67 |         ++n_rows;
 68 |       }
 69 |     }
 70 |     // go back again
 71 |     ifs.clear();
 72 |     ifs.seekg(0, std::ios::beg);
 73 |   }
 74 |   Clustering::logger(std::cout) << "    with dimensions: " << n_rows << "x"
 75 |                                 << n_cols << "\n" << std::endl;
 76 |   std::map<std::size_t, bool> col_used;
 77 |   if (usecols.size() == 0) {
 78 |     // use all columns
 79 |     n_cols_used = n_cols;
 80 |     for (std::size_t i=0; i < n_cols; ++i) {
 81 |       col_used[i] = true;
 82 |     }
 83 |   } else {
 84 |     // use only defined columns
 85 |     n_cols_used = usecols.size();
 86 |     for (std::size_t i=0; i < n_cols; ++i) {
 87 |       col_used[i] = false;
 88 |     }
 89 |     for (std::size_t i: usecols) {
 90 |       col_used[i] = true;
 91 |     }
 92 |   }
 93 |   // allocate memory
 94 |   // DC_MEM_ALIGNMENT is defined during cmake and
 95 |   // set depending on usage of SSE2, SSE4_1, AVX or Xeon Phi
 96 |   NUM* coords = (NUM*) _mm_malloc(sizeof(NUM)*n_rows*n_cols_used, DC_MEM_ALIGNMENT);
 97 |   ASSUME_ALIGNED(coords);
 98 |   // read data
 99 |   for (std::size_t cur_row = 0; cur_row < n_rows; ++cur_row) {
100 |     std::size_t cur_col = 0;
101 |     for (std::size_t i=0; i < n_cols; ++i) {
102 |       NUM buf;
103 |       ifs >> buf;
104 |       if (col_used[i]) {
105 |         coords[cur_row*n_cols_used + cur_col] = buf;
106 |         ++cur_col;
107 |       }
108 |     }
109 |   }
110 |   return std::make_tuple(coords, n_rows, n_cols_used);
111 | }
112 | 
113 | 
114 | template <typename NUM>
115 | void
116 | free_coords(NUM* coords) {
117 |   _mm_free(coords);
118 | }
119 | 
120 | template <typename NUM>
121 | std::vector<NUM>
122 | dim1_sorted_coords(const NUM* coords
123 |                  , std::size_t n_rows
124 |                  , std::size_t n_cols) {
125 |   std::vector<NUM> sorted_coords(n_rows*n_cols);
126 |   if (n_cols == 1) {
127 |     // directly sort on data if just one column
128 |     for (std::size_t i=0; i < n_rows; ++i) {
129 |       sorted_coords[i] = coords[i];
130 |     }
131 |     std::sort(sorted_coords.begin(), sorted_coords.end());
132 |   } else {
133 |     std::vector<std::vector<NUM>> c_tmp(n_rows
134 |                                       , std::vector<float>(n_cols));
135 |     for (std::size_t i=0; i < n_rows; ++i) {
136 |       for (std::size_t j=0; j < n_cols; ++j) {
137 |         c_tmp[i][j] = coords[i*n_cols+j];
138 |       }
139 |     }
140 |     // sort on first index
141 |     std::sort(c_tmp.begin()
142 |             , c_tmp.end()
143 |             , [] (const std::vector<NUM>& lhs
144 |                 , const std::vector<NUM>& rhs) {
145 |                 return lhs[0] < rhs[0];
146 |               });
147 |     // feed sorted data into 1D-array
148 |     for (std::size_t i=0; i < n_rows; ++i) {
149 |       for (std::size_t j=0; j < n_cols; ++j) {
150 |         sorted_coords[i*n_cols+j] = c_tmp[i][j];
151 |       }
152 |     }
153 |   }
154 |   return sorted_coords;
155 | }
156 | 
157 | template <typename NUM>
158 | std::vector<NUM>
159 | boxlimits(const std::vector<NUM>& xs
160 |         , std::size_t boxsize
161 |         , std::size_t n_rows
162 |         , std::size_t n_cols) {
163 |   //std::size_t n_xs = xs.size() / n_dim;
164 |   std::size_t n_boxes = n_rows / boxsize;
165 |   if (n_boxes * boxsize < n_rows) {
166 |     ++n_boxes;
167 |   }
168 |   std::vector<NUM> boxlimits(n_boxes);
169 |   for (std::size_t i=0; i < n_boxes; ++i) {
170 |     // split into boxes on 1st dimension
171 |     // (i.e. col-index == 0)
172 |     boxlimits[i] = xs[i*boxsize*n_cols];
173 |   }
174 |   return boxlimits;
175 | }
176 | 
177 | template <typename NUM>
178 | std::pair<std::size_t, std::size_t>
179 | min_max_box(const std::vector<NUM>& limits
180 |           , NUM val
181 |           , NUM radius) {
182 |   std::size_t n_boxes = limits.size();
183 |   if (n_boxes == 0) {
184 |     return {0,0};
185 |   } else {
186 |     std::size_t i_min = n_boxes - 1;
187 |     std::size_t i_max = 0;
188 |     NUM lbound = val - radius;
189 |     NUM ubound = val + radius;
190 |     for (std::size_t i=1; i < n_boxes; ++i) {
191 |       if (lbound < limits[i]) {
192 |         i_min = i-1;
193 |         break;
194 |       }
195 |     }
196 |     for (std::size_t i=n_boxes; 0 < i; --i) {
197 |       if (limits[i-1] < ubound) {
198 |         i_max = i-1;
199 |         break;
200 |       }
201 |     }
202 |     return {i_min, i_max};
203 |   }
204 | }
205 | 
206 | 
207 | template <typename KEY, typename VAL>
208 | void
209 | write_map(std::string filename, std::map<KEY, VAL> mapping,
210 |           std::string header_comment, bool val_then_key) {
211 |   std::ofstream ofs(filename);
212 |   if (ofs.fail()) {
213 |     std::cerr << "error: cannot open file '" << filename << "' for writing." << std::endl;
214 |     exit(EXIT_FAILURE);
215 |   }
216 |   ofs << header_comment;
217 |   if (val_then_key) {
218 |     for (auto key_val: mapping) {
219 |       ofs << key_val.second << " " << key_val.first << "\n";
220 |     }
221 |   } else {
222 |     for (auto key_val: mapping) {
223 |       ofs << key_val.first << " " << key_val.second << "\n";
224 |     }
225 |   }
226 | }
227 | 
228 | template <typename NUM>
229 | std::vector<NUM>
230 | read_single_column(std::string filename) {
231 |   std::vector<NUM> dat;
232 |   std::ifstream ifs(filename);
233 |   if (ifs.fail()) {
234 |     std::cerr << "error: cannot open file '" << filename << "'" << std::endl;
235 |     exit(EXIT_FAILURE);
236 |   } else {
237 |     while (!ifs.eof() && !ifs.bad()) {
238 |       NUM buf;
239 |       ifs >> buf;
240 |       if ( ! ifs.fail()) {
241 |         dat.push_back(buf);
242 |       } else {  // if conversion error, skip (comment) line
243 |         ifs.clear();
244 |         ifs.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
245 |       }
246 |     }
247 |   }
248 |   if (dat.empty()) {
249 |     std::cerr << "error: opened empty file '" << filename << "'" << std::endl;
250 |     exit(EXIT_FAILURE);
251 |   }
252 |   return dat;
253 | }
254 | 
255 | 
256 | template <typename NUM>
257 | void
258 | write_single_column(std::string filename, std::vector<NUM> dat,
259 |                     std::string header_comment, bool with_scientific_format) {
260 |   std::ofstream ofs(filename);
261 |   if (ofs.fail()) {
262 |     std::cerr << "error: cannot open file '" << filename << "' for writing." << std::endl;
263 |     exit(EXIT_FAILURE);
264 |   }
265 |   ofs << header_comment;
266 |   if (with_scientific_format) {
267 |     ofs << std::scientific;
268 |   }
269 |   for (NUM i: dat) {
270 |     ofs << i << "\n";
271 |   }
272 | }
273 | 
274 | template <typename NUM>
275 | NUM
276 | string_to_num(const std::string &s) {
277 |   std::stringstream ss(s);
278 |   NUM buf;
279 |   ss >> buf;
280 |   return buf;
281 | }
282 | 
283 | template <typename T>
284 | std::vector<T>
285 | unique_elements(std::vector<T> xs) {
286 |   std::sort(xs.begin()
287 |           , xs.end());
288 |   auto last = std::unique(xs.begin()
289 |                         , xs.end());
290 |   xs.erase(last
291 |          , xs.end());
292 |   return xs;
293 | }
294 | 
295 | 
296 | } // end namespace Tools
297 | } // end namespace Clustering
298 | 
299 | 


--------------------------------------------------------------------------------
/src/tools.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2015-2017, Florian Sittel (www.lettis.net)
  3 | Copyright (c) 2018-2020, Daniel Nagel
  4 | All rights reserved.
  5 | 
  6 | Redistribution and use in source and binary forms, with or without modification,
  7 | are permitted provided that the following conditions are met:
  8 | 
  9 | 1. Redistributions of source code must retain the above copyright notice,
 10 |    this list of conditions and the following disclaimer.
 11 | 
 12 | 2. Redistributions in binary form must reproduce the above copyright notice,
 13 |    this list of conditions and the following disclaimer in the documentation
 14 |    and/or other materials provided with the distribution.
 15 | 
 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 17 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 18 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 19 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 20 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 21 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 22 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 23 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 24 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 25 | */
 26 | 
 27 | #include "tools.hpp"
 28 | #include "logger.hpp"
 29 | 
 30 | #include <cmath>
 31 | #include <stdarg.h>
 32 | 
 33 | namespace Clustering {
 34 | namespace Tools {
 35 | 
 36 | unsigned int
 37 | min_multiplicator(unsigned int orig
 38 |                 , unsigned int mult) {
 39 |   return (unsigned int) std::ceil(orig / ((float) mult));
 40 | };
 41 | 
 42 | void
 43 | write_fes(std::string filename, std::vector<float> fes, std::string header_comment,
 44 |           std::map<std::string,float> stringMap) {
 45 |   append_commentsMap(header_comment, stringMap);
 46 |   header_comment.append("#\n# free energy of each frame\n");
 47 |   write_single_column<float>(filename, fes, header_comment, true);
 48 | }
 49 | 
 50 | void
 51 | write_pops(std::string filename, std::vector<std::size_t> pops, std::string header_comment,
 52 |            std::map<std::string,float> stringMap) {
 53 |   append_commentsMap(header_comment, stringMap);
 54 |   header_comment.append("#\n# point density of each frame\n");
 55 |   write_single_column<std::size_t>(filename, pops, header_comment, false);
 56 | }
 57 | 
 58 | std::vector<std::size_t>
 59 | read_clustered_trajectory(std::string filename) {
 60 |   return read_single_column<std::size_t>(filename);
 61 | }
 62 | 
 63 | void
 64 | write_clustered_trajectory(std::string filename, std::vector<std::size_t> traj,
 65 |                            std::string header_comment, std::map<std::string,float> stringMap) {
 66 |   append_commentsMap(header_comment, stringMap);
 67 |   header_comment.append("#\n# state/cluster id frames are assigned to\n");
 68 |   write_single_column<std::size_t>(filename, traj, header_comment, false);
 69 | }
 70 | 
 71 | //// from: https://github.com/lettis/Kubix
 72 | /**
 73 | behaves like sprintf(char*, ...), but with c++ strings and returns the result
 74 | 
 75 | \param str pattern to be printed to
 76 | \return resulting string
 77 | The function internally calls sprintf, but converts the result to a c++ string and returns that one.
 78 | Problems of memory allocation are taken care of automatically.
 79 | */
 80 | std::string
 81 | stringprintf(const std::string& str, ...) {
 82 |   unsigned int size = 256;
 83 |   va_list args;
 84 |   char* buf = (char*) malloc(size * sizeof(char));
 85 |   va_start(args, str);
 86 |   while (size <= (unsigned int) vsnprintf(buf, size, str.c_str(), args)) {
 87 |     size *= 2;
 88 |     buf = (char*) realloc(buf, size * sizeof(char));
 89 |   }
 90 |   va_end(args);
 91 |   std::string result(buf);
 92 |   free(buf);
 93 |   return result;
 94 | }
 95 | 
 96 | std::vector<float>
 97 | read_free_energies(std::string filename) {
 98 |   return read_single_column<float>(filename);
 99 | }
100 | 
101 | std::pair<Neighborhood, Neighborhood>
102 | read_neighborhood(const std::string filename) {
103 |   Neighborhood nh;
104 |   Neighborhood nh_high_dens;
105 |   std::ifstream ifs(filename);
106 |   if (ifs.fail()) {
107 |     std::cerr << "error: cannot open file '" << filename << "' for reading." << std::endl;
108 |     exit(EXIT_FAILURE);
109 |   } else {
110 |     std::size_t i=0;
111 |     while (!ifs.eof() && !ifs.bad()) {
112 |       std::size_t buf1;
113 |       float buf2;
114 |       std::size_t buf3;
115 |       float buf4;
116 |       ifs >> buf1;
117 |       ifs >> buf2;
118 |       ifs >> buf3;
119 |       ifs >> buf4;
120 |       if ( ! ifs.fail()) {
121 |         nh[i] = std::pair<std::size_t, float>(buf1, buf2);
122 |         nh_high_dens[i] = std::pair<std::size_t, float>(buf3, buf4);
123 |         ++i;
124 |       } else {  // if conversion error, skip (comment) line
125 |         ifs.clear();
126 |         ifs.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
127 |       }
128 |     }
129 |   }
130 |   return {nh, nh_high_dens};
131 | }
132 | 
133 | std::vector<std::size_t>
134 | read_concat_limits(std::string filename) {
135 |   std::vector<std::size_t> concat_limits = read_single_column<std::size_t>(filename);
136 | 
137 |   for (std::size_t i=0; i+1 < concat_limits.size(); ++i){
138 |     concat_limits[i+1] += concat_limits[i];
139 |   }
140 | 
141 |   return concat_limits;
142 | }
143 | 
144 | void
145 | write_neighborhood(const std::string filename,
146 |                    const Neighborhood& nh,
147 |                    const Neighborhood& nh_high_dens,
148 |                    std::string header_comment,
149 |                    std::map<std::string,float> stringMap) {
150 |   std::ofstream ofs(filename);
151 |   if (ofs.fail()) {
152 |     std::cerr << "error: cannot open file '" << filename << "' for writing." << std::endl;
153 |     exit(EXIT_FAILURE);
154 |   }
155 |   append_commentsMap(header_comment, stringMap);
156 |   header_comment.append("#\n# column definitions:\n"
157 |                         "#        nn = nearest neighbor\n"
158 |                         "#     nn_hd = nearest neighbor with higher density\n"
159 |                         "#     id(i) = id/line number of i\n"
160 |                         "#   dsqr(i) = squared euclidean distance to i\n#\n"
161 |                         "# id(nn)  dsqr(nn) id(nn_hd) dsqr(nn_hd)\n");
162 |   ofs << header_comment;
163 |   auto p = nh.begin();
164 |   auto p_hd = nh_high_dens.begin();
165 |   while (p != nh.end() && p_hd != nh_high_dens.end()) {
166 |     // first: key (not used)
167 |     // second: neighbor
168 |     // second.first: id; second.second: squared dist
169 |     ofs << p->second.first    << " " << p->second.second    << " "
170 |         << p_hd->second.first << " " << p_hd->second.second << "\n";
171 |     ++p;
172 |     ++p_hd;
173 |   }
174 | }
175 | 
176 | std::map<std::size_t, std::size_t>
177 | microstate_populations(std::vector<std::size_t> traj) {
178 |   std::map<std::size_t, std::size_t> populations;
179 |   for (std::size_t state: traj) {
180 |     if (populations.count(state) == 0) {
181 |       populations[state] = 1;
182 |     } else {
183 |       ++populations[state];
184 |     }
185 |   }
186 |   return populations;
187 | }
188 | 
189 | void
190 | check_concat_limits(std::vector<std::size_t> concat_limits, std::size_t n_frames) {
191 |   if (concat_limits.back() < n_frames) {
192 |     Clustering::logger(std::cout) << "warning: last " << n_frames - concat_limits.back()
193 |                                   << " frames are ignored. check concat-limits/nframes"
194 |                                   << std::endl;
195 |   }
196 |   if (concat_limits.front() == 0) {
197 |     Clustering::logger(std::cout) << "warning: first trajectory is of zero length. check\n"
198 |                                   << "         help for correct usage of --concat-limits"
199 |                                   << std::endl;
200 |   }
201 |   if (concat_limits.back() > n_frames) {
202 |     Clustering::logger(std::cout) << "warning: limits are larger than the file length.\n"
203 |                                   << "         Check your limits!" <<std::endl;
204 |   }
205 | }
206 | 
207 | float
208 | read_next_float(std::ifstream &ifs) {
209 |   std::string s;
210 |   if (ifs.peek() != '\n') {
211 |     ifs >> std::ws;
212 |     while (!std::isdigit(ifs.peek()) && ifs.peek() != '\n') {
213 |       ifs >> s;
214 |       if (ifs.peek() != '\n') {
215 |         ifs >> std::ws;
216 |       }
217 |     }
218 |   }
219 |   float val;
220 |   // catch if line end was case
221 |   if (ifs.peek() == '\n') {
222 |     val = -1.;
223 |   } else {
224 |     ifs >> val;
225 |   }
226 |   return val;
227 | }
228 | 
229 | void
230 | read_comments(std::string filename, std::map<std::string,float> &stringMap) {
231 |   std::vector<std::size_t> dat;
232 |   std::ifstream ifs(filename);
233 |   if (ifs.fail()) {
234 |     std::cerr << "error: cannot open file '" << filename << "'" << std::endl;
235 |     exit(EXIT_FAILURE);
236 |   } else {
237 |     while (!ifs.eof() && !ifs.bad()) {
238 |       std::size_t buf;
239 |       ifs >> buf;
240 |       if (ifs.fail()) {
241 |         ifs.clear();
242 |         std::string s;
243 |         ifs >> s;
244 |         if (s == "#@" && ifs.peek() != '\n') {
245 |           ifs >> s;
246 |           for (auto & x : stringMap)
247 |           {
248 |             if (s == x.first) {
249 |               float val = read_next_float(ifs);
250 |               if ((x.second != 0) && (std::abs(x.second-val) > 0.001)) {
251 |                 Clustering::logger(std::cout) << "warning: the values of " << x.first
252 |                                               << " are not in agreement\n"
253 |                                               << "        " << val << " vs. "
254 |                                               << x.second<< std::endl;
255 |               }
256 |               stringMap[x.first] = val;
257 |             }
258 |           }
259 |         }
260 |         ifs.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
261 |       }
262 |     }
263 |   }
264 |   return;
265 | }
266 | 
267 | void
268 | append_commentsMap(std::string &header_comment, std::map<std::string,float> &stringMap) {
269 |   header_comment.append("#\n# The following comments are reused for identifying\n# user-based mistakes and should not be modified.\n");
270 |   for (auto &x : stringMap)
271 |   {
272 |     if (x.second != 0.) {
273 |       header_comment.append(stringprintf("#@   %s = %.5f\n", x.first.c_str(), x.second));
274 |     }
275 |   }
276 |   return;
277 | }
278 | 
279 | 
280 | } // end namespace Tools
281 | } // end namespace Clustering
282 | 


--------------------------------------------------------------------------------
/src/density_clustering.hpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without modification,
  6 | are permitted provided that the following conditions are met:
  7 | 
  8 | 1. Redistributions of source code must retain the above copyright notice,
  9 |    this list of conditions and the following disclaimer.
 10 | 
 11 | 2. Redistributions in binary form must reproduce the above copyright notice,
 12 |    this list of conditions and the following disclaimer in the documentation
 13 |    and/or other materials provided with the distribution.
 14 | 
 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 24 | */
 25 | 
 26 | #pragma once
 27 | 
 28 | #include <vector>
 29 | #include <map>
 30 | #include <set>
 31 | #include <array>
 32 | #include <utility>
 33 | #include <string>
 34 | 
 35 | #include <boost/program_options.hpp>
 36 | 
 37 | #include "tools.hpp"
 38 | /*! \file
 39 |  * \brief Density-based clustering
 40 |  *
 41 |  * \sa \link Clustering::Noise
 42 |  */
 43 | 
 44 | //! general namespace for clustering package
 45 | namespace Clustering {
 46 |   /*!
 47 |    * \brief namespace for density-based clustering functions
 48 |    *
 49 |    * This module contains all function for assigning each frame a free energy
 50 |    * and a nearest neighbor. Further, it identifies clusters.
 51 |    */
 52 |   namespace Density {
 53 |     //! matches frame id to free energy
 54 |     using FreeEnergy = std::pair<std::size_t, float>;
 55 |     //! matches neighbor's frame id to distance
 56 |     using Neighbor = Clustering::Tools::Neighbor;
 57 |     //! map frame id to neighbors
 58 |     using Neighborhood = Clustering::Tools::Neighborhood;
 59 |     //! encodes 2D box for box-assisted search algorithm
 60 |     using Box = std::array<int, 2>;
 61 |     //! encodes box differences in 2D, i.e. if you are at
 62 |     //! the center box, the 9 different tuples hold the steppings
 63 |     //! to the 9 spacial neighbors (including the center box itself).
 64 |     constexpr int BOX_DIFF[9][2] = {{-1, 1}, { 0, 1}, { 1, 1}
 65 |                                   , {-1, 0}, { 0, 0}, { 1, 0}
 66 |                                   , {-1,-1}, { 0,-1}, { 1,-1}};
 67 |     //! number of neigbor boxes in 2D grid (including center box).
 68 |     const int N_NEIGHBOR_BOXES = 9;
 69 | //    //! encodes box differences in 3D, i.e. if you are at
 70 | //    //! the center box, the 27 different tuples hold the steppings
 71 | //    //! to the 27 spacial neighbors (including the center box itself).
 72 | //    constexpr int BOX_DIFF[27][3] = {{-1, 1,-1}, { 0, 1,-1}, { 1, 1,-1}
 73 | //                                   , {-1, 0,-1}, { 0, 0,-1}, { 1, 0,-1}
 74 | //                                   , {-1,-1,-1}, { 0,-1,-1}, { 1,-1,-1}
 75 | //                                   , {-1, 1, 0}, { 0, 1, 0}, { 1, 1, 0}
 76 | //                                   , {-1, 0, 0}, { 0, 0, 0}, { 1, 0, 0}
 77 | //                                   , {-1,-1, 0}, { 0,-1, 0}, { 1,-1, 0}
 78 | //                                   , {-1, 1, 1}, { 0, 1, 1}, { 1, 1, 1}
 79 | //                                   , {-1, 0, 1}, { 0, 0, 1}, { 1, 0, 1}
 80 | //                                   , {-1,-1, 1}, { 0,-1, 1}, { 1,-1, 1}};
 81 | //    //! number of neigbor boxes in cubic 3D grid (including center box).
 82 | //    const int N_NEIGHBOR_BOXES = 27;
 83 |     //! the full grid constructed for boxed-assisted nearest neighbor
 84 |     //! search with fixed distance criterion.
 85 |     struct BoxGrid {
 86 |       //! total number of boxes
 87 |       std::vector<int> n_boxes;
 88 |       //! matching frame id to the frame's assigned box
 89 |       std::vector<Box> assigned_box;
 90 |       //! the boxes with a list of assigned frame ids
 91 |       std::map<Box, std::vector<int>> boxes;
 92 |     };
 93 |     //! returns neighbor box given by neighbor index (in 3D: 27 different neighbors, including center itself)
 94 |     //! and the given center box.
 95 |     constexpr Box
 96 |     neighbor_box(const Box center, const int i_neighbor);
 97 |     //! uses fixed radius to separate coordinate space in equally sized
 98 |     //! boxes for box-assisted nearest neighbor search.
 99 |     BoxGrid
100 |     compute_box_grid(const float* coords,
101 |                      const std::size_t n_rows,
102 |                      const std::size_t n_cols,
103 |                      const float radius);
104 |     //! returns true, if the box is a valid box in the grid.
105 |     //! return false, if the box is outside of the grid.
106 |     bool
107 |     is_valid_box(const Box box,
108 |                  const BoxGrid& grid);
109 |     //! calculate population of n-dimensional hypersphere per frame for one fixed radius.
110 |     std::vector<std::size_t>
111 |     calculate_populations(const float* coords,
112 |                           const std::size_t n_rows,
113 |                           const std::size_t n_cols,
114 |                           const float radius);
115 |     //! calculate populations of n-dimensional hypersphere per frame for
116 |     //! different radii in one go. computationally much more efficient than
117 |     //! running single-radius version for every radius.
118 |     std::map<float, std::vector<std::size_t>>
119 |     calculate_populations(const float* coords,
120 |                           const std::size_t n_rows,
121 |                           const std::size_t n_cols,
122 |                           const std::vector<float> radii);
123 |     //! re-use populations to calculate local free energy estimate
124 |     //! via $\Delta G = -k_B T \\ln(P)$.
125 |     std::vector<float>
126 |     calculate_free_energies(const std::vector<std::size_t>& pops);
127 |     //! returns the given free energies sorted lowest to highest.
128 |     //! original indices are retained.
129 |     std::vector<FreeEnergy>
130 |     sorted_free_energies(const std::vector<float>& fe);
131 |     //! for every frame: compute the nearest neighbor (first tuple field)
132 |     //! and the nearest neighbor with lower free energy, i.e. higher density (second tuple field).
133 |     std::tuple<Neighborhood, Neighborhood>
134 |     nearest_neighbors(const float* coords,
135 |                       const std::size_t n_rows,
136 |                       const std::size_t n_cols,
137 |                       const std::vector<float>& free_energy);
138 |     //! log output for screening steps
139 |     void
140 |     screening_log(const double sigma2
141 |                 , const std::size_t first_frame_above_threshold
142 |                 , const std::vector<FreeEnergy>& fe_sorted);
143 |     //! prepare data for initial density clustering as used
144 |     //! in the screening process
145 |     std::tuple<std::vector<std::size_t>
146 |              , std::size_t
147 |              , double
148 |              , std::vector<FreeEnergy>
149 |              , std::set<std::size_t>
150 |              , std::size_t>
151 |     prepare_initial_clustering(const std::vector<float>& free_energy
152 |                              , const Neighborhood& nh
153 |                              , const float free_energy_threshold
154 |                              , const std::size_t n_rows
155 |                              , const std::vector<std::size_t> initial_clusters);
156 |     //! return clustered trajectory with new, distinct cluster names.
157 |     std::vector<std::size_t>
158 |     normalized_cluster_names(std::size_t first_frame_above_threshold
159 |                            , std::vector<std::size_t> clustering
160 |                            , std::vector<FreeEnergy>& fe_sorted);
161 |     //! lump clusters based on distance threshold in screening process
162 |     bool
163 |     lump_initial_clusters(const std::set<std::size_t>& local_nh
164 |                         , std::size_t& distinct_name
165 |                         , std::vector<std::size_t>& clustering
166 |                         , const std::vector<FreeEnergy>& fe_sorted
167 |                         , std::size_t first_frame_above_threshold);
168 |     //! compute local neighborhood of a given frame.
169 |     //! neighbor candidates are all frames below a given limit,
170 |     //! effectively limiting the frames to the ones below a free energy cutoff.
171 |     std::set<std::size_t>
172 |     high_density_neighborhood(const float* coords,
173 |                               const std::size_t n_cols,
174 |                               const std::vector<FreeEnergy>& sorted_fe,
175 |                               const std::size_t i_frame,
176 |                               const std::size_t limit,
177 |                               const float max_dist);
178 |     //! compute sigma2 as deviation of squared nearest-neighbor distances.
179 |     //! sigma2 is given by E[x^2] > Var(x) = E[x^2] - E[x]^2,
180 |     //! with x being the distances between nearest neighbors).
181 |     double
182 |     compute_sigma2(const Neighborhood& nh);
183 |     //! compare two two dimensional pairs by their second entry
184 |     bool
185 |     compare2DVector(const std::pair<std::size_t,std::size_t>& p1,
186 |                     const std::pair<std::size_t,std::size_t>& p2);
187 |     //! check if float has at maximum two digits
188 |     bool
189 |     has2digits(float val);
190 |     //! sorts the cluster by decreasing population and renames them from 1..N
191 |     std::vector<std::size_t>
192 |     sorted_cluster_names (std::vector<std::size_t> clustering);
193 |     //! given an initial clustering computed from free energy cutoff screenings,
194 |     //! assign all yet unclustered frames (those in 'state 0') to their geometrically
195 |     //! next cluster. do this by starting at the lowest free energy of unassigned frames,
196 |     //! then assigning the next lowest, etc.
197 |     //! thus, all initial clusters will be filled with growing free energy, effectively producing
198 |     //! microstates separated close to the free energy barriers.
199 |     std::vector<std::size_t>
200 |     assign_low_density_frames(const std::vector<std::size_t>& initial_clustering,
201 |                               const Neighborhood& nh_high_dens,
202 |                               const std::vector<float>& free_energy);
203 |     //! \brief user interface and controlling function for density-based geometric clustering.
204 |     //! \param file input file with coordinates
205 |     //! \param free-energy-input previously computed free energies (input)
206 |     //! \param free-energy computed free energies (output)
207 |     //! \param population computed populations (output)
208 |     //! \param output clustered trajectory
209 |     //! \param radii list of radii for free energy / population computations (input)
210 |     //! \param radius radius for clustering (input)
211 |     //! \param nearest-neighbors-input previously computed nearest neighbor list (input)
212 |     //! \param nearest-neighbors nearest neighbor list (output)
213 |     //! \param threshold-screening option for automated free energy threshold screening (input)
214 |     //! \param threshold threshold for single run with limited free energy (input)
215 |     //! \param only-initial if true, do not fill microstates up to barriers,
216 |     //!                       but keep initial clusters below free energy cutoff (bool flag)
217 |     void
218 |     main(boost::program_options::variables_map args);
219 |   } // end namespace Density
220 | } // end namespace Clustering
221 | 
222 | 


--------------------------------------------------------------------------------
/src/noise.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2015-2019, Florian Sittel (www.lettis.net) and Daniel Nagel
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without modification,
  6 | are permitted provided that the following conditions are met:
  7 | 
  8 | 1. Redistributions of source code must retain the above copyright notice,
  9 |    this list of conditions and the following disclaimer.
 10 | 
 11 | 2. Redistributions in binary form must reproduce the above copyright notice,
 12 |    this list of conditions and the following disclaimer in the documentation
 13 |    and/or other materials provided with the distribution.
 14 | 
 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 24 | */
 25 | 
 26 | #include "noise.hpp"
 27 | 
 28 | #include "logger.hpp"
 29 | #include "tools.hpp"
 30 | 
 31 | #include <iostream>
 32 | #include <fstream>
 33 | #include <algorithm>
 34 | #include <vector>
 35 | 
 36 | #include <boost/filesystem.hpp>
 37 | #include <omp.h>
 38 | 
 39 | namespace Clustering {
 40 | namespace Noise {
 41 |   void
 42 |   main(boost::program_options::variables_map args) {
 43 |     using namespace Clustering::Tools;
 44 |     namespace b_fs = boost::filesystem;
 45 |     namespace b_po = boost::program_options;
 46 |     // load states
 47 |     Clustering::logger(std::cout) << "~~~ reading files\n"
 48 |                                   << "    trajectory from: " << args["states"].as<std::string>()
 49 |                                   << std::endl;
 50 |     std::vector<std::size_t> states = Clustering::Tools::read_clustered_trajectory(args["states"].as<std::string>());
 51 |     std::vector<std::size_t> states_without_noise;
 52 |     std::copy(states.begin(), states.end(), std::back_inserter(states_without_noise));
 53 |     std::set<std::size_t> state_names(states.begin(), states.end());
 54 |     std::size_t n_frames = states.size();
 55 |     // shift cmin fomr [0,100] -> [0,1]
 56 |     float cmin = 0.01*args["cmin"].as<float>();
 57 |     std::string basename = args["basename"].as<std::string>();
 58 |     basename.append(".");
 59 |     Clustering::verbose = args["verbose"].as<bool>();
 60 |     // generate header comment
 61 |     std::string header_comment = args["header"].as<std::string>();
 62 |     std::map<std::string,float> commentsMap = args["commentsMap"].as<std::map<std::string,float>>();
 63 |     // read previously used parameters
 64 |     read_comments(args["states"].as<std::string>(), commentsMap);
 65 |     commentsMap["cmin"] = cmin;
 66 |     // noise state is 1 lower than lowest
 67 |     auto lowestState = std::min_element(states.begin(), states.end());
 68 |     std::size_t noiseState = *lowestState-1;
 69 |     
 70 |     if (args.count("output") || args.count("cores")) {
 71 |       // load concatenation limits to treat concatenated trajectories correctly
 72 |       // when performing dynamical corrections
 73 |       std::vector<std::size_t> concat_limits;
 74 |       if (args.count("concat-limits")) {
 75 |         Clustering::logger(std::cout) << "    limits from: "
 76 |                                       << args["concat-limits"].as<std::string>() << std::endl;
 77 |         concat_limits = Clustering::Tools::read_concat_limits(args["concat-limits"].as<std::string>());
 78 |       } else if (args.count("concat-nframes")) {
 79 |         std::size_t n_frames_per_subtraj = args["concat-nframes"].as<std::size_t>();
 80 |         for (std::size_t i=n_frames_per_subtraj; i <= n_frames; i += n_frames_per_subtraj) {
 81 |           concat_limits.push_back(i);
 82 |         }
 83 |       } else {
 84 |         concat_limits = {n_frames};
 85 |       }
 86 |       // check if concat_limits are well definied
 87 |       Clustering::Tools::check_concat_limits(concat_limits, n_frames);
 88 |       Clustering::logger(std::cout) << "    interpret data as " << concat_limits.size()
 89 |                                     << " trajectories" << std::endl;
 90 |       if (commentsMap["limits"] == 0) {
 91 |         commentsMap["limits"] = concat_limits.size();
 92 |       } else if (std::abs(commentsMap["limits"]-concat_limits.size()) > 0.001) {
 93 |         Clustering::logger(std::cout) << "warning: the number of limits are not in agreement\n"
 94 |                                       << "         " << commentsMap["limits"] << " vs. "
 95 |                                       << concat_limits.size() << std::endl;
 96 |       }
 97 |       // findest highest clust file
 98 |       b_fs::path cwd(b_fs::current_path());
 99 |       b_fs::path wd_basename(basename);
100 | 
101 |       // if relative or absolute path is given, use this instead of cwd
102 |       if (wd_basename.parent_path() != "") {
103 |         cwd = wd_basename.parent_path();
104 |       }
105 | 
106 |       typedef std::vector<b_fs::path> vec;             // store paths,
107 |       vec v;                                           // so we can sort them later
108 | 
109 |       std::copy(b_fs::directory_iterator(cwd), b_fs::directory_iterator(), std::back_inserter(v));
110 | 
111 |       std::sort(v.begin(), v.end());             // sort, since directory iteration
112 |                                                  // is not ordered on some file systems
113 | //      std::cout << " basename: " << basename << "\n";
114 | //      std::cout << " v.end(): " << v.back().string() << "\n";      
115 |       // iterate reverse over all files in directory
116 |       std::string clust_filename;
117 |       std::size_t found = std::string::npos;
118 |       for (vec::reverse_iterator it(v.rbegin()), it_end(v.rend()); it != it_end; ++it)
119 |       {
120 |         std::ostringstream oss;
121 |         oss << *it;
122 |         std::string file_str = oss.str();
123 | 
124 |         found = file_str.rfind(basename);
125 |         if (found!=std::string::npos) {
126 |           // if commentsMap is provided, check if found fe > fe_max
127 |           if (commentsMap.count("screening_to") && commentsMap.count("screening_step")) {
128 |             float fe_max;
129 |             try{
130 |               fe_max = std::stof(file_str.substr(found+basename.length(),file_str.length()-found-basename.length()-1));
131 |               if ((fe_max > commentsMap["screening_to"] + commentsMap["screening_step"]) ||
132 |                  (fe_max < commentsMap["screening_to"])){
133 |                 continue;
134 |               }
135 |             } catch (...) {
136 |                 continue;
137 |             }
138 |           }
139 |           clust_filename = file_str.substr(found,file_str.length()-found-1);
140 |           break;
141 |         }
142 |       }
143 |       // catch if file not found
144 |       if (found == std::string::npos) {
145 |         std::cerr << "\n" << "error (noise): cluster file of type " << basename << " not found\n\n";
146 |         exit(EXIT_FAILURE);
147 |       }
148 |       
149 |       // open highest clust file
150 |       header_comment.append(Clustering::Tools::stringprintf("#\n# Execution remarks:\n"
151 |                             "# used for highest cluster file: %s\n", clust_filename.c_str()));
152 |       Clustering::logger(std::cout) << "    highest cluster: " << clust_filename  << std::endl;
153 |       std::vector<std::size_t> clust = Clustering::Tools::read_clustered_trajectory(clust_filename);
154 |       // check if parameters are identical to states ones
155 |       read_comments(clust_filename, commentsMap);
156 |       if (n_frames != clust.size()) {
157 |         std::cerr << "\n" << "error (noise): clust file is not of same length as state trajectory." << "\n\n";
158 |         exit(EXIT_FAILURE);
159 |       }
160 |       // generate counts of each cluster id
161 |       CounterClustMap counts;
162 |       for (std::size_t i=0; i < n_frames; ++i) {
163 |         CounterClustMap::iterator it(counts.find(clust[i]));
164 |         if (it != counts.end()){
165 |           it->second++;
166 |         } else {
167 |           counts[clust[i]] = 1;
168 |         }
169 |       }
170 |       Clustering::logger(std::cout) << "~~~ noise assignment" << std::endl;
171 |       std::size_t noise_frames = 0;
172 |       // define noise frames as state 0
173 |       for (std::size_t i=0; i < n_frames; ++i) {
174 |         if (counts[clust[i]] < cmin*n_frames){
175 |           states[i] = noiseState;
176 |           ++noise_frames;
177 |         }      
178 |       }
179 |       float noise_frames_per = 100.*noise_frames / n_frames;
180 |       Clustering::logger(std::cout) << Clustering::Tools::stringprintf("    %.2f", noise_frames_per)
181 |                                     << "% of frames were identified as noise" << std::endl;
182 |       header_comment.append(Clustering::Tools::stringprintf("# %.2f", noise_frames_per) +
183 |                             "% of frames were identified as noise\n");
184 |       // TODO: remove following line. Should we keep with argument?
185 |       // Clustering::Tools::write_clustered_trajectory("microstatesNoiseDef", states);
186 |       // noise core trajectory
187 |       std::vector<std::size_t> noise_traj(n_frames);
188 |       std::size_t current_core = states[0];
189 |       std::vector<long> cores(n_frames);
190 |       std::size_t changed_frames = 0;
191 |       // honour concatenation limits, i.e. treat every concatenated trajectory-part on its own
192 |       std::size_t last_limit = 0;
193 |       for (std::size_t next_limit: concat_limits) {
194 |         std::size_t next_limit_corrected = std::min(next_limit, n_frames);
195 |         for (std::size_t i=last_limit; i < next_limit_corrected; ++i) {
196 |           if (states[i] != noiseState) {
197 |             current_core = states[i];
198 |             break;      
199 |           }
200 |         }
201 |         for (std::size_t i=last_limit; i < next_limit_corrected; ++i) {
202 |           // coring window
203 |           if (states[i] != noiseState) {
204 |             current_core = states[i];
205 |             cores[i] = current_core;
206 |           } else {
207 |             cores[i] = -1;
208 |           }
209 |           if (current_core != states_without_noise[i]) {
210 |             ++changed_frames;
211 |           }
212 |           noise_traj[i] = current_core;
213 |         }
214 |         last_limit = next_limit_corrected;
215 |       }
216 |       float changed_frames_per = 100.*changed_frames / n_frames;
217 |       Clustering::logger(std::cout) << Clustering::Tools::stringprintf("    %.2f", changed_frames_per)
218 |                                     << "% of frames were reassigned\n"
219 |                                     << "    store result in: " << args["output"].as<std::string>()
220 |                                     << std::endl;
221 |       header_comment.append(Clustering::Tools::stringprintf("# %.2f", changed_frames_per) +
222 |                             "% of frames were reassigned\n");
223 |       // write cored trajectory to file
224 |       if (args.count("output")) {
225 |         Clustering::Tools::write_clustered_trajectory(args["output"].as<std::string>(),
226 |                                                       noise_traj,
227 |                                                       header_comment,
228 |                                                       commentsMap);
229 |       }
230 |       // write core information to file
231 |       if (args.count("cores")) {
232 |         append_commentsMap(header_comment, commentsMap);
233 |         Clustering::Tools::write_single_column<long>(args["cores"].as<std::string>(),
234 |                                                      cores,
235 |                                                      header_comment,
236 |                                                      false);
237 |       }
238 |     } else {
239 |       std::cerr << "\n" << "error (noise): nothing to do! please define '--output' or '--cores'" << "\n\n";
240 |       exit(EXIT_FAILURE);
241 |     }
242 |   }
243 | } // end namespace Noise
244 | } // end namespace Clustering
245 | 
246 | 


--------------------------------------------------------------------------------
/src/state_filter.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2015, Florian Sittel (www.lettis.net)
  3 | All rights reserved.
  4 | 
  5 | Redistribution and use in source and binary forms, with or without modification,
  6 | are permitted provided that the following conditions are met:
  7 | 
  8 | 1. Redistributions of source code must retain the above copyright notice,
  9 |    this list of conditions and the following disclaimer.
 10 | 
 11 | 2. Redistributions in binary form must reproduce the above copyright notice,
 12 |    this list of conditions and the following disclaimer in the documentation
 13 |    and/or other materials provided with the distribution.
 14 | 
 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 16 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 17 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 18 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 19 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 20 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 21 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 22 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 23 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 24 | */
 25 | 
 26 | #include "coords_file/coords_file.hpp"
 27 | 
 28 | #include <boost/program_options.hpp>
 29 | 
 30 | #include <algorithm>
 31 | #include <iostream>
 32 | #include <iomanip>
 33 | #include <string>
 34 | #include <random>
 35 | #include <queue>
 36 | #include <map>
 37 | #include <vector>
 38 | 
 39 | #include "state_filter.hpp"
 40 | #include "tools.hpp"
 41 | #include "logger.hpp"
 42 | 
 43 | 
 44 | namespace Clustering {
 45 | namespace Filter {
 46 |   void
 47 |   fixedprint(double num, std::size_t prec, std::size_t width){
 48 |     std::cout.width(width);
 49 |     std::cout << std::setprecision(prec);
 50 |     std::cout << num;
 51 |     std::cout.width(0);
 52 |     return;
 53 |   }
 54 | 
 55 |   void
 56 |   main(boost::program_options::variables_map args) {
 57 |     using namespace Clustering::Tools;
 58 |     // load states
 59 |     Clustering::logger(std::cout) << "~~~ reading files\n"
 60 |                                   << "    trajectory from: "
 61 |                                   << args["states"].as<std::string>()
 62 |                                   << std::endl;
 63 |     std::string fname_states = args["states"].as<std::string>();
 64 |     std::vector<std::size_t> states = Clustering::Tools::read_clustered_trajectory(args["states"].as<std::string>());
 65 |     std::size_t n_frames = states.size();
 66 |     if (args["list"].as<bool>()) { // mode stats with verbose true
 67 |       std::map<std::string,float> commentsMap = args["commentsMap"].as<std::map<std::string,float>>();
 68 |       // read previously used parameters
 69 |       read_comments(args["states"].as<std::string>(), commentsMap);
 70 |       std::priority_queue<std::pair<std::size_t, std::size_t>> pops;
 71 |       // list states with pops
 72 |       std::set<std::size_t> state_ids(states.begin(), states.end());
 73 |       for (std::size_t id: state_ids) {
 74 |         std::size_t pop = std::count(states.begin(), states.end(), id);
 75 |         pops.push({pop, id});
 76 |       }
 77 | 
 78 |       // load concat limits
 79 |       std::vector<std::size_t> concat_limits;
 80 |       if (args.count("concat-limits")) {
 81 |         Clustering::logger(std::cout) << "    limits from: "
 82 |                                       << args["concat-limits"].as<std::string>() << std::endl;
 83 |         concat_limits = Clustering::Tools::read_concat_limits(args["concat-limits"].as<std::string>());
 84 |       } else if (args.count("concat-nframes")) {
 85 |         std::size_t n_frames_per_subtraj = args["concat-nframes"].as<std::size_t>();
 86 |         for (std::size_t i=n_frames_per_subtraj; i <= n_frames; i += n_frames_per_subtraj) {
 87 |           concat_limits.push_back(i);
 88 |         }
 89 |       } else {
 90 |         concat_limits = {n_frames};
 91 |       }
 92 |       // check if concat_limits are well definied
 93 |       Clustering::Tools::check_concat_limits(concat_limits, n_frames);
 94 |       Clustering::logger(std::cout) << "    interpret data as " << concat_limits.size()
 95 |                                     << " trajectories" << std::endl;
 96 |       if (commentsMap["limits"] == 0) {
 97 |         commentsMap["limits"] = concat_limits.size();
 98 |       } else if (std::abs(commentsMap["limits"]-concat_limits.size()) > 0.001) {
 99 |         Clustering::logger(std::cout) << "warning: the number of limits are not in agreement\n"
100 |                                       << "         " << commentsMap["limits"] << " vs. "
101 |                                       << concat_limits.size() << std::endl;
102 |       }
103 | 
104 |       // get number of entering each state
105 |       std::map<std::size_t, std::size_t> entered;
106 |       std::map<std::size_t, std::size_t> left;
107 |       //entered[states[0]] = 1;
108 | //      std::size_t diff(n_frames);
109 |       std::size_t last_limit = 0;
110 |       for (std::size_t next_limit: concat_limits) {
111 |         std::size_t next_limit_corrected = std::min(next_limit, n_frames);
112 |         for (std::size_t i=last_limit; i < next_limit_corrected-1; ++i) {
113 |           if (states[i+1] != states[i]){
114 |             std::map<std::size_t, std::size_t>::iterator it(entered.find(states[i+1]));
115 |             if (it != entered.end()){
116 |               it->second++;
117 |             } else {
118 |               entered[states[i+1]] = 1;
119 |             }
120 |             std::map<std::size_t, std::size_t>::iterator it_l(left.find(states[i]));
121 |             if (it_l != left.end()){
122 |               it_l->second++;
123 |             } else {
124 |               left[states[i]] = 1;
125 |             }
126 | 
127 |           }
128 |         }
129 |         last_limit = next_limit_corrected;
130 |       }
131 |       std::cout << "~~~ state stats\n"
132 |                 << "    state  population  pop [%]  tot [%]  entered     left" << std::endl;
133 |       std::cout << std::fixed;
134 |       double total_pop = 0.;
135 |       std::size_t total_entered = 0;
136 |       std::size_t total_left = 0;
137 |       while ( ! pops.empty()) {
138 |         auto pop_id = pops.top(); // get top element
139 |         pops.pop(); // remove top element
140 |         std::cout << "    ";
141 |         // state id
142 |         fixedprint(pop_id.second, 0, 5);
143 |         // absolute pop
144 |         fixedprint(pop_id.first, 0, 12);
145 |         // relative pop
146 |         fixedprint(100.*pop_id.first/(float)n_frames, 3, 9);
147 |         // total pop
148 |         total_pop += 100.*pop_id.first/(float)n_frames;
149 |         fixedprint(total_pop, 3, 9);
150 |         // entered
151 |         std::map<std::size_t, std::size_t>::iterator it(entered.find(pop_id.second));
152 |         if (it != entered.end()){
153 |           total_entered += it->second;
154 |           fixedprint(it->second, 0, 9);
155 |         } else { // the following should never be the case
156 |           fixedprint(0, 0, 9);
157 |         }
158 |         std::map<std::size_t, std::size_t>::iterator it_l(left.find(pop_id.second));
159 |         if (it_l != left.end()){
160 |           total_left += it_l->second;
161 |           fixedprint(it_l->second, 0, 9);
162 |         } else { // the following should never be the case
163 |           fixedprint(0, 0, 9);
164 |         }
165 |         std::cout << std::endl;
166 |       }
167 |       std::cout << "\n~~~ total number of microstates: " << entered.size()
168 |                 << "\n                    transitions: " << total_entered
169 |                 << std::endl;
170 |     } else {
171 |       // filter data
172 |       std::string coords_name = args["coords"].as<std::string>();
173 |       Clustering::logger(std::cout) << "        coords from: "
174 |                                     << coords_name
175 |                                     << std::endl;
176 |       // find selected (or all) states
177 |       std::vector<std::size_t> selected_states;
178 |       if (args.count("selected-states")) {
179 |         selected_states = args["selected-states"].as<std::vector<std::size_t>>();
180 |       } else { // use all states
181 |         std::vector<std::size_t> unique_states(states);
182 |         std::sort(unique_states.begin(), unique_states.end());
183 |         auto last = std::unique(unique_states.begin(), unique_states.end());
184 |         unique_states.erase(last, unique_states.end());
185 |         selected_states = unique_states;
186 |       }
187 |       // get file extension of coords
188 |       std::string file_extension = "";
189 |       if (coords_name.compare(coords_name.size()-4, 1, ".") == 0){
190 |         file_extension = coords_name.substr(coords_name.size()-4, 4);
191 |       }
192 |       std::string output_basename;
193 |       if (args.count("output")) {
194 |         output_basename = args["output"].as<std::string>();
195 |       } else {
196 |         if (file_extension.size()==0) {
197 |           output_basename = coords_name;
198 |         } else {
199 |           output_basename = coords_name.substr(0,coords_name.size()-4);
200 |         }
201 |       }
202 |       // filter data
203 |       Clustering::logger(std::cout) << "\n~~~ filter states:" << std::endl;
204 |       std::size_t every_nth = args["every-nth"].as<std::size_t>();
205 |       if (every_nth > 1) {
206 |         Clustering::logger(std::cout) << "    use only every " << every_nth
207 |                                       << "th frame" << std::endl;
208 |       }
209 |       if (args.count("nRandom") and (every_nth > 1)) {
210 |         std::cerr << "\nerror parsing arguments:\n\n"
211 |                   << "Use either 'every-nth' or 'nRandom'"
212 |                   << "\n\n" << std::endl;
213 |         exit(EXIT_FAILURE);
214 |       }
215 |       std::size_t nRandom = 0;
216 |       if (args.count("nRandom")) {
217 |         nRandom = args["nRandom"].as<std::size_t>();
218 |       }
219 |       // initialize random number generator
220 |       std::random_device rd;
221 |       std::mt19937 g(rd());
222 |       for (std::size_t selected_state: selected_states){
223 |         std::vector<std::size_t> selected_state_idx;
224 |         if (nRandom > 0) {
225 |           // get all indices corresponding to selected state
226 |           for(std::size_t idx=0; idx<states.size(); ++idx){
227 |               if (states[idx] == selected_state) {
228 |                 selected_state_idx.push_back(idx);
229 |               }
230 |           }
231 | 
232 |           // catch if state has less frames than requested
233 |           std::size_t nRandomState = std::min(nRandom, selected_state_idx.size());
234 |           // shuffle indices
235 |           std::shuffle(selected_state_idx.begin(), selected_state_idx.end(), g);
236 |           // extract first nRandom one
237 |           selected_state_idx = {selected_state_idx.begin(), selected_state_idx.begin() + nRandomState};
238 |         }
239 |          // open coords
240 |         CoordsFile::FilePointer coords_in = CoordsFile::open(coords_name, "r");
241 |         // get output name
242 |         std::string basename = output_basename + ".state%i" + file_extension;
243 |         std::string output_name = Clustering::Tools::stringprintf(basename,
244 |                                                                   selected_state);
245 |         CoordsFile::FilePointer coords_out = CoordsFile::open(output_name, "w");
246 | 
247 |         Clustering::logger(std::cout) << "    " << selected_state
248 |                                       << " : "
249 |                                       << output_name
250 |                                       << std::endl;
251 |         std::size_t nth = 0;  // counting frames
252 |         for (std::size_t idx=0; idx< n_frames; ++idx) {
253 |           if (states[idx] == selected_state) {
254 |             if (nRandom > 0) {
255 |               if (std::count(selected_state_idx.begin(), selected_state_idx.end(), idx)) {
256 |                 coords_out->write(coords_in->next());
257 |               } else {
258 |                 coords_in->next();
259 |               }
260 |             } else {
261 |               if ((nth % every_nth) == 0) {
262 |                 coords_out->write(coords_in->next());
263 |               } else {
264 |                 coords_in->next();
265 |               }
266 |               ++nth;
267 |             }
268 |           } else {
269 |             coords_in->next();
270 |           }
271 |         }
272 |       }
273 |     }
274 |   }
275 | } // end namespace Filter
276 | } // end namespace Clustering
277 | 


--------------------------------------------------------------------------------
/src/coords_file/xdrfile/xdrfile_c_test.c:
--------------------------------------------------------------------------------
  1 | /* -*- mode: c; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- 
  2 |  *
  3 |  * $Id: xdrfile_c_test.c,v 1.7 2009/05/18 09:06:38 spoel Exp $
  4 |  *
  5 |  * Copyright (c) Erik Lindahl, David van der Spoel 2003,2004.
  6 |  * Coordinate compression (c) by Frans van Hoesel. 
  7 |  *
  8 |  * This program is free software; you can redistribute it and/or
  9 |  * modify it under the terms of the GNU Lesser General Public License
 10 |  * as published by the Free Software Foundation; either version 3
 11 |  * of the License, or (at your option) any later version.
 12 |  */
 13 | 
 14 | /* Get HAVE_RPC_XDR_H, F77_FUNC from config.h if available */
 15 | #ifdef HAVE_CONFIG_H
 16 | #include <config.h>
 17 | #endif
 18 | 
 19 | #include <stdio.h>
 20 | #include <stdlib.h>
 21 | #include <string.h>
 22 | #include <math.h>
 23 | #include <limits.h>
 24 | #ifdef HAVE_UNISTD
 25 | #include "unistd.h"
 26 | #endif
 27 | 
 28 | /* get fixed-width types if we are using ANSI C99 */
 29 | #ifdef HAVE_STDINT_H
 30 | #  include <stdint.h>
 31 | #elif (defined HAVE_INTTYPES_H)
 32 | #  include <inttypes.h>
 33 | #endif
 34 | 
 35 | #ifdef HAVE_RPC_XDR_H
 36 | #  include <rpc/rpc.h>
 37 | #  include <rpc/xdr.h>
 38 | #endif
 39 | 
 40 | #include <time.h>
 41 | #include <float.h>
 42 | #include "xdrfile.h"
 43 | #include "xdrfile_trr.h"
 44 | #include "xdrfile_xtc.h"
 45 | 
 46 | /* This program tests reading and writing to XDR files */
 47 | 
 48 | static void _die(char *msg, int line, char *file) {
 49 | 	fprintf(stderr, "Fatal error: %s\n", msg);
 50 | 	fprintf(stderr, "Death occurred at %s, line %d\n", file, line);
 51 | 	exit(1);
 52 | }
 53 | #define die(msg) _die(msg,__LINE__,__FILE__)
 54 | 
 55 | static void _die_r(char *msg, int result,int line, char *file) {
 56 | 	fprintf(stderr, "Fatal error: %s\n", msg);
 57 | 	fprintf(stderr,"result = %d\n",result);
 58 | 	fprintf(stderr, "Death occurred at %s, line %d\n", file, line);
 59 | 	exit(1);
 60 | }
 61 | #define die_r(msg,res) _die_r(msg,res,__LINE__,__FILE__)
 62 | 
 63 | static void test_xtc()
 64 | {
 65 | 	char *testfn = "test.xtc";
 66 | 	XDRFILE *xd;
 67 | 	int result,i,j,k,nframes=13;
 68 | 	int natoms2,natoms1=173;
 69 | 	int step2,step1=1993;
 70 | 	float time2,time1=1097.23;
 71 | 	matrix box2,box1;
 72 | 	rvec *x2,*x1;
 73 | 	float prec2,prec1=1000;
 74 | 	float toler=1e-3;
 75 | 	
 76 | 	printf("Testing xtc functionality:");
 77 | 	for(i=0; (i<DIM); i++)
 78 | 		for(j=0; (j<DIM); j++)
 79 | 			box1[i][j] = (i+1)*3.7 + (j+1);
 80 | 	x1 = calloc(natoms1,sizeof(*x1));
 81 | 	if (NULL == x1)
 82 | 		die("Allocating memory for x1 in test_xtc");
 83 | 	
 84 | 	for(i=0; (i<natoms1); i++)
 85 | 		for(j=0; (j<DIM); j++)
 86 | 			x1[i][j] = (i+1)*3.7 + (j+1);
 87 | 	xd = xdrfile_open(testfn,"w");
 88 | 	if (NULL == xd)
 89 | 		die("Opening xdrfile for writing");
 90 | 	for(k=0; (k<nframes); k++)
 91 | 		{
 92 | 			result = write_xtc(xd,natoms1,step1+k,time1+k,box1,x1,prec1);
 93 | 			if (0 != result)
 94 | 				die_r("Writing xtc file",result);
 95 | 		}
 96 | 	xdrfile_close(xd);
 97 | 	
 98 | 	result = read_xtc_natoms(testfn,&natoms2);
 99 | 	if (exdrOK != result)
100 | 		die_r("read_xtc_natoms",result);
101 | 	if (natoms2 != natoms1)
102 | 		die("Number of atoms incorrect when reading trr");
103 | 	x2 = calloc(natoms2,sizeof(x2[0]));
104 | 	if (NULL == x2)
105 | 		die("Allocating memory for x2");
106 | 		
107 | 		
108 | 	xd = xdrfile_open(testfn,"r");
109 | 	if (NULL == xd)
110 | 		die("Opening xdrfile for reading");
111 | 	
112 | 	k = 0;
113 | 	do
114 | 		{
115 | 			result = read_xtc(xd,natoms2,&step2,&time2,box2,x2,&prec2);
116 | 			if (exdrENDOFFILE != result)
117 | 				{
118 | 					if (exdrOK != result)
119 | 						die_r("read_xtc",result);
120 | 					if (natoms2 != natoms1)
121 | 						die("natoms2 != natoms1");
122 | 					if (step2-step1 != k)
123 | 						die("incorrect step");
124 | 					if (fabs(time2-time1-k) > toler)
125 | 						die("incorrect time");
126 | 					if (fabs(prec2-prec1) > toler)
127 | 						die("incorrect precision");
128 | 					for(i=0; (i<DIM); i++)
129 | 						for(j=0; (j<DIM); j++)
130 | 							if (fabs(box2[i][j] - box1[i][j]) > toler)
131 | 								die("box incorrect");
132 | 					for(i=0; (i<natoms1); i++)
133 | 						for(j=0; (j<DIM); j++)
134 | 							if (fabs(x2[i][j] - x1[i][j]) > toler)
135 | 								die("x incorrect");
136 | 				}
137 | 			k++;
138 | 		} while (result == exdrOK);
139 | 		
140 | 	xdrfile_close(xd);
141 | #ifdef HAVE_UNISTD
142 | 	unlink(testfn);
143 | #endif
144 | 	printf(" PASSED\n");
145 | }
146 | 
147 | static void test_trr()
148 | {
149 | 	char *testfn = "test.trr";
150 | 	XDRFILE *xd;
151 | 	int result,i,j,k,nframes=13;
152 | 	int natoms2,natoms1=173;
153 | 	int step2,step1=1993;
154 | 	float time2,time1=1097.23;
155 | 	matrix box2,box1;
156 | 	rvec *x2,*x1;
157 | 	float lambda2,lambda1=0.4;
158 | 	float toler=1e-3;
159 | 	
160 | 	printf("Testing trr functionality:");
161 | 	for(i=0; (i<DIM); i++)
162 | 		for(j=0; (j<DIM); j++)
163 | 			box1[i][j] = (i+1)*3.7 + (j+1);
164 | 	x1 = calloc(natoms1,sizeof(*x1));
165 | 	if (NULL == x1)
166 | 		die("Allocating memory for x1 in test_xtc");
167 | 	
168 | 	for(i=0; (i<natoms1); i++)
169 | 		for(j=0; (j<DIM); j++)
170 | 			x1[i][j] = (i+1)*3.7 + (j+1);
171 | 	xd = xdrfile_open(testfn,"w");
172 | 	if (NULL == xd)
173 | 		die("Opening trr file for writing");
174 | 	for(k=0; (k<nframes); k++)
175 | 		{
176 | 			result = write_trr(xd,natoms1,step1+k,time1+k,lambda1,box1,x1,NULL,NULL);
177 | 			if (0 != result)
178 | 				die_r("Writing trr file",result);
179 | 		}
180 | 	xdrfile_close(xd);
181 | 	
182 | 	result = read_trr_natoms(testfn,&natoms2);
183 | 	if (exdrOK != result)
184 | 		die_r("read_trr_natoms",result);
185 | 	if (natoms2 != natoms1)
186 | 		die("Number of atoms incorrect when reading trr");
187 | 	x2 = calloc(natoms2,sizeof(x2[0]));
188 | 	if (NULL == x2)
189 | 		die("Allocating memory for x2");
190 | 		
191 | 		
192 | 	xd = xdrfile_open(testfn,"r");
193 | 	if (NULL == xd)
194 | 		die("Opening trr file for reading");
195 | 	
196 | 	for(k=0; (k<nframes); k++) 
197 | 		{
198 | 			result = read_trr(xd,natoms2,&step2,&time2,&lambda2,box2,x2,NULL,NULL);
199 | 			if (exdrOK != result)
200 | 				die_r("read_xtc",result);
201 | 			if (natoms2 != natoms1)
202 | 				die("natoms2 != natoms1");
203 | 			if (step2-step1 != k)
204 | 				die("incorrect step");
205 | 			if (fabs(time2-time1-k) > toler)
206 | 				die("incorrect time");
207 | 			if (fabs(lambda2-lambda2) > toler)
208 | 				die("incorrect lambda");
209 | 			for(i=0; (i<DIM); i++)
210 | 				for(j=0; (j<DIM); j++)
211 | 					if (fabs(box2[i][j] - box1[i][j]) > toler)
212 | 						die("box incorrect");
213 | 			for(i=0; (i<natoms1); i++)
214 | 				for(j=0; (j<DIM); j++)
215 | 					if (fabs(x2[i][j] - x1[i][j]) > toler)
216 | 						die("x incorrect");
217 | 		} 
218 | 	
219 | 	xdrfile_close(xd);
220 | #ifdef HAVE_UNISTD
221 | 	unlink(testfn);
222 | #endif
223 | 	printf(" PASSED\n");
224 | }
225 | 
226 | static void test_basic()
227 | {
228 | 	float test_ii;      // 7 significant digits
229 | 	double test_jj;     // 16 significant digits
230 | #define EPSILON_1 1e-7
231 | #define EPSILON_2 1e-4
232 | 	
233 | 	printf("Testing basic xdrfile library:");
234 | 	for (test_ii = 1.0e1; test_ii < 1.0e2; (test_ii = test_ii + pow(M_PI, 0.00011)))
235 | 		{
236 | 		
237 | #define BUFLEN 37
238 | 	XDRFILE *xfp;
239 | 	int i, j, k, len, ncoord = BUFLEN/3;
240 | 	char ptr[BUFLEN], *buf = "abcdefghijklmnopqrstuvwxyz";
241 | 	char *testfn = "test.xdr";
242 | 	unsigned char uptr[BUFLEN];
243 | 	short sptr[BUFLEN], sptr2[BUFLEN];
244 | 	unsigned short usptr[BUFLEN], usptr2[BUFLEN];
245 | 	int iptr[BUFLEN], iptr2[BUFLEN];
246 | 	unsigned int uiptr[BUFLEN], uiptr2[BUFLEN];
247 | 	float fptr[BUFLEN], fptr2[BUFLEN];
248 | 	double dptr[BUFLEN], dptr2[BUFLEN];
249 | 	char optr[BUFLEN], optr2[BUFLEN];
250 | #define NPREC 1
251 | 
252 | 	float  fprec[] = {234.45};
253 | 	double dprec[] = {234.45};
254 | 
255 | 	/* Can not write a string that's on the stack since all data is
256 | 	   treated as variables.
257 | 	 */
258 | 	len = strlen(buf) + 1;
259 | 	if (len >= BUFLEN)
260 | 		die("Increase BUFLEN");
261 | 	strcpy(ptr, buf);
262 | 	strcpy((char *) uptr, buf);
263 | 	/* Initiate float arrays */
264 | 	for (i = 0; (i < BUFLEN); i++) 
265 | 	{
266 | 		fptr[i] = cos(i * 13.0 / M_PI);
267 | 		dptr[i] = sin(i * 13.0 / M_PI);
268 | 	}
269 | 	/* Initiate opaque array */
270 | 	memcpy(optr, dptr, BUFLEN);
271 | 
272 | 	/*************************************/
273 | 	/*           WRITING BIT             */
274 | 	/*************************************/
275 | 
276 | 	if ((xfp = xdrfile_open("test.xdr", "w")) == NULL)
277 | 		die("Can not open file for writing");
278 | 
279 | 	if (xdrfile_write_char(ptr, len, xfp) != len)
280 | 		die("Writing char string");
281 | 	if (xdrfile_write_uchar(uptr, len, xfp) != len)
282 | 		die("Writing uchar string");
283 | 	if (xdrfile_write_short(sptr, BUFLEN,xfp) != BUFLEN)
284 | 		die("Writing short array");
285 | 	if (xdrfile_write_ushort(usptr, BUFLEN,xfp) != BUFLEN)
286 | 		die("Writing ushort array");
287 | 	if (xdrfile_write_int(iptr, BUFLEN,xfp) != BUFLEN)
288 | 		die("Writing int array");
289 | 	if (xdrfile_write_uint(uiptr, BUFLEN,xfp) != BUFLEN)
290 | 		die("Writing uint array");
291 | 	if (xdrfile_write_float(fptr, BUFLEN,xfp) != BUFLEN)
292 | 		die("Writing float array");
293 | 	if (xdrfile_write_double(dptr, BUFLEN,xfp) != BUFLEN)
294 | 		die("Writing double array");
295 | 	if (xdrfile_write_string(buf, xfp) != len)
296 | 		die("Writing string");
297 | 	if (xdrfile_write_opaque(optr, BUFLEN,xfp) != BUFLEN)
298 | 		die("Writing opaque");
299 | 	for (k = 0; (k < NPREC); k++) {
300 | 		if (xdrfile_compress_coord_float(fptr, ncoord, fprec[k], xfp)
301 | 				!= ncoord)
302 | 			die("Writing compress_coord_float");
303 | 		if (xdrfile_compress_coord_double(dptr, ncoord, dprec[k], xfp)
304 | 				!= ncoord)
305 | 			die("Writing compress_coord_double");
306 | 	}
307 | 	if (xdrfile_close(xfp) != 0)
308 | 		die("Can not close xdr file");
309 | 
310 | 	/*************************************/
311 | 	/*          READING BIT              */
312 | 	/*************************************/
313 | 	if ((xfp = xdrfile_open(testfn, "r")) == NULL)
314 | 		die("Can not open file for reading");
315 | 
316 | 	if ((xdrfile_read_char(ptr, len, xfp)) != len)
317 | 		die("Not the right number of chars read from string");
318 | 	if (strcmp(ptr, buf) != 0)
319 | 		printf("did not read the expected chars");
320 | 	if (xdrfile_read_uchar(uptr, len, xfp) != len)
321 | 		die("Not the right number of uchars read from string");
322 | 	if (strcmp((char *) uptr, buf) != 0)
323 | 		printf("did not read the expected uchars");
324 | 	if (xdrfile_read_short(sptr2, BUFLEN,xfp) != BUFLEN)
325 | 		die("Reading short array");
326 | 	for (i = 0; (i < BUFLEN); i++)
327 | 		if (sptr2[i] != sptr[i]) {
328 | 			fprintf(stderr, "i: %5d, wrote: %10d, read: %10d\n", i, sptr[i],
329 | 					sptr2[i]);
330 | 			die("Comparing short array");
331 | 		}
332 | 	if (xdrfile_read_ushort(usptr2, BUFLEN,xfp) != BUFLEN)
333 | 		die("Reading ushort array");
334 | 	for (i = 0; (i < BUFLEN); i++)
335 | 		if (usptr2[i] != usptr[i]) {
336 | 			fprintf(stderr, "i: %5d, wrote: %10d, read: %10d\n", i, usptr[i],
337 | 					usptr2[i]);
338 | 			die("Comparing ushort array");
339 | 		}
340 | 	if (xdrfile_read_int(iptr2, BUFLEN,xfp) != BUFLEN)
341 | 		die("Reading int array");
342 | 	for (i = 0; (i < BUFLEN); i++)
343 | 		if (iptr2[i] != iptr[i]) {
344 | 			fprintf(stderr, "i: %5d, wrote: %10d, read: %10d\n", i, iptr[i],
345 | 					iptr2[i]);
346 | 			die("Comparing int array");
347 | 		}
348 | 	if (xdrfile_read_uint(uiptr2, BUFLEN,xfp) != BUFLEN)
349 | 		die("Reading uint array");
350 | 	for (i = 0; (i < BUFLEN); i++)
351 | 		if (uiptr2[i] != uiptr[i]) {
352 | 			fprintf(stderr, "i: %5d, wrote: %10d, read: %10d\n", i, uiptr[i],
353 | 					uiptr2[i]);
354 | 			die("Comparing uint array");
355 | 		}
356 | 	if (xdrfile_read_float(fptr2, BUFLEN,xfp) != BUFLEN)
357 | 		die("Reading float array");
358 | 	for (i = 0; (i < BUFLEN); i++)
359 | 		if (fptr2[i] != fptr[i]) {
360 | 			fprintf(stderr, "i: %5d, wrote: %12g, read: %12g\n", i, fptr[i],
361 | 					fptr2[i]);
362 | 			die("Comparing float array");
363 | 		}
364 | 	if (xdrfile_read_double(dptr2, BUFLEN,xfp) != BUFLEN)
365 | 		die("Reading double array");
366 | 	for (i = 0; (i < BUFLEN); i++)
367 | 		if (dptr2[i] != dptr[i]) {
368 | 			fprintf(stderr, "i: %5d, wrote: %12g, read: %12g\n", i, dptr[i],
369 | 					dptr2[i]);
370 | 			die("Comparing double array");
371 | 		}
372 | 	if (xdrfile_read_string(ptr, BUFLEN,xfp) != len)
373 | 		die("Reading string");
374 | 	if (strcmp(ptr, buf) != 0)
375 | 		die("Comparing strings");
376 | 	if (xdrfile_read_opaque(optr2, BUFLEN,xfp) != BUFLEN)
377 | 		die("Reading opaque array");
378 | 	for (i = 0; (i < BUFLEN); i++)
379 | 		if (optr2[i] != optr[i]) {
380 | 			fprintf(stderr, "i: %5d, wrote: %2d, read: %2d\n", i, optr[i],
381 | 					optr2[i]);
382 | 			die("Comparing opaque array");
383 | 		}
384 | 	for (k = 0; (k < NPREC); k++) {
385 | 		float ff, fx;
386 | 		double dd, dx;
387 | 		int nc = ncoord;
388 | 		if (xdrfile_decompress_coord_float(fptr2, &nc, &ff, xfp) != ncoord)
389 | 			die("Reading compress_coord_float");
390 | 		if (fabs(ff - fprec[k]) > EPSILON_1) 
391 | 			{
392 | 				printf("Found precision %f, expected %f\n", ff, fprec[k]);
393 | 				die("Float precision");
394 | 			}
395 | 		if (ff <= 0)
396 | 			ff = 1000;
397 | 
398 | 
399 | 		for (i = 0; (i < ncoord); i++)
400 | 			for (j = 0; (j < 3); j++) {
401 | 				fx = rint(fptr[3 * i + j] * ff) / ff;
402 | 				if (fabs(fx - fptr2[3 * i + j]) > EPSILON_1) {
403 | 					printf(	"prec: %10g, i: %3d, j: %d, fx: %10g, fptr2: %12g, fptr: %12g\n",
404 | 							ff, i, j, fx, fptr2[3 * i + j], fptr[3 * i + j]);
405 | 					die("Reading decompressed float coordinates");
406 | 				}
407 | 			}
408 | 		if (xdrfile_decompress_coord_double(dptr2, &nc, &dd, xfp) != ncoord)
409 | 			die("Reading compress_coord_double");
410 | 
411 | 		if (fabs(dd - dprec[k]) > EPSILON_2)
412 | 			die("Double precision");
413 | 
414 | 		for (i = 0; (i < ncoord); i++)
415 | 			for (j = 0; (j < 3); j++) {
416 | 				dx = rint(dptr[3 * i + j] * dd) / dd;
417 | 				if (fabs(dx - dptr2[3 * i + j]) > EPSILON_2) {
418 | 					printf(	"prec: %10g, i: %3d, j: %d, dx: %10g, dptr2: %12g, dptr: %12g\n",
419 | 							dd, i, j, dx, dptr2[3 * i + j], dptr[3 * i + j]);
420 | 					die("Reading decompressed double coordinates");
421 | 				}
422 | 			}
423 | 	}
424 | 
425 | 	if (xdrfile_close(xfp) != 0)
426 | 		die("Can not close xdr file");
427 | 		} 
428 | #ifdef HAVE_UNISTD
429 | 	unlink(testfn);
430 | #endif
431 | 	printf(" PASSED\n");
432 | }
433 | 
434 | int main(int argc, char *argv[]) 
435 | {
436 | 	/* Test basic stuff */
437 | 	test_basic();
438 | 	/* Now test writing a complete xtc file */
439 | 	test_xtc();
440 | 
441 | 	test_trr();
442 | 		
443 | 	return 0;
444 | }
445 | 


--------------------------------------------------------------------------------
/src/coords_file/xdrfile/xdrfile_trr.c:
--------------------------------------------------------------------------------
  1 | /* -*- mode: c; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- 
  2 |  *
  3 |  * $Id: xdrfile_trr.c,v 1.7 2009/05/18 09:06:38 spoel Exp $
  4 |  *
  5 |  * Copyright (c) Erik Lindahl, David van der Spoel 2003,2004.
  6 |  * Coordinate compression (c) by Frans van Hoesel. 
  7 |  *
  8 |  * This program is free software; you can redistribute it and/or
  9 |  * modify it under the terms of the GNU Lesser General Public License
 10 |  * as published by the Free Software Foundation; either version 3
 11 |  * of the License, or (at your option) any later version.
 12 |  */
 13 | 
 14 | #include <stdlib.h>
 15 | #include <string.h>
 16 | 
 17 | #ifdef HAVE_CONFIG_H
 18 | #include "config.h"
 19 | #endif
 20 | 
 21 | #include "xdrfile.h"
 22 | #include "xdrfile_trr.h"
 23 | 
 24 | #define BUFSIZE		128
 25 | #define GROMACS_MAGIC   1993
 26 | 
 27 | typedef struct		/* This struct describes the order and the	*/
 28 | /* sizes of the structs in a trjfile, sizes are given in bytes.	*/
 29 | {
 30 |     mybool  bDouble;        /* Double precision?                            */
 31 |     int	ir_size;	/* Backward compatibility		        */
 32 |     int	e_size;		/* Backward compatibility		        */
 33 |     int	box_size;	/* Non zero if a box is present			*/
 34 |     int   vir_size;       /* Backward compatibility		        */
 35 |     int   pres_size;      /* Backward compatibility		        */
 36 |     int	top_size;	/* Backward compatibility		        */
 37 |     int	sym_size;	/* Backward compatibility		        */
 38 |     int	x_size;		/* Non zero if coordinates are present		*/
 39 |     int	v_size;		/* Non zero if velocities are present		*/
 40 |     int	f_size;		/* Non zero if forces are present		*/
 41 | 
 42 |     int	natoms;		/* The total number of atoms			*/
 43 |     int	step;		/* Current step number				*/
 44 |     int	nre;		/* Backward compatibility		        */
 45 |     float	tf;		/* Current time					*/
 46 |     float	lambdaf;		/* Current value of lambda			*/
 47 |     double	td;		/* Current time					*/
 48 |     double	lambdad;		/* Current value of lambda			*/
 49 | } t_trnheader;
 50 | 
 51 | static int nFloatSize(t_trnheader *sh,int *nflsz)
 52 | {
 53 |     int nflsize=0;
 54 |   
 55 |     if (sh->box_size)
 56 |         nflsize = sh->box_size/(DIM*DIM);
 57 |     else if (sh->x_size)
 58 |         nflsize = sh->x_size/(sh->natoms*DIM);
 59 |     else if (sh->v_size)
 60 |         nflsize = sh->v_size/(sh->natoms*DIM);
 61 |     else if (sh->f_size)
 62 |         nflsize = sh->f_size/(sh->natoms*DIM);
 63 |     else 
 64 |         return exdrHEADER;
 65 |   
 66 |     if (((nflsize != sizeof(float)) && (nflsize != sizeof(double))))
 67 |         return exdrHEADER;
 68 |       
 69 |     *nflsz = nflsize;
 70 |   
 71 |     return exdrOK;
 72 | }
 73 | 
 74 | static int do_trnheader(XDRFILE *xd,mybool bRead,t_trnheader *sh)
 75 | {
 76 | 	int magic=GROMACS_MAGIC;
 77 | 	int nflsz,slen,result;
 78 | 	char *version = "GMX_trn_file";
 79 | 	char buf[BUFSIZE];
 80 |   
 81 | 	if (xdrfile_read_int(&magic,1,xd) != 1)
 82 | 		return exdrINT;
 83 |   
 84 | 	if (bRead) 
 85 |     {
 86 |         if (xdrfile_read_int(&slen,1,xd) != 1)
 87 |             return exdrINT;
 88 |         if (slen != strlen(version)+1)
 89 |             return exdrSTRING;
 90 |         if (xdrfile_read_string(buf,BUFSIZE,xd) <= 0)
 91 |             return exdrSTRING;
 92 |     }
 93 | 	else 
 94 |     {
 95 |         slen = strlen(version)+1;
 96 |         if (xdrfile_read_int(&slen,1,xd) != 1)
 97 |             return exdrINT;
 98 |         if (xdrfile_write_string(version,xd) != (strlen(version)+1) )
 99 |             return exdrSTRING;
100 |     }
101 | 	if (xdrfile_read_int(&sh->ir_size,1,xd) != 1)
102 | 		return exdrINT;
103 | 	if (xdrfile_read_int(&sh->e_size,1,xd) != 1)
104 | 		return exdrINT;
105 | 	if (xdrfile_read_int(&sh->box_size,1,xd) != 1)
106 | 		return exdrINT;
107 | 	if (xdrfile_read_int(&sh->vir_size,1,xd) != 1)
108 | 		return exdrINT;
109 | 	if (xdrfile_read_int(&sh->pres_size,1,xd) != 1)
110 | 		return exdrINT;
111 | 	if (xdrfile_read_int(&sh->top_size,1,xd) != 1)
112 | 		return exdrINT;
113 | 	if (xdrfile_read_int(&sh->sym_size,1,xd) != 1)
114 | 		return exdrINT;
115 | 	if (xdrfile_read_int(&sh->x_size,1,xd) != 1)
116 | 		return exdrINT;
117 | 	if (xdrfile_read_int(&sh->v_size,1,xd) != 1)
118 | 		return exdrINT;
119 | 	if (xdrfile_read_int(&sh->f_size,1,xd) != 1)
120 | 		return exdrINT;
121 | 	if (xdrfile_read_int(&sh->natoms,1,xd) != 1)
122 | 		return exdrINT;
123 | 	
124 | 	if ((result = nFloatSize(sh,&nflsz)) != exdrOK)
125 | 		return result;
126 | 	sh->bDouble = (nflsz == sizeof(double));
127 | 	
128 | 	if (xdrfile_read_int(&sh->step,1,xd) != 1)
129 | 		return exdrINT;
130 | 	if (xdrfile_read_int(&sh->nre,1,xd) != 1)
131 | 		return exdrINT;
132 | 	if (sh->bDouble) 
133 |     {
134 |         if (xdrfile_read_double(&sh->td,1,xd) != 1)
135 |             return exdrDOUBLE;
136 |         sh->tf = sh->td;
137 |         if (xdrfile_read_double(&sh->lambdad,1,xd) != 1)
138 |             return exdrDOUBLE;
139 |         sh->lambdaf = sh->lambdad;
140 |     }
141 | 	else 
142 |     {
143 |         if (xdrfile_read_float(&sh->tf,1,xd) != 1)
144 |             return exdrFLOAT;
145 |         sh->td = sh->tf;
146 |         if (xdrfile_read_float(&sh->lambdaf,1,xd) != 1)
147 |             return exdrFLOAT;
148 |         sh->lambdad = sh->lambdaf;
149 |     }
150 |   
151 |     return exdrOK;
152 | }
153 | 
154 | static int do_htrn(XDRFILE *xd,mybool bRead,t_trnheader *sh,
155 | 				   matrix box,rvec *x,rvec *v,rvec *f)
156 | {
157 | 	double pvd[DIM*DIM];
158 | 	double *dx=NULL;
159 | 	float  pvf[DIM*DIM];
160 | 	float  *fx=NULL;
161 | 	int    i,j;
162 | 	
163 | 	if (sh->bDouble) 
164 | 	{
165 | 		if (sh->box_size != 0) 
166 |         {
167 |             if (!bRead) 
168 |             {
169 |                 for(i=0; (i<DIM); i++)
170 |                     for(j=0; (j<DIM); j++)
171 |                         if (NULL != box)
172 |                         {
173 |                             pvd[i*DIM+j] = box[i][j];
174 |                         }
175 |             }
176 |             if (xdrfile_read_double(pvd,DIM*DIM,xd) == DIM*DIM) 
177 |             {
178 |                 for(i=0; (i<DIM); i++)
179 |                     for(j=0; (j<DIM); j++)
180 |                         if (NULL != box)
181 |                         {
182 |                             box[i][j] = pvd[i*DIM+j];
183 |                         }
184 |             }
185 |             else
186 |                 return exdrDOUBLE;
187 |         }
188 | 			
189 | 		if (sh->vir_size != 0) 
190 |         {
191 |             if (xdrfile_read_double(pvd,DIM*DIM,xd) != DIM*DIM) 
192 |                 return exdrDOUBLE;
193 |         }
194 | 		
195 | 		if (sh->pres_size!= 0) 
196 |         {
197 |             if (xdrfile_read_double(pvd,DIM*DIM,xd) != DIM*DIM) 
198 |                 return exdrDOUBLE;
199 |         }
200 | 		
201 | 		if ((sh->x_size != 0) || (sh->v_size != 0) || (sh->f_size != 0)) {
202 | 			dx = calloc(sh->natoms*DIM,sizeof(dx[0]));
203 | 			if (NULL == dx)
204 | 				return exdrNOMEM;
205 | 		}
206 | 		if (sh->x_size   != 0) 
207 |         {
208 |             if (!bRead) 
209 |             {
210 |                 for(i=0; (i<sh->natoms); i++)
211 |                     for(j=0; (j<DIM); j++)
212 |                         if (NULL != x)
213 |                         {
214 |                             dx[i*DIM+j] = x[i][j];
215 |                         }
216 |             }
217 |             if (xdrfile_read_double(dx,sh->natoms*DIM,xd) == sh->natoms*DIM)
218 |             {
219 |                 if (bRead) 
220 |                 {
221 |                     for(i=0; (i<sh->natoms); i++)
222 |                         for(j=0; (j<DIM); j++)
223 |                             if (NULL != x)
224 |                             {
225 |                                 x[i][j] = dx[i*DIM+j];
226 |                             }
227 |                 }
228 |             }
229 |             else
230 |                 return exdrDOUBLE;
231 |         }
232 | 		if (sh->v_size   != 0) 
233 |         {
234 |             if (!bRead) 
235 |             {
236 |                 for(i=0; (i<sh->natoms); i++)
237 |                     for(j=0; (j<DIM); j++)
238 |                         if (NULL != x)
239 |                         {
240 |                             dx[i*DIM+j] = v[i][j];
241 |                         }
242 |             }
243 |             if (xdrfile_read_double(dx,sh->natoms*DIM,xd) == sh->natoms*DIM)
244 |             {
245 |                 for(i=0; (i<sh->natoms); i++)
246 |                     for(j=0; (j<DIM); j++)
247 |                         if (NULL != v)
248 |                         {
249 |                             v[i][j] = dx[i*DIM+j];
250 |                         }
251 |             }
252 |             else
253 |                 return exdrDOUBLE;
254 |         }
255 | 		if (sh->f_size   != 0) 
256 |         {
257 |             if (!bRead) 
258 |             {
259 |                 for(i=0; (i<sh->natoms); i++)
260 |                     for(j=0; (j<DIM); j++)
261 |                         if (NULL != x)
262 |                         {
263 |                             dx[i*DIM+j] = f[i][j];
264 |                         }
265 |             }
266 |             if (xdrfile_read_double(dx,sh->natoms*DIM,xd) == sh->natoms*DIM)
267 |             {
268 |                 for(i=0; (i<sh->natoms); i++)
269 |                 {
270 |                     for(j=0; (j<DIM); j++)
271 |                     {
272 |                         if (NULL != f)
273 |                         {
274 |                             f[i][j] = dx[i*DIM+j];
275 |                         }
276 |                     }
277 |                 }
278 |             }
279 |             else
280 |                 return exdrDOUBLE;
281 |         }
282 | 		if ((sh->x_size != 0) || (sh->v_size != 0) || (sh->f_size != 0)) {
283 | 			free(dx);
284 | 		}
285 | 	}
286 | 	else
287 | 		/* Float */
288 | 	{
289 | 		if (sh->box_size != 0) 
290 |         {
291 |             if (!bRead) 
292 |             {
293 |                 for(i=0; (i<DIM); i++)
294 |                     for(j=0; (j<DIM); j++)
295 |                         if (NULL != box)
296 |                         {
297 |                             pvf[i*DIM+j] = box[i][j];
298 |                         }
299 |             }
300 |             if (xdrfile_read_float(pvf,DIM*DIM,xd) == DIM*DIM) 
301 |             {
302 |                 for(i=0; (i<DIM); i++)
303 |                 {
304 |                     for(j=0; (j<DIM); j++)
305 |                     {
306 |                         if (NULL != box)
307 |                         {
308 |                             box[i][j] = pvf[i*DIM+j];
309 |                         }
310 |                     }
311 |                 }
312 |             }
313 |             else
314 |                 return exdrFLOAT;
315 |         }
316 | 			
317 | 		if (sh->vir_size != 0) 
318 |         {
319 |             if (xdrfile_read_float(pvf,DIM*DIM,xd) != DIM*DIM) 
320 |                 return exdrFLOAT;
321 |         }
322 | 		
323 | 		if (sh->pres_size!= 0) 
324 |         {
325 |             if (xdrfile_read_float(pvf,DIM*DIM,xd) != DIM*DIM) 
326 |                 return exdrFLOAT;
327 |         }
328 | 		
329 | 		if ((sh->x_size != 0) || (sh->v_size != 0) || (sh->f_size != 0)) {
330 | 			fx = calloc(sh->natoms*DIM,sizeof(fx[0]));
331 | 			if (NULL == fx)
332 | 				return exdrNOMEM;
333 | 		}
334 | 		if (sh->x_size   != 0) 
335 |         {
336 |             if (!bRead) 
337 |             {
338 |                 for(i=0; (i<sh->natoms); i++)
339 |                     for(j=0; (j<DIM); j++)
340 |                         if (NULL != x)
341 |                         {
342 |                             fx[i*DIM+j] = x[i][j];
343 |                         }
344 |             }
345 |             if (xdrfile_read_float(fx,sh->natoms*DIM,xd) == sh->natoms*DIM)
346 |             {
347 |                 if (bRead) 
348 |                 {
349 |                     for(i=0; (i<sh->natoms); i++)
350 |                         for(j=0; (j<DIM); j++)
351 |                             if (NULL != x)
352 |                                 x[i][j] = fx[i*DIM+j];
353 |                 }
354 |             }
355 |             else
356 |                 return exdrFLOAT;
357 |         }
358 | 		if (sh->v_size   != 0) 
359 |         {
360 |             if (!bRead) 
361 |             {
362 |                 for(i=0; (i<sh->natoms); i++)
363 |                     for(j=0; (j<DIM); j++)
364 |                         if (NULL != x)
365 |                         {
366 |                             fx[i*DIM+j] = v[i][j];
367 |                         }
368 |             }
369 |             if (xdrfile_read_float(fx,sh->natoms*DIM,xd) == sh->natoms*DIM)
370 |             {
371 |                 for(i=0; (i<sh->natoms); i++)
372 |                     for(j=0; (j<DIM); j++)
373 |                         if (NULL != v)
374 |                             v[i][j] = fx[i*DIM+j];
375 |             }
376 |             else
377 |                 return exdrFLOAT;
378 |         }
379 | 		if (sh->f_size   != 0) 
380 |         {
381 |            if (!bRead) 
382 |             {
383 |                 for(i=0; (i<sh->natoms); i++)
384 |                     for(j=0; (j<DIM); j++)
385 |                         if (NULL != x)
386 |                         {
387 |                             fx[i*DIM+j] = f[i][j];
388 |                         }
389 |             }
390 |              if (xdrfile_read_float(fx,sh->natoms*DIM,xd) == sh->natoms*DIM)
391 |             {
392 |                 for(i=0; (i<sh->natoms); i++)
393 |                     for(j=0; (j<DIM); j++)
394 |                         if (NULL != f)
395 |                             f[i][j] = fx[i*DIM+j];
396 |             }
397 |             else
398 |                 return exdrFLOAT;
399 |         }
400 | 		if ((sh->x_size != 0) || (sh->v_size != 0) || (sh->f_size != 0)) {
401 | 			free(fx);
402 | 		}
403 | 	}
404 | 	return exdrOK;
405 | }
406 | 
407 | static int do_trn(XDRFILE *xd,mybool bRead,int *step,float *t,float *lambda,
408 | 				  matrix box,int *natoms,rvec *x,rvec *v,rvec *f)
409 | {
410 |     t_trnheader *sh;
411 |     int result;
412 |   
413 |     sh = calloc(1,sizeof(*sh));
414 |   
415 |     if (!bRead) {
416 |         sh->box_size = (NULL != box) ? sizeof(matrix):0;
417 |         sh->x_size   = ((NULL != x) ? (*natoms*sizeof(x[0])):0);
418 |         sh->v_size   = ((NULL != v) ? (*natoms*sizeof(v[0])):0);
419 |         sh->f_size   = ((NULL != f) ? (*natoms*sizeof(f[0])):0);
420 |         sh->natoms = *natoms;
421 |         sh->step   = *step;
422 |         sh->nre    = 0;
423 |         sh->td      = *t;
424 |         sh->lambdad = *lambda;
425 |         sh->tf      = *t;
426 |         sh->lambdaf = *lambda;
427 |     }
428 |     if ((result = do_trnheader(xd,bRead,sh)) != exdrOK)
429 |         return result;
430 |     if (bRead) {
431 |         *natoms = sh->natoms;
432 |         *step   = sh->step;
433 |         *t      = sh->td;
434 |         *lambda = sh->lambdad;
435 |     }
436 |     if ((result = do_htrn(xd,bRead,sh,box,x,v,f)) != exdrOK)
437 |         return result;
438 | 
439 |     free(sh);
440 |   
441 |     return exdrOK;
442 | }
443 | 
444 | /************************************************************
445 |  *
446 |  *  The following routines are the exported ones
447 |  *
448 |  ************************************************************/
449 |  
450 | int read_trr_natoms(char *fn,int *natoms)
451 | {
452 | 	XDRFILE *xd;
453 | 	t_trnheader sh;
454 | 	int  result;
455 | 	
456 | 	xd = xdrfile_open(fn,"r");
457 | 	if (NULL == xd)
458 | 		return exdrFILENOTFOUND;
459 | 	if ((result = do_trnheader(xd,1,&sh)) != exdrOK)
460 | 		return result;
461 | 	xdrfile_close(xd);
462 | 	*natoms = sh.natoms;
463 | 	
464 | 	return exdrOK;
465 | }
466 | 
467 | int write_trr(XDRFILE *xd,int natoms,int step,float t,float lambda,
468 | 			  matrix box,rvec *x,rvec *v,rvec *f)
469 | {
470 | 	return do_trn(xd,0,&step,&t,&lambda,box,&natoms,x,v,f);
471 | }
472 | 
473 | int read_trr(XDRFILE *xd,int natoms,int *step,float *t,float *lambda,
474 | 			 matrix box,rvec *x,rvec *v,rvec *f)
475 | {
476 | 	return do_trn(xd,1,step,t,lambda,box,&natoms,x,v,f);
477 | }
478 | 
479 | 


--------------------------------------------------------------------------------
/src/coring.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright (c) 2015-2017, Florian Sittel (www.lettis.net)
  3 | Copyright (c) 2018-2021, Daniel Nagel
  4 | All rights reserved.
  5 | 
  6 | Redistribution and use in source and binary forms, with or without modification,
  7 | are permitted provided that the following conditions are met:
  8 | 
  9 | 1. Redistributions of source code must retain the above copyright notice,
 10 |    this list of conditions and the following disclaimer.
 11 | 
 12 | 2. Redistributions in binary form must reproduce the above copyright notice,
 13 |    this list of conditions and the following disclaimer in the documentation
 14 |    and/or other materials provided with the distribution.
 15 | 
 16 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
 17 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 18 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
 19 | SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 20 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
 21 | OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 22 | HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 23 | TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 24 | EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 25 | */
 26 | 
 27 | #include "coring.hpp"
 28 | 
 29 | #include "logger.hpp"
 30 | #include "tools.hpp"
 31 | 
 32 | #include <iostream>
 33 | #include <fstream>
 34 | #include <algorithm>
 35 | #include <vector>
 36 | #include <numeric>
 37 | 
 38 | #include <omp.h>
 39 | 
 40 | namespace Clustering {
 41 | namespace Coring {
 42 |   WTDMap
 43 |   compute_wtd(std::list<std::size_t> streaks) {
 44 |     WTDMap wtd;
 45 |     if (streaks.size() > 0) {
 46 |       streaks.sort(std::greater<std::size_t>());
 47 |       std::size_t max_streak = streaks.front();
 48 |       for (std::size_t i=0; i <= max_streak; ++i) {
 49 |         float n_steps = 0.0f;
 50 |         for (auto s: streaks) {
 51 |           if (i > s) {
 52 |             break;
 53 |           }
 54 |           n_steps += 1.0f;
 55 |         }
 56 |         wtd[i] = n_steps / ((float) streaks.size());
 57 |       }
 58 |     }
 59 |     return wtd;
 60 |   }
 61 | 
 62 |   void
 63 |   main(boost::program_options::variables_map args) {
 64 |     using namespace Clustering::Tools;
 65 |     namespace b_po = boost::program_options;
 66 |     // load states
 67 |     Clustering::logger(std::cout) << "~~~ reading files\n"
 68 |                                   << "    trajectory from: " << args["states"].as<std::string>()
 69 |                                   << std::endl;
 70 |     std::vector<std::size_t> states = Clustering::Tools::read_clustered_trajectory(args["states"].as<std::string>());
 71 |     std::set<std::size_t> state_names(states.begin(), states.end());
 72 |     std::size_t n_frames = states.size();
 73 |     bool iterative_coring = args["iterative"].as<bool>();
 74 |     std::string header_comment = args["header"].as<std::string>();
 75 |     std::map<std::string,float> commentsMap = args["commentsMap"].as<std::map<std::string,float>>();
 76 |     // read previously used parameters
 77 |     read_comments(args["states"].as<std::string>(), commentsMap);
 78 |     if (args.count("output") || args.count("distribution") || args.count("cores")) {
 79 |       // load concatenation limits to treat concatenated trajectories correctly
 80 |       // when performing dynamical corrections
 81 |       std::vector<std::size_t> concat_limits;
 82 |       if (args.count("concat-limits")) {
 83 |         Clustering::logger(std::cout) << "    limits from: "
 84 |                                       << args["concat-limits"].as<std::string>() << std::endl;
 85 |         concat_limits = Clustering::Tools::read_concat_limits(args["concat-limits"].as<std::string>());
 86 |       } else if (args.count("concat-nframes")) {
 87 |         std::size_t n_frames_per_subtraj = args["concat-nframes"].as<std::size_t>();
 88 |         for (std::size_t i=n_frames_per_subtraj; i <= n_frames; i += n_frames_per_subtraj) {
 89 |           concat_limits.push_back(i);
 90 |         }
 91 |       } else {
 92 |         concat_limits = {n_frames};
 93 |       }
 94 |       // check if concat_limits are well definied
 95 |       Clustering::Tools::check_concat_limits(concat_limits, n_frames);
 96 |       Clustering::logger(std::cout) << "    interpret data as " << concat_limits.size()
 97 |                                     << " trajectories" << std::endl;
 98 |       if (commentsMap["limits"] == 0) {
 99 |         commentsMap["limits"] = concat_limits.size();
100 |       } else if (std::abs(commentsMap["limits"]-concat_limits.size()) > 0.001) {
101 |         Clustering::logger(std::cout) << "warning: the number of limits are not in agreement\n"
102 |                                       << "         " << commentsMap["limits"] << " vs. "
103 |                                       << concat_limits.size() << std::endl;
104 |       }
105 |       // load window size information
106 |       std::map<std::size_t, std::size_t> coring_windows;
107 |       std::size_t size_for_all = 1;
108 |       try{  // read single integer as coring window
109 |         size_for_all = std::stoi(args["windows"].as<std::string>());
110 |       } catch (...) {  // read window file
111 |         Clustering::logger(std::cout) << "\n~~~ coring windows:\n    from file: "
112 |                                       << args["windows"].as<std::string>() << std::endl;
113 |         std::ifstream ifs(args["windows"].as<std::string>());
114 |         std::string buf;
115 |         std::size_t state, window;
116 |         size_for_all = 1;
117 |         if (ifs.fail()) {
118 |           std::cerr << "error: cannot open file '"
119 |                     << args["windows"].as<std::string>()
120 |                     << "'" << std::endl;
121 |           exit(EXIT_FAILURE);
122 |         } else {
123 |           while (ifs.good()) {
124 |             if (std::isdigit(ifs.peek())) {
125 |               ifs >> state;
126 |               ifs >> window;
127 |               if ( ! ifs.fail()) {
128 |                 coring_windows[state] = window;
129 |               } else {
130 |                 std::cerr << "error: file not correctly formated." << std::endl;
131 |               }
132 |             } else if (ifs.peek() == '*') {
133 |               ifs >> buf;
134 |               ifs >> window;
135 |               if ( ! ifs.fail()) {
136 |                 size_for_all = window;
137 |               } else {
138 |                 std::cerr << "error: file not correctly formated." << std::endl;
139 |               }
140 |             } else {
141 |               ifs.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
142 |             }
143 |           }
144 |         }
145 |       }
146 |       // fill remaining, not explicitly defined states with common window size
147 |       std::size_t undefined_windows = 0;
148 |       for (std::size_t name: state_names) {
149 |         if ( ! coring_windows.count(name)){
150 |           coring_windows[name] = size_for_all;
151 |           ++undefined_windows;
152 |         }
153 |       }
154 |       // if only single coring window is used
155 |       if (coring_windows.size() == 0) {
156 |         commentsMap["single_coring_time"] = size_for_all;
157 |       }
158 |       header_comment.append(Clustering::Tools::stringprintf(
159 |         "#\n# coring specific parameters: \n"
160 |         "#    %i state-specific coring windows were read\n"
161 |         "#    %i frames is used for reamining states\n",
162 |       state_names.size() - undefined_windows, size_for_all));
163 |       if (iterative_coring) {
164 |           header_comment.append("# iterative mode active\n");
165 |       }
166 |       if ((state_names.size() - undefined_windows) > 0) {
167 |         Clustering::logger(std::cout) << "    " << state_names.size() - undefined_windows
168 |                                       << " state-specific coring windows were read" << std::endl;
169 |       }
170 |       if (size_for_all > 1) {
171 |         Clustering::logger(std::cout) << "    default window was set to " << size_for_all
172 |                                       << " frames" << std::endl;
173 |       }
174 | 
175 |       // get smallest coring window to prevent window of size 0
176 |       auto min_window_iter = std::min_element(
177 |           coring_windows.begin(), coring_windows.end(),
178 |           [](const std::pair<std::size_t, std::size_t>& p1, const std::pair<std::size_t, std::size_t>& p2) {
179 |               return p1.second < p2.second;
180 |           }
181 |       );
182 |       std::size_t min_window = min_window_iter->second;
183 |       if (min_window == 0) {
184 |           std::cerr << "error: no window of size 0 is allowed. A window of length 1"
185 |                     << " corresponds to no coring" << std::endl;
186 |           exit(EXIT_FAILURE);
187 |       }
188 | 
189 |       // core trajectory
190 |       Clustering::logger(std::cout) << "\n~~~ coring trajectory" << std::endl;
191 |       std::vector<std::size_t> cored_traj(n_frames);
192 |       // copy states trajectory
193 |       std::vector<std::size_t> cored_traj_prev(n_frames);
194 |       std::copy(states.begin(), states.end(), cored_traj_prev.begin());
195 |       std::vector<long> cores(n_frames);
196 |       std::size_t changed_frames = 0;
197 | 
198 |       // get greatest coring window
199 |       auto max_window_iter = std::max_element(
200 |           coring_windows.begin(), coring_windows.end(),
201 |           [](const std::pair<std::size_t, std::size_t>& p1, const std::pair<std::size_t, std::size_t>& p2) {
202 |               return p1.second < p2.second;
203 |           }
204 |       );
205 |       std::size_t max_window = max_window_iter->second;
206 |       Clustering::logger(std::cout) << "    max coring window: " << max_window << std::endl;
207 | 
208 |       // generate range with iterative slices or single value
209 |       std::vector<std::size_t> max_coring_window;
210 |       if (iterative_coring && max_window > 1) {
211 |           max_coring_window.resize(max_window-1);
212 |           std::iota(max_coring_window.begin(), max_coring_window.end(), 2);
213 |       } else {
214 |           max_coring_window.push_back(max_window);
215 |       }
216 | 
217 |       for (std::size_t curr_max_window: max_coring_window) {
218 |           std::size_t current_core = cored_traj_prev[0];
219 |           bool is_in_core = true;
220 |           // honour concatenation limits, i.e. treat every concatenated trajectory-part on its own
221 |           std::size_t last_limit = 0;
222 |           for (std::size_t next_limit: concat_limits) {
223 |             // this should never have an impact for correct limits
224 |             std::size_t next_limit_corrected = std::min(next_limit, n_frames);
225 |             // find first core
226 |             current_core = cored_traj_prev[last_limit];  // fallback option
227 |             for (std::size_t i=last_limit; i < next_limit_corrected; ++i) {
228 |               std::size_t cw = std::min(curr_max_window, coring_windows[cored_traj_prev[i]]);
229 |               std::size_t w = std::min(i+cw, next_limit);
230 |               for (std::size_t j=i+1; j < w; ++j) {
231 |                 if (cored_traj_prev[j] != cored_traj_prev[i]) {
232 |                   goto try_next_state;
233 |                 }
234 |               }
235 |               current_core = cored_traj_prev[i];
236 |               break;
237 | 
238 |               try_next_state: ;
239 |             }
240 |             // core trajectories
241 |             for (std::size_t i=last_limit; i < next_limit_corrected; ++i) {
242 |               // coring window
243 |               std::size_t cw = std::min(curr_max_window, coring_windows[cored_traj_prev[i]]);
244 |               if (i+cw <= next_limit) {
245 |                 // std::size_t w = std::min(i+cw, next_limit_corrected);
246 |                 is_in_core = true;
247 |                 std::size_t j;
248 |                 // for iterative coring only last frame needs to be checked
249 |                 if (iterative_coring) {
250 |                     j=i+cw-1;
251 |                 } else {
252 |                     j=i+1;
253 |                 }
254 |                 for (; j < i+cw; ++j) {
255 |                   if (cored_traj_prev[j] != cored_traj_prev[i]) {
256 |                     is_in_core = false;
257 |                     break;
258 |                     }
259 |                 }
260 |               } else {  // <-- so last frames can not be in core? should be true
261 |                 is_in_core = false;
262 |               }
263 | 
264 |               if (is_in_core) {
265 |                 current_core = cored_traj_prev[i];
266 |               }
267 | 
268 |               // generate statistic only for last iteration
269 |               if (curr_max_window == max_window) {
270 |                 if (is_in_core) {
271 |                   cores[i] = current_core;
272 |                 } else {
273 |                   cores[i] = -1;
274 |                 }
275 |                 if (current_core != states[i]) {
276 |                   ++changed_frames;
277 |                 }
278 |               }
279 |               cored_traj[i] = current_core;
280 |             }
281 |             last_limit = next_limit_corrected;
282 |           }
283 |         std::copy(cored_traj.begin(), cored_traj.end(), cored_traj_prev.begin());
284 |       }
285 |       float changed_frames_perc = (float) 100*changed_frames / n_frames;
286 |       Clustering::logger(std::cout) << Clustering::Tools::stringprintf("    %.2f", changed_frames_perc)
287 |                                     << "% of frames were changed\n    " << changed_frames
288 |                                     << " frames in total"
289 |                                     << std::endl;
290 |       // write cored trajectory to file
291 |       std::string header_coring = header_comment
292 |                   + Clustering::Tools::stringprintf("#    %.2f", changed_frames_perc)
293 |                   + "% of frames were changed\n";
294 |       if (args.count("output")) {
295 |         Clustering::logger(std::cout) << "    store result in: " << args["output"].as<std::string>()
296 |                                       << std::endl;
297 |         Clustering::Tools::write_clustered_trajectory(args["output"].as<std::string>(),
298 |                                                       cored_traj,
299 |                                                       header_coring,
300 |                                                       commentsMap);
301 |       }
302 |       // write core information to file
303 |       if (args.count("cores")) {
304 |         append_commentsMap(header_coring, commentsMap);
305 |         Clustering::Tools::write_single_column<long>(args["cores"].as<std::string>(),
306 |                                                      cores,
307 |                                                      header_coring,
308 |                                                      false);
309 |       }
310 |       // compute/save escape time distributions
311 |       if (args.count("distribution")) {
312 |         Clustering::logger(std::cout) << "~~~ generating distribution" << std::endl;
313 |         std::map<std::size_t, std::list<std::size_t>> streaks;
314 |         std::size_t current_state = cored_traj[0];
315 |         long n_counts = 0;
316 |         for (std::size_t state: cored_traj) {
317 |           if (state == current_state) {
318 |             ++n_counts;
319 |           } else {
320 |             streaks[current_state].push_back(n_counts);
321 |             current_state = state;
322 |             n_counts = 1;
323 |           }
324 |         }
325 |         streaks[current_state].push_back(n_counts);
326 | 
327 |         // append values to header comment
328 |         append_commentsMap(header_comment, commentsMap);
329 | 
330 |         std::map<std::size_t, WTDMap> etds;
331 |         for (std::size_t state: state_names) {
332 |           etds[state] = compute_wtd(streaks[state]);
333 |         }
334 |         // write WTDs to file
335 |         Clustering::logger(std::cout) << "    storing..." << std::endl;
336 |         for (auto state_etd: etds) {
337 |           std::string fname = Clustering::Tools::stringprintf(args["distribution"].as<std::string>() + "_%d", state_etd.first);
338 |           Clustering::Tools::write_map<std::size_t, float>(fname, state_etd.second, header_comment);
339 |         }
340 |       }
341 |     } else {
342 |       std::cerr << "\n" << "error (coring): nothing to do! please define '--output', '--distribution' or both!" << "\n\n";
343 |       exit(EXIT_FAILURE);
344 |     }
345 |   }
346 | } // end namespace Coring
347 | } // end namespace Clustering
348 | 


--------------------------------------------------------------------------------