event_list.h

Go to the documentation of this file.

/*----------------------------------------------------------------------------------------
PAPRECA hybrid off-lattice kinetic Monte Carlo/Molecular dynamics simulator.
Copyright (C) 2024 Stavros Ntioudis, James P. Ewen, Daniele Dini, and C. Heath Turner
 
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 EVENT_LIST_H
#define EVENT_LIST_H
 
//system headers
#include <utility>
#include <unordered_map>
#include <string>
#include <vector>
#include <unordered_set>
#include <unordered_map>
#include <mpi.h>
 
//LAMMPS Headers
#include "lammps.h"
#include "atom.h"
#include "pointers.h"
#include "molecule.h"
 
//kMC Headers
#include "utilities.h"
 
 
namespace PAPRECA{
 
    class PredefinedReaction{
        
        
        public:
            //Constructors/Destructors. The user can use the first constructor if no catalyzing_type(s) are defined. We know that a reaction is NOT catalyzed if the catalyzing_types vector is empty.
            PredefinedReaction( const int &atom1_type_in , const int &atom2_type_in , const int &bond_type_in , const double &rate_in  );
            PredefinedReaction( const int &atom1_type_in , const int &atom2_type_in , const int &bond_type_in , const double &rate_in , const std::vector< int > &catalyzing_types_in );
            ~PredefinedReaction( );
            
            //Functions
            const int &getAtom1Type( ) const;
            const int &getAtom2Type( ) const;
            const int &getBondType( ) const;
            void setLengthEquil( const double &length_equil_in );
            const double &getLengthEquil( ) const;
            void setLimitLowSqr( const double &limit_low_sqr_in );
            const double &getLimitLowSqr( ) const;
            void setLimitHighSqr( const double &limit_high_sqr_in );
            const double &getLimitHighSqr( ) const;
            void setSqrLimits( const double &length_equil_in , const double &length_perc_in );
            const double &getRate( ) const;
            const std::vector< int > &getCatalyzingTypes( ) const;
            const bool &isForm( ) const;
        
        protected:
            int atom1_type = -1;
            int atom2_type = -2;
            int bond_type = -3;
            double length_equil = 0.0; //Optional:  Equilibrium bond length
            double limit_low_sqr = 0.0; //Optional: Acceptable event only if bond length>= length_limit
            double limit_high_sqr = 0.0;
            double rate = 0.0;
            std::vector< int > catalyzing_types; 
            bool is_form = false; 
            
            
    };
    
    class PredefinedBondForm : public PredefinedReaction{
    
        
        public:
            //Constructors/Destructors
            PredefinedBondForm( const int &atom1_type_in , const int &atom2_type_in , const int &bond_type_in , const double &rate_in , const double &bond_dist_sqr_in , const int &delete_atoms_in , const int &lone_candidates_in , const bool &same_mol_in );
            PredefinedBondForm( const int &atom1_type_in , const int &atom2_type_in , const int &bond_type_in , const double &rate_in , const double &bond_dist_sqr_in , const int &delete_atoms_in , const int &lone_candidates_in , const bool &same_mol_in , const std::vector< int > &catalyzing_types_in );
            ~PredefinedBondForm( );
            
            //Functions
            const double &getBondDistSqr( ) const;
            const bool &isSameMol( ) const; 
            const int &isDeleteAtoms( ) const;
            const int &isLone( ) const;
            
        protected:
            double bond_dist_sqr = 0.0; 
            bool same_mol = false; 
            int delete_atoms = 0;  
            int lone_candidates = 0; 
    };
 
 
    class PredefinedDiffusionHop{
        
        
        public:
            //Constructor/Destructors
            PredefinedDiffusionHop( const int &parent_type_in , const double &insertion_vel_in , const double &diffusion_dist_in , const double &rate_in , const std::string &custom_style_in , const std::vector< int > &style_atomtypes_in ); //Initializing a PredefinedDiffusionHop object without a diffused type immediately sets the diffusion type to displacive (i.e., the parent atom moves).
            PredefinedDiffusionHop( const int &parent_type_in , const double &insertion_vel_in , const double &diffusion_dist_in , const double &rate_in , const std::string &custom_style_in , const std::vector< int > &style_atomtypes_in , const int &diffused_type_in , const bool &is_displacive_in ); //This constructor gives the freedom to set diffused type as well as type of diffusion hop (i.e., displacive==parent atom moves, non-displacive==new atom spawns on vacant site).
            ~PredefinedDiffusionHop( );
            
            //Functions
            const int &getParentAtomType( ) const;
            const double &getInsertionVel( ) const;
            const int &getDiffusedAtomType( ) const;
            const bool &isDisplacive( ) const; 
            const double &getDiffusionDist( ) const;
            const double &getRate( ) const;
            const std::string &getCustomStyle( ) const;
            const std::vector< int > &getStyleAtomTypes( ) const;
            
        private:
            int parent_type = -1; 
            double insertion_vel = 0.0; 
            int diffused_type = -2; 
            bool is_displacive = false; //You can have displacive diffusion and the parent type being different from the diffused type, if you want the atom type to change when it moves.
            double diffusion_dist = 0.0; 
            std::string custom_style = "NONE"; 
            std::vector< int > style_atomtypes; 
            double rate = 0.0;
    
    };
    
    class PredefinedDeposition{
        
        public:
            //Constructor/Destructor
            PredefinedDeposition( LAMMPS_NS::LAMMPS *lmp , const int &parent_type_in , const double &rate_in , const double &depo_offset_in , const double &insertion_vel_in , const std::string &adsorbate_name_in );
            PredefinedDeposition( LAMMPS_NS::LAMMPS *lmp , const int &parent_type_in , const double &rate_in , const double &depo_offset_in , const double &insertion_vel_in , const std::string &adsorbate_name_in , const double &sticking_coeff_in );
            ~PredefinedDeposition( );
            
            //Functions
            const int &getParentType( ) const;
            const double &getRate( ) const;
            const double &getDepoOffset( ) const;
            const double &getInsertionVel( ) const;
            const bool &hasVariableStickingCoeff( ) const;
            const double &getStickingCoeff( ) const;
            void setStickingCoeff( const double &sticking_coeff_in );
            void incrementDepositionTries( );
            const int &getDepositionTries( ) const;
            void resetDepositionTries( );
            void incrementDepositionSites( );
            const int &getDepositionSites( ) const;
            void resetDepositionSites( );
            void resetDepositionTriesAndSites( );
            const std::string &getAdsorbateName( ) const;
            const int &getAtomsNum( ) const;
            int *getAtomTypes( );
            double *getCenter( ) ;
            double **getCoords( );
            
        
        private:
            int parent_type = -1; 
            double rate = 0.0;
            double depo_offset = 0.0; 
            double insertion_vel = 0.0; 
            bool variable_sticking = true; 
            int deposition_tries = 0; 
            int deposition_sites = 0; 
            double sticking_coeff = -1.0; 
            std::string adsorbate_name = "NONE"; 
            
            //Lammps template definitions
            int atoms_num = 0; 
            int *atom_types = NULL; 
            double *center = NULL; //< Template molecule center coordinates array from lammps. This is a pointer to a double[3] array (defined in the LAMMPS header molecule.h).
            double **coords = NULL; 
    
    
    };
    
    class PredefinedMonoatomicDesorption{
        
        public:
            //Constructors/Destructors
            PredefinedMonoatomicDesorption( const int &parent_type_in , const double &rate_in );
            ~PredefinedMonoatomicDesorption( );
            
            //Functions
            const int &getParentAtomType( ) const;
            const double &getRate( ) const;
            
            private:
                int parent_type = -1;
                double rate = 0.0;
                
    };
    
    //Typedefs
    typedef std::unordered_map< int , PredefinedReaction* > TYPE2REACTION_MAP;
    typedef std::unordered_map< INT_PAIR , PredefinedBondForm* , PairHash > PAIR2BONDFORM_MAP;
                         
    typedef std::unordered_map< int , PredefinedDiffusionHop* > TYPE2DIFFUSION_MAP;
    typedef std::unordered_map< int , PredefinedDeposition* > TYPE2DEPOSITION_MAP;
    typedef std::unordered_map< int , PredefinedMonoatomicDesorption* > TYPE2MONODES_MAP;
    
    
    class PredefinedEventsCatalog{
        
            
        private:
        
            friend class PaprecaConfig; //PaprecaConfig is a friend class as it accesses some of those private members to return predefined events to the main function.
        
            //Functions used by the destructor
            void deletePredefinedDepositionsFromMap( );
            void deletePredefinedDiffusionsFromMap( );
            void deletePredefinedBondFormsFromMap( );
            void clearBondsMaxMap( );
            void deletePredefinedBondBreaksFromMap( );
            void deletePredefinedMonoatomicDesorptionsFromMap( );
            
            //Constructors/Destructors
            PredefinedEventsCatalog( );
            ~PredefinedEventsCatalog( );
            
            //PredefinedReactions
            INT_SET bond_breaks_set; 
            TYPE2REACTION_MAP bond_breaks_map; 
            
            //Predefined bond forms
            PAIR_SET bond_forms_set; 
            PAIR2BONDFORM_MAP bond_forms_map; 
            INT2INT_MAP bonds_max; 
            INT2INTSMAP_MAP bondtypes_max; 
            
            //Predefined diffusions
            INT_SET diffusions_set; 
            TYPE2DIFFUSION_MAP diffusions_map; 
            
            
            //Predefined depositions
            INT_SET depositions_set; 
            TYPE2DEPOSITION_MAP depositions_map; 
            
            //Predefined Monoatomic Desorptions
            INT_SET monodes_set; 
            TYPE2MONODES_MAP monodes_map; 
            
    
    };
    
    
}//end of namespace PAPRECA
 
 
#endif