EnergySpectrum.c File Reference

Functions
double	getETtime ()
int	main (int argc, char **argv)

Function Documentation

getETtime()

double getETtime

(

)

                   {
  struct timeval tv;
  gettimeofday(&tv, NULL);
  return tv.tv_sec +(double)tv.tv_usec *1e-6;
}

main()

int main	(	int	argc,
		char **	argv
	)

                                {
  if(argc != 7) {
    fprintf(stderr, "Usage: 1.This 2.(Number of elements) 3.(Number of blocks) 4.(Max elements on a site)  5.|U|*100 6.|V|*100 7.OutDir\n");
    exit(EX_USAGE);
  }
  const MKL_INT N = atoi(argv[1]);
  const MKL_INT L = atoi(argv[2]);
  const MKL_INT MaxOnSite = atoi(argv[3]);
  const double U = -atoi(argv[4])/100.0;
  double V = -atoi(argv[5])/100.0;
 
  const MKL_INT NDIV = 200;
  MKL_INT dim_tot, dim_odd, dim_even, NumPairs;
 
  double start, end;
 
  //******************** Allocation ********************//
  MKL_INT **basis=NULL, *order=NULL;
  double **eigenEnergy;
  MKL_Complex16 **Hamiltonian_Odd, **Hamiltonian_Even;
  fprintf(stdout, "# Generating basis vectors...\n");
  dim_tot  = alloc_BasisVectors(N, L, MaxOnSite, &basis, &order, &NumPairs);
  dim_odd  = NumPairs;
  dim_even = dim_tot -dim_odd;
  fprintf(stdout, "# dim_tot = %lld, dim_even = %lld, dim_odd = %lld\n", dim_tot, dim_even, dim_odd);
  eigenEnergy = alloc_dmatrix(NDIV+1, dim_tot);
  Hamiltonian_Odd  = alloc_zmatrix(dim_odd, dim_odd);
  Hamiltonian_Even = alloc_zmatrix(dim_even, dim_even);
  //******************** (END)Allocation ********************//
 
 
  //****************************************//
  //****************************************//
  for(MKL_INT rep = 0;rep <= NDIV; ++rep) {
    V = -20.0*rep/NDIV;
    fprintf(stdout, "# Constructing Hamiltonian...\n");
    Construct_Hamiltonian(Hamiltonian_Odd, dim_odd, Hamiltonian_Even, dim_even, L, basis, U, V);
    start = getETtime();
      fprintf(stdout, "# Diagonalizing Hamiltonian...\n"); fflush(stdout);
      EigenEnergy_zmatrix(dim_even, Hamiltonian_Even, &(eigenEnergy[rep][0]));
      EigenEnergy_zmatrix(dim_odd,  Hamiltonian_Odd,  &(eigenEnergy[rep][dim_even]));
    end = getETtime();
    fprintf(stderr, "# (%lld %lld), Real time(sec): %.6lf sec\n", N, L, end-start);
    fflush(stdout); fflush(stderr);
  }
 
  //************************************************************//
  //************************************************************//
  //************************************************************//
  //******************** Check for the directory structure ********************
  const MKL_INT BUFSIZE = 1000;
  char dstr[BUFSIZE], str[BUFSIZE], stemp[BUFSIZE];
  strcpy(dstr, argv[6]);
  strcat(dstr, "/BICData"); mkdir(dstr, 0744);
  strcat(dstr, "/PBC");     mkdir(dstr, 0744);
  if(U > 0) sprintf(stemp, "/N%lld_U%lld_Max%lld_L%lld",  N, (MKL_INT)( 100*U), MaxOnSite, L);
  else      sprintf(stemp, "/N%lld_nU%lld_Max%lld_L%lld", N, (MKL_INT)(-100*U), MaxOnSite, L);
  strcat(dstr, stemp);  mkdir(dstr, 0744);
  //******************** (END)Check for the directory structure ********************
 
  char *filename = str;
  strcpy(str, dstr);
  sprintf(stemp, "/EnergySpectra.txt");
  strcat(str, stemp);
  FILE* OutFp;
  OutFp = fopen(filename, "w");
    if(OutFp == NULL) {
      printf("Can't open a file %s.", filename);
      exit(EX_CANTCREAT);
    }
  fprintf(OutFp, "# N=%lld, L=%lld, MaxOnSite=%lld\n", N, L, MaxOnSite);
  fprintf(OutFp, "# U=%+lf\n", U);
  fprintf(OutFp, "# dim_even=%lld\n", dim_even);
  fprintf(OutFp, "# 1.(V) 2.(Eigenergy)\n\n");
  start = getETtime();
  for(MKL_INT rep = 0;rep <= NDIV; ++rep) {
    V = -20.0*rep/NDIV;
    fprintf(OutFp, "%lf ", V);
    for(MKL_INT j = 0;j < dim_tot; ++j) fprintf(OutFp, "%+le ", eigenEnergy[rep][j]);
    fprintf(OutFp, "\n");
  }
 
  //******************** Free ********************//
  free_dmatrix(eigenEnergy);
  free_zmatrix(Hamiltonian_Odd);
  free_zmatrix(Hamiltonian_Even);
  free_BasisVectors(basis, order);
  //******************** (END)Free ********************//
 
  return 0;
}