void testTortureExecute(void)
{
#if 0
int eval;
ftest(3.0, &eval);
ftest(3.5, &eval);
ftest(4.0, &eval);
ftest(5.0, &eval);
return;
#endif
}
int main()
{
int e=0;
printf("Big-endian:\n");
printf(" Test 1: ");
e+=ftest(test1k, btest1p, btest1c, B_Blowfish_Encrypt, B_Blowfish_Decrypt);
printf(" Test 2: ");
e+=ftest(test2k, btest2p, btest2c, B_Blowfish_Encrypt, B_Blowfish_Decrypt);
printf("Little-endian:\n");
printf(" Test 1: ");
e+=ftest(test1k, btest1p, btest1l, L_Blowfish_Encrypt, L_Blowfish_Decrypt);
printf(" Test 2: ");
e+=ftest(test2k, btest2p, btest2l, L_Blowfish_Encrypt, L_Blowfish_Decrypt);
return e;
}
LOCAL_C TInt formatThread(TAny*)
{
TBusLocalDrive anotherDrive;
RTest ftest(_L("Formatting thread"));
ftest.Title();
ftest.Start(_L("Connect to local drive"));
TBool changeFlag=EFalse;
ftest(anotherDrive.Connect(TheDriveNumber,changeFlag)==KErrNone);
ftest.Next(_L("Format disk"));
ftest(anotherDrive.Format(0,KTestDriverMediaSize)==KErrNone);
anotherDrive.Disconnect();
ftest.End();
return(KErrNone);
}
static void run_test(int i)
{
double cpe;
printf("Description: %s, ",
test_descr[i]);
idx = i;
cpe = find_cpe(test, ASIZE);
/* print results */
printf("CPE = %.2f\n", cpe);
ftest(i);
}
int main()
{
/*
float e = std::numeric_limits<float>::epsilon();
float e2 = 1.0f / 8388608.0f;
std::cout << "e = " << e << "\n";
std::cout << "log(e) = " << log(e) / log(2) << "\n";
std::cout << "e2 = " << e2 << "\n";
std::cout << "log(e2) = " << log(e2) / log(2) << "\n";
*/
ftest();
}
int
main (void)
{
return ftest (ARCH_V4);
}
int
main (void)
{
return ftest (ARCH_V5TE);
}
int
main (void)
{
return ftest (ARCH_V6T2);
}
// #include"reaction.h"
int main(){
////////Input Parameters of the potential (fit parameters) /////
std::string parameters_filename="Input.inp";
NuclearParameters Nu = read_nucleus_parameters( "Input/nca40.inp" );
double Ef=Nu.Ef;
int lmax=6;
double z0=20.0;
double zp0;
double A0=40.0;
double tz=-0.5;
int type=1;
int mvolume = 4;
int AsyVolume = 1;
double A = 40.0;
if (tz>0) { zp0=1;}
else {zp0=0;}
double ph_gap = Nu.ph_gap;
cout<<"ph_gap = "<<Nu.ph_gap<<endl;
double rStart = .05;
double rmax = 12.;
double ham_pts = 180;
double rdelt = rmax / ham_pts;
//THIS IS ANOTHER CHANGE FROM THE OLD TOO////////////////
double rdelt_p = rdelt / 1.025641026;
// Construct Parameters Object
Parameters p = get_parameters( parameters_filename, Nu.A, Nu.Z, zp0 );
// Construct Potential Object
pot pottt = get_bobs_pot2( type, mvolume, AsyVolume, tz, Nu, p );
pot * pott = &pottt;
// store coulomb potential in order to compare with
boundRspace initiate(rmax , ham_pts , Ef, ph_gap , lmax , Nu.Z , zp0 , Nu.A , pott);
double Elower = -11.61818;
double Eupper = -9.4;
double jj = .5;
int ll = 0;
int Ifine = 1;
initiate.searchNonLoc( Elower, Eupper, jj, ll, Ifine);
initiate.exteriorWaveFunct(ll);
initiate.normalizeWF();
double tol=.01;
double estart=Ef;
///// Making rmesh///
//THIS IS THE DIFFERENCE FROM SKYRMEOLD////////////////////////////////
//vector <double> rmesh_p = initiate.make_rmesh();
std::vector<double> rmesh_p= initiate.make_rmesh_point();
std::vector<double> rmesh= initiate.make_rmesh();
// Create momentum space grid
std::vector<double> kmesh;
std::vector<double> kweights;
double const kmax = 5.0;
int const kpts = rmesh.size();
kmesh.resize( kpts );
kweights.resize( kpts );
GausLeg( 0., kmax, kmesh, kweights );
double J =0.5;
double Emax=2*-4.7;
double Emin=-200.0 + Emax;
std::ofstream filee("waves/neutron/natural/wave.out");
std::cout<<Elower<<std::endl;
//Generating the propagator
std::vector< lj_eigen_t > bound_levels = initiate.get_bound_levels( rmesh, tol );
std::vector< mesh_t > emesh_vec =
initiate.get_emeshes( rmesh, Emin, Emax, bound_levels );
cout<<"emesh_vec = "<<emesh_vec.size()<<endl;
std::vector< prop_t > prop_vec = initiate.get_propagators( rmesh, emesh_vec );
double onum=0.0;
double num=0.0;
double part=0;
double kpart=0;
vector<double> denk;
denk.assign( kmesh.size(), 0 );
vector<double> k_dist;
k_dist.assign( kmesh.size(), 0 );
vector <double> natden;
natden.assign(rmesh.size(),0);
vector <double> natdenk;
natdenk.assign(kmesh.size(),0);
vector <double> ktest;
ktest.assign(kmesh.size(),0);
vector <double> diag;
diag.assign(kmesh.size(),0);
double dom=0;
double expo=0;
int Nmax=5;
string stable = "waves/neutron/natural/table.txt";
ofstream ftable(stable.c_str());
string presky = "waves/neutron/data/n";
vector<double> kdist;
kdist.assign(rmesh.size(),0);
lmax=0;
//Starting loop over L and J to go through all the orbitals
for(int L=0;L<lmax+1;L++){
for(int s=0;s<2;s++){
J=L-0.5+s;
if(J<0){
J=0.5;
s=1;
}
cout<<"L = "<<L<<" J = "<<J<<endl;
string jlab;
if(J==0.5){
jlab="12";
}else if(J==1.5){
jlab="32";
}else if(J==2.5){
jlab="52";
}else if(J==3.5){
jlab="72";
}else if(J==4.5){
jlab="92";
}else if(J==5.5){
jlab="112";
}else if(J==6.5){
jlab="132";
}
string llab;
if(L==0){
llab="s";
}else if(L==1){
llab="p";
}else if(L==2){
llab="d";
}else if(L==3){
llab="f";
}else if(L==4){
llab="g";
}else if(L==5){
llab="h";
}else if(L==6){
llab="i";
}
/*
int Nmax=10;
if(L>1){
Nmax=9;
}
if(L>3){
Nmax=8;
}
if(L==6 && J == 5.5){
Nmax=7;
}
*/
Nmax=4;
if(L>3) Nmax = 1;
int Mmax=Nmax;
ftable<<endl;
ftable<<llab<<jlab<<endl;
ftable<<" ";
for(int i=0;i<Mmax;i++){
ftable<<i<<" ";
}
ftable<<endl;
string dest = "waves/neutron/natural/";
int index=initiate.index_from_LJ(L,J);
const prop_t &propE = prop_vec.at(index);
const mesh_t &emesh = emesh_vec.at(index);
// Create Bessel Function matrix in k and r
matrix_t bess_mtx( kmesh.size(), rmesh.size() );
bess_mtx.clear();
matrix_t bess_mtx_sky(kmesh.size(),rmesh.size());
bess_mtx_sky.clear();
for( unsigned int nk = 0; nk < kmesh.size(); ++nk ) {
for( unsigned int nr = 0; nr < rmesh.size(); ++nr ) {
double rho = kmesh[nk] * rmesh_p[nr];
bess_mtx( nk, nr ) = gsl_sf_bessel_jl( L, rho );
bess_mtx_sky(nk,nr) = gsl_sf_bessel_jl(L, kmesh[nk]*rmesh[nr]);
}
}
matrix_t d_mtx( rmesh.size(), rmesh.size() ); // density matrix
d_mtx.clear();
//Remember that propE is actually G*r*r'*rdelt
for(unsigned int n=0;n<emesh.size();++n){
double Edelt=emesh[n].second;
for( unsigned int i = 0; i < rmesh.size(); ++i ) {
for( unsigned int j = 0; j < rmesh.size(); ++j ) {
d_mtx(i,j) -= Edelt * imag(propE[n](i,j)) / M_PI;
}
}
}
const lj_eigen_t &levels = bound_levels.at(index);
//this adds the QP peaks to the particle number
for ( unsigned int N = 0; N < levels.size(); ++N ){
if ( ( levels[N].first <= Ef ) &&
( levels[N].first > Emax ) ) {
double QPE = levels[N].first;
const std::vector<double> &QPF = levels[N].second;
double S = initiate.sfactor( rmesh, QPE, L, J, QPF );
for ( unsigned int i = 0; i < rmesh.size(); ++i ) {
for(int j=0;j<rmesh.size();j++){
d_mtx(i,j) += S * QPF[i] * QPF[j] * rmesh[i]*rmesh[j]*rdelt;
}
}
}
}
matrix_t k_mtx( rmesh.size(), rmesh.size() ); // density matrix
k_mtx.clear();
matrix_t mtx(rmesh.size(),rmesh.size() );
mtx.clear();
matrix_t diff_mtx(rmesh.size(),rmesh.size());
diff_mtx.clear();
matrix_t r_mtx( rmesh.size(), rmesh.size() ); // testing to see if this is the same as the original
r_mtx.clear();
double maxR = rmesh[rmesh.size()-1];
double minR = rmesh[0];
/* for(int i=0;i<rmesh.size();i++){
for(int j=0;j<rmesh.size();j++){
//d_mtx(i,j) = exp(-pow(rmesh[i]-rmesh[j],2));
//mtx(i,j) = (1.0 / pow(kmesh[i]*kmesh[j],2) ) * (cos(kmesh[i]*maxR) - cos(kmesh[i]*minR) ) * (cos(kmesh[j]*maxR) - cos(kmesh[i]*minR) ) * (2.0/M_PI);
}
f4[i] = mtx(i,i);
} */
for(int i=0;i<rmesh.size();i++){
if(i%30==0) cout<<i<<endl;
for(int j=0;j<rmesh.size();j++){
double kd=0;
double kr;
double kr2;
for(int ii=0;ii<rmesh.size();ii++){
for(int jj=0;jj<rmesh.size();jj++){
//dmtx already has r*r'*dr
kd += d_mtx(ii,jj) * bess_mtx(i,ii) * bess_mtx(j,jj) /( rmesh[ii] * rmesh[jj] * rdelt) * pow( rdelt_p * rmesh_p[ii] * rmesh_p[jj], 2) * (2.0/M_PI);
//kd += d_mtx(ii,jj) * bess_mtx(i,ii) * bess_mtx(j,jj) * pow(rdelt * rmesh[ii] * rmesh[jj],2) * (2.0/M_PI);
kr = kmesh[i] * rmesh[ii];
kr2 = kmesh[j] * rmesh[jj];
//kd += d_mtx(ii,jj) * sin(kr)/kr * sin(kr2)/kr2 * pow(rdelt * rmesh[ii] * rmesh[jj], 2) * (2.0/M_PI);
//kd += d_mtx(ii,jj) * sin(kr)/kr * sin(kr2)/kr2 / ( rmesh[ii] * rmesh[jj] * rdelt) * pow( rdelt_p * rmesh_p[ii] * rmesh_p[jj], 2) * (2.0/M_PI);
}
}
//including this for diagonalization
k_mtx(i,j) = kd * kmesh[i] * kmesh[j] * kweights[i];
}
//f2[i] = k_mtx(i,i);
kdist[i] += k_mtx(i,i) * (2*J+1) / (4*M_PI);
}
for(int i=0;i<rmesh.size();i++){
if(i%30==0) cout<<i<<endl;
for(int j=0;j<rmesh.size();j++){
double kd=0;
double kr;
double kr2;
for(int ii=0;ii<rmesh.size();ii++){
for(int jj=0;jj<rmesh.size();jj++){
//already includes kk'dk
kd += k_mtx(ii,jj) * bess_mtx(ii,i) * bess_mtx(jj,j) * kmesh[ii] * kmesh[jj] * kweights[jj] * (2.0/M_PI);
}
}
//including this for diagonalization
r_mtx(i,j) = kd * rmesh[i] * rmesh[j] * rdelt;
}
}
vector <eigen_t> eig = initiate.real_eigvecs(d_mtx);
vector <eigen_t> eigr = initiate.real_eigvecs(r_mtx);
vector <eigen_t> eigk = initiate.real_eigvecs(k_mtx);
vector <eigen_t> eigm = initiate.real_eigvecs(mtx);
ofstream diff("waves/diff.txt");
for(int i=0;i<rmesh.size();i++){
diff<<rmesh[i]<<" "<<eig[rmesh.size()-1].second[i]/rmesh[i]<<" "<<eigr[rmesh.size()-1].second[i]/rmesh[i]<<endl;
}
cout<<"maxR = "<<maxR<<endl;
cout<<"minR = "<<minR<<endl;
cout<<"kmesh[10] = "<<kmesh[100]<<endl;
double eignorm=0;
double reignorm=0;
double keignorm=0;
ofstream feval("waves/evals.txt");
for(int i=0;i<rmesh.size();i++){
double spot=rmesh.size()-1-i;
feval<<eig[spot].first<<" "<<eigr[spot].first<<endl;
eignorm += pow(eig[spot].first,2);
reignorm += pow(eigr[spot].first,2);
keignorm += pow(eigk[spot].first,2);
}
// cout<<"eigval d_mtx[0] = "<<eig[0].first<<endl;
cout<<"eigval d_mtx[N] = "<<eig[rmesh.size()-1].first<<endl;
cout<<"eigval r_mtx[N] = "<<eigr[rmesh.size()-1].first<<endl;
// cout<<"eigval k_mtx[0] = "<<eigk[0].first<<endl;
cout<<"eigval k_mtx[N] = "<<eigk[rmesh.size()-1].first<<endl;
cout<<"eigval mtx[N] = "<<eigm[rmesh.size()-1].first<<endl;
cout<<"k_mtx(10,10) = "<<k_mtx(100,100)<<endl;
cout<<"mtx(10,10) = "<<mtx(100,100)<<endl;
vector <double> f(rmesh.size());
vector <double> f2(rmesh.size());
vector <double> f3(rmesh.size());
vector <double> f4(rmesh.size());
for(int i=0;i<rmesh.size();i++){
f[i] = eig[rmesh.size()-1].second[i]/rmesh_p[i];
}
double fk;
for(int i=0;i<rmesh.size();i++){
fk=0;
for(int j=0;j<rmesh.size();j++){
fk += f[j] * sin(rmesh[j] * kmesh[i])/(rmesh[j]*kmesh[i]) * pow(rmesh[j],2) * rdelt * sqrt(2.0/M_PI);
}
f2[i] = fk;
f4[i] = 1.0/pow(kmesh[i],2) * (cos(minR*kmesh[i]) - cos(maxR*kmesh[i]) );
}
for(int i=0;i<rmesh.size();i++){
fk=0;
for(int j=0;j<rmesh.size();j++){
fk += f2[j] * sin(rmesh[i] * kmesh[j])/(rmesh[i]*kmesh[j]) * pow(kmesh[j],2) * kweights[j] * sqrt(2.0/M_PI);
}
f3[i] = fk;
}
ofstream compk("waves/compk.txt");
for(int i=0;i<rmesh.size();i++){
compk<<kmesh[i]<<" "<<f2[i]<<" "<<f4[i]<<endl;
}
ofstream compr("waves/compr.txt");
for(int i=0;i<rmesh.size();i++){
compr<<rmesh[i]<<" "<<f[i]<<" "<<f3[i]<<endl;
}
double ksum=0;
double rsum=0;
for(int i=0;i<kmesh.size()-1;i++){
if(eigk[i].first > 0.5 && eigk[i].first < 2){
cout <<"eigk = " << eig[i].first << endl;
}
rsum += eig[i].first;
ksum += eigk[i].first;
}
rsum += eig[rmesh.size()-1].first;
cout<<"ksum = "<<ksum<<endl;
cout<<"rsum = "<<rsum<<endl;
//Transforming natural orbits to k-space
vector <double> knat;
knat.assign(kmesh.size(),0);
for(int ik=0;ik<kmesh.size();ik++){
double kn=0;
for(int ir=0;ir<rmesh.size();ir++){
kn += rdelt_p * sqrt(2.0/M_PI) * bess_mtx(ik,ir) * eig[rmesh.size()-1].second[ir] / rmesh[ir]
* pow(rmesh_p[ir],2);
}
knat[ik] = kn;
}
double fnorm=0;
double fnorm2=0;
for(int i =0;i<rmesh.size();i++){
fnorm += pow(knat[i] * kmesh[i],2) * kweights[i];
fnorm2 += pow(eigk[kmesh.size()-1].second[i] * kmesh[i], 2) * kweights[i];
}
cout<<"fnorm = "<<fnorm<<endl;
cout<<"fnorm2 = "<<fnorm2<<endl;
string eiglab = dest + "eig" + llab+jlab+".txt";
ofstream fval(eiglab.c_str());
matrix_t sky_mtx(Mmax, Mmax); // density matrix
sky_mtx.clear();
//Starting loop over N
for(int N=0;N<Nmax;N++){
string Nlab;
ostringstream convert;
convert << N;
Nlab = convert.str();
ftable<<Nlab<<" ";
double spot = rmesh.size()-N-1;
double enorm=0;
for(int i=0;i<rmesh.size();++i){
enorm += rdelt * pow( eig[spot].second[i],2);
}
string veclab = dest + "eig" + llab + jlab + Nlab + ".txt";
std::ofstream feig(veclab.c_str());
//opening skyrme file which gives u(r)
string skyfile0 = presky + llab + jlab + Nlab + ".txt";
std::ifstream filein0(skyfile0.c_str());
double sky0[rmesh.size()];
std::string line0;
int i;
i=0;
while(getline(filein0,line0)){
sky0[i]=atof(line0.c_str());
i++;
}
filein0.close();
//flipping the natural orbits if they are upside down
// if((eig[spot].second[1]<0 && sky0[1]>0) || (eig[spot].second[1]>0 && sky0[1]<0)){
// for(int i=0;i<rmesh.size();i++){
// eig[spot].second[i] *= -1.0;
//}
//}
for(int i=0;i<rmesh.size();++i){
//want to give R(r), so print out u(r)/r
feig<<rmesh[i]<<" "<<eig[spot].second[i]/sqrt(enorm)/rmesh[i]<<" "<<sky0[i]/rmesh[i]<<endl;
}
//Transforming natural orbits to k-space
vector <double> knat;
knat.assign(kmesh.size(),0);
for(int ik=0;ik<kmesh.size();ik++){
double kn=0;
for(int ir=0;ir<rmesh.size();ir++){
kn += rdelt_p * sqrt(2.0/M_PI) * bess_mtx(ik,ir) * eig[spot].second[ir] / sqrt(enorm) / rmesh[ir]
* pow(rmesh_p[ir],2);
}
knat[ik] = kn;
}
double nnorm=0;
for(int i=0;i<kmesh.size();i++){
nnorm += pow(knat[i]*kmesh[i],2) * kweights[i];
}
// double newnorm=0;
//for(int i=0;i<kmesh.size();i++){
//knat[i] /= sqrt(nnorm);
// newnorm += pow(knat[i],2);
//}
//cout<<"newnorm = "<<nnorm<<endl;
for(int i=0;i<rmesh.size();i++){
natden[i] += eig[spot].first*pow(eig[spot].second[i]/rmesh[i]/sqrt(enorm),2)*(2*J+1)/(4*M_PI);
natdenk[i] += eig[spot].first * pow(knat[i],2) * (2*J+1) / (4*M_PI);
}
vector <double> wave;
wave.assign(kmesh.size(),0);
vector <double> waver;
waver.assign(rmesh.size(),0);
double csquare=0;
//beginning loop over M to sum over skyrme wave functions
for(int M=0;M<Mmax;M++){
string Mlab;
ostringstream convert;
convert << M;
Mlab = convert.str();
//opening skyrme file which gives u(r)
string skyfile = presky + llab + jlab + Mlab + ".txt";
std::ifstream filein(skyfile.c_str());
double skyrme[rmesh.size()];
std::string line;
int i;
i=0;
while(getline(filein,line)){
skyrme[i]=atof(line.c_str());
i++;
}
filein.close();
//Transforming skyrme wavefunctions to k-space
vector <double> ksky;
ksky.assign(kmesh.size(),0);
for(int ik=0;ik<kmesh.size();ik++){
double ks=0;
for(int ir=0;ir<rmesh.size();ir++){
ks += rdelt * sqrt(2.0/M_PI) * bess_mtx_sky(ik,ir) * skyrme[ir] * rmesh[ir];
}
ksky[ik] = ks;
}
if(M==N){
string test = "waves/neutron/natural/wave" + llab + jlab + Mlab + ".txt";
ofstream ftest(test.c_str());
for(int i=0;i<kmesh.size();i++){
ftest<<kmesh[i]<<" "<<knat[i]<<" "<<ksky[i]<<endl;
}
}
int M2max=Mmax;
double proj=0;
for(int i=0;i<kmesh.size();i++){
proj += ksky[i] * knat[i] * pow(kmesh[i],2) * kweights[i];
}
ftable<<proj<<" ";
for(int M2=0;M2<M2max;M2++){
string M2lab;
ostringstream convert;
convert << M2;
M2lab = convert.str();
string skyfile2 = presky + llab + jlab + M2lab + ".txt";
std::ifstream filein2(skyfile2.c_str());
double skyrme2[rmesh.size()];
std::string line2;
int i;
i=0;
while(getline(filein2,line2)){
skyrme2[i]=atof(line2.c_str());
i++;
}
filein2.close();
if(N==0){
//creating matrix in skyrme space
double sky=0;
for(int i=0;i<rmesh.size();i++){
for(int j=0;j<rmesh.size();j++){
sky += skyrme[i] * skyrme2[j] * d_mtx(i,j) * rdelt;
}
}
sky_mtx(M,M2) = sky;
}
//Transforming skyrme wavefunctions to k-space
vector <double> ksky2;
ksky2.assign(kmesh.size(),0);
for(int ik=0;ik<kmesh.size();ik++){
double ks2=0;
for(int ir=0;ir<rmesh.size();ir++){
ks2 += rdelt * sqrt(2.0/M_PI) * bess_mtx_sky(ik,ir) * skyrme2[ir] * rmesh[ir];
}
ksky2[ik] = ks2;
}
double proj2=0;
for(int i=0;i<kmesh.size();i++){
proj2 += ksky2[i] * knat[i] * pow(kmesh[i],2) * kweights[i];
}
//if(M != M2){
//cout<<"proj1 = "<<proj<<endl;
//cout<<"proj2 = "<<proj2<<endl;
//}
for(int i=0;i<kmesh.size();i++){
denk[i] += eig[spot].first * (2*J+1) / (4*M_PI) * ksky[i] * ksky2[i] * proj * proj2;
if(M != M2){
ktest[i] += eig[spot].first * (2*J+1) / (4*M_PI) * ksky[i] * ksky2[i] * proj * proj2;
}
}
} //end loop over M2
for(int i=0;i<kmesh.size();i++){
wave[i] += skyrme[i] * proj;
}
csquare += pow(proj,2);
} //ending loop over M
ftable<<endl;
if(L==0){
dom += eig[spot].first * (2*J+1) / (4*M_PI) * pow(knat[0],2);
expo += eig[spot].first * (2*J+1) / (4*M_PI) * pow(wave[0],2);
}
for(int i=0;i<kmesh.size();i++){
diag[i] += eig[spot].first * (2*J+1) / (4*M_PI) * pow(wave[i],2);
}
double overlap=0;
for(int i=0;i<kmesh.size();i++){
overlap += knat[i] * wave[i] * pow(kmesh[i],2) * kweights[i];
}
//ut<<" N = "<<N<<" overlap = "<<overlap<<endl;
//cout<<"N = "<<N<<" csquare = "<<csquare<<endl;
string comp = "waves/neutron/natural/comp" + llab + jlab + Nlab + ".txt";
ofstream fcomp(comp.c_str());
double wavenorm=0;
double natnorm=0;
for(int i=0;i<rmesh.size();i++){
wavenorm += pow(wave[i],2) * rdelt;
}
for(int i=0;i<kmesh.size();i++){
fcomp<<rmesh[i]<<" "<<wave[i]/sqrt(wavenorm)/rmesh[i]<<endl;
}
} //ending loop over N
//ftable.close();
vector <eigen_t> eigsky = initiate.real_eigvecs(sky_mtx);
cout<<"Mmax = "<<Mmax<<endl;
for(int M=0;M<Mmax;M++){
string Mlab;
ostringstream convert;
convert << M;
Mlab = convert.str();
int spot = Mmax - M - 1;
string fname = "waves/eigvec" + llab + jlab + Mlab + ".txt";
ofstream feigsky(fname.c_str());
//the eigenvector is already normalized
for(int i=0;i<Nmax;i++){
feigsky << eigsky[spot].second[i] << endl;
}
cout << "eigval = " << eigsky[spot].first << endl;
vector<double> qpf;
qpf.assign(rmesh.size(),0);
for(int j=0;j<Mmax;j++){
string Nlab;
ostringstream convert;
convert << j;
Nlab = convert.str();
string skyfile = presky + llab + jlab + Nlab + ".txt";
std::ifstream filein(skyfile.c_str());
double skyrme[rmesh.size()];
std::string line;
int i;
i=0;
while(getline(filein,line)){
skyrme[i]=atof(line.c_str());
i++;
}
filein.close();
for(int i=0;i<rmesh.size();i++){
qpf[i] += eigsky[spot].second[j] * skyrme[i];
}
}
string qpname = "waves/nat" + llab + jlab + Mlab + ".txt";
ofstream qpfile(qpname.c_str());
double norm=0;
for(int i=0;i<rmesh.size();i++){
norm += pow(qpf[i],2) * rdelt;
}
double fac;
if(qpf[10] < 0){
fac = -1.0;
}else{
fac = 1.0;
}
for(int i=0;i<rmesh.size();i++){
qpfile << rmesh[i] <<" "<< qpf[i] / sqrt(norm) / rmesh[i] * fac << endl;
}
}
} //ending loop over j
} //ending loop over L
double knum=0;
double kdiag=0;
double kdistnum=0;
ofstream fdiag("waves/neutron/natural/diagk.txt");
ofstream sdenk("waves/neutron/natural/skydenk.txt");
ofstream fdenr("waves/neutron/natural/natden.txt");
ofstream fdenk("waves/neutron/natural/natdenk.txt");
ofstream fdist("waves/kdist.txt");
double k_part=0;
kpart=0;
for(int i=0;i<kmesh.size();i++){
kpart += denk[i] * pow(kmesh[i],2) * kweights[i] * 4 * M_PI;
knum += ktest[i] * pow(kmesh[i],2) * kweights[i] * 4 * M_PI;
k_part += natdenk[i] * kweights[i] * pow(kmesh[i],2) * 4 * M_PI;
kdiag += diag[i] * kweights[i] * pow(kmesh[i],2) * 4 * M_PI;
kdistnum += kdist[i] * pow(kmesh[i],2) * kweights[i] * 4 * M_PI;
}
for(int i=0;i<kmesh.size();i++){
sdenk<<kmesh[i]<<" "<<denk[i]<<endl;
fdenk<<kmesh[i]<<" "<<natdenk[i]<<endl;
fdiag<<kmesh[i]<<" "<<diag[i]/kdiag<<endl;
fdist<<kmesh[i]<<" "<<kdist[i]/kdistnum<<endl;
}
double nat=0;
for(int i=0;i<rmesh.size();i++){
nat += natden[i] * rdelt_p * pow(rmesh_p[i],2) * 4*M_PI;
}
for(int i=0;i<rmesh.size();i++){
fdenr<<rmesh_p[i]<<" "<<natden[i]/nat<<endl;
}
cout<<"expoansion = "<<expo/kpart<<endl;
cout<<"natural = "<<dom/k_part<<endl;
cout<<"ktest = "<<knum<<endl;
cout<<"kdiag = "<<kdiag<<endl;
cout<<"particle number from sky density (k) = "<<kpart<<endl;
cout<<"particle number from natural (r) = "<<nat<<endl;
cout<<"particle number from natural (k) = "<<k_part<<endl;
cout<<"particle number from kdist (k) = "<<kdistnum<<endl;
}
void
testTortureExecute (void)
{
#if INT_MAX == 2147483647
ftest(0x00000000,0x80000000);
ftest(0x80000000,0x00000000);
ftest(0x12345678,0x92345678);
ftest(0x92345678,0x12345678);
ftest(0x7fffffff,0xffffffff);
ftest(0xffffffff,0x7fffffff);
ftestu(0x00000000,0x80000000);
ftestu(0x80000000,0x00000000);
ftestu(0x12345678,0x92345678);
ftestu(0x92345678,0x12345678);
ftestu(0x7fffffff,0xffffffff);
ftestu(0xffffffff,0x7fffffff);
#endif
#if INT_MAX == 32767
ftest(0x0000,0x8000);
ftest(0x8000,0x0000);
ftest(0x1234,0x9234);
ftest(0x9234,0x1234);
ftest(0x7fff,0xffff);
ftest(0xffff,0x7fff);
ftestu(0x0000,0x8000);
ftestu(0x8000,0x0000);
ftestu(0x1234,0x9234);
ftestu(0x9234,0x1234);
ftestu(0x7fff,0xffff);
ftestu(0xffff,0x7fff);
#endif
return;
}
