int main(int argc, char *argv[])
{
  createinfo(argc, argv);
  
  int c;
  int cm=1;
  int deformation=0;

  if (argc < 3) {
    fprintf(stderr, "\nusage: %s interaction slaterdetfile\n",
	    argv[0]);
    exit(-1);
  }
  
  char* interactionfile = argv[optind];
  char* slaterdetfile = argv[optind+1];

  Interaction Int;
  readInteractionfromFile(&Int, interactionfile);
  Int.cm = cm;

  SlaterDet Q;
  readSlaterDetfromFile(&Q, slaterdetfile);

  Observables Obs;

  calcObservables(&Int, &Q, &Obs);

  fprintinfo(stdout);
  fprintObservables(stdout, &Int, &Q, &Obs);

  return 0;
}
Exemple #2
0
int main(int argc, char *argv[])
{
    printinfo("3\n");

    fprintinfo(stderr, "3\n");

    return EXIT_SUCCESS;
}
void FORTRAN(egradf)(const double* x, double* gradf)
{
#ifndef MPI
  if (sigterminate)
    longjmp(env, 1);
#endif

  copyxtopara(x, Min.q);
  Min.P->ParatoSlaterDet(Min.q, Min.Q);

  // nail to center-of-mass
  moveboostSlaterDet(Min.Q, Work.X);

  double eintr, eproj;

  calcgradprojectedHamiltonian(Min.Q,
			       Min.Int,
			       Min.j, Min.par, Min.ival, 
                               Min.angpara, Min.cmpara,
			       &eintr, &eproj);

  // add gradient from intrinsic energy

  calcSlaterDetAux(Min.Q, Work.X);
  calcgradSlaterDetAux(Min.Q, Work.X, Work.dX);
  calcgradHamiltonian(Min.Int, Min.Q, Work.X, Work.dX, Work.dH);

  addmulttogradSlaterDet(Work.dhproj, Work.dH, Min.alpha);

  Min.P->ParaprojectgradSlaterDet(Min.q, Work.dhproj, gradf);
  FORTRAN(o8cnt).icgf++;
  fprintf(stderr, "grad %3d: \tE = %8.3f MeV, Eproj = %8.3f MeV, Eintr = %8.3f MeV\n", 
	  FORTRAN(o8cnt).icgf, hbc*(eproj+Min.alpha*eintr), hbc*eproj, hbc*eintr);


  if (Min.log && !(FORTRAN(o8cnt).icgf % Min.log)) {
    char logfname[255];
    sprintf(logfname, "%s.minvapp.%03d.log", Min.logfile, FORTRAN(o8cnt).icgf);
    FILE* logfp;
    if (!(logfp = fopen(logfname, "w"))) {
      fprintf(stderr, "couldn't open %s for writing\n", logfname);
    } else {
      fprintinfo(logfp);
      fprintf(logfp, "# step %3d: \tE = %8.3f MeV, Eproj = %8.3f MeV, Eintr = %8.3f MeV\n", 
	      FORTRAN(o8cnt).icgf, hbc*(eproj+Min.alpha*eintr), hbc*eproj, hbc*eintr);
      fprintf(logfp, "\n# Parameterization\n");
      fprintf(logfp, "<Parameterization %s>\n", Min.P->name);
      Min.P->Parawrite(logfp, Min.q);
      fprintf(logfp, "\n# SlaterDet\n");
      writeSlaterDet(logfp, Min.Q);
      fclose(logfp);
    }
  }  

}
Exemple #4
0
int main(int argc, char *argv[])
{
    int fd = 0;
    int retcode = 0;
    void *addr = NULL;
    struct stat st = {0};

    printinfo("open filename: %s\n", MMAP_FILE);
    fd = open(MMAP_FILE, O_RDWR);
    if (fd < 0)
    {
        fprintinfo(stderr, "open %s file failure\n", MMAP_FILE);
        return EXIT_FAILURE;
    }
    printinfo("open filename: %s, fd = %d\n", MMAP_FILE, fd);
/*
    printinfo("stat filename: %s\n", MMAP_FILE);
    retcode = stat(MMAP_FILE, &st);
    if (retcode != 0)
    {
        fprintinfo(stderr, "get %s file stat failure\n", MMAP_FILE);
        return EXIT_FAILURE;
    }

    printinfo("blocksize = %ld, total size = %ld, protection = %d\n", st.st_blksize, st.st_size, st.st_mode);
*/
    printinfo("mmap fd: %d, size = %ld, attribute: (prot = %d, shared = %d)\n", fd, st.st_size, PROT_READ|PROT_WRITE, MAP_PRIVATE);
    addr = mmap(NULL, 10, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (addr == NULL)
    {
        fprintinfo(stderr, "");
    }

    printinfo("addr = %p\n", addr);

    strcpy(addr, "private");

    printinfo("write info : %s\n", addr);

    return EXIT_SUCCESS;
}
Exemple #5
0
int main(int argc, char *argv[])
{
    int retcode = 0 ;
//    pthread_mutexattr_t attr;
    pthread_mutex_t *addr = NULL;

    addr = mapaddr_init(sizeof(*addr), MAP_PROCESS_SHARED);
    if (addr == NULL)
    {
        printinfo("get thread mutex space failure\n");
        return EXIT_FAILURE;
    }
/*
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);

    pthread_mutex_init(addr, &attr);
*/
    retcode = pthread_mutex_lock(addr);
    if (retcode != 0)
    {
        fprintinfo(stderr, "thread mutex failure retcode = %d\n", retcode);
        return EXIT_FAILURE;
    }

    printinfo("current process pid = %d\n", getpid());
    sleep(1);

    pthread_mutex_unlock(addr);

//    pthread_mutex_destroy(addr);

    mapaddr_destroy(addr, sizeof(*addr));

    return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
  createinfo(argc, argv);

#ifdef MPI
  MPI_Init(&argc, &argv);
  MPI_Comm_rank(MPI_COMM_WORLD, &mpirank);
  MPI_Comm_size(MPI_COMM_WORLD, &mpisize);

  // fprintf(stderr, "... [%2d] %s\n", mpirank, hostname());

  if (mpirank != 0) {
    MinimizerSlave();
    MPI_Finalize();
    exit(0);
  } else {
#endif

  int c;
  int cm=1;
  int overwrite=0;
  int maxsteps=250;
  int log=0;
  double shakemag=0.0;
  int constcm=0, constT2=0, constS2=0, constL2=0, constLS=0, constJ2=0;
  int constj2=0;
  int constnosci=0;
  int constmradius=0, constmquadrupole=0, constmoctupole=0;
  int consteradius=0, constedipole=0, constequadrupole=0, consteoctupole=0;
  int constnradius=0, constnquadrupole=0, constnoctupole=0;
  int constdquadrupole=0;
  int constbeta=0, constgamma=0;
  double constT2val=0.0, constS2val=0.0;
  double constL2val=0.0, constLSval=0.0, constJ2val=0.0;
  double constj2val=0.0;
  double constnoscival=0.0;
  double constmrval=0.0, constmqval=0.0, constmoval=0.0;
  double consterval=0.0, constedval=0.0, consteqval=0.0, consteoval=0.0;
  double constnrval=0.0, constnqval=0.0, constnoval=0.0;
  double constbval=0.0, constgval=0.0;
  double constdqval = 0.0;
  

  Constraint Const[MAXCONSTRAINT];
  int nconst = 0;

  if (argc < 3) {
    fprintf(stderr, "\nusage: %s interaction slaterdetfile\n"
	    "\n   -o              overwrite in all cases"
	    "\n   -l EVERY        log EVERY step"
	    "\n   -m MAXSTEPS     maximum number of steps (default %d)"
	    "\n   -s MAGNITUDE    shake parameters before minimization"
	    "\n   -C              constrain center of mass"
	    "\n   -T T2		  constrain T2"
	    "\n   -S S2           constrain S2"
	    "\n   -L LS           constrain LS"
	    "\n   -J J2           constrain J2"
	    "\n   -j j2           constrain single-particle angular momentum"
	    "\n   -N NOSCI        constrain number of oscillator quanta"
	    "\n   -R RADIUS       constrain radius"
	    "\n   -D DIPOLE       constrain dipole moments"
	    "\n   -Q QUADRUPOLE   constrain quadrupole moments"
	    "\n   -O OCTUPOLE     constrain octupole moments"
	    "\n   -B BETA         constrain quadrupole deformation"
	    "\n   -G GAMMA        constrain quadrupole deformation\n"
	    // "\n   -M              constrain main axes of quadrupole tensor"
	    // "\n   -I Jz           cranking constrain"
	    , argv[0], maxsteps);
    cleanup(-1);
  }
  
  while((c = getopt(argc, argv, "ol:m:s:CT:L:S:J:j:N:R:D:Q:O:B:G:")) != -1)
    switch (c) {
    case 'o':
      overwrite = 1;
      break;
    case 'l':
      log = atoi(optarg);
      break;
    case 'm':
      maxsteps = atoi(optarg);
      break;
    case 's':
      shakemag = atof(optarg);
      break;
    case 'C':
      constcm = 1;
      break;
    case 'T':
      constT2 = 1;
      constT2val = atof(optarg);
      break;
    case 'L':
      constLS = 1;
      constLSval = atof(optarg);
      break;
    case 'S':
      constS2 = 1;
      constS2val = atof(optarg);
      break;
    case 'J':
      constJ2 = 1;
      constJ2val = atof(optarg);
      break;
    case 'j':
      constj2 = 1;
      constj2val = atof(optarg);
      break;
    case 'N':
      constnosci = 1;
      constnoscival = atof(optarg);
      break;
    case 'R':
      if (optarg[0] == 'E') {
	consteradius = 1;
	consterval = atof(optarg+2);
      } else if (optarg[0] == 'N') {
	constnradius = 1;
	constnrval = atof(optarg+2);
      } else {
	constmradius = 1;
	constmrval = atof(optarg);
      }
      break;
    case 'D':
      constedipole = 1;
      constedval = atof(optarg);
      break;
    case 'Q':
      if (optarg[0] == 'E') {
	constequadrupole = 1;
	consteqval = atof(optarg+2);
      } else if (optarg[0] == 'N') {
        constnquadrupole = 1;
        constnqval = atof(optarg+2);
      } else if (optarg[0] == 'D') {
        constdquadrupole = 1;
        constdqval = atof(optarg+2);
      } else {
	constmquadrupole = 1;
	constmqval = atof(optarg);
      }
      break;
    case 'O':
      if (optarg[0] == 'E') {
	consteoctupole = 1;
	consteoval = atof(optarg+2);
      } else if (optarg[0] == 'N') {
	constnoctupole = 1;
	constnoval = atof(optarg+2);
      } else {
	constmoctupole = 1;
	constmoval = atof(optarg);
      }
      break;
    case 'B':
      constbeta = 1;
      constbval = atof(optarg);
      break;
    case 'G':
      constgamma = 1;
      constgval = atof(optarg);
      break;
    }
  
  if (constcm) {
    Const[nconst] = ConstraintCM;
    nconst++;
    // Const[nconst  ] = ConstraintX;
    // Const[nconst+1] = ConstraintY;
    // Const[nconst+2] = ConstraintZ;
    // Const[nconst+3] = ConstraintPX;
    // Const[nconst+4] = ConstraintPY;
    // Const[nconst+5] = ConstraintPZ;
    // nconst += 6;
  }
  if (constT2) {
    Const[nconst] = ConstraintT2;
    Const[nconst].val = constT2val;
    nconst++;
  }
  if (constS2) {
    Const[nconst] = ConstraintS2;
    Const[nconst].val = constS2val;
    nconst++;
  }
/*   if (constL2) { */
/*     Const[nconst] = ConstraintL2; */
/*     Const[nconst].val = constL2val; */
/*     nconst++; */
/*   } */
  if (constLS) { 
    Const[nconst] = ConstraintLS;
    Const[nconst].val = constLSval;
    nconst++;
  }
  if (constJ2) {
    Const[nconst] = ConstraintJ2;
    Const[nconst].val = constJ2val;
    nconst++;
  }
  if (constj2) {
    Const[nconst] = ConstraintJ2;
    Const[nconst].val = constj2val;
    nconst++;
  }
  if (constnosci) {
    Const[nconst] = ConstraintNOsci;
    Const[nconst].val = SQR(constnoscival);
    nconst++;
  }
  if (constmradius) {
    Const[nconst] = ConstraintR2;
    Const[nconst].val = SQR(constmrval);
    nconst++;
  }
  if (consteradius) {
    Const[nconst] = ConstraintER2;
    Const[nconst].val = SQR(consterval);
    nconst++;
  }
  if (constnradius) {
    Const[nconst] = ConstraintNR2;
    Const[nconst].val = SQR(constnrval);
    nconst++;
  }
  if (constedipole) {
    Const[nconst] = ConstraintED2;
    Const[nconst].val = constedval;
    nconst++;
  }
  if (constmquadrupole) {
    Const[nconst] = ConstraintQ2;
    Const[nconst].val = constmqval;
    nconst++;
  }
  if (constequadrupole) {
    Const[nconst] = ConstraintEQ2;
    Const[nconst].val = consteqval;
    nconst++;
  }
  if (constnquadrupole) {
    Const[nconst] = ConstraintNQ2;
    Const[nconst].val = constnqval;
    nconst++;
  }
   if (constdquadrupole) {
   Const[nconst] = ConstraintDetQ;
   Const[nconst].val = constdqval;
    nconst++;
    // ConstraintQuadrupole q;
    //  fprintf(stderr, "The quadrupole tensor is: %f\n", q[i]);
  }
  if (constmoctupole) {
    Const[nconst] = ConstraintO2;
    Const[nconst].val = constmoval;
    nconst++;
  }
  if (consteoctupole) {
    Const[nconst] = ConstraintEO2;
    Const[nconst].val = consteoval;
    nconst++;
  }
  if (constnoctupole) {
    Const[nconst] = ConstraintNO2;
    Const[nconst].val = constnoval;
    nconst++;
  }
  if (constbeta) {
    Const[nconst] = ConstraintQ2;
    Const[nconst].val = sqrt(24*M_PI/5)*constbval;
    nconst++;
  }
  if (constgamma) {
    if (!constbeta) {
      fprintf(stderr, "gamma constraint only in combination with beta constraint\n");
      exit(-1);
    }
    Const[nconst] = ConstraintDetQ;
    Const[nconst].val = sqrt(4*M_PI/5)*constbval*cbrt(2*cos(3*constgval*M_PI/180));
    nconst++;
  }

  char* interactionfile = argv[optind];
  char* parafile = argv[optind+1];

  Interaction Int;
  if (readInteractionfromFile(&Int, interactionfile))
    cleanup(-1);
  Int.cm = cm;

  Parameterization P;
  Para qinitial;
  if (readParafromFile(&P, &qinitial, parafile))
    cleanup(-1);

  SlaterDet Q;
  SlaterDetAux X;

  P.ParainitSlaterDet(&qinitial, &Q);
  initSlaterDetAux(&Q, &X);
  P.ParatoSlaterDet(&qinitial, &Q);

#ifdef MPI
  int task=TASKSTART;
  BroadcastTask(&task);

  BroadcastInteraction(&Int);
  BroadcastA(&Q.A);
#endif

  calcSlaterDetAux(&Q, &X);
  double einitial;
  calcHamiltonian(&Int, &Q, &X, &einitial); 

  int i;
  for (i=0; i<nconst; i++)
    fprintf(stderr, "# constraining %4s to %8.3f\n", 
	    Const[i].label, Const[i].output(Const[i].val)); 

  fprintf(stderr, "\ninitial:\tE = %8.3f MeV\n\n", hbc*einitial);


  Para q;
  P.Paraclone(&qinitial, &q);

  // shaking the parameters ?
  if (shakemag)
    shakePara(&q, shakemag);

  // in FMD parameterization move SlaterDet to origin in phase space
  if (!strcmp(P.name, "FMD")) {
    P.ParatoSlaterDet(&q, &Q);
    moveboostorientSlaterDet(&Q, &X);
    SlaterDetinitFMD(&Q, &q);
  }

  // minimize !
  MinimizeDONLP2(&Int, Const, nconst, &P, &q, maxsteps, log, parafile); 

  double e;
  P.ParatoSlaterDet(&q, &Q);

  calcSlaterDetAux(&Q, &X);
  calcHamiltonian(&Int, &Q, &X, &e);

  fprintf(stderr, "\nfinal:  \tE = %8.3f MeV\n\n", hbc*e);

  // output files

  // backup of parafile

  backup(parafile);

  // save minimization result in MIN directory
  {
    P.ParatoSlaterDet(&q, &Q);

    // orient SlaterDet
    moveboostorientSlaterDet(&Q, &X);

    // normalize SlaterDet
    normalizeSlaterDet(&Q, &X);

    // in FMD parameterization we copy the relocated SlaterDet
    if (!strcmp(P.name, "FMD"))
      SlaterDetinitFMD(&Q, &q);

    // calculate the observables
    Observables Obs;
  
    calcObservables(&Int, &Q, &Obs);

    ensuredir("MIN");
    char outfile[1024];
    sprintf(outfile, "MIN/%s-min.%d", parafile, (int) time(NULL));

    fprintf(stderr, "... writing Parameters to file %s\n", outfile);

    FILE* outfp;
    if (!(outfp = fopen(outfile, "w"))) {
      fprintf(stderr, "couldn't open %s for writing\n", outfile);
      cleanup(-1);
    }

    fprintinfo(outfp);

    fprintf(outfp, "\n# minimized %s for %s in %s parameterization\n"
            "# using %s interaction\n", 
            cm ? "< Hintr >" : "< H >", q.name, P.name, Int.name);
  
    fprintf(outfp, "# einitial: %8.3f MeV\n", hbc*einitial);
    fprintf(outfp, "# efinal:   %8.3f MeV\n", hbc*e);

    fprintObservables(outfp, &Int, &Q, &Obs);

    fprintf(outfp, "\n# Parameterization\n");
    fprintf(outfp, "<Parameterization %s>\n", P.name);
    P.Parawrite(outfp, &q);
 
    fprintf(outfp, "\n# SlaterDet\n");
    writeSlaterDet(outfp, &Q);

    fclose(outfp);  
  }

  // save minimization result in parafile
  {
    // no improvement ? then write initial parameters
    if (!overwrite && einitial < e) 
      P.Paraclone(&qinitial, &q);

    P.ParatoSlaterDet(&q, &Q);

    // orient SlaterDet
    moveboostorientSlaterDet(&Q, &X);

    // normalize SlaterDet
    normalizeSlaterDet(&Q, &X);

    // in FMD parameterization we copy the relocated SlaterDet
    if (!strcmp(P.name, "FMD"))
      SlaterDetinitFMD(&Q, &q);

    // calculate the observables
    Observables Obs;
  
    calcObservables(&Int, &Q, &Obs);

    fprintf(stderr, "... writing Parameters to file %s\n", parafile);

    FILE* outfp;
    if (!(outfp = fopen(parafile, "w"))) {
      fprintf(stderr, "couldn't open %s for writing\n", parafile);
      cleanup(-1);
    }

    fprintinfo(outfp);

    fprintf(outfp, "\n# minimized %s for %s in %s parameterization\n"
            "# using %s interaction\n", 
            cm ? "< Hintr >" : "< H >", q.name, P.name, Int.name);
  
    fprintf(outfp, "\n# einitial: %8.3f MeV\n", hbc*einitial);
    fprintf(outfp, "# efinal:   %8.3f MeV\n", hbc*e);

    if (overwrite)
      fprintf(outfp, "\n# overwrite flag: use new parameters\n\n");
    if (!overwrite && einitial < e)
      fprintf(outfp, "\n# no improvement by minimization: use initial parameters\n\n");

    fprintObservables(outfp, &Int, &Q, &Obs);

    fprintf(outfp, "\n# Parameterization\n");
    fprintf(outfp, "<Parameterization %s>\n", P.name);
    P.Parawrite(outfp, &q);
 
    fprintf(outfp, "\n# SlaterDet\n");
    writeSlaterDet(outfp, &Q);

    fclose(outfp);  
  }

  fprintf(stderr, "... %4.2f minutes computing time used\n", usertime()/60.0);

  cleanup(0);

#ifdef MPI
  }
#endif
}
int main(int argc, char* argv[])
{
  createinfo(argc, argv);

  /* enough arguments ? */

  if (argc < 2) {
    fprintf(stderr, "\nusage: %s [OPTIONS] mcstate"
	    "\n   -A             show all eigenstates\n", argv[0]);
    exit(-1);
  }

  int all=0;
  int hermit=0;

  char c;

  /* manage command-line options */

  while ((c = getopt(argc, argv, "A")) != -1)
    switch (c) {
    case 'A':
      all=1;
      break;
    }

  char* mcstatefile = argv[optind];
  char** mbfile;

  // open multiconfigfile
  Projection P;
  SlaterDet* Q;
  Symmetry* S;
  Eigenstates E;
  int n;

  readMulticonfigfile(mcstatefile, &mbfile, &P, &Q, &S, &E, &n);

  void* radiime[n*n]; 

  int a,b;
  for (b=0; b<n; b++)	
    for (a=0; a<n; a++) {
      radiime[a+b*n] = initprojectedMBME(&P, &OpSDRadii);
    }

  // read or calculate matrix elements
  for (b=0; b<n; b++)
    for (a=0; a<n; a++) {
      if (readprojectedMBMEfromFile(mbfile[a], mbfile[b], &P, 
				    &OpSDRadii, S[a], S[b], 
				    radiime[a+b*n])) {
	calcprojectedMBME(&P, &OpSDRadii, &Q[a], &Q[b], 
			  S[a], S[b], radiime[a+b*n]);
	writeprojectedMBMEtoFile(mbfile[a], mbfile[b], &P, 
				 &OpSDRadii, S[a], S[b], 
				 radiime[a+b*n]);
      }
    }


  if (hermit) {
    hermitizeprojectedMBME(&P, &OpSDRadii, radiime, n);
  }

  fprintf(stderr, "calculate expectation values\n");

  // calculate expectation values
  void* radiiexp = initprojectedVector(&P, &OpSDRadii, n);
  calcexpectprojectedMBME(&P, &OpSDRadii, radiime, S, &E, radiiexp);


  // output

  char outfile[255];
  char tostrip[255];
  FILE* outfp;

  snprintf(tostrip, 255, ".states");
  snprintf(outfile, 255, "%s.radii", stripstr(mcstatefile, tostrip));
  if (!(outfp = fopen(outfile, "w"))) {
    fprintf(stderr, "couldn't open %s for writing\n", outfile);
    goto cleanup;
  }

  fprintinfo(outfp);
  fprintProjectinfo(outfp, &P);

  writeprojectedSDRadii(outfp, Q, &P, radiiexp, &E);

  fclose(outfp);

 cleanup:

  return 0;
}
int main(int argc, char* argv[])
{
  createinfo(argc, argv);

  /* enough arguments ? */

  if (argc < 2) {
    fprintf(stderr, "\nusage: %s [OPTIONS] mcstatefin mcstateini"
	    "\n   -a             show all eigenstates\n", argv[0]);
    exit(-1);
  }

  int all=0;
  int hermit=0;

  char c;

  /* manage command-line options */

  while ((c = getopt(argc, argv, "a")) != -1)
    switch (c) {
    case 'a':
      all=1;
      break;
    }

  char* mcstatefilefin = argv[optind];
  char* mcstatefileini = argv[optind+1];
  char** mbfilefin; char** mbfileini;

  // open multiconfigfile
  Projection P;
  SlaterDet *Qfin, *Qini;
  Symmetry *Sfin, *Sini;
  Eigenstates Efin, Eini;
  int nfin, nini;

  readMulticonfigfile(mcstatefileini, &mbfileini, &P, &Qini, &Sini, &Eini, &nini);
  readMulticonfigfile(mcstatefilefin, &mbfilefin, &P, &Qfin, &Sfin, &Efin, &nfin);

  int direction;
  if (Qfin[0].Z - Qini[0].Z == 1) {
    fprintf(stderr, "GT+ transitions");
    direction = +1;
  }
  if (Qfin[0].Z - Qini[0].Z == -1) {
    fprintf(stderr, "GT- transitions");
    direction = -1;
  }

 
  ManyBodyOperator OpGT;

  if (direction == +1)
    OpGT = OpGTplus;
  if (direction == -1)
    OpGT = OpGTminus;


  int a,b; 

  void** gtme[nfin*nini];

  for (b=0; b<nini; b++)	
    for (a=0; a<nfin; a++)
      gtme[a+b*nfin] = initprojectedMBME(&P, &OpGT);


  // read or calculate matrix elements
  for (b=0; b<nini; b++)
    for (a=0; a<nfin; a++)
      if (readprojectedMBMEfromFile(mbfilefin[a], mbfileini[b], &P,
                                    &OpGT, Sfin[a], Sini[b], gtme[a+b*nfin])) {
	calcprojectedMBME(&P, &OpGT, &Qfin[a], &Qini[b], Sfin[a], Sini[b],
                          gtme[a+b*nfin]);
        writeprojectedMBMEtoFile(mbfilefin[a], mbfileini[b], &P,
                                 &OpGT, Sfin[a], Sini[b], gtme[a+b*nfin]);
      } 
  
  fprintf(stderr, "calculate transition strengths\n");

  void**** gttrans = initprojectedtransitionVector(&P, &OpGT, nfin, nini);
  calctransitionprojectedMBME(&P, &OpGT, gtme, Sfin, Sini, &Efin, &Eini, gttrans);

  // output

  char outfile[511];
  char tostrip[255];
  FILE* outfp;

  snprintf(tostrip, 255, ".states");
  snprintf(outfile, 255, "%s--%s.transgt", 
           stripstr(mcstatefilefin, tostrip), stripstr(mcstatefileini, tostrip));
  if (!(outfp = fopen(outfile, "w"))) {
    fprintf(stderr, "couldn't open %s for writing\n", outfile);
    goto cleanup;
  }

  fprintinfo(outfp);
  fprintProjectinfo(outfp, &P);

  if (direction == +1)
    writeprojectedtransitionGTplus(outfp, &P, gttrans, &Efin, &Eini);
  else
    writeprojectedtransitionGTminus(outfp, &P, gttrans, &Efin, &Eini);

  fclose(outfp);

 cleanup:

  return 0;
}
int main(int argc, char *argv[])
{
  createinfo(argc, argv);

#ifdef MPI
  MPI_Init(&argc, &argv);
  MPI_Comm_rank(MPI_COMM_WORLD, &mpirank);
  MPI_Comm_size(MPI_COMM_WORLD, &mpisize);

  // fprintf(stderr, "... [%2d] %s\n", mpirank, hostname());

  if (mpirank != 0) {
    MinimizerprojSlave();

    MPI_Finalize();
  } else {
#endif

  int c;
  int cm=0;
  int ival=-1;
  int j=0;
  int par=0;
  double threshkmix=0.1;
  double minnormkmix=0.01;
  double alpha=0.1;
  int overwrite=0;
  int log=0;
  int maxsteps=250;
  double shakemag=0.0;
  int constcm=1, constT2=0, constS2=0, constL2=0, constLS=0, constJ2=0;
  int constj2=0;
  int constnosci=0, constpnosci=0, constnnosci=0;
  int constbeta=0, constgamma=0;
  int constmradius=0, constmquadrupole=0, constmoctupole=0;
  int consteradius=0, constedipole=0, constequadrupole=0, consteoctupole=0;
  int constnradius=0, constnquadrupole=0, constnoctupole=0;
  int constparp=0, constparn=0, constparch=0, constd3h=0, constsxz=0, constsyz=0;
  double constT2val=0.0, constS2val=0.0;
  double constL2val=0.0, constLSval=0.0, constJ2val=0.0;
  double constj2val=0.0;
  double constnoscival=0.0, constpnoscival=0.0, constnnoscival=0.0;
  double constmrval=0.0, constmqval=0.0, constmoval=0.0;
  double constbval=0.0, constgval=0.0;
  double consterval=0.0, constedval=0.0, consteqval=0.0, consteoval=0.0;
  double constnrval=0.0, constnqval=0.0, constnoval=0.0;

  Constraint Const[MAXCONSTRAINT];
  int nconst = 0;

  if (argc < 5) {
    fprintf(stderr, "\nusage: %s PROJPARA interaction slaterdetfile\n"
            "\n   -i I            optimize Ith eigenvalue"
	    "\n   -j J            project onto angular momentum"
	    "\n   -p[+1|-1]       project onto parity"
            "\n   -t THRESH       K-mixing threshold"
            "\n   -n NORM         minimal norm for K-mixing eigenstates"
            "\n   -a ALPHA        minimize (eproj + ALPHA eintr)"
	    "\n   -l EVERY        log EVERY step"
	    "\n   -o              overwrite in all cases"
	    "\n   -m MAXSTEPS     maximum number of steps (default %d)"
	    "\n   -s MAGNITUDE    shake parameters before minimization"
	    "\n   -T T2           constrain isospin"
	    "\n   -L l2           constrain single-particle l2"
	    "\n   -S ls           constrain single-particle ls"
	    "\n   -J J2           constrain angular momentum"
	    "\n   -j j2           constrain single-particle angular momentum"
	    "\n   -N NOSCI        constrain number of oscillator quanta"
	    "\n   -R RADIUS       constrain radius"
	    "\n   -D DIPOLE       constrain dipole moments"
	    "\n   -Q QUADRUPOLE   constrain quadrupole moments"
	    "\n   -O OCTUPOLE     constrain octupole moments"
            "\n   -P[+1|-1]       constrain parity of intrinsic state"
            "\n   -C              constrain on symmetry under parity and charge"
            "\n   -V [xz|yz]      constrain reflection symmetry of intrinsic state"
            "\n   -3              constrain intrinsic state to d3h symmetry\n"
	    // "\n   -I Jz           cranking constrain"
	    , argv[0], maxsteps);
    cleanup(-1);
  }
  
  while((c = getopt(argc, argv, "i:j:p:a:n:t:Lol:m:s:T:L:S:J:N:R:D:Q:B:G:O:P:CV:3")) != -1)
    switch (c) {
    case 'i':
      ival = atoi(optarg)-1;
      break;
    case 'j':
      j = atoi(optarg);
      break;
    case 'p':
      par = atoi(optarg);
      break;
    case 'n':
      minnormkmix = atof(optarg);
      break;
    case 't':
      threshkmix = atof(optarg);
      break;
    case 'a':
      alpha = atof(optarg);
      break;
    case 'o':
      overwrite = 1;
      break;
    case 'l':
      log = atoi(optarg);
      break;
    case 'm':
      maxsteps = atoi(optarg);
      break;
    case 's':
      shakemag = atof(optarg);
      break;
    case 'T':
      constT2 = 1;
      constT2val = atof(optarg);
      break;
    case 'L':
      constL2 = 1;
      constL2val = atof(optarg);
      break;
    case 'S':
      constS2 = 1;
      constS2val = atof(optarg);
      break;
    case 'J':
      constJ2 = 1;
      constJ2val = atof(optarg);
      break;
      /*
    case 'j':
      constj2 = 1;
      constj2val = atof(optarg);
      break;
      */
    case 'N':
      if (optarg[0] == 'P') {
        constpnosci = 1;
        constpnoscival = atof(optarg+2);
      } else if (optarg[0] == 'N') {
        constnnosci = 1;
        constnnoscival = atof(optarg+2);
      } else {
        constnosci = 1;
        constnoscival = atof(optarg);
      }
      break;
    case 'R':
      if (optarg[0] == 'E' || optarg[0] == 'P') {
	consteradius = 1;
	consterval = atof(optarg+2);
      } else if (optarg[0] == 'N') {
        constnradius = 1;
        constnrval = atof(optarg+2);
      } else {
	constmradius = 1;
	constmrval = atof(optarg);
      }
      break;
    case 'D':
      constedipole = 1;
      constedval = atof(optarg);
      break;
    case 'Q':
      if (optarg[0] == 'E' || optarg[0] == 'P') {
	constequadrupole = 1;
	consteqval = atof(optarg+2);
      } else if (optarg[0] == 'N') {
	constnquadrupole = 1;
	constnqval = atof(optarg+2);
      } else {
	constmquadrupole = 1;
	constmqval = atof(optarg);
      }
      break;
    case 'B':
      constbeta = 1;
      constbval = atof(optarg);
      break;
    case 'G':
      constgamma = 1;
      constgval = atof(optarg);
      break;
    case 'O':
      if (optarg[0] == 'E' || optarg[0] == 'P') {
	consteoctupole = 1;
	consteoval = atof(optarg+2);
      } else if (optarg[0] == 'N') {
	constnoctupole = 1;
	constnoval = atof(optarg+2);
      } else {
	constmoctupole = 1;
	constmoval = atof(optarg);
      }
      break;
    case 'P':
      if (atoi(optarg) == +1) 
        constparp = 1;
      else
        constparn = 1;
      break;
    case 'C':
      constparch = 1;
      break;
    case 'V':
      if (!strcmp(optarg, "xz"))
        constsxz = 1;
      else if (!strcmp(optarg, "yz"))
        constsyz = 1;
      break;
    case '3':
      constd3h = 1;
      break;
    }
  
  if (constcm) {
    Const[nconst] = ConstraintCM;
    nconst++;
  }
  if (constT2) {
    Const[nconst] = ConstraintT2;
    Const[nconst].val = constT2val;
    nconst++;
  }
  if (constS2) {
    Const[nconst] = ConstraintS2;
    Const[nconst].val = constS2val;
    nconst++;
  }
/*   if (constL2) { */
/*     Const[nconst] = ConstraintL2; */
/*     Const[nconst].val = constL2val; */
/*     nconst++; */
/*   } */
/*   if (constLS) { */
/*     Const[nconst] = ConstraintLS; */
/*     Const[nconst].val = constLSval; */
/*     nconst++; */
/*   } */
  if (constJ2) {
    Const[nconst] = ConstraintJ2;
    Const[nconst].val = constJ2val;
    nconst++;
  }
  if (constj2) {
    Const[nconst] = ConstraintJ2;
    Const[nconst].val = constj2val;
    nconst++;
  }
  if (constnosci) {
    Const[nconst] = ConstraintNOsci;
    Const[nconst].val = SQR(constnoscival);
    nconst++;
  }
  if (constpnosci) {
    Const[nconst] = ConstraintPNOsci;
    Const[nconst].val = SQR(constpnoscival);
    nconst++;
  }
  if (constnnosci) {
    Const[nconst] = ConstraintNNOsci;
    Const[nconst].val = SQR(constnnoscival);
    nconst++;
  }
  if (constmradius) {
    Const[nconst] = ConstraintR2;
    Const[nconst].val = SQR(constmrval);
    nconst++;
  }
  if (consteradius) {
    Const[nconst] = ConstraintER2;
    Const[nconst].val = SQR(consterval);
    nconst++;
  }
  if (constnradius) {
    Const[nconst] = ConstraintNR2;
    Const[nconst].val = SQR(constnrval);
    nconst++;
  }
  if (constedipole) {
    Const[nconst] = ConstraintED2;
    Const[nconst].val = constedval;
    nconst++;
  }
  if (constnquadrupole) {
    Const[nconst] = ConstraintNQ2;
    Const[nconst].val = constnqval;
    nconst++;
  }
  if (constmquadrupole) {
    Const[nconst] = ConstraintQ2;
    Const[nconst].val = constmqval;
    nconst++;
  }
  if (constbeta) {
    Const[nconst] = ConstraintQ2;
    Const[nconst].val = sqrt(24*M_PI/5)*constbval;
    nconst++;
  }
  if (constgamma) {
    if (!constbeta) {
      fprintf(stderr, "gamma constraint only in combination with beta constraint\n");
      exit(-1);
    }
    Const[nconst] = ConstraintDetQ;
    Const[nconst].val = sqrt(4*M_PI/5)*constbval*cbrt(2*cos(3*constgval*M_PI/180));
    nconst++;
  }
  if (constequadrupole) {
    Const[nconst] = ConstraintEQ2;
    Const[nconst].val = consteqval;
    nconst++;
  }
  if (constmoctupole) {
    Const[nconst] = ConstraintO2;
    Const[nconst].val = constmoval;
    nconst++;
  }
  if (consteoctupole) {
    Const[nconst] = ConstraintEO2;
    Const[nconst].val = consteoval;
    nconst++;
  }
  if (constnoctupole) {
    Const[nconst] = ConstraintNO2;
    Const[nconst].val = constnoval;
    nconst++;
  }
  if (constparp) {
    Const[nconst] = ConstraintParityP;
    nconst++;
  }
  if (constparn) {
    Const[nconst] = ConstraintParityN;
    nconst++;
  }
  if (constparch) {
    Const[nconst] = ConstraintParityCharge;
    nconst++;
  }
  if (constsxz) {
    Const[nconst] = ConstraintSxz;
    nconst++;
  }
  if (constsyz) {
    Const[nconst] = ConstraintSyz;
    nconst++;
  }
  if (constd3h) {
    Const[nconst] = ConstraintD3H;
    nconst++;
  }

  int i;
  char* projpar = argv[optind];
  char* interactionfile = argv[optind+1];
  char* parafile = argv[optind+2];

  // set up angular integration
  angintegrationpara AngPar;
  initAngintegration(&AngPar, projpar);

  Interaction Int;
  if (readInteractionfromFile(&Int, interactionfile))
    cleanup(-1);
  Int.cm = cm;

  // optimize which eigenvalue
  if (ival==-1)
    ival = 0;

  // configuration to be varied
  Parameterization P;
  Para qinitial;
  if (readParafromFile(&P, &qinitial, parafile)) {
    fprintf(stderr, "couldn't read %s\n", parafile);
    cleanup(-1);
  }

  SlaterDet Q;
  P.ParainitSlaterDet(&qinitial, &Q);
  P.ParatoSlaterDet(&qinitial, &Q);

  if (!par)
    par = (Q.A % 2) ? -1 : +1;

#ifdef MPI
  int task=TASKSTART;
  BroadcastTask(&task);

  BroadcastInteraction(&Int);
  BroadcastA(&Q.A);
#endif

  initWork(j, par, &AngPar, &Int, &Q);
  
  SlaterDetAux X;
  initSlaterDetAux(&Q, &X);

  moveboostorientSlaterDet(&Q, &X);

  double eintri, eproji;
  calcprojectedHamiltonian(&Q, &Int, j, par, ival, &AngPar,
                           &eintri, &eproji);

  for (int i=0; i<nconst; i++)
    fprintf(stderr, "# constraining %4s to %8.3f\n", 
	    Const[i].label, Const[i].output(Const[i].val)); 

  double einitial = eproji + alpha*eintri;

  fprintf(stderr, "\ninitial:\tE = %8.3f MeV, Eproj = %8.3f MeV, Eintr = %8.3f MeV\n\n", 
	  hbc*einitial, hbc*eproji, hbc*eintri);

  Para q;
  P.Paraclone(&qinitial, &q);

  // shaking the parameters ?
  if (shakemag) {
    shakePara(&q, shakemag);
  }

  // in FMD parameterization move SlaterDet to origin in phase space
  // if (!strcmp(P.name, "FMD")) {
  //   P.ParatoSlaterDet(&q, &Q);
  //   moveboostorientSlaterDet(&Q, &X);
  //   SlaterDetinitFMD(&Q, &q);
  // }

  // minimize !
  MinimizeDONLP2vapp(&Int, j, par, ival, threshkmix, minnormkmix, alpha,
                     &AngPar, 
                     Const, nconst,
                     &P, &q, maxsteps,
                     log, parafile); 

  P.ParatoSlaterDet(&q, &Q);

  double eintrf, eprojf;

  calcprojectedHamiltonian(&Q, &Int, j, par, ival, &AngPar,
                           &eintrf, &eprojf);

  double e = eprojf + alpha*eintrf;

  fprintf(stderr, "\nfinal:\tE = %8.3f MeV, Eproj = %8.3f, Eintr = %8.3f MeV\n\n", 
	  hbc*e, hbc*eprojf, hbc*eintrf);

  moveboostorientSlaterDet(&Q, &X);
  
  calcprojectedHamiltonian(&Q, &Int, j, par, ival, &AngPar,
                           &eintrf, &eprojf);

  e = eprojf + alpha*eintrf;

  fprintf(stderr, "\nboosted:\tE = %8.3f MeV, Eproj = %8.3f, Eintr = %8.3f MeV\n\n", 
	  hbc*e, hbc*eprojf, hbc*eintrf);

  // output files

  // backup of parafile

  backup(parafile);

  // switch on cm for output
  Int.cm = 1;

  // save minimization result in MIN directory
  {
    P.ParatoSlaterDet(&q, &Q);

    // orient SlaterDet
    moveboostorientSlaterDet(&Q, &X);

    // normalize SlaterDet
    normalizeSlaterDet(&Q, &X);

    // in FMD parameterization we copy the relocated SlaterDet
    if (!strcmp(P.name, "FMD"))
      SlaterDetinitFMD(&Q, &q);

    // calculate the observables
    Observables Obs;
  
    calcObservables(&Int, &Q, &Obs);

    ensuredir("MIN");
    char outfile[1024];
    sprintf(outfile, "MIN/%s-minvapp.%d", parafile, (int) time(NULL));

    fprintf(stderr, "... writing Parameters to file %s\n", outfile);

    FILE* outfp;
    if (!(outfp = fopen(outfile, "w"))) {
      fprintf(stderr, "couldn't open %s for writing\n", outfile);
      cleanup(-1);
    }

    fprintinfo(outfp);

    fprintf(outfp, "\n# minimized %s for %s in %s parameterization\n"
            "# projected on J^pi = %s\n"
            "# K-mixing: threshold: %f, minnorm: %f\n"
            "# optimized eigenvalue #%d\n"
            "# using %s interaction\n", 
            "< H > - < Tcm >_intr", q.name, P.name, 
            AngmomtoStr(j, par == +1 ? 0 : 1), 
            threshkmix, minnormkmix, ival+1,
            Int.name);
  
    fprintf(outfp, "\n# initial: e = %8.3f MeV, eproj = %8.3f MeV, eintr = %8.3f MeV\n", 
            hbc*einitial, hbc*eproji, hbc*eintri);
    fprintf(outfp, "# final:   e = %8.3f MeV, eproj = %8.3f MeV, eintr = %8.3f MeV\n", 
            hbc*e, hbc*eprojf, hbc*eintrf);

    fprintObservables(outfp, &Int, &Q, &Obs);

    fprintf(outfp, "\n# Parameterization\n");
    fprintf(outfp, "<Parameterization %s>\n", P.name);
    P.Parawrite(outfp, &q);
 
    fprintf(outfp, "\n# SlaterDet\n");
    writeSlaterDet(outfp, &Q);

    fclose(outfp);  
  }

  // save minimization result in parafile
  {
    // no improvement ? then write initial parameters
    if (!overwrite && einitial < e) 
      P.Paraclone(&qinitial, &q);

    P.ParatoSlaterDet(&q, &Q);

    // orient SlaterDet
    moveboostorientSlaterDet(&Q, &X);

    // normalize SlaterDet
    normalizeSlaterDet(&Q, &X);

    // in FMD parameterization we copy the relocated SlaterDet
    if (!strcmp(P.name, "FMD"))
      SlaterDetinitFMD(&Q, &q);

    // calculate the observables
    Observables Obs;
  
    calcObservables(&Int, &Q, &Obs);

    fprintf(stderr, "... writing Parameters to file %s\n", parafile);

    FILE* outfp;
    if (!(outfp = fopen(parafile, "w"))) {
      fprintf(stderr, "couldn't open %s for writing\n", parafile);
      cleanup(-1);
    }

    fprintinfo(outfp);

    fprintf(outfp, "\n# minimized %s for %s in %s parameterization\n"
            "# projected on J^pi = %s\n"
            "# K-mixing: threshold: %f, minnorm: %f\n"
            "# optimized eigenvalue #%d\n"
            "# using %s interaction\n", 
            "< H > - < Tcm >_intr", q.name, P.name, 
            AngmomtoStr(j, par == +1 ? 0 : 1),
            threshkmix, minnormkmix, ival+1,
            Int.name);

    fprintf(outfp, "\n# initial: e = %8.3f MeV, eproj = %8.3f MeV, eintr = %8.3f MeV\n", 
            hbc*einitial, hbc*eproji, hbc*eintri);
    fprintf(outfp, "# final:   e = %8.3f MeV, eproj = %8.3f MeV, eintr = %8.3f MeV\n", 
            hbc*e, hbc*eprojf, hbc*eintrf);

    if (overwrite)
      fprintf(outfp, "\n# overwrite flag: use new parameters\n\n");
    if (!overwrite && einitial < e)
      fprintf(outfp, "\n# no improvement by minimization: use initial parameters\n\n");

    fprintObservables(outfp, &Int, &Q, &Obs);

    fprintf(outfp, "\n# Parameterization\n");
    fprintf(outfp, "<Parameterization %s>\n", P.name);
    P.Parawrite(outfp, &q);
 
    fprintf(outfp, "\n# SlaterDet\n");
    writeSlaterDet(outfp, &Q);

    fclose(outfp);  
  }

  fprintf(stderr, "... %4.2f minutes computing time used\n", usertime()/60.0);

  cleanup(0);

#ifdef MPI
  }
#endif
}
int main(int argc, char *argv[])
{
  createinfo(argc, argv);
  
  int c;
  int nljorder=0;
  int potentialonly=0;
  int cm=0;
  double omega=0.0;

  if (argc < 3) {
    fprintf(stderr, "\nusage: %s interaction slaterdetfile\n"
	    "\n   -s           sort sp states according to n, l, j"
	    "\n   -v           use only potential"
	    "\n   -o OMEGA     use oscillator constant [MeV]"
	    "\n   -c           T-Tcm\n",
	    argv[0]);
    exit(-1);
  }
  
  while((c = getopt(argc, argv, "svco:")) != -1)
    switch (c) {
    case 's':
      nljorder = 1;
      break;
    case 'v':
      potentialonly=1;
      break;
    case 'c':
      cm = 1;
      break;
    case 'o':
      omega = atof(optarg)/hbc;
      break;
    }
  
  char* interactionfile = argv[optind];
  char* slaterdetfile = argv[optind+1];

  Interaction Int;
  if (readInteractionfromFile(&Int, interactionfile))
    exit(-1);
  Int.cm = cm;

  SlaterDet Q;
  if (readSlaterDetfromFile(&Q, slaterdetfile))
    exit(-1);

  // number of nucleons
  int A = Q.A;

  // single-particle overlap matrix
  SlaterDetAux X;
  initSlaterDetAux(&Q, &X);
  calcSlaterDetAux(&Q, &X);

  // Tcm
  double tcm;
  calcTCM(&Q, &X, &tcm);

  // derive oscillator constant from center of mass motion
  double omegacm = 4.0/3.0*tcm;

  if (omega == 0.0)
    omega = omegacm;

  complex double n[A*A];
  copycmat(A, X.n, n);

  // hartree-fock matrix in Gaussian single-particle basis

  complex double hhf[A*A];
  if (potentialonly)	calcPotentialHF(&Int, &Q, &X, hhf);
  else			calcHamiltonianHF(&Int, &Q, &X, hhf);
  
  complex double l2hf[A*A];
  calcl2HF(&Q, &X, l2hf);
  
  complex double j2hf[A*A];
  calcj2HF(&Q, &X, j2hf);

  complex double hoscihf[A*A];
  calcHOsciHF(&Q, &X, omega, hoscihf);

  complex double t3hf[A*A];
  calct3HF(&Q, &X, t3hf);

  complex double parhf[A*A];
  calcparHF(&Q, &X, parhf);

  // solve eigenvalue problem
  complex double lambda[A];
  complex double V[A*A];
  int dim;

  if (nljorder) {
    complex double nljhf[A*A];
    int i;
    for (i=0; i<A*A; i++)
      nljhf[i] = 10000*hoscihf[i]/omega - 100*j2hf[i] + l2hf[i];

      generalizedeigensystem(nljhf, n, A, 0.0, lambda, V, &dim);
  } else
    generalizedeigensystem(hhf, n, A, 0.0, lambda, V, &dim);

  // calculate expectation values
  double norm[A];
  expect(A, n, V, norm);

  double h[A];
  expect(A, hhf, V, h);

  double l2[A];
  expect(A, l2hf, V, l2);
  
  double j2[A];
  expect(A, j2hf, V, j2);

  double hosci[A];
  expect(A, hoscihf, V, hosci);

  double t3[A];
  expect(A, t3hf, V, t3);

  double par[A];
  expect(A, parhf, V, par);

  fprintinfo(stdout);

  // sort single-particle states by energy
  SingleParticleState sp[A];

  int i;
  for (i=0; i<A; i++) {
    sp[i].rank = lambda[i];
    sp[i].e = h[i]/norm[i];
    sp[i].j2 = j2[i]/norm[i];
    sp[i].l2 = l2[i]/norm[i];
    sp[i].hosci = hosci[i]/norm[i];
    sp[i].t3 = t3[i]/norm[i];
    sp[i].pi = par[i]/norm[i];
  }	
  
  qsort(sp, A, sizeof(SingleParticleState), cmpSingleParticleState);
  
  // print proton and neutron levels

  fprintf(stdout, "\nusing oscillator constant: hbar Omega = %8.3f MeV\n",
	  omega*hbc);

  fprintf(stdout, "\nproton levels:\n");
  for (i=0; i<A; i++)
    if (sp[i].t3 > 0.0) {
      fprintf(stdout, "e: %8.3f MeV, j: %5.3f, l: %5.3f, pi: %+5.2f, nosci: %5.3f\n",
	      hbc*sp[i].e, angroot(sp[i].j2), angroot(sp[i].l2), sp[i].pi,
	      sp[i].hosci/omega-1.5);
    }

  fprintf(stdout, "\nneutron levels:\n");
  for (i=0; i<A; i++)
    if (sp[i].t3 < 0.0) {
      fprintf(stdout, "e: %8.3f MeV, j: %5.3f, l: %5.3f, pi: %+5.2f, nosci: %5.3f\n",
	      hbc*sp[i].e, angroot(sp[i].j2), angroot(sp[i].l2), sp[i].pi,
	      sp[i].hosci/omega-1.5);
    }

  return 0;
}