papreca_config.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 PAPRECA_CONFIG_H
#define PAPRECA_CONFIG_H
 
//LAMMPS Headers
#include "lammps.h"
#include "library.h"
#include "random_mars.h"
 
 
//System Headers
#include <mpi.h>
#include <limits>
#include <fstream>
#include <iostream>
 
 
//kMC Headers
#include "event_list.h"
#include "lammps_wrappers.h"
#include "utilities.h"
#include "export_files.h"
 
namespace PAPRECA{
    
    /*This function stores variables that are necessary for the PAPRECA run.
    You can consider this class as a container storing the simulation settings and global variables.
    Most variables in this class are initialized by the PAPRECA input file.*/
    
    class PaprecaConfig{
        
        public:
        
            //Constructors/Destructors
            PaprecaConfig( );
            ~PaprecaConfig( );
            
            //Essential parameters
            void setKMCsteps( const unsigned long int &KMC_steps_in );
            const unsigned long int &getKMCsteps( ) const;
            void setKMCperMD( const unsigned long int &KMC_per_MD_in );
            const unsigned long int &getKMCperMD( ) const;
            void setTimeEnd( const double &time_end_in );
            const double &getTimeEnd( );
            
            //Random numbers
            void initRanNumGenerator( LAMMPS_NS::LAMMPS *lmp , const int &seed );
            const double getUniformRanNum( ) const;
            const bool ranNumGeneratorIsInitialized( ) const;
            
            //Atom groups
            void setFluidAtomTypes( const std::vector< int > &fluid_atomtypes_in );
            const std::vector< int > &getFluidAtomTypes( ) const;
            void setFrozenAtomTypes( const std::vector< int > &frozen_atomtypes_in );
            const std::vector< int > &getFrozenAtomTypes( ) const;
            
            //Predefined events
            PredefinedReaction *getReactionFromBondType( const int &bond_type );
            PredefinedBondForm *getBondFormFromAtomTypesPair( const INT_PAIR &types_pair );
            int getMaxBondsFromSpecies( const int &atom_type );
            int getMaxBondTypesOfSpecies( const int &atom_type , const int &bond_type );
            PredefinedDiffusionHop *getDiffusionHopFromAtomType( const int &atom_type );
            PredefinedDeposition *getDepositionFromParentAtomType( const int &atom_type );
            PredefinedMonoatomicDesorption *getMonoatomicDesorptionFromAtomType( const int &atom_type );
            void initPredefinedReaction( const int &atom1_type , const int &atom2_type , const int &bond_type , const double &rate , const std::vector< int > &catalyzing_types , const double &length_equil , const double &length_limit );
            void initPredefinedBondForm( const int &atom1_type , const int &atom2_type , const int &bond_type , const double &bond_dist , const int &delete_atoms , const int &lone_candidates , const bool &same_mol , const double &rate , const std::vector< int > &catalyzing_types , const double &length_equil , const double &length_perc );
            void initPredefinedDiffusionHop( const int &parent_type , const double &insertion_vel , const double &diff_dist , const bool &is_displacive , const int &diffused_type , const double &rate , const std::string &custom_style , const std::vector< int > &custom_atomtypes );
            void initPredefinedDeposition( LAMMPS_NS::LAMMPS *lmp , const int &parent_type , const double &depo_offset , const double &insertion_vel , const std::string &adsorbate_name , const double &rate , const bool &variable_sticking , const double &sticking_coeff );
            void initPredefinedMonoatomicDesorption( const int &parent_type , const double &rate );
            void setSpeciesMaxBonds( const int &species , const int &bonds_max );
            void setSpeciesMaxBondTypes( const int &species , const int &bond_type , const int &bonds_max );
            void calcStickingCoeffs( );
            const bool predefinedCatalogHasBondBreakEvents( ) const;
            const bool predefinedCatalogHasBondFormEvents( ) const;
            const bool predefinedCatalogHasDiffusionHopEvents( ) const;
            const bool predefinedCatalogHasDepositionEvents( ) const;
            const bool predefinedCatalogHasMonoDesEvents( ) const;
            const bool predefinedCatalogIsEmpty( ) const;
            
            //Random Deposition and Diffusion Vectors
            void setRandomDepoVecs( const bool &random_depovecs_in );
            const bool &depoVecsAreRandom( ) const;
            void setRandomDiffVecs( const bool &random_diffvecs_in );
            const bool &diffVecsAreRandom( ) const;
            void setRandomDiffVecsStyle( const std::string &diffvecs_style_in );
            const std::string &getRandomDiffVecsStyle( ) const;
 
            
            //Deposition height settings
            void setDepoHeights( const double &height_deposcan_in , const double &height_deporeject_in );
            const double &getHeightDepoScan( ) const;
            const double &getHeightDepoReject( ) const;
            
            //Desorption settings
            void setDesorptionHeight( const double &desorb_cut_in );
            const double &getDesorptionHeight( ) const;
            void setDesorbDelMax( const int &desorb_delmax_in );
            const int &getDesorbDelMax( ) const;
            void setDesorptionStyle( const std::string &desorb_style_in );
            const std::string &getDesorptionStyle( ) const;
            
            //Film height calculation settings
            void setHeightMethod( const std::string &height_method_in );
            const std::string &getHeightMethod( ) const;
            void setHeightPercentage( const double &height_percentage_in ); //Only for method mass_bins!
            const double &getHeightPercentage( ) const; //Only for film height percentage method!
            void setBinWidth( const double &bin_width_in );
            const double &getBinWidth( ) const;
            
