Homec4science
Diffusion lammps (lammps-icms) Browse

lammps/lib/atc/SchrodingerSolver.h
db1e17197fcflammps-icms

Last Change
Raw File

SchrodingerSolver.h
View Options

#ifndef SCHRODINGER_SOLVER_H
#define SCHRODINGER_SOLVER_H
// ATC includes
#include "Array2D.h"
#include "LinearSolver.h"
// other includes
#include <vector>
#include <map>
#include <set>
namespace ATC {
// Forward class declarations
class ATC_Coupling;
class FE_Engine;
class PrescribedDataManager;
class PhysicsModel;
class PoissonSolver;
/**
* @class SchrodingerSolver
* @brief a class to solve the (time-independent) Schrodinger equation
*/
class SchrodingerSolver {
public:
/** Constructor */
SchrodingerSolver(
const FieldName fieldName,
const PhysicsModel * physicsModel,
const FE_Engine * feEngine,
const PrescribedDataManager * prescribedDataMgr,
/*const*/ ATC_Coupling * atc,
bool parallel = true
);
/** Destructor */
virtual ~SchrodingerSolver(){};
/** parser */
bool modify(int narg, char **arg){ return false;}
/** initialize */
void initialize(void);
/** solve */
virtual bool solve(FIELDS & fields);
protected:
/** Pointer to ATC */
ATC_Coupling * atc_;
/** Pointer to FE_Engine */
const FE_Engine * feEngine_;
/** Pointer to PrescribedDataManager */
const PrescribedDataManager * prescribedDataMgr_;
/** Pointer to FE_Engine */
const PhysicsModel * physicsModel_;
/** field to solve for */
FieldName fieldName_;
/** number of nodes */
int nNodes_;
/** mass matrix */
DENS_MAT M_;
bool parallel_;
};
/**
* @class SchrodingerSolver
* @brief a class to solve the Schrodinger equation on slices
*/
class SliceSchrodingerSolver : public SchrodingerSolver {
public:
/** Constructor */
SliceSchrodingerSolver(
const FieldName fieldName,
const PhysicsModel * physicsModel,
const FE_Engine * feEngine,
const PrescribedDataManager * prescribedDataMgr,
/*const*/ ATC_Coupling * atc,
const Array< std::set<int> > & oneDslices,
const Array< double > & oneDdxs,
bool parallel = true
);
/** Destructor */
virtual ~SliceSchrodingerSolver(){};
/** parser */
bool modify(int narg, char **arg){return false;}
/** initialize */
void initialize(void);
/** solve */
virtual bool solve(FIELDS & fields);
Array< std::set<int> > & slices(void){ return oneDslices_;}
Array< double > & dxs(void){ return oneDdxs_;}
protected:
Array< std::set<int> > oneDslices_;
Array< double > oneDdxs_;
};
/**
* @class SchrodingerSolver
* @brief a class to solve the Schrodinger-Poisson system
*/
class SchrodingerPoissonSolver {
public:
SchrodingerPoissonSolver(
/*const*/ ATC_Coupling * atc,
SchrodingerSolver * schrodingerSolver,
PoissonSolver * poissonSolver,
const PhysicsModel * physicsModel,
int maxConsistencyIter
);
virtual ~SchrodingerPoissonSolver(void){};
virtual void solve(
FIELDS & rhs,
GRAD_FIELD_MATS & fluxes
);
protected:
ATC_Coupling * atc_;
SchrodingerSolver * schrodingerSolver_;
PoissonSolver * poissonSolver_;
const PhysicsModel * physicsModel_;
int maxConsistencyIter_;
int maxConstraintIter_;
int nNodes_;
double Ef0_;
double Ef_shift_;
double safe_dEf_;
double tol_;
};
/**
* @class SchrodingerSolver
* @brief a class to solve the Schrodinger-Poisson system on slices
*/
class SliceSchrodingerPoissonSolver : public SchrodingerPoissonSolver {
public:
SliceSchrodingerPoissonSolver(
/*const*/ ATC_Coupling * atc,
SchrodingerSolver * schrodingerSolver,
PoissonSolver * poissonSolver,
const PhysicsModel * physicsModel,
int maxConsistencyIter,
int maxConstraintIter,
int oneDconserve,
double Ef_shift,
double safe_dEf
);
virtual ~SliceSchrodingerPoissonSolver(void){};
virtual void solve(
FIELDS & rhs,
GRAD_FIELD_MATS & fluxes
);
protected:
int nslices_;
double update_fermi_energy(double target, bool first,
GRAD_FIELD_MATS & fluxes);
int oneDconserve_;
int oneDcoor_;
Array< std::set<int> > & oneDslices_;
Array< double > & oneDdxs_;
Array2D<double> EfHistory_;
};
/**
* @class SchrodingerSolver
* @brief a class to solve the Schrodinger-Poisson system on slices
*/
class GlobalSliceSchrodingerPoissonSolver : public SliceSchrodingerPoissonSolver {
public:
GlobalSliceSchrodingerPoissonSolver(
/*const*/ ATC_Coupling * atc,
SchrodingerSolver * schrodingerSolver,
PoissonSolver * poissonSolver,
const PhysicsModel * physicsModel,
int maxConsistencyIter,
int maxConstraintIter,
int oneDconserve,
double Ef0,
double alpha,
double safe_dEf,
double tol,
double mu, double D
);
virtual ~GlobalSliceSchrodingerPoissonSolver(void);
virtual void solve(
FIELDS & rhs,
GRAD_FIELD_MATS & fluxes
);
protected:
void compute_flux(const DENS_MAT & n, const DENS_MAT & phi);
void update_fermi_level();
void report(int i);
void exponential_electron_density();
class LinearSolver * solver_;
double alpha_;
int sliceSize_, nNodes_, nfreeSlices_, nfixed_, nLambda_;
SPAR_MAT K_;
SPAR_MAT G_,G2_; // 1D & 2D grad mats = int N gradN dv
DENS_VEC J_;
DENS_VEC flux_;
DENS_VEC dJ_;
DENS_VEC lambda_;
DENS_VEC F_;
DENS_VEC Phi_;
DENS_VEC n_;
Array2D <bool> rhsMask_;
double mobility_;
double diffusivity_;
double norm_, norm0_;
};
/**
* @class SchrodingerSolver
* @brief a manager class
*/
class SchrodingerPoissonManager {
public:
SchrodingerPoissonManager();
~SchrodingerPoissonManager(){};
/** parser */
bool modify(int narg, char **arg);
/** initialize */
SchrodingerPoissonSolver * initialize(
/*const*/ ATC_Coupling * atc,
SchrodingerSolver * schrodingerSolver,
PoissonSolver * poissonSolver,
const PhysicsModel * physicsModel
);
protected:
int maxConsistencyIter_;
int maxConstraintIter_;
bool oneD_;
int oneDconserve_;
double Ef_shift_;
double safe_dEf_;
double alpha_;
double tol_;
double mu_, D_;
};
} // namespace ATC
#endif
c4science · Help