Diffusion lammps (efficient_neuronet) Browse

fix_qeq_reax_kokkos.h
2993aec312a7efficient_neuronet

fix_qeq_reax_kokkos.h
View Options

			/* -- c++ -- ----------------------------------------------------------
			LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
			http://lammps.sandia.gov, Sandia National Laboratories
			Steve Plimpton, sjplimp@sandia.gov

			Copyright (2003) Sandia Corporation. Under the terms of Contract
			DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
			certain rights in this software. This software is distributed under
			the GNU General Public License.

			See the README file in the top-level LAMMPS directory.
			------------------------------------------------------------------------- */

			#ifdef FIX_CLASS

			FixStyle(qeq/reax/kk,FixQEqReaxKokkos<LMPDeviceType>)
			FixStyle(qeq/reax/kk/device,FixQEqReaxKokkos<LMPDeviceType>)
			FixStyle(qeq/reax/kk/host,FixQEqReaxKokkos<LMPHostType>)

			#else

			#ifndef LMP_FIX_QEQ_REAX_KOKKOS_H
			#define LMP_FIX_QEQ_REAX_KOKKOS_H

			#include "fix_qeq_reax.h"
			#include "kokkos_type.h"
			#include "neigh_list.h"
			#include "neigh_list_kokkos.h"

			namespace LAMMPS_NS {

			struct TagSparseMatvec1 {};
			struct TagSparseMatvec2 {};
			struct TagSparseMatvec3 {};
			struct TagZeroQGhosts{};

			template<class DeviceType>
			class FixQEqReaxKokkos : public FixQEqReax {
			public:
			typedef DeviceType device_type;
			typedef ArrayTypes<DeviceType> AT;
			FixQEqReaxKokkos(class LAMMPS , int, char *);
			~FixQEqReaxKokkos();

			void cleanup_copy();
			void init();
			void setup_pre_force(int);
			void pre_force(int);

			KOKKOS_INLINE_FUNCTION
			void num_neigh_item(int, int&) const;

			KOKKOS_INLINE_FUNCTION
			void zero_item(int) const;

			KOKKOS_INLINE_FUNCTION
			void compute_h_item(int, int &, const bool &) const;

			KOKKOS_INLINE_FUNCTION
			void mat_vec_item(int) const;

			KOKKOS_INLINE_FUNCTION
			void sparse12_item(int) const;

			template<int NEIGHFLAG>
			KOKKOS_INLINE_FUNCTION
			void sparse13_item(int) const;

			KOKKOS_INLINE_FUNCTION
			void sparse22_item(int) const;

			template<int NEIGHFLAG>
			KOKKOS_INLINE_FUNCTION
			void sparse23_item(int) const;

			KOKKOS_INLINE_FUNCTION
			void sparse32_item(int) const;

			template<int NEIGHFLAG>
			KOKKOS_INLINE_FUNCTION
			void sparse33_item(int) const;

			typedef typename Kokkos::TeamPolicy <DeviceType, TagSparseMatvec1> ::member_type membertype1;
			KOKKOS_INLINE_FUNCTION
			void operator() (TagSparseMatvec1, const membertype1 &team) const;

			typedef typename Kokkos::TeamPolicy <DeviceType, TagSparseMatvec2> ::member_type membertype2;
			KOKKOS_INLINE_FUNCTION
			void operator() (TagSparseMatvec2, const membertype2 &team) const;

			typedef typename Kokkos::TeamPolicy <DeviceType, TagSparseMatvec3> ::member_type membertype3;
			KOKKOS_INLINE_FUNCTION
			void operator() (TagSparseMatvec3, const membertype3 &team) const;

			KOKKOS_INLINE_FUNCTION
			void operator()(TagZeroQGhosts, const int&) const;

			KOKKOS_INLINE_FUNCTION
			void vecsum2_item(int) const;

			KOKKOS_INLINE_FUNCTION
			double norm1_item(int) const;

			KOKKOS_INLINE_FUNCTION
			double norm2_item(int) const;

			KOKKOS_INLINE_FUNCTION
			double dot1_item(int) const;

			KOKKOS_INLINE_FUNCTION
			double dot2_item(int) const;

			KOKKOS_INLINE_FUNCTION
			void precon1_item(int) const;

			KOKKOS_INLINE_FUNCTION
			void precon2_item(int) const;

			KOKKOS_INLINE_FUNCTION
			double precon_item(int) const;

			KOKKOS_INLINE_FUNCTION
			double vecacc1_item(int) const;

			KOKKOS_INLINE_FUNCTION
			double vecacc2_item(int) const;

			KOKKOS_INLINE_FUNCTION
			void calculate_q_item(int) const;

			KOKKOS_INLINE_FUNCTION
			double calculate_H_k(const F_FLOAT &r, const F_FLOAT &shld) const;

			struct params_qeq{
			params_qeq(){chi=0;eta=0;gamma=0;};
			params_qeq(int i){chi=0;eta=0;gamma=0;};
			F_FLOAT chi, eta, gamma;
			};

			virtual int pack_forward_comm(int, int , double , int, int *);
			virtual void unpack_forward_comm(int, int, double *);
			int pack_reverse_comm(int, int, double *);
			void unpack_reverse_comm(int, int , double );
			double memory_usage();

			protected:
			int inum;
			int allocated_flag;

			typedef Kokkos::DualView<int***,DeviceType> tdual_int_1d;
			Kokkos::DualView<params_qeq*,Kokkos::LayoutRight,DeviceType> k_params;
			typename Kokkos::DualView<params_qeq*, Kokkos::LayoutRight,DeviceType>::t_dev_const params;

			typename ArrayTypes<DeviceType>::t_x_array x;
			typename ArrayTypes<DeviceType>::t_v_array v;
			typename ArrayTypes<DeviceType>::t_f_array_const f;
			//typename ArrayTypes<DeviceType>::t_float_1d_randomread mass, q;
			typename ArrayTypes<DeviceType>::t_float_1d_randomread mass;
			typename ArrayTypes<DeviceType>::t_float_1d q;
			typename ArrayTypes<DeviceType>::t_int_1d type, tag, mask;

			DAT::tdual_float_1d k_q;
			typename AT::t_float_1d d_q;
			HAT::t_float_1d h_q;

			typename ArrayTypes<DeviceType>::t_neighbors_2d d_neighbors;
			typename ArrayTypes<DeviceType>::t_int_1d_randomread d_ilist, d_numneigh;

			DAT::tdual_ffloat_1d k_tap;
			typename AT::t_ffloat_1d d_tap;

			typename AT::t_int_1d d_firstnbr;
			typename AT::t_int_1d d_numnbrs;
			typename AT::t_int_1d d_jlist;
			typename AT::t_ffloat_1d d_val;

			DAT::tdual_ffloat_1d k_t, k_s;
			typename AT::t_ffloat_1d d_Hdia_inv, d_b_s, d_b_t, d_t, d_s;
			HAT::t_ffloat_1d h_t, h_s;
			typename AT::t_ffloat_1d_randomread r_b_s, r_b_t, r_t, r_s;

			DAT::tdual_ffloat_1d k_o, k_d;
			typename AT::t_ffloat_1d d_p, d_o, d_r, d_d;
			HAT::t_ffloat_1d h_o, h_d;
			typename AT::t_ffloat_1d_randomread r_p, r_o, r_r, r_d;

			DAT::tdual_ffloat_2d k_shield, k_s_hist, k_t_hist;
			typename AT::t_ffloat_2d d_shield, d_s_hist, d_t_hist;
			HAT::t_ffloat_2d h_s_hist, h_t_hist;
			typename AT::t_ffloat_2d_randomread r_s_hist, r_t_hist;

			void init_shielding_k();
			void init_hist();
			void allocate_matrix();
			void allocate_array();
			void cg_solve1();
			void cg_solve2();
			void calculate_q();

			int neighflag, pack_flag;
			int nlocal,nall,nmax,newton_pair;
			int count, isuccess;
			double alpha, beta, delta, cutsq;

			int iswap;
			int first;
			typename AT::t_int_2d d_sendlist;
			typename AT::t_xfloat_1d_um v_buf;

			};

			template <class DeviceType>
			struct FixQEqReaxKokkosNumNeighFunctor {
			typedef DeviceType device_type ;
			typedef int value_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosNumNeighFunctor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii, int &maxneigh) const {
			c.num_neigh_item(ii, maxneigh);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosMatVecFunctor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosMatVecFunctor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.mat_vec_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosComputeHFunctor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosComputeHFunctor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii, int &m_fill, const bool &final) const {
			c.compute_h_item(ii,m_fill,final);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosZeroFunctor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosZeroFunctor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.zero_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosSparse12Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosSparse12Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.sparse12_item(ii);
			}
			};

			template <class DeviceType,int NEIGHFLAG>
			struct FixQEqReaxKokkosSparse13Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosSparse13Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.template sparse13_item<NEIGHFLAG>(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosSparse22Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosSparse22Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.sparse22_item(ii);
			}
			};

			template <class DeviceType,int NEIGHFLAG>
			struct FixQEqReaxKokkosSparse23Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosSparse23Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.template sparse23_item<NEIGHFLAG>(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosSparse32Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosSparse32Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.sparse32_item(ii);
			}
			};

			template <class DeviceType,int NEIGHFLAG>
			struct FixQEqReaxKokkosSparse33Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosSparse33Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.template sparse33_item<NEIGHFLAG>(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosVecSum2Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosVecSum2Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.vecsum2_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosNorm1Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			typedef double value_type;
			FixQEqReaxKokkosNorm1Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii, value_type &tmp) const {
			tmp += c.norm1_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosNorm2Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			typedef double value_type;
			FixQEqReaxKokkosNorm2Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii, value_type &tmp) const {
			tmp += c.norm2_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosDot1Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			typedef double value_type;
			FixQEqReaxKokkosDot1Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii, value_type &tmp) const {
			tmp += c.dot1_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosDot2Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			typedef double value_type;
			FixQEqReaxKokkosDot2Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii, value_type &tmp) const {
			tmp += c.dot2_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosPrecon1Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosPrecon1Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.precon1_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosPrecon2Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosPrecon2Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.precon2_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosPreconFunctor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			typedef double value_type;
			FixQEqReaxKokkosPreconFunctor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii, value_type &tmp) const {
			tmp += c.precon_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosVecAcc1Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			typedef double value_type;
			FixQEqReaxKokkosVecAcc1Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii, value_type &tmp) const {
			tmp += c.vecacc1_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosVecAcc2Functor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			typedef double value_type;
			FixQEqReaxKokkosVecAcc2Functor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii, value_type &tmp) const {
			tmp += c.vecacc2_item(ii);
			}
			};

			template <class DeviceType>
			struct FixQEqReaxKokkosCalculateQFunctor {
			typedef DeviceType device_type ;
			FixQEqReaxKokkos<DeviceType> c;
			FixQEqReaxKokkosCalculateQFunctor(FixQEqReaxKokkos<DeviceType>* c_ptr):c(*c_ptr) {
			c.cleanup_copy();
			};
			KOKKOS_INLINE_FUNCTION
			void operator()(const int ii) const {
			c.calculate_q_item(ii);
			}
			};

			}

			#endif
			#endif

lammps/src/KOKKOS/fix_qeq_reax_kokkos.h2993aec312a7efficient_neuronet

fix_qeq_reax_kokkos.hView Options

lammps/src/KOKKOS/fix_qeq_reax_kokkos.h
2993aec312a7efficient_neuronet

fix_qeq_reax_kokkos.h
View Options