void Save(Vec u, const char* filename) {
int n, rank;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
VecGetSize(u, &n);
Vec uloc;
VecCreateSeq(PETSC_COMM_SELF, n, &uloc);
VecScatter ctx;
VecScatterCreateToZero(u, &ctx, &uloc);
VecScatterBegin(ctx, u, uloc, INSERT_VALUES, SCATTER_FORWARD);
VecScatterEnd(ctx, u, uloc, INSERT_VALUES, SCATTER_FORWARD);
const PetscScalar *pu;
VecGetArrayRead(uloc, &pu);
if (rank==0) {
int sq = sqrt(n);
std::ofstream out(filename);
for (size_t i=0; i<n; i++) {
out << pu[i] << std::endl;
if ((i+1)%sq == 0) out << std::endl;
}
}
VecRestoreArrayRead(uloc, &pu);
VecScatterDestroy(&ctx);
VecDestroy(&uloc);
}
//------------------------------------------------------------------------------
// Save solution to file
//------------------------------------------------------------------------------
PetscErrorCode savesol(int nx, double dx, Vec ug)
{
int i, rank;
static int count = 0;
PetscErrorCode ierr;
MPI_Comm_rank(PETSC_COMM_WORLD, &rank);
// Gather entire solution on rank=0 process. This is bad thing to do
// in a real application.
VecScatter ctx;
Vec uall;
ierr = VecScatterCreateToZero(ug,&ctx,&uall); CHKERRQ(ierr);
// scatter as many times as you need
ierr = VecScatterBegin(ctx,ug,uall,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
ierr = VecScatterEnd(ctx,ug,uall,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
// destroy scatter context and local vector when no longer needed
ierr = VecScatterDestroy(&ctx); CHKERRQ(ierr);
if(rank==0)
{
PetscScalar *uarray;
ierr = VecGetArray(uall, &uarray); CHKERRQ(ierr);
FILE *f;
f = fopen("sol.dat","w");
for(i=0; i<nx; ++i)
fprintf(f, "%e %e\n", xmin+i*dx, uarray[i]);
fclose(f);
printf("Wrote solution into sol.dat\n");
ierr = VecRestoreArray(uall, &uarray); CHKERRQ(ierr);
if(count==0)
{
// Initial solution is copied to sol0.dat
system("cp sol.dat sol0.dat");
count = 1;
}
}
ierr = VecDestroy(&uall); CHKERRQ(ierr);
return(0);
}
PETSC_EXTERN void PETSC_STDCALL vecscattercreatetozero_(Vec *vin,VecScatter *ctx,Vec *vout, int *ierr)
{
CHKFORTRANNULLOBJECT(vout);
*ierr = VecScatterCreateToZero(*vin,ctx,vout);
}
PetscErrorCode cHamiltonianMatrix::measurement(){
double *ALLdepart = new double[Nt];
double *ALLentropy = new double[Nt];
gsl_matrix* density1 = gsl_matrix_alloc(L,Nt);//background fermion density
gsl_matrix* density2 = gsl_matrix_alloc(L,Nt);//background fermion density
gsl_vector* corr12 = gsl_vector_alloc(Nt);//correlation betwen fermion up and down.
// The density correlation is in fact proportional to the interacting energy.
double var_rank;
PetscScalar var_tmp, var_tmp2;
gsl_complex var_tmp_gsl;
Vec vectort;
VecScatter ctx;
ofstream output;
VecScatterCreateToZero(WFt[0],&ctx,&vectort);
if(rank==0) cout << size << endl;
gsl_matrix_complex* RDM = gsl_matrix_complex_alloc(dim2,dim2);
gsl_vector *eval_RDM = gsl_vector_alloc(dim2);
gsl_eigen_herm_workspace* w_RDM = gsl_eigen_herm_alloc(dim2);
for (int itime = 0; itime < Nt; ++itime) {
if (rank==0&&itime%10==0) cout << "this is time " << itime << endl;
// % ## departure ##
var_rank = 0.0;
for (int ivar = rstart; ivar < rend; ++ivar) {
ierr = VecGetValues(WFt[itime],1,&ivar,&var_tmp);CHKERRQ(ierr);
var_rank += pow(gsl_vector_get(rr,ivar)*PetscAbsComplex(var_tmp),2);
}
MPI_Reduce(&var_rank, &(ALLdepart[itime]), 1, MPI_DOUBLE, MPI_SUM, 0, PETSC_COMM_WORLD);
ALLdepart[itime] = sqrt(ALLdepart[itime]);
// % ## entropy ##
VecScatterBegin(ctx,WFt[itime],vectort,INSERT_VALUES,SCATTER_FORWARD);
VecScatterEnd(ctx,WFt[itime],vectort,INSERT_VALUES,SCATTER_FORWARD);
if(rank==0) {
int ivar;double eigen_RDM;
gsl_matrix_complex_set_zero(RDM);
for (int row2 = 0; row2 < dim2; ++row2) {
for (int col2 = row2; col2 < dim2; ++col2) {
var_tmp_gsl.dat[0] = 0.0; var_tmp_gsl.dat[1] = 0.0;
for (int jjj = 0; jjj < dim; ++jjj) {
ivar = row2*dim+jjj;
ierr = VecGetValues(vectort,1,&ivar,&var_tmp);CHKERRQ(ierr);
ivar = col2*dim+jjj;
ierr = VecGetValues(vectort,1,&ivar,&var_tmp2);CHKERRQ(ierr);
var_tmp_gsl.dat[0] += PetscRealPart(var_tmp*PetscConj(var_tmp2));
var_tmp_gsl.dat[1] += PetscImaginaryPart(var_tmp*PetscConj(var_tmp2));
}
gsl_matrix_complex_set(RDM,row2,col2,var_tmp_gsl);
if (col2 != row2) {
gsl_matrix_complex_set(RDM,col2,row2,gsl_matrix_complex_get(RDM,row2,col2));
}
}
}
gsl_eigen_herm(RDM,eval_RDM,w_RDM);
ALLentropy[itime] = 0;
for (ivar = 0; ivar < dim2; ++ivar) {
eigen_RDM = gsl_vector_get(eval_RDM, ivar);
// cout << eigen_RDM << endl;
ALLentropy[itime] += -eigen_RDM*log(eigen_RDM);
}
}
// % ## density distribution of impurity fermion
if(rank==0) {
int ivar;
for (int row2 = 0; row2 < dim2; ++row2) {
for (int jpar = 0; jpar < N2; ++jpar) {
double density_tmp=0;
for (int jjj = 0; jjj < dim; ++jjj) {
ivar = row2*dim+jjj;
ierr = VecGetValues(vectort,1,&ivar,&var_tmp);CHKERRQ(ierr);
density_tmp +=pow(PetscAbsComplex(var_tmp),2);
}
/*if (itime==0) {
if (rank==0) cout << "density_tmp=" << density_tmp << endl;
}*/
gsl_matrix_set(density2,gsl_matrix_get(basis2,jpar,row2)-1,itime,gsl_matrix_get(density2,gsl_matrix_get(basis2,jpar,row2)-1,itime)+density_tmp);
}
}
}
/*if (rank==0) {
cout << "density of impurity:" << endl;
for (int jpar =0; jpar < L; ++jpar) {
cout << gsl_matrix_get(density2,jpar,itime) << "\t";
}
cout << endl;
}*/
// % ## density distribution of majority fermions
if(rank==0) {
int ivar;
for (int jjj = 0; jjj < dim; ++jjj) {
for (int jpar = 0; jpar < N; ++jpar) {
double density_tmp=0;
for (int row2 = 0; row2 < dim2; ++row2) {
ivar = row2*dim+jjj;
ierr = VecGetValues(vectort,1,&ivar,&var_tmp);CHKERRQ(ierr);
density_tmp +=pow(PetscAbsComplex(var_tmp),2);
}
gsl_matrix_set(density1,gsl_matrix_get(basis1,jpar,jjj)-1,itime,gsl_matrix_get(density1,gsl_matrix_get(basis1,jpar,jjj)-1,itime)+density_tmp);
}
}
}
// correlation between impurity and majority fermion
if(rank==0) {
int ivar;
double corr_tmp=0;
for (int jimp=0; jimp<dim2; ++jimp) {
for (int jmaj=0; jmaj<dim; ++jmaj) {
for (int jpar=0; jpar<N; ++jpar) {
if (gsl_matrix_get(basis1,jpar,jmaj)==jimp+1){
ivar = jimp*dim+jmaj;
ierr = VecGetValues(vectort,1,&ivar,&var_tmp);CHKERRQ(ierr);
corr_tmp+=pow(PetscAbsComplex(var_tmp),2);
}
}
}
}
gsl_vector_set(corr12,itime,corr_tmp);
}// end of correlation
}
if (rank == 0) {
char filename[50];
sprintf(filename,"measurement.data");
output.open(filename);
output.is_open();
output.precision(16);
for (int itime = 0; itime < Nt; ++itime) {
if (itime==0) {
// cout << "time t[1] " << '\t' << "departure[2] " << '\t' << "entropy[3]" << '\t' << "density of majority [L]" <<'\t' << "density of impurity [L]" << endl;
}
output << dt*itime-3 << '\t' << ALLdepart[itime] << '\t' << ALLentropy[itime] << '\t';
for (int jpar = 0; jpar < L; ++jpar) {
output << gsl_matrix_get(density1,jpar,itime) << '\t';
}
for (int jpar = 0; jpar < L; ++jpar) {
output << gsl_matrix_get(density2,jpar,itime) << '\t';
}
output << gsl_vector_get(corr12,itime) << '\t';
output << endl;
}
output.close();
}
// CopyFile(source,destination,FALSE);
delete[] ALLdepart;
VecScatterDestroy(&ctx);
VecDestroy(&vectort);
gsl_matrix_complex_free(RDM);
gsl_vector_free(eval_RDM);
gsl_eigen_herm_free(w_RDM);
gsl_matrix_free(density1);
gsl_matrix_free(density2);
gsl_vector_free(corr12);
// CopyFile(source,destination,FALSE);
return ierr;
}
static PetscErrorCode TaoSolve_BMRM(Tao tao)
{
PetscErrorCode ierr;
TAO_DF df;
TAO_BMRM *bmrm = (TAO_BMRM*)tao->data;
/* Values and pointers to parts of the optimization problem */
PetscReal f = 0.0;
Vec W = tao->solution;
Vec G = tao->gradient;
PetscReal lambda;
PetscReal bt;
Vec_Chain grad_list, *tail_glist, *pgrad;
PetscInt i;
PetscMPIInt rank;
/* Used in converged criteria check */
PetscReal reg;
PetscReal jtwt = 0.0, max_jtwt, pre_epsilon, epsilon, jw, min_jw;
PetscReal innerSolverTol;
MPI_Comm comm;
PetscFunctionBegin;
ierr = PetscObjectGetComm((PetscObject)tao,&comm);CHKERRQ(ierr);
ierr = MPI_Comm_rank(comm, &rank);CHKERRQ(ierr);
lambda = bmrm->lambda;
/* Check Stopping Condition */
tao->step = 1.0;
max_jtwt = -BMRM_INFTY;
min_jw = BMRM_INFTY;
innerSolverTol = 1.0;
epsilon = 0.0;
if (!rank) {
ierr = init_df_solver(&df);CHKERRQ(ierr);
grad_list.next = NULL;
tail_glist = &grad_list;
}
df.tol = 1e-6;
tao->reason = TAO_CONTINUE_ITERATING;
/*-----------------Algorithm Begins------------------------*/
/* make the scatter */
ierr = VecScatterCreateToZero(W, &bmrm->scatter, &bmrm->local_w);CHKERRQ(ierr);
ierr = VecAssemblyBegin(bmrm->local_w);CHKERRQ(ierr);
ierr = VecAssemblyEnd(bmrm->local_w);CHKERRQ(ierr);
/* NOTE: In application pass the sub-gradient of Remp(W) */
ierr = TaoComputeObjectiveAndGradient(tao, W, &f, G);CHKERRQ(ierr);
ierr = TaoLogConvergenceHistory(tao,f,1.0,0.0,tao->ksp_its);CHKERRQ(ierr);
ierr = TaoMonitor(tao,tao->niter,f,1.0,0.0,tao->step);CHKERRQ(ierr);
ierr = (*tao->ops->convergencetest)(tao,tao->cnvP);CHKERRQ(ierr);
while (tao->reason == TAO_CONTINUE_ITERATING) {
/* Call general purpose update function */
if (tao->ops->update) {
ierr = (*tao->ops->update)(tao, tao->niter);CHKERRQ(ierr);
}
/* compute bt = Remp(Wt-1) - <Wt-1, At> */
ierr = VecDot(W, G, &bt);CHKERRQ(ierr);
bt = f - bt;
/* First gather the gradient to the master node */
ierr = VecScatterBegin(bmrm->scatter, G, bmrm->local_w, INSERT_VALUES, SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(bmrm->scatter, G, bmrm->local_w, INSERT_VALUES, SCATTER_FORWARD);CHKERRQ(ierr);
/* Bring up the inner solver */
if (!rank) {
ierr = ensure_df_space(tao->niter+1, &df);CHKERRQ(ierr);
ierr = make_grad_node(bmrm->local_w, &pgrad);CHKERRQ(ierr);
tail_glist->next = pgrad;
tail_glist = pgrad;
df.a[tao->niter] = 1.0;
df.f[tao->niter] = -bt;
df.u[tao->niter] = 1.0;
df.l[tao->niter] = 0.0;
/* set up the Q */
pgrad = grad_list.next;
for (i=0; i<=tao->niter; i++) {
if (!pgrad) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Assert that there are at least tao->niter+1 pgrad available");
ierr = VecDot(pgrad->V, bmrm->local_w, ®);CHKERRQ(ierr);
df.Q[i][tao->niter] = df.Q[tao->niter][i] = reg / lambda;
pgrad = pgrad->next;
}
if (tao->niter > 0) {
df.x[tao->niter] = 0.0;
ierr = solve(&df);CHKERRQ(ierr);
} else
df.x[0] = 1.0;
/* now computing Jt*(alpha_t) which should be = Jt(wt) to check convergence */
jtwt = 0.0;
ierr = VecSet(bmrm->local_w, 0.0);CHKERRQ(ierr);
pgrad = grad_list.next;
for (i=0; i<=tao->niter; i++) {
jtwt -= df.x[i] * df.f[i];
ierr = VecAXPY(bmrm->local_w, -df.x[i] / lambda, pgrad->V);CHKERRQ(ierr);
pgrad = pgrad->next;
}
ierr = VecNorm(bmrm->local_w, NORM_2, ®);CHKERRQ(ierr);
reg = 0.5*lambda*reg*reg;
jtwt -= reg;
} /* end if rank == 0 */
/* scatter the new W to all nodes */
ierr = VecScatterBegin(bmrm->scatter,bmrm->local_w,W,INSERT_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = VecScatterEnd(bmrm->scatter,bmrm->local_w,W,INSERT_VALUES,SCATTER_REVERSE);CHKERRQ(ierr);
ierr = TaoComputeObjectiveAndGradient(tao, W, &f, G);CHKERRQ(ierr);
ierr = MPI_Bcast(&jtwt,1,MPIU_REAL,0,comm);CHKERRQ(ierr);
ierr = MPI_Bcast(®,1,MPIU_REAL,0,comm);CHKERRQ(ierr);
jw = reg + f; /* J(w) = regularizer + Remp(w) */
if (jw < min_jw) min_jw = jw;
if (jtwt > max_jtwt) max_jtwt = jtwt;
pre_epsilon = epsilon;
epsilon = min_jw - jtwt;
if (!rank) {
if (innerSolverTol > epsilon) innerSolverTol = epsilon;
else if (innerSolverTol < 1e-7) innerSolverTol = 1e-7;
/* if the annealing doesn't work well, lower the inner solver tolerance */
if(pre_epsilon < epsilon) innerSolverTol *= 0.2;
df.tol = innerSolverTol*0.5;
}
tao->niter++;
ierr = TaoLogConvergenceHistory(tao,min_jw,epsilon,0.0,tao->ksp_its);CHKERRQ(ierr);
ierr = TaoMonitor(tao,tao->niter,min_jw,epsilon,0.0,tao->step);CHKERRQ(ierr);
ierr = (*tao->ops->convergencetest)(tao,tao->cnvP);CHKERRQ(ierr);
}
/* free all the memory */
if (!rank) {
ierr = destroy_grad_list(&grad_list);CHKERRQ(ierr);
ierr = destroy_df_solver(&df);CHKERRQ(ierr);
}
ierr = VecDestroy(&bmrm->local_w);CHKERRQ(ierr);
ierr = VecScatterDestroy(&bmrm->scatter);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
PetscInt n = 3,i,len,start,end;
PetscErrorCode ierr;
PetscMPIInt size,rank;
PetscScalar value,*yy;
Vec x,y,z,y_t;
VecScatter toall,tozero;
ierr = PetscInitialize(&argc,&argv,(char*)0,help);CHKERRQ(ierr);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size);CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr);
/* create two vectors */
ierr = VecCreateMPI(PETSC_COMM_WORLD,PETSC_DECIDE,size*n,&x);CHKERRQ(ierr);
/* each processor inserts its values */
ierr = VecGetOwnershipRange(x,&start,&end);CHKERRQ(ierr);
for (i=start; i<end; i++) {
value = (PetscScalar) i;
ierr = VecSetValues(x,1,&i,&value,INSERT_VALUES);CHKERRQ(ierr);
}
ierr = VecAssemblyBegin(x);CHKERRQ(ierr);
ierr = VecAssemblyEnd(x);CHKERRQ(ierr);
ierr = VecView(x,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = VecScatterCreateToAll(x,&toall,&y);CHKERRQ(ierr);
ierr = VecScatterBegin(toall,x,y,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(toall,x,y,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterDestroy(toall);CHKERRQ(ierr);
/* Cannot view the above vector with VecView(), so place it in an MPI Vec
and do a VecView() */
ierr = VecGetArray(y,&yy);CHKERRQ(ierr);
ierr = VecGetLocalSize(y,&len);CHKERRQ(ierr);
ierr = VecCreateMPIWithArray(PETSC_COMM_WORLD,len,PETSC_DECIDE,yy,&y_t);CHKERRQ(ierr);
ierr = VecView(y_t,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
ierr = VecDestroy(y_t);
ierr = VecRestoreArray(y,&yy);CHKERRQ(ierr);
ierr = VecScatterCreateToAll(x,&tozero,&z);CHKERRQ(ierr);
ierr = VecScatterBegin(tozero,x,z,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(tozero,x,z,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterDestroy(tozero);CHKERRQ(ierr);
if (!rank) {
ierr = VecView(z,PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);
}
ierr = VecDestroy(z);CHKERRQ(ierr);
ierr = VecScatterCreateToZero(x,&tozero,&z);CHKERRQ(ierr);
ierr = VecScatterBegin(tozero,x,z,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterEnd(tozero,x,z,INSERT_VALUES,SCATTER_FORWARD);CHKERRQ(ierr);
ierr = VecScatterDestroy(tozero);CHKERRQ(ierr);
ierr = VecDestroy(z);CHKERRQ(ierr);
ierr = VecDestroy(x);CHKERRQ(ierr);
ierr = VecDestroy(y);CHKERRQ(ierr);
ierr = PetscFinalize();CHKERRQ(ierr);
return 0;
}
void PETSC_STDCALL vecscattercreatetozero_(Vec vin,VecScatter *ctx,Vec *vout, int *__ierr ){
*__ierr = VecScatterCreateToZero(
(Vec)PetscToPointer((vin) ),ctx,vout);
}
