Lattice.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 LATTICE_HPP
#define LATTICE_HPP

#include <algorithm>
#include <tr1/functional>
#include "Site.hpp"

namespace Surface {
        

        extern unsigned temperature_; 
        
        inline unsigned temperature()
        { return temperature_; }        
        
        inline void set_temperature(unsigned temperature)
        { temperature_ = temperature; }
        

        extern std::vector<Site::Name> name_set_;
        extern Site::Name fcc;
        extern Site::Name hcp;
        extern Site::Name bridge;
        extern Site::Name any;
        
        inline std::vector<Site::Name> name_set()
        { return name_set_; }
        
        inline std::vector<Site::Name>::size_type multiplicity()
        { return name_set_.size(); }
        
        
        class Lattice { 
                
                typedef std::vector<Site*> SiteContainer;
                
        public:
                
                //typedef SiteContainer::pointer pointer;
                //typedef SiteContainer::reference reference;
                //typedef SiteContainer::const_reference const_reference;
                
                typedef SiteContainer::iterator iterator;
                
                typedef SiteContainer::const_iterator const_iterator;
                
                typedef SiteContainer::size_type size_type;
                
                Lattice(const size_type length_side):
                length_side_(length_side), site_container_() {
                        name_set_.push_back(fcc);
                        name_set_.push_back(hcp);
                        // bridge, etc. are treated separately
                        
                        const size_type sz = length_side*length_side; 
                        site_container_.reserve(sz);
                        for (size_type i = 0; i != sz; ++i) {
                                const Site::Name 
                                name = name_set()[i % multiplicity()];
                                site_container_.push_back(new Site(name, i, no_species));
                        }
                }
                
                ~Lattice() {
                        for (iterator iter = begin(), last = end();
                                 iter != last; ++iter) 
                        { delete *iter; *iter = NULL; }
                }
                
                void Populate(double coverage, const Species& species);
                
                void Clean();
                
                void set_bridge(const Bridge& bridge);
                

                
                size_type width()
                { return length_side_; }
                
                size_type height()
                { return length_side_; }
                
                

                                
                iterator begin()
                { return site_container_.begin(); }
                
                iterator end()
                { return site_container_.end(); }
                
                const_iterator begin() const
                { return site_container_.begin(); }
                
                const_iterator end() const
                { return site_container_.end(); }
                
                size_type size() const
                { return site_container_.size(); }
                
                bool empty() const
                { return site_container_.empty(); }
                
                Site* operator[](size_type n)
                { return site_container_[n]; }
                
                const Site* const operator[](size_type n) const
                { return site_container_[n]; }
                
                Site* at(size_type n)
                { return site_container_.at(n); }
                
                const Site* const at(size_type n) const
                { return site_container_.at(n); }
                
                
        private:
                Lattice (const Lattice&);
                void operator= (const Lattice&);
                
                const size_type length_side_;
                SiteContainer site_container_;
        };
        

        
        void Populate(Lattice::iterator first, Lattice::iterator last,
                                  double coverage, const Species& species);
        
        void Clean(Lattice::iterator first, Lattice::iterator last);
        
        void SetBridge(Lattice::iterator first, Lattice::iterator last,
                                   const Bridge& bridge);
        
        
        class HelicalBoundaryConditions: 
        public std::tr1::function<Site*(Site*, Interactions::TwoBody::RelativeIndexContainer::value_type)> {
        public:
                HelicalBoundaryConditions(Surface::Lattice::iterator first,
                                                                  Surface::Lattice::size_type size):
                first_(first), size_lattice_(size) 
                { };
                
                Site* operator()(const Site* site_ptr, 
                                                 Interactions::TwoBody::RelativeIndexContainer::value_type offset);
                
        private:
                Surface::Lattice::iterator first_;
                Surface::Lattice::size_type size_lattice_;
        };
        
} // namespace Surface


#include <ostream>
inline std::ostream& 
operator<< (std::ostream& os, const Surface::Lattice& lattice) {
        for (Surface::Lattice::const_iterator iter = lattice.begin(),
                 last = lattice.end(); iter != last; ++iter) 
        { os << **iter << "\n"; }
        return os;
}

#endif

---

Project's page