PLaSK library

Loading...
Searching...
No Matches
kublybr.h
Go to the documentation of this file.
1#if(defined(_MSC_VER) && _MSC_VER < 1600) // RPSMES wymaga Visuala 6 (sprawdzamy < VS2010)
2#define RPSMES
3#elif(!defined(PLASK))
4#define MICHAL
5#endif
6
7#include "gsl/gsl_sf_airy.h"
8#include "gsl/gsl_sf_fermi_dirac.h"
9#include "jama/jama_lu.h"
10#include "jama/jama_svd.h"
11#include "tnt/tnt.h"
12
13#include <cmath>
14#include <complex>
15#include <fstream>
16#include <iomanip>
17#include <list>
18#include <set>
19#include <sstream>
20
21#include <sstream>
22#include <string>
23#include <vector>
24
25#ifdef MICHAL
26#include <boost/lexical_cast.hpp>
27#include <boost/regex.hpp>
28#endif
29
30#if(defined(MICHAL) || defined(_DEBUG))
31#define LOGUJ
32#endif
33
34 namespace kubly
35{
36
37/*******************************************************************/
38// MD: Nie bedziemy drukowac bledow na ekranie i przerywac programu,
39// MD: ale bedziemy wyrzucac poprawny wyjatek (GCC wydrukuje komunikat)
40 class Error : public std::exception
41{
42 std::ostringstream oss;
43 mutable std::string _msg;
44
45 public:
46 Error() {}
47 Error(const char * msg) { oss << msg; }
48 Error(const Error & orig) { oss << orig.oss.str(); }
49 template <typename T> Error & operator<<(T arg)
50 {
51 oss << arg;
52 return *this;
53 }
54 virtual const char * what() const throw()
55 {
56 _msg = oss.str();
57 return _msg.c_str();
58 }
59 virtual ~Error() throw() {}
60};
61
62/*******************************************************************/
63 typedef TNT::Array2D<double> A2D;
64 typedef TNT::Array1D<double> A1D;
65
66 typedef std::pair<double, double> parad;
67
68 bool jaksortpar(parad a, parad b);
69
70/*******************************************************************/
71 class warstwa
72{
73 friend class struktura;
74 friend class obszar_aktywny;
75 friend class wzmocnienie;
76 // friend void zrobmacierz(double, std::vector<warstwa> &, A2D & );
77
78 double x_pocz;
79 double x_kon;
80 double y_pocz;
81 double y_kon;
82 double pole; // ladunek razy pole
83 double nieparab; // alfa nieparabolicznosci
84 double nieparab_2; // alfa nieparabolicznosci kwadratowa
85 double m_p; // masa prostopadla
86 int zera_ffal(double E, double A, double B, double sasiadl, double sasiadp) const;
87 int zera_ffal(double E, double A, double B) const;
88 double norma_kwadr(double E, double A, double B) const;
89 double tryg_kwadr_pierwotna(double x, double E, double A, double B) const;
90 double exp_kwadr_pierwotna(double x, double E, double A, double B) const;
91 double airy_kwadr_pierwotna(double x, double E, double A, double B) const;
92 inline double masa_p(double E) const;
93
94 protected:
95 /*
96 double x_pocz;
97 double x_kon;
98 double y_pocz;
99 double y_kon;*/
100
101 warstwa * nast; // wskaznik na sasiadke z prawej
102 double masa_r; // masa rownolegla
103 double tryga(double x, double E) const;
104 double trygb(double x, double E) const;
105 double expa(double x, double E) const;
106 double expb(double x, double E) const;
107 double Ai(double x, double E) const;
108 double Ai_skala(double x, double E) const;
109 double Bi(double x, double E) const;
110 double Bi_skala(double x, double E) const;
111 double tryga_prim(double x, double E) const;
112 double trygb_prim(double x, double E) const;
113 double expa_prim(double x, double E) const;
114 double expb_prim(double x, double E) const;
115 double Ai_prim(double x, double E) const;
116 double Ai_prim_skala(double x, double E) const;
117 double Bi_prim(double x, double E) const;
118 double Bi_prim_skala(double x, double E) const;
119 double funkcjafal(double x, double E, double A, double B) const;
120 double funkcjafal_prim(double x, double E, double A, double B) const;
121 parad AB_z_wartp(double w, double wp, double E) const;
122 double k_kwadr(double E) const;
123 double Eodk(double k) const;
124 void przesun_igreki(double);
125
126 public:
127 warstwa(double m_p, double m_r, double x_p, double y_p, double x_k, double y_k, double niepar = 0,
128 double niepar_2 = 0);
129 // warstwa(const warstwa &);
130 // warstwa & operator=(const warstwa &);
131 double ffala(double x, double E) const;
132 double ffalb(double x, double E) const;
133 double ffala_prim(double x, double E) const;
134 double ffalb_prim(double x, double E) const;
135};
136/*******************************************************************/
137 class warstwa_skraj : public warstwa
138{
139 friend class struktura;
140 friend class obszar_aktywny;
141 friend class wzmocnienie;
142
143 public:
144 enum strona
145 {
146 lewa,
147 prawa
148 };
149
150 private:
151 strona lp;
152 double masa_p;
153 double masa_r;
154 double iks;
155 double y;
156
157 int zera_ffal(double E, double A, double B) const;
158 double norma_kwadr(double E, double A) const;
159 void przesun_igreki(double dE);
160
161 public:
162 warstwa_skraj(strona lczyp, double m_p, double m_r, double x, double y);
163 warstwa_skraj();
164 warstwa_skraj(const warstwa_skraj &);
165 double ffala(double x, double E) const;
166 double ffalb(double x, double E) const;
167 double ffala_prim(double x, double E) const;
168 double ffalb_prim(double x, double E) const;
169 double funkcjafal(double x, double E, double C) const;
170 double funkcjafal_prim(double x, double E, double C) const;
171 parad AB_z_wartp(double w, double wp, double E) const;
172};
173/*******************************************************************/
174 class stan
175{
176 friend class struktura;
177 friend class obszar_aktywny;
178
179 std::vector<double> wspolczynniki;
180
181 stan(double E, A2D & V, int lz);
182
183 stan(double E, std::vector<parad> & W, int lz);
184 //
185 void przesun_poziom(double);
186
187 public:
188 stan();
189
190 std::vector<double> prawdopodobienstwa;
191 double poziom;
192 int liczba_zer;
193};
194/*******************************************************************/
195 class punkt
196{
197 public:
198 punkt();
199 punkt(double e, double w);
200 punkt(const stan &);
201 double en;
202 double wart;
203};
204/*******************************************************************/
205 class struktura
206{ // struktura poziomow itp
207
208 friend class wzmocnienie;
209 friend class obszar_aktywny;
210
211 public:
212 enum rodzaj
213 {
214 el,
215 hh,
216 lh
217 };
218
219 private:
220 double dokl;
221 double gora; // skrajna lewa bariera
222 double dol;
223
224 warstwa_skraj lewa, prawa;
225 // std::vector<int> gwiazdki;
226 std::vector<warstwa> kawalki; // Wewnetrzne warstwy
227 std::vector<double> progi; // Poziome bariery dajace falszywe zera
228 // std::vector<stan> rozwiazania;
229
230 void zrobmacierz(double, A2D &);
231 double sieczne(double (struktura::*f)(double), double pocz, double kon);
232 // 1.5
233 // double bisekcja(double (struktura::*f)(double), double pocz, double kon);
234 double bisekcja(double (struktura::*f)(double), double pocz, double kon, double dokl = 1e-9);
235 //
236 double norma_stanu(stan & st);
237 double energia_od_k_na_ntym(double k, int nr_war, int n);
238 double iloczyn_pierwotna_bezpola(double x, int nr_war, const struktura * struk1, const struktura * struk2, int i,
239 int j);
240
241 public:
242 // MD `rozwiazania` oraz `gwiazdki` sa publiczne
243 std::vector<stan> rozwiazania;
244 std::vector<int> gwiazdki;
245
246 static const double przelm;
247 static const double przels;
248 static const double pi;
249 static const double eps0;
250 static const double c;
251 static const double kB;
252
253 rodzaj typ;
254 std::string nazwa;
255 struktura(const std::vector<warstwa *> &, rodzaj);
256
257 // MD: wczytywanie z pliku wylaczone w PLaSKu i RPSMESie
258#ifdef MICHAL
259 struktura(std::ifstream & plik, rodzaj co, bool bezlicz = false);
260 struktura(std::ifstream & plik, const std::vector<double> & poziomy, rodzaj co);
261#endif
262
263 static double dlugosc_z_A(const double);
264 static double dlugosc_na_A(const double);
265 static double koncentracja_na_cm_3(const double);
266
267 double czyosobliwa(double E);
268 // double funkcjafal(double x, double E, int n, double A, double B);
269 int ilezer_ffal(double E);
270 int ilezer_ffal(double E, A2D & V);
271 std::vector<double> zageszczanie(punkt p0, punkt pk);
272 double sprawdz_ciaglosc(double E, A2D & V);
273 void szukanie_poziomow(double Ek, double rozdz = 1e-6, bool debug = false);
274 void szukanie_poziomow_2(double Ek, double rozdz = 1e-6, bool debug = false);
275 void stany_z_tablicy(const std::vector<double> & energie);
276 void normowanie();
277 double ilenosnikow(double qFl, double T);
278 double ilenosnikow(double qFl, double T, std::set<int> ktore_warstwy);
279 std::vector<double> koncentracje_w_warstwach(double qFl, double T);
280 void poziomy_do_pliku_(std::ofstream & plik, char c, double iRefBand, double iX1,
281 double iX2); // LUKASZ skopiowane ze starych kublow
282 void funkcje_do_pliku_(std::ofstream & plik, char c, double iRefBand, double krok,
283 double skala); // LUKASZ skopiowane ze starych kublow
284 void funkcje_do_pliku(std::ofstream & plik, double krok);
285 void funkcja1_do_pliku(std::ofstream & plik, stan & st, double krok);
286 void struktura_do_pliku(std::ofstream & plik); // do rysowania studni
287 void przesun_energie(double);
288 // double dE_po_dl(size_t nr, chrop ch); //pochodna nr-tego poziomu po szerokosci studni
289
290 void profil(double Ek, double rozdz);
291 std::vector<std::vector<double> > rysowanie_funkcji(double E, double x0, double xk, double krok);
292 // dopisek 1.5
293 parad sklejanie_od_lewej(double E);
294 int ilezer_ffal(double E, std::vector<parad> & W);
295 std::vector<parad> wsp_sklejanie_od_lewej(double E);
296 double blad_sklejania(double E);
297 double poprawianie_poziomu(double E, double DE);
298 void szukanie_poziomow_zpoprawka(double Ek, double rozdz);
299 void szukanie_poziomow_zpoprawka2(double Ek, double rozdz);
300};
301/*******************************************************************/
302 class obszar_aktywny
303{
304 friend class wzmocnienie;
305
306 // MD: 4 kontruktory dziela wiekszosc kodu - nalezy to wyciagnac do jednej osobnej metody
307 void _obszar_aktywny(struktura * elektron, const std::vector<struktura *> & dziury, double Eg,
308 const std::vector<double> * DSO, double chropo, double matelem = 0., double Temp = 300.);
309 void _obszar_aktywny(struktura * elektron, const std::vector<struktura *> & dziury, struktura * elektron_m,
310 const std::vector<struktura *> & dziury_m, double Eg, const std::vector<double> * DSO, double br,
311 double matelem = 0., double Temp = 300.);
312
313 public: // MD
314 double przekr_max; // maksymalna calka przekrycia
315 double chrop; // chropowatosc interfejsow, wzgledna (nalezy rozumiec jako wzgledna chropowatosc najwazniejszej studni)
316 double broad; // mnoznik do nierownomiernosci
317 std::vector<struktura *> pasmo_przew;
318 std::vector<struktura *> pasmo_wal;
319 std::vector<struktura *> pasmo_przew_mod;
320 std::vector<struktura *> pasmo_wal_mod;
321 std::vector<std::vector<A2D *> > calki_przekrycia;
322 std::vector<std::vector<TNT::Array2D<std::vector<double> > *> > calki_przekrycia_kawalki;
323 std::vector<double> Egcc; // Przerwy energetyczne (dodatkowe, bo moga byc juz wpisane w igrekach struktur) lewych
324 // elektronowych warstw skrajnych wzgledem zerowego pasma przewodnictwa (na ogol jedno 0)
325 std::vector<double> Egcv; // Przerwy energetyczne miedzy zerami elektronowymi a dziurowymi (chyba najlepiej, zeby zera
326 // byly w skrajnych warstwach)
327 std::vector<double> DeltaSO; // DeltySO w warstwach wzgledem zerowego pasma walencyjnego
328 std::vector<double> el_mac; // Elementy macierzowe w warstwach
329 double T_ref; // Temperatura odniesienia, dla ktorej ustawione sa przerwy energetyczne
330 // double element(int nr_war); // przenioslem do publicznych LUKASZ 23.05.2023
331
332 public:
333 obszar_aktywny(struktura * elektron, const std::vector<struktura *> & dziury, double Eg,
334 const std::vector<double> & DSO, double chropo, double matelem = 0., double Temp = 300.);
335 obszar_aktywny(struktura * elektron, const std::vector<struktura *> & dziury, struktura * elektron_m,
336 const std::vector<struktura *> dziury_m, double Eg, const std::vector<double> & DSO, double br,
337 double matelem = 0., double Temp = 300.);
338 obszar_aktywny(struktura * elektron, const std::vector<struktura *> & dziury, double Eg, double DSO, double chropo,
339 double matelem = 0., double Temp = 300);
340#ifdef MICHAL
341 obszar_aktywny(struktura * elektron, const std::vector<struktura *> & dziury, struktura * elektron_m,
342 const std::vector<struktura *> dziury_m, double Eg, double DSO, double broad, double Temp = 300,
343 double matelem = 0.);
344#else
345 obszar_aktywny(struktura * elektron, const std::vector<struktura *> & dziury, struktura * elektron_m,
346 const std::vector<struktura *> dziury_m, double Eg, double DSO, double broad, double matelem = 0.,
347 double Temp = 300);
348#endif
349 void zapisz_poziomy(std::string nazwa);
350 double min_przerwa_energetyczna() const;
351 // void policz_calki(const struktura * elektron, const struktura * dziura, A2D & macierz);
352 void policz_calki(const struktura * elektron, const struktura * dziura, A2D & macierz,
353 TNT::Array2D<std::vector<double> > & wekt_calk_kaw);
354 void policz_calki_kawalki(const struktura * elektron, const struktura * dziura,
355 TNT::Array2D<vector<double> > & macierz); // dopisane na szybko, bo kompilator nie widzial
356
357 double calka_ij(const struktura * elektron, const struktura * dziura, int i, int j, vector<double> & wektor_calk_kaw);
358 double iloczyn_pierwotna_bezpola(double x, int nr_war, const struktura * struk1, const struktura * struk2, int i,
359 int j);
360 double calka_iloczyn_zpolem(int nr_war, const struktura * struk1, const struktura * struk2, int i,
361 int j); // numeryczne calkowanie
362 // void macierze_przejsc();
363 void zrob_macierze_przejsc(); // dopisane 2013
364 void paryiprzekrycia_dopliku(ofstream & plik, int nr_c, int nr_v);
365 double przekrycia_schodkowe(double E, int nr_c, int nr_v);
366 void przekrycia_dopliku(ofstream & plik, int nr_c, int nr_v);
367
368 double element(int nr_war); // przenioslem z prywatnych LUKASZ 23.05.2023
369 void ustaw_element(double iM); // dodalem metode LUKASZ 23.05.2023
370};
371/*******************************************************************/
372 class wzmocnienie
373{
374 public: // LUKASZ dodalem public
375 const obszar_aktywny * pasma;
376 double nosniki_c, nosniki_v; // gestosc powierzchniowa
377 std::set<int> warstwy_do_nosnikow;
378 double T;
379 std::string ch_br; // LUKASZ skopiowane ze starych kublow
380 std::vector<double> Egcv_T;
381 double n_r;
382 double qFlc; // quasi-poziom Fermiego dla elektronow wzgledem 0 struktur pasma c
383 double qFlv; // quasi-poziom Fermiego dla elektronow wzgledem 0 struktur pasma v, w geometrii elektronowej, czyli
384 // studnie to gorki
385 // double posz_en; // Poszerzenie energetyczne (sigma w RN) wynikajace z chropowatosci. Uproszczone, wspolne dla
386 // wszystkich par stanow
387
388 void ustaw_przerwy(double poprawka = 0.); // ustawia przerwy energetyczne dla podanej temperatury
389 double sieczne(double (wzmocnienie::*f)(double), double pocz, double kon);
390 double przel_gest_z_cm2(double gest_w_cm2); // gestosc powierzchniowa
391 double przel_gest_na_cm2(double gest_w_wew);
392 double gdzie_qFlc(double E);
393 double gdzie_qFlv(double E);
394 double kodE(double E, double mc, double mv);
395 double rored(double, double mc, double mv);
396 double erf_dorored(double E, double E0, double sigma);
397 double rored_posz(double E, double E0, double mc, double mv, double sigma);
398 double fc(double E);
399 double fv(double E);
400 double posz_z_chrop(size_t nr_c, int poz_c, size_t nr_v, int poz_v);
401 double posz_z_br(size_t nr_c, int poz_c, size_t nr_v, int poz_v);
402 double nosniki_w_c(double Fl);
403 void policz_qFlc();
404 double nosniki_w_v(double Fl);
405 void policz_qFlv();
406
407 // MD: jak juz wprowadzamy mozliwosc wyboru wersji, to opiszmy ja porzadnie
408 enum Wersja
409 {
410 Z_CHROPOWATOSCIA,
411 Z_POSZERZENIEM
412 };
413
414 private:
415 Wersja wersja; // MD
416
417 public:
418 double szer_do_wzmoc; // szerokosc obszaru czynnego, ktora bedzie model optyczny rozpatrywal
419 wzmocnienie(obszar_aktywny * obsz, double konc_pow, double T, double wsp_zal, double poprawkaEg = 0.,
420 double szdowzm = -1., Wersja wersja = Z_POSZERZENIEM);
421
422 std::vector<double> koncentracje_elektronow_w_warstwach();
423 std::vector<double> koncentracje_dziur_w_warstwach();
424 double pozFerm_przew();
425 double pozFerm_wal();
426 double rozn_poz_Ferm();
427 double szerdowzmoc();
428 double wzmocnienie_od_pary_poziomow(double E, size_t nr_c, int poz_c, size_t nr_v, int poz_v,
429 double polar); // MD - dodalem polar 2024-09-02
430 double wzmocnienie_od_pary_pasm(double E, size_t nr_c, size_t nr_v, double polar); // MD - dodalem polar 2024-09-02
431 double spont_od_pary_poziomow(double E, size_t nr_c, int poz_c, size_t nr_v, int poz_v, double polar);
432 double spont_od_pary_pasm(double E, size_t nr_c, size_t nr_v, double polar);
433 double wzmocnienie_calk_ze_splotem(double E, double b, double polar, // MD - dodalem polar 2024-09-02
434 double blad = 0.02); // podzial na kawalek o promieniu Rb wokol 0 i reszte
435 double wzmocnienie_calk_bez_splotu(double E, double polar); // MD - dodalem polar 2024-09-02
436 double
437 wzmocnienie_calk_bez_splotu_L(double lambda,
438 double polar); // dodalem metode LUKASZ LUKI 23.05.2023, MD - dodalem polar 2024-09-02
439 double lumin(double E, double polar = 2.); // polar = 0. -> TE, polar = 1. -> TM, polar = 2. -> TE + TM,
440 void profil_wzmocnienia_ze_splotem_dopliku(std::ofstream & plik, double pocz, double kon, double krok, double b);
441 void profil_wzmocnienia_bez_splotu_dopliku(std::ofstream & plik, double pocz, double kon, double krok);
442 void profil_wzmocnienia_bez_splotu_dopliku_L(std::ofstream & plik, double pocz, double kon,
443 double krok); // dodalem metode LUKASZ LUKI 23.05.2023
444 void profil_lumin_dopliku(std::ofstream & plik, double pocz, double kon, double krok);
445 void profil_lumin_dopliku_L(std::ofstream & plik, double pocz, double kon,
446 double krok); // dodalem metode LUKASZ LUKI 5.09.2023
447
448 double moc_lumin();
449 static double L(double x, double b);
450};
451
452} // namespace kubly
453
454#ifndef PLASK
455 using namespace kubly;
456#endif