← Back to branch summary

~ubuntu-branches/debian/sid/lammps/sid

« back to all changes in this revision

Viewing changes to lib/atc/SchrodingerSolver.h

  • Committer: Package Import Robot
  • Author(s): Anton Gladky
  • Date: 2013-11-20 22:41:36 UTC
  • mfrom: (1.2.2)
  • Revision ID: package-import@ubuntu.com-20131120224136-tzx7leh606fqnckm
Tags: 0~20131119.git7162cf0-1
* [e65b919] Imported Upstream version 0~20131119.git7162cf0
* [f7bddd4] Fix some problems, introduced by upstream recently.
* [3616dfc] Use wrap-and-sort script.
* [7e92030] Ignore quilt dir

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/atc/SchrodingerSolver.h
 
1
#ifndef SCHRODINGER_SOLVER_H
 
2
#define SCHRODINGER_SOLVER_H
 
3
 
 
4
// ATC includes
 
5
#include "Array2D.h"
 
6
#include "LinearSolver.h"
 
7
 
 
8
// other includes
 
9
#include <vector>
 
10
#include <map>
 
11
#include <set>
 
12
 
 
13
namespace ATC {
 
14
 
 
15
// Forward class declarations
 
16
class ATC_Coupling;
 
17
class FE_Engine;
 
18
class PrescribedDataManager;
 
19
class PhysicsModel;
 
20
class PoissonSolver;
 
21
 
 
22
/**
 
23
 *  @class SchrodingerSolver
 
24
 *  @brief a class to solve the (time-independent) Schrodinger equation 
 
25
 */
 
26
class SchrodingerSolver {
 
27
 
 
28
 public:
 
29
 
 
30
  /** Constructor */
 
31
  SchrodingerSolver(
 
32
    const FieldName fieldName,
 
33
    const PhysicsModel * physicsModel,
 
34
    const FE_Engine * feEngine,
 
35
    const PrescribedDataManager * prescribedDataMgr,
 
36
    /*const*/ ATC_Coupling * atc,
 
37
    const int solverType = ATC::LinearSolver::DIRECT_SOLVE,
 
38
    bool parallel = false
 
39
  );
 
40
 
 
41
  /** Destructor */
 
42
  virtual ~SchrodingerSolver();
 
43
 
 
44
  /** parser */
 
45
  bool modify(int narg, char **arg){ return false;}
 
46
 
 
47
  /** initialize */
 
48
  void initialize(void);
 
49
 
 
50
  /** solve */
 
51
  virtual bool solve(FIELDS & fields); 
 
52
 
 
53
 
 
54
  
 
55
 
 
56
 protected:
 
57
  
 
58
  /** Pointer to ATC */
 
59
  ATC_Coupling * atc_;
 
60
 
 
61
  /** Pointer to FE_Engine */
 
62
  const FE_Engine * feEngine_;
 
63
 
 
64
  /** Pointer to PrescribedDataManager */
 
65
  const PrescribedDataManager * prescribedDataMgr_;
 
66
 
 
67
  /** Pointer to FE_Engine */
 
68
  const PhysicsModel * physicsModel_;
 
69
 
 
70
  /** field to solve for */
 
71
  FieldName fieldName_;
 
72
 
 
73
  /** linear solver */
 
74
  LinearSolver * solver_;
 
75
  int solverType_;
 
76
 
 
77
  /** number of nodes */
 
78
  int nNodes_;
 
79
 
 
80
  /** stiffness matrix */
 
81
 
 
82
  //SPAR_MAT stiffness_;
 
83
 
 
84
  //SPAR_MAT massMatrix_;
 
85
  DENS_MAT M_;
 
86
 
 
87
  bool parallel_;
 
88
 
 
89
};
 
90
 
 
91
class SliceSchrodingerSolver : public SchrodingerSolver {
 
92
 
 
93
 public:
 
94
 
 
95
  /** Constructor */
 
96
  SliceSchrodingerSolver(
 
97
    const FieldName fieldName,
 
98
    const PhysicsModel * physicsModel,
 
99
    const FE_Engine * feEngine,
 
100
    const PrescribedDataManager * prescribedDataMgr,
 
101
    /*const*/ ATC_Coupling * atc,
 
102
    const Array< std::set<int> > & oneDslices,
 
103
    const int solverType = ATC::LinearSolver::DIRECT_SOLVE,
 
104
    bool parallel = false
 
105
  );
 
106
 
 
107
  /** Destructor */
 
108
  virtual ~SliceSchrodingerSolver();
 
109
 
 
110
  /** parser */
 
111
  bool modify(int narg, char **arg){return false;}
 
112
 
 
113
  /** initialize */
 
114
  void initialize(void);
 
115
 
 
116
  /** solve */
 
117
  virtual bool solve(FIELDS & fields); 
 
118
 
 
119
  Array< std::set<int> > & slices(void){ return oneDslices_;} 
 
120
 
 
121
 protected:
 
122
 
 
123
  Array< std::set<int> > oneDslices_;
 
124
 
 
125
};
 
126
 
 
127
class SchrodingerPoissonSolver  {
 
128
  public:
 
129
    SchrodingerPoissonSolver(
 
130
      /*const*/ ATC_Coupling * atc,
 
131
      SchrodingerSolver * schrodingerSolver,
 
132
      PoissonSolver * poissonSolver,
 
133
      const PhysicsModel * physicsModel,
 
134
      int maxConsistencyIter
 
135
    );
 
136
    virtual ~SchrodingerPoissonSolver(void);
 
137
    virtual void solve(
 
138
      FIELDS & rhs,
 
139
      GRAD_FIELD_MATS & fluxes
 
140
    );
 
141
  protected:
 
142
    ATC_Coupling * atc_;
 
143
    SchrodingerSolver * schrodingerSolver_;
 
144
    PoissonSolver * poissonSolver_;
 
145
    const PhysicsModel * physicsModel_;
 
146
    int maxConsistencyIter_;
 
147
    int nNodes_;
 
148
};
 
149
 
 
150
class SliceSchrodingerPoissonSolver : public SchrodingerPoissonSolver  {
 
151
  public:
 
152
    SliceSchrodingerPoissonSolver(
 
153
      /*const*/ ATC_Coupling * atc,
 
154
      SchrodingerSolver * schrodingerSolver,
 
155
      PoissonSolver * poissonSolver,
 
156
      const PhysicsModel * physicsModel,
 
157
      int maxConsistencyIter,
 
158
      int maxConstraintIter,
 
159
      int oneDconserve,
 
160
      double Ef_shift,
 
161
      double safe_dEf
 
162
    );
 
163
    virtual ~SliceSchrodingerPoissonSolver(void);
 
164
    virtual void solve(
 
165
      FIELDS & rhs,
 
166
      GRAD_FIELD_MATS & fluxes
 
167
    );
 
168
  protected:
 
169
    double update_fermi_energy(double target, bool first, 
 
170
      GRAD_FIELD_MATS & fluxes);
 
171
    int maxConstraintIter_;
 
172
    int oneDconserve_;
 
173
    int oneDcoor_;
 
174
    double Ef_shift_;
 
175
    double safe_dEf_;
 
176
    Array< std::set<int> > & oneDslices_;
 
177
    Array2D<double> EfHistory_;
 
178
};
 
179
 
 
180
class SchrodingerPoissonManager  {
 
181
  public:
 
182
    SchrodingerPoissonManager();
 
183
    ~SchrodingerPoissonManager();
 
184
 
 
185
    /** parser */
 
186
    bool modify(int narg, char **arg);
 
187
 
 
188
    /** initialize */
 
189
    SchrodingerPoissonSolver * initialize(   
 
190
      /*const*/ ATC_Coupling * atc,
 
191
      SchrodingerSolver * schrodingerSolver,
 
192
      PoissonSolver * poissonSolver,
 
193
      const PhysicsModel * physicsModel
 
194
    );
 
195
  protected:
 
196
    int maxConsistencyIter_;
 
197
    int maxConstraintIter_;
 
198
    bool oneD_;
 
199
    int oneDconserve_;
 
200
    double Ef_shift_;
 
201
    double safe_dEf_;
 
202
};
 
203
} // namespace ATC
 
204
#endif