28 #ifndef MPS_INITIALIZER_H
29 #define MPS_INITIALIZER_H
35 #include <boost/tokenizer.hpp>
45 template<
class Matrix,
class SymmGroup>
50 typename SymmGroup::charge right_end_,
51 std::vector<int>
const& site_type_)
65 std::size_t L = mps.
length();
67 maquis::cout <<
"Right end: " <<
right_end << std::endl;
73 mps[i].divide_by_scalar(mps[i].scalar_norm());
77 maquis::cout <<
"init norm: " <<
norm(mps) << std::endl;
88 template<
class Matrix,
class SymmGroup>
93 typename SymmGroup::charge right_end,
94 std::vector<int>
const& site_type)
95 :
di(parms, phys_dims, right_end, site_type)
100 di.init_sectors(mps,
di.init_bond_dimension,
false, 1.);
106 template<
class Matrix,
class SymmGroup>
111 typename SymmGroup::charge right_end,
112 std::vector<int>
const& site_type)
113 :
di(parms, phys_dims, right_end, site_type)
118 di.init_sectors(mps, 5,
true);
125 template<
class Matrix,
class SymmGroup>
130 typename SymmGroup::charge right_end,
131 std::vector<int>
const& site_type)
132 :
di(parms, phys_dims, right_end, site_type)
137 di.init_sectors(mps, 5,
false, 1.);
145 template<
class Matrix,
class SymmGroup>
149 std::vector<int>
const& site_type_)
150 : phys_dims(phys_dims_)
151 , site_type(site_type_)
156 std::size_t L = mps.
length();
159 triv.
insert( std::make_pair(SymmGroup::IdentityCharge, 1) );
161 for (
int i = 0; i < L; ++i)
166 std::vector<Index<SymmGroup> > phys_dims;
167 std::vector<int> site_type;
275 template<
class Matrix,
class SymmGroup>
281 std::vector<int>
const& site_type_)
282 : coeff(params[
"init_coeff"].as<std::vector<double> >())
283 , phys_dims(phys_dims_)
284 , site_type(site_type_)
289 assert(coeff.size() == mps.
length());
290 if (phys_dims[0].size() != 1)
throw std::runtime_error(
"coherent_mps_init only for TrivialGroup.");
292 typedef typename SymmGroup::charge charge;
294 using std::exp;
using std::sqrt;
using std::pow;
295 using boost::math::factorial;
297 size_t L = coeff.size();
300 trivial_i.
insert(std::make_pair(SymmGroup::IdentityCharge, 1));
302 for (
int p=0; p<L; ++p) {
304 Matrix m(phys_dims[site_type[p]][s].second, 1, 0.);
305 for (
int ss=0; ss<phys_dims[site_type[p]][s].second; ++ss) {
306 m(ss, 0) = pow(coeff[p], ss) *
sqrt(factorial<double>(ss)) / factorial<double>(ss);
309 block.
insert_block(m, SymmGroup::IdentityCharge, SymmGroup::IdentityCharge);
318 std::vector<double> coeff;
319 std::vector<Index<SymmGroup> > phys_dims;
320 std::vector<int> site_type;
323 template<
class Matrix,
class SymmGroup>
329 std::vector<int>
const& site_type_)
330 : coeff(params[
"init_coeff"].as<std::vector<double> >())
331 , phys_rho_dims(phys_dims_)
332 , site_type(site_type_)
339 assert(coeff.size() == mps.
length());
340 if (phys_rho_dims[0].size() != 1)
throw std::runtime_error(
"coherent_dm_mps_init only for TrivialGroup.");
342 std::vector<Index<SymmGroup> > phys_psi_dims(phys_rho_dims.size());
343 for (
int type=0; type<phys_rho_dims.size(); ++type)
344 phys_psi_dims[type].insert( std::make_pair( SymmGroup::IdentityCharge, static_cast<size_t>(
sqrt(
double(phys_rho_dims[type][0].second))) ) );
346 typedef typename SymmGroup::charge charge;
348 using std::exp;
using std::sqrt;
using std::pow;
349 using boost::math::factorial;
351 size_t L = coeff.size();
354 trivial_i.
insert(std::make_pair(SymmGroup::IdentityCharge, 1));
356 for (
int p=0; p<L; ++p) {
358 Matrix m(phys_rho_dims[site_type[p]][s].second, 1, 0.);
359 for (
int ss1=0; ss1<phys_psi_dims[site_type[p]][s].second; ++ss1)
360 for (
int ss2=0; ss2<phys_psi_dims[site_type[p]][s].second; ++ss2) {
361 m(ss1*phys_psi_dims[site_type[p]][s].second+ss2, 0) = pow(coeff[p], ss1) *
sqrt(factorial<double>(ss1)) / factorial<double>(ss1);
362 m(ss1*phys_psi_dims[site_type[p]][s].second+ss2, 0) *= pow(coeff[p], ss2) *
sqrt(factorial<double>(ss2)) / factorial<double>(ss2);
365 block.
insert_block(m, SymmGroup::IdentityCharge, SymmGroup::IdentityCharge);
374 std::vector<double> coeff;
375 std::vector<Index<SymmGroup> > phys_rho_dims;
376 std::vector<int> site_type;
379 template<
class Matrix,
class SymmGroup>
385 std::vector<int>
const& site_type_)
387 : occupation(params[
"init_basis_state"].as<std::vector<int> >())
388 , phys_dims(phys_dims_)
389 , site_type(site_type_)
394 assert(occupation.size() == mps.
length());
395 if (phys_dims[0].size() != 1)
throw std::runtime_error(
"basis_mps_init only for TrivialGroup.");
396 typedef typename SymmGroup::charge charge;
397 charge C = SymmGroup::IdentityCharge;
399 std::vector<boost::tuple<charge, size_t> > state(mps.
length());
400 for (
int i=0; i<mps.
length(); ++i)
401 state[i] = boost::make_tuple(C, occupation[i]);
402 mps = state_mps<Matrix>(state, phys_dims, site_type);
406 std::vector<int> occupation;
407 std::vector<Index<SymmGroup> > phys_dims;
408 std::vector<int> site_type;
411 template<
class Matrix,
class SymmGroup>
417 std::vector<int>
const& site_type_)
418 : occupation(params[
"init_basis_state"].as<std::vector<int> >())
419 , phys_rho_dims(phys_dims_)
420 , site_type(site_type_)
425 assert(occupation.size() == mps.
length());
426 if (phys_rho_dims.size() != 1)
throw std::runtime_error(
"basis_dm_mps_init only for unique site basis.");
427 if (phys_rho_dims[0].size() != 1)
throw std::runtime_error(
"basis_dm_mps_init only for TrivialGroup.");
428 typedef typename SymmGroup::charge charge;
429 charge C = SymmGroup::IdentityCharge;
432 size_t N =
sqrt(
double(phys_rho_dims[0][0].second));
434 std::vector<boost::tuple<charge, size_t> > state(mps.
length());
435 for (
int i=0; i<mps.
length(); ++i)
436 state[i] = boost::make_tuple(C, occupation[i] + occupation[i]*N);
437 mps = state_mps<Matrix>(state, phys_rho_dims, site_type);
441 std::vector<int> occupation;
442 std::vector<Index<SymmGroup> > phys_rho_dims;
443 std::vector<int> site_type;
446 template<
class Matrix,
class SymmGroup>
450 typedef std::vector<boost::tuple<typename SymmGroup::charge, size_t> >
state_type;
453 typename SymmGroup::charge right_end_,
454 std::vector<int>
const& site_type_)
455 : basis_index(params[
"init_basis_state"].as<std::vector<int> >())
456 , phys_dims(phys_dims_)
457 , right_end(right_end_)
458 , site_type(site_type_)
463 typename SymmGroup::charge right_end_,
464 std::vector<int>
const& site_type_)
465 : phys_dims(phys_dims_)
466 , right_end(right_end_)
467 , site_type(site_type_)
473 if (state.size() == 0) {
474 assert(basis_index.size() == mps.
length());
475 state.resize(mps.
length());
476 maquis::cout <<
"state: ";
477 for (
int i=0; i<mps.
length(); ++i) {
478 state[i] = phys_dims[site_type[i]].element(basis_index[i]);
479 maquis::cout << boost::get<0>(state[i]) <<
":" << boost::get<1>(state[i])<<
" ";
481 maquis::cout <<
"\n";
484 mps = state_mps<Matrix>(state, phys_dims, site_type);
486 throw std::runtime_error(
"Initial state does not satisfy total quantum numbers.");
490 std::vector<int> basis_index;
491 std::vector<Index<SymmGroup> > phys_dims;
492 typename SymmGroup::charge right_end;
493 std::vector<int> site_type;
void operator()(MPS< Matrix, SymmGroup > &mps)
SymmGroup::charge right_end
empty_mps_init(std::vector< Index< SymmGroup > > const &phys_dims_, std::vector< int > const &site_type_)
functions to compress the MPS
void operator()(MPS< Matrix, SymmGroup > &mps)
initialize all allowed quantum number sectors in the MPS
default_mps_init< Matrix, SymmGroup > di
void operator()(MPS< Matrix, SymmGroup > &mps)
basis_mps_init_generic(BaseParameters ¶ms, std::vector< Index< SymmGroup > > const &phys_dims_, typename SymmGroup::charge right_end_, std::vector< int > const &site_type_)
declaration of the MPS class (vector of MPSTensor)
default_mps_init(BaseParameters &parms, std::vector< Index< SymmGroup > > const &phys_dims_, typename SymmGroup::charge right_end_, std::vector< int > const &site_type_)
void swap(MPSTensor< Matrix, SymmGroup > &x, MPSTensor< Matrix, SymmGroup > &y)
convert a basis state into MPS
void init_sectors(MPS< Matrix, SymmGroup > &mps, size_t Mmax, bool fillrand=true, typename Matrix::value_type val=0)
size_type insert_block(Matrix const &, charge, charge)
void operator()(MPS< Matrix, SymmGroup > &mps)
basis_mps_init(BaseParameters ¶ms, std::vector< Index< SymmGroup > > const &phys_dims_, std::vector< int > const &site_type_)
void operator()(MPS< Matrix, SymmGroup > &mps)
basis_mps_init_generic(state_type const &state_, std::vector< Index< SymmGroup > > const &phys_dims_, typename SymmGroup::charge right_end_, std::vector< int > const &site_type_)
block_matrix< Matrix, SymmGroup > sqrt(block_matrix< Matrix, SymmGroup > m)
Index< SymmGroup > const & col_dim(size_t i) const
std::vector< boost::tuple< typename SymmGroup::charge, size_t > > state_type
std::vector< Index< SymmGroup > > phys_dims
void operator()(MPS< Matrix, SymmGroup > &mps)
default_mps_init< Matrix, SymmGroup > di
std::size_t init_bond_dimension
std::vector< Index< SymmGroup > > allowed_sectors(std::vector< int > const &site_type, std::vector< Index< SymmGroup > > const &phys_dims, typename SymmGroup::charge right_end, std::size_t Mmax)
#define parallel_for(constraint,...)
coherent_mps_init(BaseParameters ¶ms, std::vector< Index< SymmGroup > > const &phys_dims_, std::vector< int > const &site_type_)
functions to operate on MPS and MPO (compute expectation values, etc.)
MPS< Matrix, SymmGroup >::scalar_type norm(MPS< Matrix, SymmGroup > const &mps)
basis_dm_mps_init(BaseParameters ¶ms, std::vector< Index< SymmGroup > > const &phys_dims_, std::vector< int > const &site_type_)
void operator()(MPS< Matrix, SymmGroup > &mps)
std::string description() const
void operator()(MPS< Matrix, SymmGroup > &mps)
thin_const_mps_init(BaseParameters &parms, std::vector< Index< SymmGroup > > const &phys_dims, typename SymmGroup::charge right_end, std::vector< int > const &site_type)
coherent_dm_mps_init(BaseParameters ¶ms, std::vector< Index< SymmGroup > > const &phys_dims_, std::vector< int > const &site_type_)
std::size_t insert(std::pair< charge, std::size_t > const &x)
const_mps_init(BaseParameters &parms, std::vector< Index< SymmGroup > > const &phys_dims, typename SymmGroup::charge right_end, std::vector< int > const &site_type)
void operator()(MPS< Matrix, SymmGroup > &mps)
block_matrix< Matrix, SymmGroup > & data()
std::vector< int > site_type
static MPS< Matrix, SymmGroup > l2r_compress(MPS< Matrix, SymmGroup > mps, std::size_t Mmax, double cutoff, bool verbose=false)
default_mps_init< Matrix, SymmGroup > di
void operator()(MPS< Matrix, SymmGroup > &mps)
thin_mps_init(BaseParameters &parms, std::vector< Index< SymmGroup > > const &phys_dims, typename SymmGroup::charge right_end, std::vector< int > const &site_type)