Frm.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 FRM_HPP
#define FRM_HPP

#include <set>
#include <vector>
#include <map>
#include <utility> // pair
#include <ostream>
#include <tr1/functional> // std::tr1::function
#include "Lattice.hpp"
#include "Reaction.hpp"

namespace Algorithms {
        
        class Frm {
                
                struct Sort_event_by_time:
                std::tr1::function<bool(Reactions::EventPtr, Reactions::EventPtr)>
                {
                        bool operator()(Reactions::EventPtr lhs, Reactions::EventPtr rhs) const
                        { return lhs->Time() < rhs->Time(); }
                };
                
                typedef std::set<Reactions::EventPtr, Sort_event_by_time> EventsQueue;
                
                typedef std::multimap<Surface::Site*, Reactions::EventPtr> EventsPerSiteContainer;
                
                typedef std::vector<Reactions::Reaction*> ReactionContainer;    
                
        public: 
                typedef std::map<Reactions::Reaction::Name, int> ReactionCounter;
                
                Frm(Surface::Lattice::iterator first, Surface::Lattice::iterator last):
                reaction_container_(), event_queue_(), time_(0.0),
                lattice_beg_(first), lattice_end_(last)
                { }
                
                void Init();
                
                void operator()();
                
                void Clear()
                { events_per_site_container_.clear(); event_queue_.clear(); }           
                

                
                double time() const
                { return time_; }
                
                ReactionCounter reaction_counter()
                { return reaction_counter_; }   
                
                

                
                void set_time(double time)
                { time_ = time; }
                
                void set_reaction_ptr(Reactions::Reaction* reaction)
                { reaction_container_.push_back(reaction); }
                
                
        private:
                Frm(const Frm&);
                void operator=(const Frm&);
                
                Reactions::EventPtr PopEvent() const
                { return *event_queue_.begin(); }
                
                void InsertEvent(Surface::Site*, const Reactions::Reaction* const);
                
                void UpdateQueue(Reactions::EventPtr);
                
                void ReorderQueue(Reactions::EventPtr);
                

                EventsQueue event_queue_;
                ReactionCounter reaction_counter_;      
                ReactionContainer reaction_container_;  
                EventsPerSiteContainer events_per_site_container_;
                
                typedef std::pair<EventsPerSiteContainer::iterator, 
                EventsPerSiteContainer::iterator> EventsRange;
                
                double time_;
                
                Surface::Lattice::iterator lattice_beg_, lattice_end_;
        };
        
} // namespace Algorithms

#endif

---

Project's page