Example #1
0
void randomize(field_offset G, Real radius)
{
  register int a, b, i;
  site *s;

  FORALLSITES(i,s) {
    for(a=0; a<3; a++) for(b=0; b<3; b++)
      (*(su3_matrix *)F_PT(s,G)).e[a][b] 
             = cmplx(radius*((Real)drand48()-0.5),
                     radius*((Real)drand48()-0.5));
    reunit_su3((su3_matrix *)F_PT(s,G));
  }
}
Example #2
0
void reunitarize() {
  register su3_matrix *mat;
  register int i,dir;
  register site *s;
  int errcount = 0;
  int errors;

  max_deviation = 0.;
  av_deviation = 0.;
  
  FORALLSITES(i,s){
#ifdef SCHROED_FUN
  for(dir=XUP; dir<=TUP; dir++ ) if(dir==TUP || s->t>0 ){
#else
    for(dir=XUP; dir<=TUP; dir++ ){
#endif
      mat = (su3_matrix *)&(s->link[dir]);
      errors = reunit_su3( mat );
      errcount += errors;
      if(errors)reunit_report_problem_matrix(mat,i,dir);
      if(errcount > MAXERRCOUNT)
	{
	  printf("Unitarity error count exceeded.\n");
	  terminate(1);
	}
    }
  }

#ifdef UNIDEBUG
  printf("Deviation from unitarity on node %d: max %.3e, avrg %.3e\n",
	 mynode(), max_deviation, av_deviation);
#endif
  if(max_deviation> TOLERANCE) 
    {
      printf("reunitarize: Node %d unitarity problem, maximum deviation=%e\n",
	     mynode(),max_deviation);
      errcount++;
      if(errcount > MAXERRCOUNT)
	{
	  printf("Unitarity error count exceeded.\n");
	  terminate(1);
	}
    }

}  /* reunitarize2 */
Example #3
0
void reunitarize() {
  register su3_matrix *mat;
  register int i,dir;
  register site *s;
  int errcount = 0;
  int errors;

  max_deviation = 0.;
  av_deviation = 0.;
  
  FORALLSITES(i,s){
#ifdef SCHROED_FUN
  for(dir=XUP; dir<=TUP; dir++ ) if(dir==TUP || s->t>0 ){
#else
    for(dir=XUP; dir<=TUP; dir++ ){
#endif
      mat = (su3_matrix *)&(s->link[dir]);
      errors = reunit_su3( mat );
      errcount += errors;
      if(errors)reunit_report_problem_matrix(mat,i,dir);
      if(errcount > MAXERRCOUNT)
	{
	  printf("Unitarity error count exceeded.\n");
	  terminate(1);
	}
    }
  }

#ifdef UNIDEBUG
  printf("Deviation from unitarity on node %d: max %.3e, avrg %.3e\n",
	 mynode(), max_deviation, av_deviation);
#endif
  if(max_deviation> TOLERANCE) 
    {
      printf("reunitarize: Node %d unitarity problem, maximum deviation=%e\n",
	     mynode(),max_deviation);
      errcount++;
      if(errcount > MAXERRCOUNT)
	{
	  printf("Unitarity error count exceeded.\n");
	  terminate(1);
	}
    }

}  /* reunitarize2 */

void reunitarize_u1() {
  register complex *mat;
  register int i,dir;
  register site *s;
  double norm;
  double deviation;

  int errcount = 0;
  int errors;

  max_deviation = 0.;
  av_deviation = 0.;

  FORALLSITES(i,s){
#ifdef SCHROED_FUN
  for(dir=XUP; dir<=TUP; dir++ ) if(dir==TUP || s->t>0 ){
#else
    for(dir=XUP; dir<=TUP; dir++ ){
#endif
      mat = (complex *)&(s->link[dir]);
      //reunitarize link
      norm = (double)cabs( mat );
      CMULREAL( *mat, 1./norm, *mat );
      //deviation = fabs(norm - 1.);
      deviation = fabs(norm*norm - 1.);
      errors = check_deviation(deviation);
      errcount += errors;
      if(errors){
	reunit_report_problem_u1(mat,i,dir);
	printf("deviation = %e, tol = %e\n", deviation, TOLERANCE);
      }
      if(errcount > MAXERRCOUNT)
	{
	  printf("Unitarity error count exceeded.\n");
	  terminate(1);
	}
    }
  }

#ifdef UNIDEBUG
  printf("Deviation from unitarity on node %d: max %.3e, avrg %.3e\n",
	 mynode(), max_deviation, av_deviation);
#endif
  if(max_deviation> TOLERANCE) 
    {
      printf("reunitarize: Node %d unitarity problem, maximum deviation=%e\n",
	     mynode(),max_deviation);
      errcount++;
      if(errcount > MAXERRCOUNT)
	{
	  printf("Unitarity error count exceeded.\n");
	  terminate(1);
	}
    }

}  /* reunitarize_u1 */
static void  
load_Y_from_V(info_t *info, hisq_auxiliary_t *aux, int umethod){
  int dir,i; 
  su3_matrix tmat;
  su3_matrix *U_link = aux->U_link;
  su3_matrix *V_link = aux->V_link;
  su3_matrix *Y_unitlink = aux->Y_unitlink;
  /* Temporary.  FIX THIS! */
  int r0[4] = {0, 0, 0, 0};

  double dtime;
  dtime=-dclock();

  int nhits = 100; // this is just a guess
  Real tol = 1.0e-5; // this is just a guess

  info->final_flop = 0.;

  switch(umethod){

  case UNITARIZE_NONE:
    //node0_printf("WARNING: UNITARIZE_NONE\n");
    FORALLFIELDSITES_OMP(i,private(dir))for(dir=XUP;dir<=TUP;dir++) 
      Y_unitlink[4*i+dir] = V_link[4*i+dir];
    END_LOOP_OMP;
    break;

  case UNITARIZE_APE:
    node0_printf("UNITARIZE_APE: derivative is not ready for this method\n"); 
    terminate(0);
    
    FORALLFIELDSITES_OMP(i,private(dir,tmat))for(dir=XUP;dir<=TUP;dir++){
      /* Use partially reunitarized link for guess */
      tmat = V_link[4*i+dir];
      reunit_su3(&tmat);
      project_su3(&tmat, &(V_link[4*i+dir]), nhits, tol);
      Y_unitlink[4*i+dir] = tmat;
    }
    END_LOOP_OMP;
    break;

  case UNITARIZE_ROOT:
    //node0_printf("WARNING: UNITARIZE_ROOT is performed\n");
    // REPHASING IS NOT NEEDED IN THIS ROUTINE BUT THIS
    // HAS TO BE CHECKED FIRST FOR NONTRIVIAL V_link ARRAYS

    /* rephase (out) V_link array */
    rephase_field_offset( V_link, OFF, NULL , r0);
    FORALLFIELDSITES_OMP(i,private(dir,tmat))for(dir=XUP;dir<=TUP;dir++){
      /* unitarize - project on U(3) */
      u3_unitarize( &( V_link[4*i+dir] ), &tmat );
      Y_unitlink[4*i+dir] = tmat;
    }
    END_LOOP_OMP;

    /* rephase (in) Y_unitlink array */
    rephase_field_offset( Y_unitlink, ON, NULL , r0);
    //printf("UNITARIZATION RESULT\n");
    //dumpmat( &( V_link[TUP][3] ) );
    //dumpmat( &( Y_unitlink[TUP][3] ) );
    break;

  case UNITARIZE_RATIONAL:
    //node0_printf("WARNING: UNITARIZE_RATIONAL is performed\n");
    // REPHASING IS NOT NEEDED IN THIS ROUTINE BUT THIS
    // HAS TO BE CHECKED FIRST FOR NONTRIVIAL V_link ARRAYS

    /* rephase (out) V_link array */
    rephase_field_offset( V_link, OFF, NULL , r0);
    FORALLFIELDSITES_OMP(i,private(dir,tmat))for(dir=XUP;dir<=TUP;dir++){
      /* unitarize - project on U(3) */
      u3_unitarize_rational( &( V_link[4*i+dir] ), &tmat );
      Y_unitlink[4*i+dir] = tmat;
    }
    END_LOOP_OMP;
    rephase_field_offset( V_link, ON, NULL , r0);

    /* rephase (in) Y_unitlink array */
    rephase_field_offset( Y_unitlink, ON, NULL , r0);
    //printf("UNITARIZATION RESULT\n");
    //dumpmat( &( V_link[TUP][3] ) );
    //dumpmat( &( Y_unitlink[TUP][3] ) );
    break;

  case UNITARIZE_ANALYTIC:
    //node0_printf("WARNING: UNITARIZE_ANALYTIC is performed\n");
    // REPHASING IS NOT NEEDED IN THIS ROUTINE BUT THIS
    // HAS TO BE CHECKED FIRST FOR NONTRIVIAL V_link ARRAYS
    /* rephase (out) V_link array */
    rephase_field_offset( V_link, OFF, NULL , r0);
    FORALLFIELDSITES_OMP(i,private(dir,tmat))for(dir=XUP;dir<=TUP;dir++){
      /* unitarize - project on U(3) */
#ifdef MILC_GLOBAL_DEBUG
#ifdef HISQ_REUNITARIZATION_DEBUG
      u3_unitarize_analytic_index( &( V_link[4*i+dir] ), &tmat, i, dir );
#else  /* HISQ_REUNITARIZATION_DEBUG */
      u3_unitarize_analytic( info, &( V_link[4*i+dir] ), &tmat );
#endif /* HISQ_REUNITARIZATION_DEBUG */
#else /* MILC_GLOBAL_DEBUG */
      u3_unitarize_analytic( info, &( V_link[4*i+dir] ), &tmat );
#endif /* MILC_GLOBAL_DEBUG */
      Y_unitlink[4*i+dir] = tmat;
    }
    END_LOOP_OMP;
    /* rephase (in) V_link array */
    rephase_field_offset( V_link, ON, NULL , r0);

    /* rephase (in) Y_unitlink array */
    rephase_field_offset( Y_unitlink, ON, NULL , r0);
    //printf("UNITARIZATION RESULT\n");
    //dumpmat( &( V_link[TUP][3] ) );
    //dumpmat( &( Y_unitlink[TUP][3] ) );

    break;

  case UNITARIZE_STOUT:

    rephase_field_offset( U_link, OFF, NULL , r0);
    rephase_field_offset( V_link, OFF, NULL , r0);
    FORALLFIELDSITES_OMP(i,private(dir))for(dir=XUP;dir<=TUP;dir++){
      /* unitarize - project on SU(3) with "stout" procedure */
      stout_smear( &( Y_unitlink[4*i+dir] ), 
                   &( V_link[4*i+dir] ),
                   &( U_link[4*i+dir] ) );
    }
    END_LOOP_OMP;
    rephase_field_offset( U_link, ON, NULL , r0);
    rephase_field_offset( V_link, ON, NULL , r0);

    /* rephase (in) Y_unitlink array */
    rephase_field_offset( Y_unitlink, ON, NULL , r0);
    //printf("UNITARIZATION RESULT\n");
    //dumpmat( &( V_link[TUP][3] ) );
    //dumpmat( &( Y_unitlink[TUP][3] ) );
    break;

  case UNITARIZE_HISQ:
    node0_printf("UNITARIZE_HISQ: not ready!\n"); 
    terminate(0);
    break;

  default:
    node0_printf("Unknown unitarization method\n"); terminate(0);
  } /* umethod */

  dtime += dclock();
  info->final_sec = dtime;
}