            //type2sigma
            void initSigmasFromLammps( LAMMPS_NS::LAMMPS *lmp );
            void setSpeciesPair2Sigma( const int &species1 , const int &species2 , const double &sigma );
            void setSigmaStyle( const std::string &sigmastyle_in );
            const std::string &getSigmaStyle( )const;
            void setSigmaMix( const std::string &mixstyle_in );
            const std::string &getSigmaMixStyle( )const;
            void mixSigmas( LAMMPS_NS::LAMMPS *lmp );
            const double getSigmaFromAtomTypes( const int &atom1_type , const int &atom2_type );
            const bool type2SigmaMapIsEmpty( ) const;
            
            //Equilibration LAMMPS
            void setMinimize1( const std::string &minimize1_in );
            const std::string &getMinimize1( ) const;
            void setMinimize2( const std::string &minimize2_in );
            const std::string &getMinimize2( ) const;
            void setTrajDuration( const int &traj_duration_in );
            const int &getTrajDuration( ) const;
            void setCtimeConvert( const double &c_convert_in );
            const double &getCtimeConvert( );
            
            //Neighbor lists
            void setNeibLists( const std::string &neiblist_half_in , const std::string &neiblist_full_in );
            const std::string &getHalfNeibListName( ) const;
            const std::string &getFullNeibListName( ) const;
            
            //Output files
            Log &getLogFile( );
            HeightVtime &getHeightVtimeFile( );
            SurfaceCoverage &getSurfaceCoverageFile( );
            void calcSurfaceCoverage( );
            ElementalDistribution &getElementalDistributionsFile( );
            ExecTime &getExecTimeFile( );
            void setupExportFiles( const int &proc_id );
            void setHybridStartTimeStamp4ExecTimeFile( const int &KMC_loopid );
            void calcHybridAndKMCTimes4ExecTimeFile( const int &nprocs , const int &KMC_loopid );
            void setMDTimeStamp4ExecTimeFile( const int &KMC_loopid );
            void calcMDTime4ExecTimeFile( const int &nprocs , const int &KMC_loopid );
            void appendExportFiles( LAMMPS_NS::LAMMPS *lmp , const int &proc_id , const double &time , const char *event_type , const double &film_height , const int &KMC_loopid );
            void dumpElementalDistributionFile( LAMMPS_NS::LAMMPS *lmp , const int &proc_id , const int &KMC_loopid , double **mass_profiles_total , double *atom_mass , const int &bins_num , const int &types_num );
            void closeExportFiles( const int &proc_id );
            void setRestartDumpFreq( const int &restart_dumpfreq_in );
            const int &getRestartDumpFreq( )const;
            void dumpLAMMPSRestart( LAMMPS_NS::LAMMPS *lmp , const int KMC_loopid );
            
        protected:
        
        
            //Random number generator.
            LAMMPS_NS::RanMars *rnum_gen = NULL; 
            
            //Essential parameters
            unsigned long int KMC_steps = 0; 
            unsigned long int KMC_per_MD = 0; 
            double time_end = std::numeric_limits< double >::max( ); 
            
            //Atom groups
            std::vector< int > fluid_atomtypes; 
            std::vector< int > frozen_atomtypes; 
            
            //Predefined events
            PredefinedEventsCatalog predefined_catalog; 
            bool random_depovecs = false; 
            bool random_diffvecs = false; 
            std::string diffvecs_style = "3D"; 
            double height_deposcan = -1;  
            double height_deporeject = -1; 
            
            //Desorption settings. For thin-film growth you might wanna delete atoms flying above a certain height, after the equilibration step.
            double desorb_cut = -1; 
            int desorb_delmax = std::numeric_limits< int >::max( ); 
            std::string desorb_style = "";  
            
            //Film Height Calculation Settings
            std::string height_method = ""; 
            double height_percentage = 0.0; 
            double bin_width = 1.0; 
            
            //Map that returns the sigma distance (i.e., equilibrium distance of species as in the LJ potential). Currently initialized from the LAMMPS input.
            INTPAIR2DOUBLE_MAP type2sigma; 
            std::string sigma_style = ""; 
            std::string sigma_mix =""; //< Two types of sigma_mix are currently supported: geom/arithm. See: https://docs.lammps.org/pair_modify.html. This variable is initialized as NONE so we know there is no mixing even when the mix keyword is not used.
            
            //Equilibrations - LAMMPS
            //The user can pass valid LAMMPS commands to minimize the configuration before the LAMMPS trajectory (minimize1) and after (minimize2)
            std::string minimize1 = ""; 
            std::string minimize2 = ""; 
            int traj_duration = 0; 
            double c_time_convert = -1; 
            
            //Neighbor lists
            std::string neiblist_half = ""; 
            std::string neiblist_full = ""; 
            
            //Output files
            Log log_file; 
            HeightVtime heightVtime_file; 
            SurfaceCoverage surfcoverage_file; 
            double surface_coverage = 0.0; 
            ElementalDistribution elementalDistribution_files; 
            ExecTime execTime_file; 
            int restart_dumpfreq = std::numeric_limits< int >::max( ); 
            
    };
            
    
}//end of namespace PAPRECA
 
 
#endif