MDHistory.hpp

#ifndef __FIBER_GRID_TYPES_MDHISTORY
#define __FIBER_GRID_TYPES_MDHISTORY
 
#include <algorithm>
 
#include "Edges.hpp"
#include "GridWithCartesianVertices.hpp"
 
using namespace Eagle::PhysicalSpace;
using namespace std;
 
namespace Fiber
{
 
class gridtypes_API MDHistory : public GridWithCartesianVertices
                              , public Edges
{
public:
typedef uint16_t      AtomType_t;
 
RefPtr<Skeleton>       DihedralSkeleton;
RefPtr<Representation> DihedralsAsVertices;
RefPtr<Field>          DihedralPositions;
 
RefPtr<Field>          AtomTypes;
 
        MDHistory( const RefPtr<Grid>&grid )
        : GridWithCartesianVertices( grid )
        , Edges( grid )
        {
                assign( grid );
        }
 
bool assign( const RefPtr<Grid>&theGrid );
bool isValid();
 
RefPtr<MemArray<1, Dihedral_t> > getDihedrals( const RefPtr<FragmentID> & frag = NullPtr() );
 
void getAtomTypeNames( std::vector<string>& names, const RefPtr<FragmentID> & frag = NullPtr() ) const;
 
static  SkeletonID    getDihedralSkeletonID();
static  RefPtr<Field> createDihedralPositionsField( const RefPtr<Grid>& grid );
 
void extractChains(const std::vector<string>& atom_filter,unsigned mindepth,unsigned maxdepth,std::vector< std::list<uint32_t> >& AllChains,
                     std::vector<string>& dict_arr,MultiArray<1, MDHistory::AtomType_t>& type_arr, MultiArray<1, EdgeCell32>& edge_arr) const;
 
void recursiveChainFinder(std::list<uint32_t>& chain, const std::vector< std::list<uint32_t> >& neighbors,
                                     std::vector< std::list<uint32_t> >& AllChains,unsigned mindepth, unsigned maxdepth,
                                     std::vector<string>& dict_arr, MultiArray<1, MDHistory::AtomType_t>& type_arr,
                                     const std::vector<string>& atom_filter) const;
 
void extractSingleCluster(uint32_t root, const std::vector<string>& atom_filter, unsigned maxdepth, std::list<uint32_t>& cluster,
                    std::vector<string>& dict_arr, MultiArray<1, MDHistory::AtomType_t>& type_arr, MultiArray<1, EdgeCell32>& edge_arr) const;
 
void recursiveClusterFinder(std::list<uint32_t> &cluster,uint32_t node,const std::vector< std::list<uint32_t> >& neighbors,
                             unsigned maxdepth,std::vector<string>& dict_arr, MultiArray<1, MDHistory::AtomType_t>& type_arr,
                            const std::vector<string>& atom_filter) const;
 
 
template<class T,class C>
bool isMember(const T& str,const C& atom_filter) const
{
        //usage example: isMember<string,std::vector<string>>(dict_arr[type_arr[AllSiblings[i]]],atom_filter)
        return (find(atom_filter.begin(),atom_filter.end(),str) != atom_filter.end());
}
 
 
 
};
 
 
}
 
 
 
#endif