atom.h

Go to the documentation of this file.

#ifndef ATOM_H
#define ATOM_H
 
#include <cstdint>
#include <iostream>
#include <set>
#include <vector>
#include <map>
 
#include <glm/glm.hpp>
 
#include <element.h>
#include <colour.h>
 
class Atom
{
public:
 
    Atom
    (
        Element symbol,
        glm::vec3 position = glm::vec3(0),
        float scale = 1.0f,
        glm::vec4 colour = glm::vec4(1.0, 0.5, 0.5, 1.0),
        glm::vec3 velocity = glm::vec3(0),
        glm::vec3 force = glm::vec3(0)
    )
    :
      symbol(symbol),
      position(position),
      scale(scale),
      colour(colour),
      velocity(velocity),
      force(force)
    {}
 
    Atom
    (
        glm::vec3 position = glm::vec3(0),
        float scale = 1.0f,
        glm::vec4 colour = glm::vec4(1.0, 0.5, 0.5, 1.0),
        glm::vec3 velocity = glm::vec3(0),
        glm::vec3 force = glm::vec3(0)
    ) : Atom(
          Element::Unknown,
          position,
          scale,
          colour,
          velocity,
          force
        )
    {}
 
    Element symbol;
    glm::vec3 position;
    float scale;
    glm::vec4 colour;
    glm::vec3 velocity;
    glm::vec3 force;
 
private:
};
 
std::ostream & operator <<(std::ostream & o, Atom & atom)
{
    return o << atom.symbol << ": " << atom.position;
}
 
glm::vec3 getCenter(const std::vector<Atom> & atoms)
{
    glm::vec3 com = glm::vec3(0);
    for (const auto & atom : atoms)
    {
        com += atom.position;
    }
    return com / float(atoms.size());
}
 
void center(std::vector<Atom> & atoms)
{
    glm::vec3 com = getCenter(atoms);
    for (auto & atom : atoms)
    {
        atom.position -= com;
    }
}
 
void centerOn(std::vector<Atom> & atoms, uint64_t index)
{
    center(atoms);
    glm::vec3 pos = atoms[index].position;
    for (auto & atom : atoms)
    {
        atom.position -= pos;
    }
}
 
void translate(std::vector<Atom> & atoms, glm::vec3 r)
{
    for (auto & atom : atoms) { atom.position += r; }
}
 
glm::vec3 min(const std::vector<Atom> & atoms)
{
    glm::vec3 min = glm::vec3(std::numeric_limits<float>::max());
    for (const auto & atom : atoms)
    {
        for (uint8_t i = 0; i < 3; i++)
        {
            min[i] = std::min(min[i], atom.position[i]);
        }
    }
    return min;
}
 
glm::vec3 max(const std::vector<Atom> & atoms)
{
    glm::vec3 max = glm::vec3(-std::numeric_limits<float>::max());
    for (const auto & atom : atoms)
    {
        for (uint8_t i = 0; i < 3; i++)
        {
            max[i] = std::max(max[i], atom.position[i]);
        }
    }
    return max;
}
 
glm::vec3 extent(const std::vector<Atom> & atoms)
{
    glm::vec3 min = glm::vec3(std::numeric_limits<float>::max());
    glm::vec3 max = glm::vec3(-std::numeric_limits<float>::max());
    for (const auto & atom : atoms)
    {
        for (uint8_t i = 0; i < 3; i++)
        {
            min[i] = std::min(min[i], atom.position[i]);
            max[i] = std::max(max[i], atom.position[i]);
        }
    }
    return max-min;
}
 
std::set<Element> uniqueElements(const std::vector<Atom> & atoms)
{
    std::set<Element> e;
    for (const auto & atom : atoms)
    {
        e.insert(atom.symbol);
    }
    return e;
}
 
float largest(const std::vector<Atom> & atoms)
{
    float r = -std::numeric_limits<float>::max();
    for (const auto & atom : atoms)
    {
        r = std::max(r, atom.scale);
    }
    return r;
}
 
std::multimap<Element, uint64_t> elementIndices(const std::vector<Atom> & atoms)
{
    std::multimap<Element, uint64_t> m;
    for (uint64_t i = 0; i < atoms.size(); i++)
    {
        m.insert(std::pair(atoms[i].symbol, i));
    }
    return m;
}
 
void applyColours
(
    std::vector<Atom> & atoms,
    const std::map<uint64_t, glm::vec4> & colours
)
{
    for (const auto & ic : colours)
    {
        atoms[ic.first].colour = ic.second;
    }
}
 
void applySizes
(
    std::vector<Atom> & atoms,
    const std::vector<float> sizes
)
{
    for (uint64_t i = 0; i < sizes.size(); i++)
    {
        atoms[i].scale = sizes[i];
    }
}
 
#endif /* ATOM_H */