VMPS++
Loading...
Searching...
No Matches
HeisenbergU1.h
Go to the documentation of this file.
1#ifndef STRAWBERRY_HEISENBERGU1
2#define STRAWBERRY_HEISENBERGU1
3
4//include <array>
5
6//include "Mpo.h"
7#include "symmetry/U1.h"
8#include "models/HeisenbergObservables.h"
9//include "bases/SpinBase.h"
10//include "DmrgExternal.h"
11//include "ParamHandler.h" // from HELPERS
12//include "symmetry/kind_dummies.h"
13#include "ParamReturner.h"
14#include "Geometry2D.h" // from TOOLS
15
16namespace VMPS
17{
18
40class HeisenbergU1 : public Mpo<Sym::U1<Sym::SpinU1>,double>, public HeisenbergObservables<Sym::U1<Sym::SpinU1> >, public ParamReturner
41{
42public:
43
44 typedef Sym::U1<Sym::SpinU1> Symmetry;
45 MAKE_TYPEDEFS(HeisenbergU1)
46
47 static qarray<1> singlet (int N=0) {return qarray<1>{0};};
48 static constexpr MODEL_FAMILY FAMILY = HEISENBERG;
49
50public:
51 typedef Symmetry::qType qType;
52 typedef SiteOperator<Symmetry,SparseMatrix<double> > OperatorType;
53
54public:
55
57 HeisenbergU1() : Mpo<Symmetry>(), ParamReturner(HeisenbergU1::sweep_defaults) {};
58
59 HeisenbergU1(Mpo<Symmetry> &Mpo_input, const vector<Param> &params)
60 :Mpo<Symmetry>(Mpo_input),
61 HeisenbergObservables(this->N_sites,params,HeisenbergU1::defaults),
62 ParamReturner(HeisenbergU1::sweep_defaults)
63 {
64 ParamHandler P(params,HeisenbergU1::defaults);
65 size_t Lcell = P.size();
66 N_phys = 0;
67 for (size_t l=0; l<N_sites; ++l) N_phys += P.get<size_t>("Ly",l%Lcell);
68 this->precalc_TwoSiteData();
69 this->HERMITIAN = true;
70 this->HAMILTONIAN = true;
71 };
72
73 HeisenbergU1 (const size_t &L, const BC &boundary=BC::OPEN, const DMRG::VERBOSITY::OPTION &VERB=DMRG::VERBOSITY::OPTION::ON_EXIT);
74
75 HeisenbergU1 (const size_t &L, const vector<Param> &params, const BC & boundary=BC::OPEN, const DMRG::VERBOSITY::OPTION &VERB=DMRG::VERBOSITY::OPTION::ON_EXIT);
77
87 template<typename Symmetry_>
88 static void set_operators (const std::vector<SpinBase<Symmetry_> > &B, const ParamHandler &P, PushType<SiteOperator<Symmetry_,double>,double>& pushlist, std::vector<std::vector<std::string>>& labellist, const BC boundary=BC::OPEN);
89
94 bool validate (qarray<1> qnum) const;
95
96 static const std::map<string,std::any> defaults;
97 static const std::map<string,std::any> sweep_defaults;
98};
99
100const std::map<string,std::any> HeisenbergU1::defaults =
101{
102 {"J",0.}, {"Jprime",0.}, {"Jrung",0.},
103 {"Jxy",0.}, {"Jxyprime",0.}, {"Jxyrung",0.},
104 {"Jz",0.}, {"Jzprime",0.}, {"Jzrung",0.},
105 {"R",0.},
106 {"Dy",0.}, {"Dyprime",0.}, {"Dyrung",0.},
107 {"Bz",0.}, {"Kz",0.},
108 {"mu",0.}, {"nu",0.}, // couple to Sz_i-1/2 and Sz_i+1/2
109 {"D",2ul}, {"maxPower",2ul}, {"CYLINDER",false}, {"Ly",1ul}, {"mfactor",1}
110};
111
112const std::map<string,std::any> HeisenbergU1::sweep_defaults =
113{
114 {"max_alpha",100.}, {"min_alpha",1.e-11}, {"lim_alpha",10ul}, {"eps_svd",1.e-7},
115 {"Mincr_abs", 50ul}, {"Mincr_per", 2ul}, {"Mincr_rel", 1.1},
116 {"min_Nsv",0ul}, {"max_Nrich",-1},
117 {"max_halfsweeps",20ul}, {"min_halfsweeps",4ul},
118 {"Minit",1ul}, {"Qinit",1ul}, {"Mlimit",1000ul},
119 {"tol_eigval",1e-7}, {"tol_state",1e-6},
120 {"savePeriod",0ul}, {"CALC_S_ON_EXIT", true}, {"CONVTEST", DMRG::CONVTEST::VAR_2SITE}
121};
122
123HeisenbergU1::
124HeisenbergU1 (const size_t &L, const BC &boundary, const DMRG::VERBOSITY::OPTION &VERB)
125:Mpo<Symmetry> (L, qarray<Symmetry::Nq>({0}), "", PROP::HERMITIAN, PROP::NON_UNITARY, boundary,VERB),
126HeisenbergObservables(L),
127ParamReturner(HeisenbergU1::sweep_defaults)
128{}
129
130HeisenbergU1::
131HeisenbergU1 (const size_t &L, const vector<Param> &params, const BC &boundary, const DMRG::VERBOSITY::OPTION &VERB)
132:Mpo<Symmetry> (L, qarray<Symmetry::Nq>({0}), "", PROP::HERMITIAN, PROP::NON_UNITARY, boundary, VERB),
133 HeisenbergObservables(L,params,HeisenbergU1::defaults),
134 ParamReturner(HeisenbergU1::sweep_defaults)
135{
136 ParamHandler P(params,defaults);
137 size_t Lcell = P.size();
138
139 for (size_t l=0; l<N_sites; ++l)
140 {
141 N_phys += P.get<size_t>("Ly",l%Lcell);
142 setLocBasis(B[l].get_basis().qloc(),l);
143 }
144
145 if (P.HAS_ANY_OF({"Jxy", "Jxypara", "Jxyperp", "Jxyfull"}))
146 {
147 this->set_name("XXZ");
148 }
149 else if (P.HAS_ANY_OF({"Jz", "Jzpara", "Jzperp", "Jzfull"}))
150 {
151 this->set_name("Ising");
152 }
153 else
154 {
155 this->set_name("Heisenberg");
156 }
157
158 PushType<SiteOperator<Symmetry,double>,double> pushlist;
159 std::vector<std::vector<std::string>> labellist;
160 set_operators(B, P, pushlist, labellist, boundary);
161
162 this->construct_from_pushlist(pushlist, labellist, Lcell);
163 this->finalize(PROP::COMPRESS, P.get<size_t>("maxPower"));
164
165 this->precalc_TwoSiteData();
166}
167
168bool HeisenbergU1::
169validate (qarray<1> qnum) const
170{
171 frac Smax(0,1);
172 frac q_in(qnum[0],2);
173 for (size_t l=0; l<N_sites; ++l) { Smax+=frac(B[l].get_D()-1,2); }
174 if (Smax.denominator()==q_in.denominator() and q_in <= Smax) {return true;}
175 else {return false;}
176}
177
178template<typename Symmetry_>
179void HeisenbergU1::
180set_operators (const std::vector<SpinBase<Symmetry_> > &B, const ParamHandler &P, PushType<SiteOperator<Symmetry_,double>,double>& pushlist, std::vector<std::vector<std::string>>& labellist, const BC boundary)
181{
182 std::size_t Lcell = P.size();
183 std::size_t N_sites = B.size();
184
185 if (labellist.size() != N_sites) {labellist.resize(N_sites);}
186
187 for (std::size_t loc=0; loc<N_sites; ++loc)
188 {
189 size_t lp1 = (loc+1)%N_sites;
190 size_t lp2 = (loc+2)%N_sites;
191
192 std::size_t orbitals = B[loc].orbitals();
193 std::size_t next_orbitals = B[lp1].orbitals();
194 std::size_t nextn_orbitals = B[lp2].orbitals();
195
196 stringstream ss1, ss2;
197 ss1 << "S=" << print_frac_nice(frac(P.get<size_t>("D",loc%Lcell)-1,2));
198 ss2 << "Ly=" << P.get<size_t>("Ly",loc%Lcell);
199 labellist[loc].push_back(ss1.str());
200 labellist[loc].push_back(ss2.str());
201
202 auto push_full = [&N_sites, &loc, &B, &P, &pushlist, &labellist, &boundary]
203 (string xxxFull, string label,
204 const vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > &first,
205 const vector<vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > > &last,
206 vector<double> factor) -> void
207 {
208 ArrayXXd Full = P.get<Eigen::ArrayXXd>(xxxFull);
209 vector<vector<std::pair<size_t,double> > > R = Geometry2D::rangeFormat(Full);
210
211 if (static_cast<bool>(boundary)) {assert(R.size() == N_sites and "Use an (N_sites)x(N_sites) hopping matrix for open BC!");}
212 else {assert(R.size() >= 2*N_sites and "Use at least a (2*N_sites)x(N_sites) hopping matrix for infinite BC!");}
213
214 for (size_t j=0; j<first.size(); j++)
215 for (size_t h=0; h<R[loc].size(); ++h)
216 {
217 size_t range = R[loc][h].first;
218 double value = R[loc][h].second;
219
220 if (range != 0)
221 {
222 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > ops(range+1);
223 ops[0] = first[j];
224 for (size_t i=1; i<range; ++i)
225 {
226 ops[i] = B[(loc+i)%N_sites].Id();
227 }
228 ops[range] = last[j][(loc+range)%N_sites];
229 pushlist.push_back(std::make_tuple(loc, ops, factor[j] * value));
230 }
231 }
232
233 stringstream ss;
234 ss << label << "(" << Geometry2D::hoppingInfo(Full) << ")";
235 labellist[loc].push_back(ss.str());
236 };
237
238 // Local terms: B, K and J⟂
239
240 param1d Bz = P.fill_array1d<double>("Bz", "Bzorb", orbitals, loc%Lcell);
241 param1d Kz = P.fill_array1d<double>("Kz", "Kzorb", orbitals, loc%Lcell);
242 param2d Jperp = P.fill_array2d<double>("Jrung", "J", "Jperp", orbitals, loc%Lcell, P.get<bool>("CYLINDER"));
243 param2d Jxyperp = P.fill_array2d<double>("Jxyrung", "Jxy", "Jxyperp", orbitals, loc%Lcell, P.get<bool>("CYLINDER"));
244 param2d Jzperp = P.fill_array2d<double>("Jzrung", "Jz", "Jzperp", orbitals, loc%Lcell, P.get<bool>("CYLINDER"));
245 param1d mu = P.fill_array1d<double>("mu", "muorb", orbitals, loc%Lcell);
246 param1d nu = P.fill_array1d<double>("nu", "nuorb", orbitals, loc%Lcell);
247
248 labellist[loc].push_back(Bz.label);
249 labellist[loc].push_back(Kz.label);
250 labellist[loc].push_back(Jperp.label);
251 labellist[loc].push_back(Jxyperp.label);
252 labellist[loc].push_back(Jzperp.label);
253 labellist[loc].push_back(mu.label);
254 labellist[loc].push_back(nu.label);
255
256 Eigen::ArrayXd Bx_array = B[loc].ZeroField();
257 Eigen::ArrayXd Kx_array = B[loc].ZeroField();
258 Eigen::ArrayXXd Dyperp_array = B[loc].ZeroHopping();
259
260 auto sum_array = [] (const ArrayXXd& a1, const ArrayXXd& a2)
261 {
262 ArrayXXd res(a1.rows(), a1.cols());
263 for (int i=0; i<a1.rows(); ++i)
264 for (int j=0; j<a1.rows(); ++j)
265 {
266 res(i,j) = a1(i,j) + a2(i,j);
267 }
268 return res;
269 };
270
271 auto Hloc = Mpo<Symmetry,double>::get_N_site_interaction(
272 B[loc].HeisenbergHamiltonian(sum_array(Jperp.a,Jxyperp.a), sum_array(Jperp.a,Jzperp.a), Bz.a, mu.a, nu.a, Kz.a));
273 pushlist.push_back(std::make_tuple(loc, Hloc, 1.));
274
275 // Full J-matrices
276 if (P.HAS("Jfull"))
277 {
278 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > first {B[loc].Sp(0), B[loc].Sm(0), B[loc].Sz(0)};
279 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Sp_ranges(N_sites);
280 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Sm_ranges(N_sites);
281 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Sz_ranges(N_sites);
282 for (size_t i=0; i<N_sites; i++) {Sp_ranges[i] = B[i].Sp(0); Sm_ranges[i] = B[i].Sm(0); Sz_ranges[i] = B[i].Sz(0);}
283
284 vector<vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > > last {Sm_ranges, Sp_ranges, Sz_ranges};
285 push_full("Jfull", "Jᵢⱼ", first, last, {0.5,0.5,1.0});
286 }
287 if (P.HAS("Jxyfull"))
288 {
289 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > first {B[loc].Sp(0), B[loc].Sm(0)};
290 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Sp_ranges(N_sites);
291 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Sm_ranges(N_sites);
292 for (size_t i=0; i<N_sites; i++) {Sp_ranges[i] = B[i].Sp(0); Sm_ranges[i] = B[i].Sm(0);}
293
294 vector<vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > > last {Sm_ranges, Sp_ranges};
295 push_full("Jxyfull", "Jxyᵢⱼ", first, last, {0.5,0.5});
296 }
297 if (P.HAS("Jzfull"))
298 {
299 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > first {B[loc].Sz(0)};
300 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Sz_ranges(N_sites);
301 for (size_t i=0; i<N_sites; i++) {Sz_ranges[i] = B[i].Sz(0);}
302
303 vector<vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > > last {Sz_ranges};
304 push_full("Jzfull", "Jzᵢⱼ", first, last, {1.0});
305 }
306 if (P.HAS("JxyfullA"))
307 {
308 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > first {B[loc].Sp(1), B[loc].Sm(1)};
309 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Sp_ranges(N_sites);
310 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Sm_ranges(N_sites);
311 for (size_t i=0; i<N_sites; i++) {Sp_ranges[i] = B[i].Sp(1);
312 Sm_ranges[i] = B[i].Sm(1);}
313
314 vector<vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > > last {Sm_ranges, Sp_ranges};
315 push_full("JxyfullA", "JxyAᵢⱼ", first, last, {0.5,0.5});
316 }
317 if (P.HAS("JzfullA"))
318 {
319 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > first {B[loc].Sz(1)};
320 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Sz_ranges(N_sites);
321 for (size_t i=0; i<N_sites; i++) {Sz_ranges[i] = B[i].Sz(1);}
322
323 vector<vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > > last {Sz_ranges};
324 push_full("JzfullA", "JzAᵢⱼ", first, last, {1.0});
325 }
326 if (P.HAS("Rfull"))
327 {
328 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > first {B[loc].Qp(0), B[loc].Qm(0), B[loc].Qz(0), B[loc].Qpz(0), B[loc].Qmz(0)};
329 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Qp_ranges(N_sites);
330 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Qm_ranges(N_sites);
331 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Qz_ranges(N_sites);
332 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Qpz_ranges(N_sites);
333 vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > Qmz_ranges(N_sites);
334 for (size_t i=0; i<N_sites; i++)
335 {
336 Qp_ranges[i] = B[i].Qp(0);
337 Qm_ranges[i] = B[i].Qm(0);
338 Qz_ranges[i] = B[i].Qz(0);
339 Qpz_ranges[i] = B[i].Qpz(0);
340 Qmz_ranges[i] = B[i].Qmz(0);
341 }
342
343 vector<vector<SiteOperatorQ<Symmetry_,Eigen::MatrixXd> > > last {Qm_ranges, Qp_ranges, Qz_ranges, Qmz_ranges, Qpz_ranges};
344 push_full("Rfull", "Rᵢⱼ", first, last, {0.5, 0.5, 1.0, 0.5, 0.5});
345 }
346
347 if (P.HAS("Jfull") or P.HAS("Jxyfull") or P.HAS("Jzfull") or P.HAS("Rfull")) continue;
348
349 // Nearest-neighbour terms: Jxy, Jz, J
350 param2d Jxypara = P.fill_array2d<double>("Jxy", "Jxypara", {orbitals, next_orbitals}, loc%Lcell);
351 param2d Jzpara = P.fill_array2d<double>("Jz", "Jzpara", {orbitals, next_orbitals}, loc%Lcell);
352 param2d Jpara = P.fill_array2d<double>("J", "Jpara", {orbitals, next_orbitals}, loc%Lcell);
353 labellist[loc].push_back(Jxypara.label);
354 labellist[loc].push_back(Jzpara.label);
355 labellist[loc].push_back(Jpara.label);
356
357 if (loc < N_sites-1 or !static_cast<bool>(boundary))
358 {
359 for (std::size_t alfa=0; alfa < orbitals; ++alfa)
360 for (std::size_t beta=0; beta < next_orbitals; ++beta)
361 {
362 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry,double>::get_N_site_interaction(B[loc].Scomp(SP,alfa),
363 B[lp1].Scomp(SM,beta)),
364 0.5*Jxypara(alfa,beta)+0.5*Jpara(alfa,beta)));
365 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry,double>::get_N_site_interaction(B[loc].Scomp(SM,alfa),
366 B[lp1].Scomp(SP,beta)),
367 0.5*Jxypara(alfa,beta)+0.5*Jpara(alfa,beta)));
368 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry,double>::get_N_site_interaction(B[loc].Scomp(SZ,alfa),
369 B[lp1].Scomp(SZ,beta)),
370 Jzpara(alfa,beta)+Jpara(alfa,beta)));
371 }
372 }
373
374 // Nearest-neighbour terms: R
375 param2d Rpara = P.fill_array2d<double>("R", "Rpara", {orbitals, next_orbitals}, loc%Lcell);
376 labellist[loc].push_back(Rpara.label);
377
378 if (loc < N_sites-1 or !static_cast<bool>(boundary))
379 {
380 for (std::size_t alfa=0; alfa < orbitals; ++alfa)
381 for (std::size_t beta=0; beta < next_orbitals; ++beta)
382 {
383 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry,double>::get_N_site_interaction(B[loc].Qp(alfa),
384 B[lp1].Qm(beta)),
385 0.5*Rpara(alfa,beta)));
386 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry,double>::get_N_site_interaction(B[loc].Qm(alfa),
387 B[lp1].Qp(beta)),
388 0.5*Rpara(alfa,beta)));
389 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry,double>::get_N_site_interaction(B[loc].Qpz(alfa),
390 B[lp1].Qmz(beta)),
391 0.5*Rpara(alfa,beta)));
392 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry,double>::get_N_site_interaction(B[loc].Qmz(alfa),
393 B[lp1].Qpz(beta)),
394 0.5*Rpara(alfa,beta)));
395 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry,double>::get_N_site_interaction(B[loc].Qz(alfa),
396 B[lp1].Qz(beta)),
397 Rpara(alfa,beta)));
398 }
399 }
400
401 // Next-nearest-neighbour terms: Jxy, Jz, J
402 param2d Jxyprime = P.fill_array2d<double>("Jxyprime", "Jxyprime_array", {orbitals, nextn_orbitals}, loc%Lcell);
403 param2d Jzprime = P.fill_array2d<double>("Jzprime", "Jzprime_array", {orbitals, nextn_orbitals}, loc%Lcell);
404 param2d Jprime = P.fill_array2d<double>("Jprime", "Jprime_array", {orbitals, nextn_orbitals}, loc%Lcell);
405 labellist[loc].push_back(Jxyprime.label);
406 labellist[loc].push_back(Jzprime.label);
407 labellist[loc].push_back(Jprime.label);
408
409 if (loc < N_sites-2 or !static_cast<bool>(boundary))
410 {
411 for (std::size_t alfa=0; alfa < orbitals; ++alfa)
412 for (std::size_t beta=0; beta < nextn_orbitals; ++beta)
413 {
414 pushlist.push_back(std::make_tuple(loc,Mpo<Symmetry,double>::get_N_site_interaction(B[loc].Scomp(SP,alfa),
415 B[lp1].Id(),
416 B[lp2].Scomp(SM,beta)),
417 0.5*Jxyprime(alfa,beta)+0.5*Jprime(alfa,beta)));
418 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry,double>::get_N_site_interaction(B[loc].Scomp(SM,alfa),
419 B[lp1].Id(),
420 B[lp2].Scomp(SP,beta)),
421 0.5*Jxyprime(alfa,beta)+0.5*Jprime(alfa,beta)));
422 pushlist.push_back(std::make_tuple(loc, Mpo<Symmetry,double>::get_N_site_interaction(B[loc].Scomp(SZ,alfa),
423 B[lp1].Id(),
424 B[lp2].Scomp(SZ,beta)),
425 Jzprime(alfa,beta)+Jprime(alfa,beta)));
426 }
427 }
428 }
429}
430
431} //end namespace VMPS
432
433#endif
frac
boost::rational< int > frac
Definition: DmrgExternal.h:11
print_frac_nice
std::string print_frac_nice(frac r)
Definition: DmrgExternal.h:32
MODEL_FAMILY
MODEL_FAMILY
Definition: DmrgTypedefs.h:96
HEISENBERG
@ HEISENBERG
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
B
@ B
Definition: DmrgTypedefs.h:130
HeisenbergObservables< Sym::U1< Sym::SpinU1 > >::B
vector< SpinBase< Sym::U1< Sym::SpinU1 > > > B
Definition: HeisenbergObservables.h:159
HeisenbergObservables< Sym::U1< Sym::SpinU1 > >::Scomp
std::enable_if<!Dummy::IS_SPIN_SU2(), Mpo< Sym::U1< Sym::SpinU1 >, double > >::type Scomp(SPINOP_LABEL Sa, size_t locx, size_t locy=0, double factor=1.) const
Definition: HeisenbergObservables.h:332
MpoTerms::N_phys
std::size_t N_phys
Definition: MpoTerms.h:400
MpoTerms::N_sites
std::size_t N_sites
Definition: MpoTerms.h:395
MpoTerms::VERB
DMRG::VERBOSITY::OPTION VERB
Definition: MpoTerms.h:102
MpoTerms::label
std::string label
Definition: MpoTerms.h:615
Mpo
Definition: Mpo.h:40
Mpo::get_N_site_interaction
static std::vector< T > get_N_site_interaction(T const &Op0, Operator const &... Ops)
Definition: Mpo.h:117
Mpo< Sym::U1< Sym::SpinU1 >, double >::precalc_TwoSiteData
void precalc_TwoSiteData(bool FORCE=false)
Sym::U1
Definition: U1.h:25
VMPS::HeisenbergU1
Heisenberg Model.
Definition: HeisenbergU1.h:41
VMPS::HeisenbergU1::OperatorType
SiteOperator< Symmetry, SparseMatrix< double > > OperatorType
Definition: HeisenbergU1.h:52
VMPS::HeisenbergU1::HeisenbergU1
HeisenbergU1(Mpo< Symmetry > &Mpo_input, const vector< Param > &params)
Definition: HeisenbergU1.h:59
VMPS::HeisenbergU1::validate
bool validate(qarray< 1 > qnum) const
Definition: HeisenbergU1.h:169
VMPS::HeisenbergU1::singlet
static qarray< 1 > singlet(int N=0)
Definition: HeisenbergU1.h:47
VMPS::HeisenbergU1::sweep_defaults
static const std::map< string, std::any > sweep_defaults
Definition: HeisenbergU1.h:97
VMPS::HeisenbergU1::qType
Symmetry::qType qType
Definition: HeisenbergU1.h:51
VMPS::HeisenbergU1::Symmetry
Sym::U1< Sym::SpinU1 > Symmetry
Definition: HeisenbergU1.h:44
VMPS::HeisenbergU1::FAMILY
static constexpr MODEL_FAMILY FAMILY
Definition: HeisenbergU1.h:48
VMPS::HeisenbergU1::defaults
static const std::map< string, std::any > defaults
Definition: HeisenbergU1.h:96
VMPS::HeisenbergU1::set_operators
static void set_operators(const std::vector< SpinBase< Symmetry_ > > &B, const ParamHandler &P, PushType< SiteOperator< Symmetry_, double >, double > &pushlist, std::vector< std::vector< std::string > > &labellist, const BC boundary=BC::OPEN)
Definition: HeisenbergU1.h:180
MAKE_TYPEDEFS
#define MAKE_TYPEDEFS(MODEL)
Definition: macros.h:4
PROP::COMPRESS
const bool COMPRESS
Definition: DmrgTypedefs.h:499
PROP::NON_UNITARY
const bool NON_UNITARY
Definition: DmrgTypedefs.h:495
PROP::HERMITIAN
const bool HERMITIAN
Definition: DmrgTypedefs.h:492
Sym::finalize
void finalize(bool PRINT_STATS=false)
Definition: functions.h:127
qarray
Definition: qarray.h:26