Geometry.hpp

/*
    dmcut2, a library for Monte-Carlo simulations at surfaces
    Copyright (C) 2008 Mathias Laurin <mathias_laurin@users.sourceforge.net>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef DMCUT2_INTERACTIONS_TWO_BODY_GEOMETRY_HPP
#define DMCUT2_INTERACTIONS_TWO_BODY_GEOMETRY_HPP

#include <string>
#include <set>
#include <vector>
#include <ostream>

#include "EnergyContainer.hpp"
#include "Species.hpp"

namespace Surface { class Site; }

namespace Interactions {
namespace TwoBody {

typedef std::vector<std::ptrdiff_t> RelativeIndexContainer;

class Geometry {        
public: 
        typedef std::vector< Surface::Site* > NeighborContainer;
        
        typedef std::string Name;
        
        Geometry(const Name& name):
        name_(name), site_ptr_(NULL),
        neighbor_container_(), energy_container_() {};
        

        
        Name name() const
        { return name_; }
        
        const NeighborContainer& neighbor_container() const
        { return neighbor_container_; }
                
        

        
        void set_interaction_energy_container(const EnergyContainer& energy_container)
        { energy_container_ = energy_container; }
        
        
        double InteractionEnergy() const;
        
private:
        NeighborContainer& neighbor_container()
        { return neighbor_container_; }

        void set_site_ptr(Surface::Site* site_ptr)
        { site_ptr_ = site_ptr; }

        Name name_;
        Surface::Site* site_ptr_;
        NeighborContainer neighbor_container_;
        EnergyContainer energy_container_;
        
        friend class LinkSites;
};

} // namespace TwoBody
} // namespace Interactions

namespace Surface { 
        class HelicalBoundaryConditions; 
        class Site;
}

#include <tr1/functional>

namespace Interactions {
namespace TwoBody {
struct LinkSites: std::tr1::function<void(Surface::Site*, RelativeIndexContainer)>
{
        LinkSites(const Surface::HelicalBoundaryConditions& boundary_conditions):
        boundary_conditions_(boundary_conditions) {};
        
        void operator()(Geometry interactions, 
                                        Surface::Site* site_ptr,
                                        RelativeIndexContainer relative_index_container) const;
        
private:
        const Surface::HelicalBoundaryConditions& boundary_conditions_;
};

} // namespace TwoBody
} // namespace Interactions
        
std::ostream& operator<<(std::ostream&, const Interactions::TwoBody::Geometry&);

#endif

---

Project's page