VMPS++
Loading...
Searching...
No Matches
KondoU0xSU2.h
Go to the documentation of this file.
1#ifndef KONDOMODEL_U0XU1_H_
2#define KONDOMODEL_U0XU1_H_
3
4#include "symmetry/SU2.h"
5#include "bases/SpinBase.h"
6#include "bases/FermionBase.h"
7#include "models/KondoObservables.h"
8#include "Mpo.h"
9//include "ParamHandler.h" // from HELPERS
10#include "ParamReturner.h"
11
12namespace VMPS
13{
31class KondoU0xSU2 : public Mpo<Sym::SU2<Sym::ChargeSU2>,double>,
32 public KondoObservables<Sym::SU2<Sym::ChargeSU2> >,
33 public ParamReturner
34{
35public:
36 typedef Sym::SU2<Sym::ChargeSU2> Symmetry;
37 typedef SiteOperatorQ<Symmetry,MatrixType> OperatorType;
38 typedef Eigen::Matrix<double,Eigen::Dynamic,Eigen::Dynamic> MatrixType;
39 MAKE_TYPEDEFS(KondoU0xSU2)
40
41private:
42 typedef Eigen::Index Index;
43 typedef Symmetry::qType qType;
44
45public:
46
48 KondoU0xSU2 (): Mpo(), KondoObservables(), ParamReturner(KondoU0xSU2::sweep_defaults) {};
49 KondoU0xSU2 (const size_t &L, const vector<Param> &params, const BC &boundary=BC::OPEN, const DMRG::VERBOSITY::OPTION &VERB=DMRG::VERBOSITY::OPTION::ON_EXIT);
51
52 static qarray<1> singlet (int N) {return qarray<1>{1};};
53 static constexpr MODEL_FAMILY FAMILY = KONDO;
54
64 template<typename Symmetry_>
65 static void set_operators (const std::vector<SpinBase<Symmetry_> > &B, const std::vector<FermionBase<Symmetry_> > &F, const vector<SUB_LATTICE> &G, const ParamHandler &P,
66 PushType<SiteOperator<Symmetry_,double>,double>& pushlist, std::vector<std::vector<std::string>>& labellist,
67 const BC boundary=BC::OPEN);
68
69 // Mpo<Symmetry> Simp (SPINOP_LABEL Sa, size_t locx, size_t locy=0) const;
70 // Mpo<Symmetry> Ssub (SPINOP_LABEL Sa, size_t locx, size_t locy=0) const;
71 // Mpo<Symmetry> n (size_t locx, size_t locy=0) const;
72
73 // Mpo<Symmetry> SimpSsub (SPINOP_LABEL SOP1, SPINOP_LABEL SOP2, size_t locx1, size_t locx2, size_t locy1=0, size_t locy2=0) const;
74 // Mpo<Symmetry> SsubSsub (SPINOP_LABEL SOP1, SPINOP_LABEL SOP2, size_t locx1, size_t locx2, size_t locy1=0, size_t locy2=0) const;
75 // Mpo<Symmetry> SimpSimp (SPINOP_LABEL SOP1, SPINOP_LABEL SOP2, size_t locx1, size_t locx2, size_t locy1=0, size_t locy2=0) const;
76
77 static const std::map<string,std::any> defaults;
78 static const map<string,any> sweep_defaults;
79
80// protected:
81
82// Mpo<Symmetry> make_corr (KONDO_SUBSYSTEM SUBSYS, string name1, string name2, size_t locx1, size_t locx2, size_t locy1, size_t locy2,
83// const OperatorType &Op1, const OperatorType &Op2, bool BOTH_HERMITIAN=false) const;
84
85// vector<FermionBase<Symmetry> > F;
86// vector<SpinBase<Symmetry> > B;
87};
88
89const std::map<string,std::any> KondoU0xSU2::defaults =
90{
91 {"t",1.}, {"tRung",0.}, {"tPrime",0.}, {"tPrimePrime",0.},
92 {"J",1.}, {"Jz",0.}, {"U",0.},
93 {"V",0.}, {"Vrung",0.},
94 {"Bz",0.}, {"Bzsub",0.}, {"Kz",0.}, {"Bx",0.}, {"Bxsub",0.}, {"Kx",0.},
95 {"Inext",0.}, {"Iprev",0.}, {"I3next",0.}, {"I3prev",0.}, {"I3loc",0.},
96 {"D",2ul}, {"maxPower",1ul}, {"CYLINDER",false}, {"Ly",1ul}, {"LyF",1ul},
97 {"SEMIOPEN_LEFT",false}, {"SEMIOPEN_RIGHT",false}, {"mfactor",1},
98 {"REMOVE_DOUBLE",false}, {"REMOVE_EMPTY",false}, {"REMOVE_UP",false}, {"REMOVE_DN",false}, {"mfactor",1}, {"k",1}
99};
100
101const map<string,any> KondoU0xSU2::sweep_defaults =
102{
103 {"max_alpha",100.}, {"min_alpha",1.}, {"lim_alpha",11ul}, {"eps_svd",1e-7},
104 {"Mincr_abs",50ul}, {"Mincr_per",2ul}, {"Mincr_rel",1.1},
105 {"min_Nsv",0ul}, {"max_Nrich",-1},
106 {"max_halfsweeps",30ul}, {"min_halfsweeps",10ul},
107 {"Minit",1ul}, {"Qinit",1ul}, {"Dlimit",10000ul},
108 {"tol_eigval",1e-6}, {"tol_state",1e-5},
109 {"savePeriod",0ul}, {"CALC_S_ON_EXIT", true}, {"CONVTEST",DMRG::CONVTEST::VAR_2SITE}
110};
111
112KondoU0xSU2::
113KondoU0xSU2 (const size_t &L, const vector<Param> &params, const BC &boundary, const DMRG::VERBOSITY::OPTION &VERB)
114:Mpo<Symmetry> (L, Symmetry::qvacuum(), "", PROP::HERMITIAN, PROP::NON_UNITARY, boundary, VERB),
115 KondoObservables(L,params,KondoU0xSU2::defaults),
116 ParamReturner(KondoU0xSU2::sweep_defaults)
117{
118 ParamHandler P(params,defaults);
119 size_t Lcell = P.size();
120
121 for (size_t l=0; l<N_sites; ++l)
122 {
123 N_phys += P.get<size_t>("LyF",l%Lcell);
124 setLocBasis((B[l].get_basis().combine(F[l].get_basis())).qloc(),l);
125 }
126 //this->GOT_SEMIOPEN_LEFT = P.get<bool>("SEMIOPEN_LEFT");
127 //this->GOT_SEMIOPEN_RIGHT = P.get<bool>("SEMIOPEN_RIGHT");
128
129 this->set_name("Kondo");
130
131 PushType<SiteOperator<Symmetry,double>,double> pushlist;
132 std::vector<std::vector<std::string>> labellist;
133 set_operators(B, F, G, P, pushlist, labellist, boundary);
134
135 this->construct_from_pushlist(pushlist, labellist, Lcell);
136 this->finalize(PROP::COMPRESS, P.get<size_t>("maxPower"));
137
138 this->precalc_TwoSiteData();
139}
140
141template<typename Symmetry_>
142void KondoU0xSU2::
143set_operators (const std::vector<SpinBase<Symmetry_> > &B, const std::vector<FermionBase<Symmetry_> > &F, const vector<SUB_LATTICE> &G, const ParamHandler &P,
144 PushType<SiteOperator<Symmetry_,double>,double>& pushlist, std::vector<std::vector<std::string>>& labellist, const BC boundary)
145{
146 std::size_t Lcell = P.size();
147 std::size_t N_sites = B.size();
148 if(labellist.size() != N_sites) {labellist.resize(N_sites);}
149
150 for (std::size_t loc=0; loc<N_sites; ++loc)
151 {
152 size_t lm1 = (loc==0)? N_sites-1 : loc-1;
153 size_t lp1 = (loc+1)%N_sites;
154 size_t lp2 = (loc+2)%N_sites;
155 size_t lp3 = (loc+3)%N_sites;
156
157 //auto Glm1 = static_cast<SUB_LATTICE>(static_cast<int>(pow(-1,lm1)));
158 //auto Glp1 = static_cast<SUB_LATTICE>(static_cast<int>(pow(-1,lp1)));
159 //auto Glp2 = static_cast<SUB_LATTICE>(static_cast<int>(pow(-1,lp2)));
160 //auto Glp3 = static_cast<SUB_LATTICE>(static_cast<int>(pow(-1,lp3)));
161
162 std::size_t Fprev_orbitals = F[lm1].orbitals();
163 std::size_t Forbitals = F[loc].orbitals();
164 std::size_t Fnext_orbitals = F[lp1].orbitals();
165 std::size_t Fnextn_orbitals = F[lp2].orbitals();
166 std::size_t F3next_orbitals = F[lp3].orbitals();
167
168 std::size_t Bprev_orbitals = B[lm1].orbitals();
169 std::size_t Borbitals = B[loc].orbitals();
170 std::size_t Bnext_orbitals = B[lp1].orbitals();
171 std::size_t Bnextn_orbitals = B[lp2].orbitals();
172 std::size_t B3next_orbitals = B[lp3].orbitals();
173
174 frac S = frac(B[loc].get_D()-1,2);
175 stringstream Slabel;
176 Slabel << "S=" << print_frac_nice(S);
177 labellist[loc].push_back(Slabel.str());
178
179 auto push_full = [&N_sites, &loc, &B, &F, &P, &pushlist, &labellist, &boundary] (string xxxFull, string label,
180 const vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > &first,
181 const vector<vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > > &last,
182 vector<double> factor, bool FERMIONIC) -> void
183 {
184 ArrayXXd Full = P.get<Eigen::ArrayXXd>(xxxFull);
185 vector<vector<std::pair<size_t,double> > > R = Geometry2D::rangeFormat(Full);
186
187 if (static_cast<bool>(boundary)) {assert(R.size() == N_sites and "Use an (N_sites)x(N_sites) hopping matrix for open BC!");}
188 else {assert(R.size() >= 2*N_sites and "Use at least a (2*N_sites)x(N_sites) hopping matrix for infinite BC!");}
189
190 for (size_t j=0; j<first.size(); j++)
191 for (size_t h=0; h<R[loc].size(); ++h)
192 {
193 size_t range = R[loc][h].first;
194 double value = R[loc][h].second;
195
196 if (range != 0)
197 {
198 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > ops(range+1);
199 ops[0] = first[j];
200 for (size_t i=1; i<range; ++i)
201 {
202 if (FERMIONIC) {ops[i] = kroneckerProduct(B[(loc+i)%N_sites].Id(), F[(loc+i)%N_sites].sign());}
203 else {ops[i] = kroneckerProduct(B[(loc+i)%N_sites].Id(), F[(loc+i)%N_sites].Id());}
204 }
205 ops[range] = last[j][(loc+range)%N_sites];
206 pushlist.push_back(std::make_tuple(loc, ops, factor[j] * value));
207 }
208 }
209
210 stringstream ss;
211 ss << label << "(" << Geometry2D::hoppingInfo(Full) << ")";
212 labellist[loc].push_back(ss.str());
213 };
214
215 if (P.HAS("tFull"))
216 {
217 SiteOperatorQ<Symmetry_,Eigen::MatrixXd> cdagup_sign_local = kroneckerProduct(B[loc].Id(),(F[loc].cdag(UP,G[loc],0) * F[loc].sign()));
218 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > cup_ranges(N_sites);
219 SiteOperatorQ<Symmetry_,Eigen::MatrixXd> cdagdn_sign_local = kroneckerProduct(B[loc].Id(),(F[loc].cdag(DN,G[loc],0) * F[loc].sign()));
220 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > cdn_ranges(N_sites);
221 for (size_t i=0; i<N_sites; i++)
222 {
223 auto Gi = static_cast<SUB_LATTICE>(static_cast<int>(pow(-1,i)));
224 cup_ranges[i] = kroneckerProduct(B[loc].Id(),F[i].c(UP,Gi,0));
225 }
226 for (size_t i=0; i<N_sites; i++)
227 {
228 auto Gi = static_cast<SUB_LATTICE>(static_cast<int>(pow(-1,i)));
229 cdn_ranges[i] = kroneckerProduct(B[loc].Id(),F[i].c(DN,Gi,0));
230 }
231
232 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > first {cdagup_sign_local, cdagdn_sign_local};
233 vector<vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > > last {cup_ranges,cdn_ranges};
234 push_full("tFull", "tᵢⱼ", first, last, {-std::sqrt(2.),- std::sqrt(2.)}, PROP::FERMIONIC);
235 }
236
237 // local terms
238
239 // Kondo-J
240 param1d J = P.fill_array1d<double>("J", "Jorb", Forbitals, loc%Lcell);
241 labellist[loc].push_back(J.label);
242
243 // Kondo-Jz
244 param1d Jz = P.fill_array1d<double>("Jz", "Jzorb", Forbitals, loc%Lcell);
245 labellist[loc].push_back(Jz.label);
246
247 // t⟂
248 param2d tPerp = P.fill_array2d<double>("tRung", "t", "tPerp", Forbitals, loc%Lcell, P.get<bool>("CYLINDER"));
249 labellist[loc].push_back(tPerp.label);
250
251 // Hubbard-U
252 param1d U = P.fill_array1d<double>("U", "Uorb", Forbitals, loc%Lcell);
253 labellist[loc].push_back(U.label);
254
255 // Bx substrate
256 param1d Bxsub = P.fill_array1d<double>("Bxsub", "Bxsuborb", Forbitals, loc%Lcell);
257 labellist[loc].push_back(Bxsub.label);
258
259 // Bx impurities
260 param1d Bx = P.fill_array1d<double>("Bx","Bxorb", Borbitals, loc%Lcell);
261 labellist[loc].push_back(Bx.label);
262
263 // Kx anisotropy
264 param1d Kx = P.fill_array1d<double>("Kx","Kxorb", Borbitals, loc%Lcell);
265 labellist[loc].push_back(Kx.label);
266
267 // Bz substrate
268 param1d Bzsub = P.fill_array1d<double>("Bzsub", "Bzsuborb", Forbitals, loc%Lcell);
269 labellist[loc].push_back(Bzsub.label);
270
271 // Bz impurities
272 param1d Bz = P.fill_array1d<double>("Bz", "Bzorb", Borbitals, loc%Lcell);
273 labellist[loc].push_back(Bz.label);
274
275 // Kz anisotropy
276 param1d Kz = P.fill_array1d<double>("Kz","Kzorb", Borbitals, loc%Lcell);
277 labellist[loc].push_back(Kz.label);
278
279 ArrayXXd muPerp = B[loc].ZeroHopping();
280 ArrayXXd nuPerp = B[loc].ZeroHopping();
281 ArrayXXd Jxyperp = B[loc].ZeroHopping();
282 ArrayXXd Jzperp = B[loc].ZeroHopping();
283 ArrayXXd DyPerp = B[loc].ZeroHopping();
284
285 //set Heisenberg part of Kondo Hamiltonian
286 auto KondoHamiltonian = kroneckerProduct(B[loc].HeisenbergHamiltonian(Jxyperp,Jzperp,Bz.a,Bx.a,muPerp,nuPerp,Kz.a,Kx.a,DyPerp), F[loc].Id());
287
288 ArrayXXd Vperp = F[loc].ZeroHopping();
289 ArrayXXd Jxysubperp = F[loc].ZeroHopping();
290 ArrayXXd Jzsubperp = F[loc].ZeroHopping();
291
292 //set Hubbard part of Kondo Hamiltonian
293 KondoHamiltonian += kroneckerProduct(B[loc].Id(), F[loc].HubbardHamiltonian(U.a,tPerp.a,Vperp,Jzsubperp,Jxysubperp,Bzsub.a,Bxsub.a));
294
295 //set Kondo part of Hamiltonian
296 for (int alfa=0; alfa<Forbitals; ++alfa)
297 {
298 if (J(alfa) != 0.)
299 {
300 assert(Borbitals == Forbitals and "Can only do a Kondo ladder with the same amount of spins and fermionic orbitals in y-direction!");
301 KondoHamiltonian += 0.5*J(alfa) * kroneckerProduct(B[loc].Scomp(SP,alfa), F[loc].Sm(alfa));
302 KondoHamiltonian += 0.5*J(alfa) * kroneckerProduct(B[loc].Scomp(SM,alfa), F[loc].Sp(alfa));
303 KondoHamiltonian += J(alfa) * kroneckerProduct(B[loc].Scomp(SZ,alfa), F[loc].Sz(alfa));
304 }
305 if (Jz(alfa) != 0.)
306 {
307 KondoHamiltonian += Jz(alfa) * kroneckerProduct(B[loc].Scomp(SZ,alfa), F[loc].Sz(alfa));
308 }
309 }
310 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry_,double>::get_N_site_interaction(KondoHamiltonian), 1.));
311
312 // NN terms
313
314 // V∥
315 param2d Vpara = P.fill_array2d<double>("V", "Vpara", {Forbitals, Fnext_orbitals}, loc%Lcell);
316 labellist[loc].push_back(Vpara.label);
317
318 // t∥
319 if (!P.HAS("tFull"))
320 {
321 param2d tPara = P.fill_array2d<double>("t", "tPara", {Forbitals, Fnext_orbitals}, loc%Lcell);
322 labellist[loc].push_back(tPara.label);
323
324 if (loc < N_sites-1 or !static_cast<bool>(boundary))
325 {
326 for (int alfa=0; alfa<Forbitals; ++alfa)
327 for (int beta=0; beta<Fnext_orbitals; ++beta)
328 {
329 auto PsiDagUp_loc = kroneckerProduct(B[loc].Id(), F[loc].cdag(UP,G[loc],alfa));
330 auto PsiDagDn_loc = kroneckerProduct(B[loc].Id(), F[loc].cdag(DN,G[loc],alfa));
331 auto Sign_loc = kroneckerProduct(B[loc].Id(), F[loc].sign());
332 auto PsiUp_lp1 = kroneckerProduct(B[lp1].Id(), F[lp1].c(UP,G[lp1],beta));
333 auto PsiDn_lp1 = kroneckerProduct(B[lp1].Id(), F[lp1].c(DN,G[lp1],beta));
334
335 auto Otmp_loc = PsiDagUp_loc * Sign_loc;
336 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry_,double>::get_N_site_interaction(Otmp_loc, PsiUp_lp1), -tPara(alfa,beta) * sqrt(2.)) );
337
338 //c†DNcDN
339 Otmp_loc = PsiDagDn_loc * Sign_loc;
340 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry_,double>::get_N_site_interaction(Otmp_loc, PsiDn_lp1), -tPara(alfa,beta) * sqrt(2.)) );
341 }
342 }
343 }
344
345 // NN spin exchange terms
346
347 param2d InextPara = P.fill_array2d<double>("Inext", "InextPara", {Borbitals, Fnext_orbitals}, loc%Lcell);
348 labellist[loc].push_back(InextPara.label);
349
350 if (loc < N_sites-1 or !static_cast<bool>(boundary))
351 {
352 for (std::size_t alfa=0; alfa<Borbitals; ++alfa)
353 for (std::size_t beta=0; beta<Fnext_orbitals; ++beta)
354 {
355 pushlist.push_back(std::make_tuple(loc,
356 Mpo<Symmetry_,double>::get_N_site_interaction(kroneckerProduct(B[loc].Scomp(SP,alfa), F[loc].Id()),
357 kroneckerProduct(B[lp1].Id(), F[lp1].Sm(beta))),
358 0.5*InextPara(alfa,beta)));
359 pushlist.push_back(std::make_tuple(loc,
360 Mpo<Symmetry_,double>::get_N_site_interaction(kroneckerProduct(B[loc].Scomp(SM,alfa), F[loc].Id()),
361 kroneckerProduct(B[lp1].Id(), F[lp1].Sp(beta))),
362 0.5*InextPara(alfa,beta)));
363 pushlist.push_back(std::make_tuple(loc,
364 Mpo<Symmetry_,double>::get_N_site_interaction(kroneckerProduct(B[loc].Scomp(SZ,alfa), F[loc].Id()),
365 kroneckerProduct(B[lp1].Id(), F[lp1].Sz(beta))),
366 InextPara(alfa,beta)));
367 }
368 }
369
370 param2d IprevPara = P.fill_array2d<double>("Iprev", "IprevPara", {Fprev_orbitals, Borbitals}, loc%Lcell);
371 labellist[loc].push_back(IprevPara.label);
372
373 if (lm1 < N_sites-1 or !static_cast<bool>(boundary))
374 {
375 for (std::size_t alfa=0; alfa<Fprev_orbitals; ++alfa)
376 for (std::size_t beta=0; beta<Borbitals; ++beta)
377 {
378 pushlist.push_back(std::make_tuple(lm1,
379 Mpo<Symmetry_,double>::get_N_site_interaction(kroneckerProduct(B[lm1].Id(), F[lm1].Sm(alfa)),
380 kroneckerProduct(B[loc].Scomp(SP,beta), F[lp1].Id())),
381 0.5*IprevPara(alfa,beta)));
382 pushlist.push_back(std::make_tuple(lm1,
383 Mpo<Symmetry_,double>::get_N_site_interaction(kroneckerProduct(B[lm1].Id(), F[lm1].Sp(alfa)),
384 kroneckerProduct(B[loc].Scomp(SM,beta), F[lp1].Id())),
385 0.5*IprevPara(alfa,beta)));
386 pushlist.push_back(std::make_tuple(lm1,
387 Mpo<Symmetry_,double>::get_N_site_interaction(kroneckerProduct(B[lm1].Id(), F[lm1].Sz(alfa)),
388 kroneckerProduct(B[loc].Scomp(SZ,beta), F[lp1].Id())),
389 IprevPara(alfa,beta)));
390 }
391 }
392
393 // NN 3-orbital spin exchange terms
394
395 param2d I3nextPara = P.fill_array2d<double>("I3next", "I3nextPara", {Forbitals, Fnext_orbitals}, loc%Lcell);
396 labellist[loc].push_back(I3nextPara.label);
397
398 if (loc < N_sites-1 or !static_cast<bool>(boundary))
399 {
400 for (std::size_t alfa=0; alfa<Forbitals; ++alfa)
401 for (std::size_t beta=0; beta<Fnext_orbitals; ++beta)
402 {
403 assert(Borbitals == 1);
404
405 auto Sm_PsiDagUp_loc = kroneckerProduct(B[loc].Scomp(SM,0), F[loc].cdag(UP,G[loc],alfa));
406 auto Sp_PsiDagDn_loc = kroneckerProduct(B[loc].Scomp(SP,0), F[loc].cdag(DN,G[loc],alfa));
407 auto Sign_loc = kroneckerProduct(B[loc].Id(), F[loc].sign());
408 auto PsiUp_lp1 = kroneckerProduct(B[lp1].Id(), F[lp1].c(UP,G[lp1],beta));
409 auto PsiDn_lp1 = kroneckerProduct(B[lp1].Id(), F[lp1].c(DN,G[lp1],beta));
410
411 auto Otmp_loc = Sm_PsiDagUp_loc * Sign_loc;
412 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry_,double>::get_N_site_interaction(Otmp_loc, PsiDn_lp1),0.5*sqrt(2.)*I3nextPara(alfa,beta)));
413
414 Otmp_loc = Sp_PsiDagDn_loc * Sign_loc;
415 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry_,double>::get_N_site_interaction(Otmp_loc, PsiUp_lp1),0.5*sqrt(2.)*I3nextPara(alfa,beta)));
416
417 pushlist.push_back(std::make_tuple(loc,
418 Mpo<Symmetry_,double>::get_N_site_interaction(kroneckerProduct(B[loc].Scomp(SZ,0), F[loc].Id()),
419 kroneckerProduct(B[lp1].Id(), F[lp1].Sz(beta))),
420 I3nextPara(alfa,beta)));
421 }
422 }
423
424 param2d I3prevPara = P.fill_array2d<double>("I3prev", "I3prevPara", {Fprev_orbitals, Forbitals}, loc%Lcell);
425 labellist[loc].push_back(I3prevPara.label);
426
427 if (lm1 < N_sites-1 or !static_cast<bool>(boundary))
428 {
429 for (std::size_t alfa=0; alfa<Fprev_orbitals; ++alfa)
430 for (std::size_t beta=0; beta<Forbitals; ++beta)
431 {
432 assert(Borbitals == 1);
433
434 auto Sm_PsiDagUp_lm1 = kroneckerProduct(B[lm1].Scomp(SM,0), F[lm1].cdag(UP,G[lm1],alfa));
435 auto Sp_PsiDagDn_lm1 = kroneckerProduct(B[lm1].Scomp(SP,0), F[lm1].cdag(DN,G[lm1],alfa));
436 auto Sign_lm1 = kroneckerProduct(B[lm1].Id(), F[lm1].sign());
437 auto PsiUp_loc = kroneckerProduct(B[loc].Id(), F[loc].c(UP,G[loc],beta));
438 auto PsiDn_loc = kroneckerProduct(B[loc].Id(), F[loc].c(DN,G[loc],beta));
439
440 auto Otmp_lm1 = Sm_PsiDagUp_lm1 * Sign_lm1;
441 pushlist.push_back(std::make_tuple(lm1, Mpo<Symmetry_,double>::get_N_site_interaction(Otmp_lm1, PsiDn_loc),0.5*sqrt(2.)*I3prevPara(alfa,beta)));
442
443 Otmp_lm1 = Sp_PsiDagDn_lm1 * Sign_lm1;
444 pushlist.push_back(std::make_tuple(lm1, Mpo<Symmetry_,double>::get_N_site_interaction(Otmp_lm1, PsiUp_loc),0.5*sqrt(2.)*I3prevPara(alfa,beta)));
445
446 pushlist.push_back(std::make_tuple(lm1,
447 Mpo<Symmetry_,double>::get_N_site_interaction(kroneckerProduct(B[lm1].Scomp(SZ,0), F[lm1].Id()),
448 kroneckerProduct(B[loc].Id(), F[loc].Sz(beta))),
449 I3prevPara(alfa,beta)));
450 }
451 }
452
453 // tPrime
454 if (!P.HAS("tFull") and P.HAS("tPrime",loc%Lcell))
455 {
456 param2d tPrime = P.fill_array2d<double>("tPrime", "tPrime_array", {Forbitals, F3next_orbitals}, loc%Lcell);
457 labellist[loc].push_back(tPrime.label);
458
459 if (loc < N_sites-2 or !static_cast<bool>(boundary))
460 {
461 auto Sign_loc = kroneckerProduct(B[loc].Id(), F[loc].sign());
462 auto Sign_lp1 = kroneckerProduct(B[lp1].Id(), F[lp1].sign());
463
464 for (std::size_t alfa=0; alfa<Forbitals; ++alfa)
465 for (std::size_t beta=0; beta<F3next_orbitals; ++beta)
466 {
467 auto PsiDagUp_loc = kroneckerProduct(B[loc].Id(), F[loc].cdag(UP,G[loc],alfa));
468 auto PsiDagDn_loc = kroneckerProduct(B[loc].Id(), F[loc].cdag(DN,G[loc],alfa));
469 auto Sign_loc = kroneckerProduct(B[loc].Id(), F[loc].sign());
470 auto PsiUp_lp2 = kroneckerProduct(B[lp1].Id(), F[lp1].c(UP,G[lp2],beta));
471 auto PsiDn_lp2 = kroneckerProduct(B[lp1].Id(), F[lp1].c(DN,G[lp2],beta));
472
473 auto Otmp_loc = PsiDagUp_loc * Sign_loc;
474 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry_,double>::get_N_site_interaction(Otmp_loc, Sign_lp1, PsiUp_lp2), -tPrime(alfa,beta) * sqrt(2.)) );
475
476 //c†DNcDN
477 Otmp_loc = PsiDagDn_loc * Sign_loc;
478 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry_,double>::get_N_site_interaction(Otmp_loc, Sign_lp1, PsiDn_lp2), -tPrime(alfa,beta) * sqrt(2.)) );
479 }
480 }
481 }
482
483 // tPrimePrime
484 if (!P.HAS("tFull") and P.HAS("tPrimePrime",loc%Lcell))
485 {
486 param2d tPrimePrime = P.fill_array2d<double>("tPrimePrime", "tPrimePrime_array", {Forbitals, F3next_orbitals}, loc%Lcell);
487 labellist[loc].push_back(tPrimePrime.label);
488
489 if (loc < N_sites-3 or !static_cast<bool>(boundary))
490 {
491 auto Sign_loc = kroneckerProduct(B[loc].Id(), F[loc].sign());
492 auto Sign_lp1 = kroneckerProduct(B[lp1].Id(), F[lp1].sign());
493 auto Sign_lp2 = kroneckerProduct(B[lp2].Id(), F[lp2].sign());
494
495 for (std::size_t alfa=0; alfa<Forbitals; ++alfa)
496 for (std::size_t beta=0; beta<F3next_orbitals; ++beta)
497 {
498 auto PsiDagUp_loc = kroneckerProduct(B[loc].Id(), F[loc].cdag(UP,G[loc],alfa));
499 auto PsiDagDn_loc = kroneckerProduct(B[loc].Id(), F[loc].cdag(DN,G[loc],alfa));
500 auto Sign_loc = kroneckerProduct(B[loc].Id(), F[loc].sign());
501 auto PsiUp_lp3 = kroneckerProduct(B[lp1].Id(), F[lp1].c(UP,G[lp3],beta));
502 auto PsiDn_lp3 = kroneckerProduct(B[lp1].Id(), F[lp1].c(DN,G[lp3],beta));
503
504 auto Otmp_loc = PsiDagUp_loc * Sign_loc;
505 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry_,double>::get_N_site_interaction(Otmp_loc, Sign_lp1, Sign_lp2, PsiDn_lp3), -tPrimePrime(alfa,beta) * sqrt(2.)));
506
507 //c†DNcDN
508 Otmp_loc = PsiDagDn_loc * Sign_loc;
509 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry_,double>::get_N_site_interaction(Otmp_loc, Sign_lp1, Sign_lp2, PsiUp_lp3), -tPrimePrime(alfa,beta) * sqrt(2.)));
510 }
511 }
512 }
513 }
514}
515
516//HamiltonianTermsXd<Sym::SU2<Sym::ChargeSU2> > KondoU0xSU2::
517//set_operators (const vector<SpinBase<Symmetry> > &B, const vector<FermionBase<Symmetry> > &F, const ParamHandler &P, size_t loc)
518//{
519// HamiltonianTermsXd<Symmetry> Terms;
520//
521// frac S = frac(B[loc].get_D()-1,2);
522// stringstream Slabel;
523// Slabel << "S=" << print_frac_nice(S);
524// Terms.info.push_back(Slabel.str());
525//
526// auto save_label = [&Terms] (string label)
527// {
528// if (label!="") {Terms.info.push_back(label);}
529// };
530//
531// size_t lp1 = (loc+1)%F.size();
532//
533// // NN terms
534//
535// auto [t,tPara,tlabel] = P.fill_array2d<double>("t","tPara",{{F[loc].orbitals(),F[lp1].orbitals()}},loc);
536// save_label(tlabel);
537//
538// auto [V,Vpara,Vlabel] = P.fill_array2d<double>("V","Vpara",{{F[loc].orbitals(),F[lp1].orbitals()}},loc);
539// save_label(Vlabel);
540//
541// for (int i=0; i<F[loc].orbitals(); ++i)
542// for (int j=0; j<F[lp1].orbitals(); ++j)
543// {
544// if (tPara(i,j) != 0.)
545// {
546// //-------------------------------------------------------------------------------------------------------------------------------------//
547// // Terms.tight.push_back(make_tuple(-tPara(i,j),
548// // kroneckerProduct(B.Id(), F.cdag(UP,i) * F.sign()),
549// // kroneckerProduct(B.Id(), F.c(UP,j))));
550// // Terms.tight.push_back(make_tuple(-tPara(i,j),
551// // kroneckerProduct(B.Id(), F.cdag(DN,i) * F.sign()),
552// // kroneckerProduct(B.Id(), F.c(DN,j))));
553// // Terms.tight.push_back(make_tuple(-tPara(i,j),
554// // kroneckerProduct(B.Id(), -1.*F.c(UP,i) * F.sign()),
555// // kroneckerProduct(B.Id(), F.cdag(UP,j))));
556// // Terms.tight.push_back(make_tuple(-tPara(i,j),
557// // kroneckerProduct(B.Id(), -1.*F.c(DN,i) * F.sign()),
558// // kroneckerProduct(B.Id(), F.cdag(DN,j))));
559//
560// // Mout += -t*std::sqrt(2.)*(Operator::prod(psidag(UP,i),psi(UP,i+1),{1})+Operator::prod(psidag(DN,i),psi(DN,i+1),{1}));
561// //-------------------------------------------------------------------------------------------------------------------------------------//
562//
563// //c†UPcUP
564//
565// auto Otmp = OperatorType::prod(OperatorType::outerprod(B[loc].Id().structured(), F[loc].psidag(UP,i), {2}),
566// OperatorType::outerprod(B[loc].Id().structured(), F[loc].sign() , {1}),
567// {2});
568// Terms.tight.push_back(make_tuple(-tPara(i,j)*sqrt(2.),
569// Otmp.plain<double>(),
570// OperatorType::outerprod(B[loc].Id().structured(), F[loc].psi(UP,i), {2}).plain<double>()));
571//
572// //c†DNcDN
573// Otmp = OperatorType::prod(OperatorType::outerprod(B[loc].Id().structured(), F[loc].psidag(DN,i), {2}),
574// OperatorType::outerprod(B[loc].Id().structured(), F[loc].sign() , {1}),
575// {2});
576// Terms.tight.push_back(make_tuple(-tPara(i,j)*sqrt(2.),
577// Otmp.plain<double>(),
578// OperatorType::outerprod(B[loc].Id().structured(), F[loc].psi(DN,i), {2}).plain<double>()));
579//
580// //-cUPc†UP
581// // Otmp = OperatorType::prod(OperatorType::outerprod(B.Id().structured(),F.psi(UP,i),{2}),
582// // OperatorType::outerprod(B.Id().structured(),F.sign() ,{1}),
583// // {2});
584// // Terms.tight.push_back(make_tuple(tPara(i,j)*sqrt(2.),
585// // Otmp.plain<double>(),
586// // OperatorType::outerprod(B.Id().structured(),F.psidag(UP,j),{2}).plain<double>()));
587//
588// //-cDNc†DN
589// // Otmp = OperatorType::prod(OperatorType::outerprod(B.Id().structured(),F.psi(DN,i),{2}),
590// // OperatorType::outerprod(B.Id().structured(),F.sign() ,{1}),
591// // {2});
592// // Terms.tight.push_back(make_tuple(tPara(i,j)*sqrt(2.),
593// // Otmp.plain<double>(),
594// // OperatorType::outerprod(B.Id().structured(),F.psidag(DN,j),{2}).plain<double>()));
595//
596// //-------------------------------------------------------------------------------------------------------------------------------------//
597// }
598// }
599//
600// // local terms
601//
602// // t⟂
603// auto [tRung,tPerp,tPerplabel] = P.fill_array2d<double>("tRung","t","tPerp",F[loc].orbitals(),loc,P.get<bool>("CYLINDER"));
604// save_label(tPerplabel);
605//
606// // Hubbard U
607// auto [U,Uorb,Ulabel] = P.fill_array1d<double>("U","Uorb",F[loc].orbitals(),loc);
608// save_label(Ulabel);
609
610// // Bx substrate
611// auto [Bxsub,Bxsuborb,Bxsublabel] = P.fill_array1d<double>("Bxsub","Bxsuborb",F[loc].orbitals(),loc);
612// save_label(Bxsublabel);
613//
614// // Bx impurities
615// auto [Bx,Bxorb,Bxlabel] = P.fill_array1d<double>("Bx","Bxorb",F[loc].orbitals(),loc);
616// save_label(Bxlabel);
617//
618// // Kx anisotropy
619// auto [Kx,Kxorb,Kxlabel] = P.fill_array1d<double>("Kx","Kxorb",B[loc].orbitals(),loc);
620// save_label(Kxlabel);
621//
622// // Bz substrate
623// auto [Bzsub,Bzsuborb,Bzsublabel] = P.fill_array1d<double>("Bzsub","Bzsuborb",F[loc].orbitals(),loc);
624// save_label(Bzsublabel);
625//
626// // Bz impurities
627// auto [Bz,Bzorb,Bzlabel] = P.fill_array1d<double>("Bz","Bzorb",F[loc].orbitals(),loc);
628// save_label(Bzlabel);
629//
630// // Kz anisotropy
631// auto [Kz,Kzorb,Kzlabel] = P.fill_array1d<double>("Kz","Kzorb",B[loc].orbitals(),loc);
632// save_label(Kzlabel);
633//
634// // OperatorType KondoHamiltonian({1},B[loc].get_structured_basis().combine(F[loc].get_basis()));
635//
636// ArrayXXd Jxyperp = B[loc].ZeroHopping();
637// ArrayXXd Jzperp = B[loc].ZeroHopping();
638// ArrayXXd Dyperp = B[loc].ZeroHopping();
639//
640// //set Heisenberg part of Kondo Hamiltonian
641// auto KondoHamiltonian = OperatorType::outerprod(B[loc].HeisenbergHamiltonian(Jxyperp,Jzperp,Bzorb,Bxorb,Kzorb,Kxorb,Dyperp).structured(),
642// F[loc].Id(),
643// {1});
644//
645// ArrayXXd Vperp = F[loc].ZeroHopping();
646// ArrayXXd Jxysubperp = F[loc].ZeroHopping();
647// ArrayXXd Jzsubperp = F[loc].ZeroHopping();
648//
649// //set Hubbard part of Kondo Hamiltonian
650// KondoHamiltonian += OperatorType::outerprod(B[loc].Id().structured(),
651// F[loc].HubbardHamiltonian(Uorb,tPerp,Vperp,Jxysubperp,Jzsubperp,Bzsuborb,Bxsuborb),
652// {1});
653//
654// //set Heisenberg part of Hamiltonian
656//
657// // Kondo-J
658// auto [J,Jorb,Jlabel] = P.fill_array1d<double>("J","Jorb",F[loc].orbitals(),loc);
659// save_label(Jlabel);
660//
661// //set interaction part of Hamiltonian.
662// for (int i=0; i<F[loc].orbitals(); ++i)
663// {
664// if (Jorb(i) != 0.)
665// {
666// KondoHamiltonian += Jorb(i) * OperatorType::outerprod(B[loc].Scomp(SZ,i).structured(), F[loc].Sz(i), {1});
667// KondoHamiltonian += 0.5*Jorb(i) * OperatorType::outerprod(B[loc].Scomp(SP,i).structured(), F[loc].Sm(i), {1});
668// KondoHamiltonian += 0.5*Jorb(i) * OperatorType::outerprod(B[loc].Scomp(SM,i).structured(), F[loc].Sp(i), {1});
669// }
670// }
671//
672// Terms.name = "Kondo U(0)⊗SU(2)";
673// Terms.local.push_back(make_tuple(1.,KondoHamiltonian.plain<double>()));
674//
675// return Terms;
676//}
677
678// Mpo<Sym::SU2<Sym::ChargeSU2> > KondoU0xSU2::
679// Simp (SPINOP_LABEL Sa, size_t locx, size_t locy) const
680// {
681// assert(locx < this->N_sites);
682// std::stringstream ss;
683
684// Mpo<Symmetry> Mout(N_sites, Symmetry::qvacuum(), ss.str());
685// for (std::size_t l=0; l<this->N_sites; l++) { Mout.setLocBasis((B[l].get_structured_basis().combine(F[l].get_basis())).qloc(),l); }
686
687// auto Sop = OperatorType::outerprod(B[locx].Scomp(Sa,locy).structured(), F[locx].Id(), {1});
688
689// Mout.setLocal(locx, Sop.plain<double>());
690// return Mout;
691// }
692
693// Mpo<Sym::SU2<Sym::ChargeSU2> > KondoU0xSU2::
694// Ssub (SPINOP_LABEL Sa, size_t locx, size_t locy) const
695// {
696// assert(locx < this->N_sites);
697// std::stringstream ss;
698
699// Mpo<Symmetry> Mout(N_sites, Symmetry::qvacuum(), ss.str());
700// for (std::size_t l=0; l<this->N_sites; l++) { Mout.setLocBasis((B[l].get_structured_basis().combine(F[l].get_basis())).qloc(),l); }
701
702// auto Sop = OperatorType::outerprod(B[locx].Id().structured(), F[locx].Scomp(Sa,locy), {1});
703
704// Mout.setLocal(locx, Sop.plain<double>());
705// return Mout;
706// }
707
708// Mpo<Sym::SU2<Sym::ChargeSU2> > KondoU0xSU2::
709// n (size_t locx, size_t locy) const
710// {
711// assert(locx < this->N_sites);
712// std::stringstream ss;
713
714// Mpo<Symmetry> Mout(N_sites, Symmetry::qvacuum(), ss.str());
715// for (std::size_t l=0; l<this->N_sites; l++) { Mout.setLocBasis((B[l].get_structured_basis().combine(F[l].get_basis())).qloc(),l); }
716
717// auto nop = OperatorType::outerprod(B[locx].Id().structured(), F[locx].n(locy), {1});
718
719// Mout.setLocal(locx, nop.plain<double>());
720// return Mout;
721// }
722
723/*Mpo<Sym::SU2<Sym::ChargeSU2> > KondoU0xSU2::*/
724/*SimpSsub (SPINOP_LABEL SOP1, SPINOP_LABEL SOP2, size_t locx1, size_t locx2, size_t locy1, size_t locy2) const*/
725/*{*/
726/* assert(locx1 < this->N_sites and locx2 < this->N_sites);*/
727/* std::stringstream ss;*/
728/* */
729/* Mpo<Symmetry> Mout(N_sites, Symmetry::qvacuum(), ss.str());*/
730/* for (std::size_t l=0; l<this->N_sites; l++) { Mout.setLocBasis((B[l].get_structured_basis().combine(F[l].get_basis())).qloc(),l); }*/
731/* */
732/* auto Sop1 = OperatorType::outerprod(B[locx1].Scomp(SOP1,locy1).structured(), F[locx2].Id(), {1});*/
733/* auto Sop2 = OperatorType::outerprod(B[locx1].Id().structured(), F[locx2].Scomp(SOP2,locy2), {1});*/
734/* */
735/* Mout.setLocal({locx1,locx2}, {Sop1.plain<double>(),Sop2.plain<double>()});*/
736/* return Mout;*/
737/*}*/
738
739// Mpo<Sym::SU2<Sym::ChargeSU2> > KondoU0xSU2::
740// make_corr (KONDO_SUBSYSTEM SUBSYS, string name1, string name2,
741// size_t locx1, size_t locx2, size_t locy1, size_t locy2,
742// const OperatorType &Op1, const OperatorType &Op2,
743// bool BOTH_HERMITIAN) const
744// {
745// assert(locx1<F.size() and locx2<F.size() and locy1<F[locx1].dim() and locy2<F[locx2].dim());
746// stringstream ss;
747// ss << name1 << "(" << locx1 << "," << locy1 << ")"
748// << name2 << "(" << locx2 << "," << locy2 << ")";
749
750// bool HERMITIAN = (BOTH_HERMITIAN and locx1==locx2 and locy1==locy2)? true:false;
751
752// OperatorType Op1Ext;
753// OperatorType Op2Ext;
754
755// Mpo<Symmetry> Mout(F.size(), Symmetry::qvacuum(), ss.str(), HERMITIAN);
756// for (size_t l=0; l<F.size(); ++l) {Mout.setLocBasis((B[l].get_structured_basis().combine(F[l].get_basis())).qloc(),l);}
757
758// if (SUBSYS == SUB)
759// {
760// Op1Ext = OperatorType::outerprod(B[locx1].Id().structured(), Op1, {1});
761// Op2Ext = OperatorType::outerprod(B[locx2].Id().structured(), Op2, {1});
762// }
763// else if (SUBSYS == IMP)
764// {
765// Op1Ext = OperatorType::outerprod(Op1, F[locx1].Id(), {1});
766// Op2Ext = OperatorType::outerprod(Op2, F[locx2].Id(), {1});
767// }
768// else if (SUBSYS == IMPSUB and locx1 != locx2)
769// {
770// Op1Ext = OperatorType::outerprod(Op1, F[locx1].Id(), {1});
771// Op2Ext = OperatorType::outerprod(B[locx2].Id().structured(), Op2, {1});
772// }
773// else if (SUBSYS == IMPSUB and locx1 == locx2)
774// {
775// OperatorType OpExt = OperatorType::outerprod(Op1, Op2, {1});
776
777// Mout.setLocal(locx1, OpExt.plain<double>());
778// return Mout;
779// }
780
781// Mout.setLocal({locx1,locx2}, {Op1Ext.plain<double>(),Op2Ext.plain<double>()});
782// return Mout;
783// }
784
785// Mpo<Sym::SU2<Sym::ChargeSU2> > KondoU0xSU2::
786// SimpSsub (SPINOP_LABEL SOP1, SPINOP_LABEL SOP2, size_t locx1, size_t locx2, size_t locy1, size_t locy2) const
787// {
788// stringstream ss1; ss1 << SOP1 << "imp";
789// stringstream ss2; ss2 << SOP2 << "sub";
790
791// return make_corr(IMPSUB, ss1.str(),ss2.str(), locx1,locx2,locy1,locy2, B[locx1].Scomp(SOP1,locy1).structured(), F[locx2].Scomp(SOP2,locy2));
792// }
793
794// Mpo<Sym::SU2<Sym::ChargeSU2> > KondoU0xSU2::
795// SimpSimp (SPINOP_LABEL SOP1, SPINOP_LABEL SOP2, size_t locx1, size_t locx2, size_t locy1, size_t locy2) const
796// {
797// stringstream ss1; ss1 << SOP1 << "imp";
798// stringstream ss2; ss2 << SOP2 << "imp";
799
800// return make_corr(IMP, ss1.str(),ss2.str(), locx1,locx2,locy1,locy2, B[locx1].Scomp(SOP1,locy1).structured(), B[locx2].Scomp(SOP2,locy2).structured());
801// }
802
803// Mpo<Sym::SU2<Sym::ChargeSU2> > KondoU0xSU2::
804// SsubSsub (SPINOP_LABEL SOP1, SPINOP_LABEL SOP2, size_t locx1, size_t locx2, size_t locy1, size_t locy2) const
805// {
806// stringstream ss1; ss1 << SOP1 << "sub";
807// stringstream ss2; ss2 << SOP2 << "sub";
808
809// return make_corr(SUB, ss1.str(),ss2.str(), locx1,locx2,locy1,locy2, F[locx1].Scomp(SOP1,locy1), F[locx2].Scomp(SOP2,locy2));
810// }
811
812} //end namespace VMPS
813
814#endif
frac
boost::rational< int > frac
Definition: DmrgExternal.h:11
print_frac_nice
std::string print_frac_nice(frac r)
Definition: DmrgExternal.h:32
DN
@ DN
Definition: DmrgTypedefs.h:38
UP
@ UP
Definition: DmrgTypedefs.h:37
MODEL_FAMILY
MODEL_FAMILY
Definition: DmrgTypedefs.h:96
KONDO
@ KONDO
Definition: DmrgTypedefs.h:96
SZ
@ SZ
Definition: DmrgTypedefs.h:60
SP
@ SP
Definition: DmrgTypedefs.h:60
SM
@ SM
Definition: DmrgTypedefs.h:60
BC
BC
Definition: DmrgTypedefs.h:161
SUB_LATTICE
SUB_LATTICE
Definition: DmrgTypedefs.h:130
B
@ B
Definition: DmrgTypedefs.h:130
kroneckerProduct
SiteOperator< Symmetry, Scalar_ > kroneckerProduct(const SiteOperator< Symmetry, Scalar_ > &O1, const SiteOperator< Symmetry, Scalar_ > &O2)
Definition: SiteOperator.h:164
KondoObservables< Sym::SU2< Sym::ChargeSU2 > >::cdag
std::enable_if< Dummy::IS_SPIN_SU2(), Mpo< Sym::SU2< Sym::ChargeSU2 > > >::type cdag(size_t locx, size_t locy=0, double factor=std::sqrt(2.)) const
Definition: KondoObservables.h:470
KondoObservables< Sym::SU2< Sym::ChargeSU2 > >::c
std::enable_if< Dummy::IS_SPIN_SU2(), Mpo< Sym::SU2< Sym::ChargeSU2 > > >::type c(size_t locx, size_t locy=0, double factor=1.) const
Definition: KondoObservables.h:422
KondoObservables< Sym::SU2< Sym::ChargeSU2 > >::S
std::enable_if< Dummy::IS_SPIN_SU2(), Mpo< Sym::SU2< Sym::ChargeSU2 > > >::type S(size_t locx, size_t locy=0, double factor=1.) const
Definition: KondoObservables.h:129
KondoObservables< Sym::SU2< Sym::ChargeSU2 > >::B
vector< SpinBase< Sym::SU2< Sym::ChargeSU2 > > > B
Definition: KondoObservables.h:208
KondoObservables< Sym::SU2< Sym::ChargeSU2 > >::Sz
std::enable_if<!Dummy::IS_SPIN_SU2(), Mpo< Sym::SU2< Sym::ChargeSU2 > > >::type Sz(size_t locx, size_t locy=0) const
Definition: KondoObservables.h:137
KondoObservables< Sym::SU2< Sym::ChargeSU2 > >::F
vector< FermionBase< Sym::SU2< Sym::ChargeSU2 > > > F
Definition: KondoObservables.h:209
KondoObservables< Sym::SU2< Sym::ChargeSU2 > >::Scomp
std::enable_if<!Dummy::IS_SPIN_SU2(), Mpo< Sym::SU2< Sym::ChargeSU2 > > >::type Scomp(SPINOP_LABEL Sa, size_t locx, size_t locy=0, double factor=1.) const
Definition: KondoObservables.h:133
MpoTerms::N_phys
std::size_t N_phys
Definition: MpoTerms.h:400
MpoTerms::finalize
void finalize(const bool COMPRESS=true, const std::size_t power=1, const double tolerance=::mynumeric_limits< double >::epsilon())
Definition: MpoTerms.h:1281
MpoTerms::N_sites
std::size_t N_sites
Definition: MpoTerms.h:395
MpoTerms::setLocBasis
void setLocBasis(const std::vector< std::vector< qType > > &q)
Definition: MpoTerms.h:715
MpoTerms::VERB
DMRG::VERBOSITY::OPTION VERB
Definition: MpoTerms.h:102
MpoTerms::set_name
void set_name(const std::string &label_in)
Definition: MpoTerms.h:471
MpoTerms::label
std::string label
Definition: MpoTerms.h:615
Mpo
Definition: Mpo.h:40
Mpo< Sym::SU2< Sym::ChargeSU2 >, double >::precalc_TwoSiteData
void precalc_TwoSiteData(bool FORCE=false)
Mpo< Sym::SU2< Sym::ChargeSU2 >, double >::construct_from_pushlist
void construct_from_pushlist(const PushType< OperatorType, CouplScalar > &pushlist, const std::vector< std::vector< std::string > > &labellist, size_t Lcell)
Sym::SU2
Definition: SU2.h:36
VMPS::KondoU0xSU2
Kondo Model.
Definition: KondoU0xSU2.h:34
VMPS::KondoU0xSU2::Index
Eigen::Index Index
Definition: KondoU0xSU2.h:42
VMPS::KondoU0xSU2::singlet
static qarray< 1 > singlet(int N)
Definition: KondoU0xSU2.h:52
VMPS::KondoU0xSU2::MatrixType
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > MatrixType
Definition: KondoU0xSU2.h:38
VMPS::KondoU0xSU2::OperatorType
SiteOperatorQ< Symmetry, MatrixType > OperatorType
Definition: KondoU0xSU2.h:37
VMPS::KondoU0xSU2::defaults
static const std::map< string, std::any > defaults
Definition: KondoU0xSU2.h:77
VMPS::KondoU0xSU2::qType
Symmetry::qType qType
Definition: KondoU0xSU2.h:43
VMPS::KondoU0xSU2::set_operators
static void set_operators(const std::vector< SpinBase< Symmetry_ > > &B, const std::vector< FermionBase< Symmetry_ > > &F, const vector< SUB_LATTICE > &G, const ParamHandler &P, PushType< SiteOperator< Symmetry_, double >, double > &pushlist, std::vector< std::vector< std::string > > &labellist, const BC boundary=BC::OPEN)
Definition: KondoU0xSU2.h:143
VMPS::KondoU0xSU2::Symmetry
Sym::SU2< Sym::ChargeSU2 > Symmetry
Definition: KondoU0xSU2.h:36
VMPS::KondoU0xSU2::FAMILY
static constexpr MODEL_FAMILY FAMILY
Definition: KondoU0xSU2.h:53
VMPS::KondoU0xSU2::sweep_defaults
static const map< string, any > sweep_defaults
Definition: KondoU0xSU2.h:78
MAKE_TYPEDEFS
#define MAKE_TYPEDEFS(MODEL)
Definition: macros.h:4
PROP::COMPRESS
const bool COMPRESS
Definition: DmrgTypedefs.h:499
PROP::FERMIONIC
const bool FERMIONIC
Definition: DmrgTypedefs.h:496
qarray
Definition: qarray.h:26