// #include"reaction.h"
int main()
{
////////Input Parameters of the potential (fit parameters) /////
std::string parameters_filename="Input.inp";
NuclearParameters Nu = read_nucleus_parameters( "Input/pca40.inp" );
double Ef=Nu.Ef;
int lmax=5;
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;
double rStart = .05;
double rmax = 12.;
double ham_pts = 180;
double rdelt = rmax / ham_pts;
// 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///
// std::vector<double> rmesh_p= initiate.make_rmesh_point();
std::vector<double> rmesh_p= initiate.make_rmesh_point();
std::vector<double> rmesh= initiate.make_rmesh();
////////////////////////////
//// s and d wave functions////
///////////////////////////
int N = 0;
int L = 1;
double J = 0.5;
double Emax=2*-4.7;
double Emin=-200.0 + Emax;
eigen_t waves0=initiate.find_boundstate(rmesh_p, estart,0,L,J,tol);
eigen_t waves1=initiate.find_boundstate(rmesh_p, estart,1,L,J,tol);
eigen_t waves2=initiate.find_boundstate(rmesh_p, estart,2,L,J,tol);
eigen_t waves3=initiate.find_boundstate(rmesh_p, estart,3,L,J,tol);
eigen_t waves4=initiate.find_boundstate(rmesh_p, estart,4,L,J,tol);
eigen_t waves5=initiate.find_boundstate(rmesh_p, estart,5,L,J,tol);
eigen_t waves6=initiate.find_boundstate(rmesh_p, estart,6,0,0.5,tol);
std::ofstream filee("waves/wave.out");
std::cout<<Elower<<std::endl;
//////////
////////////
// Plottinge Pot and wavefuntionsa and their log//
// and also the derivitaves
//////////////////////
double norm0=0,norm1=0,norm2=0,norm3=0,norm4=0,norm5=0,norm6=0;
double normAsymp_s = 0.;
double normAsymp_d = 0.;
double Mproton = 931.5;// 937.27;
double normbob= 0.;
//double Ed = -waves_d.first;
//double Es = -waves_s.first;
//double bbetta_d = std::sqrt(2. * Mproton * (40./41.) * Ed /(197. * 197.));
//double bbetta_s = std::sqrt(2. * Mproton * (40./41.) * Es /(197. * 197.));
//double llambbda = 2.0 * Mproton * (40./41.) * 1.44 * 19. /(197. * 197.);
for(int ii=0;ii<rmesh_p.size();++ii){
norm0 += rdelt * std::pow(rmesh_p[ii] * waves0.second[ii],2) ;
norm1 += rdelt * std::pow(rmesh_p[ii] * waves1.second[ii],2) ;
norm2 += rdelt * std::pow(rmesh_p[ii] * waves2.second[ii],2) ;
norm3 += rdelt * std::pow(rmesh_p[ii] * waves3.second[ii],2) ;
norm4 += rdelt * std::pow(rmesh_p[ii] * waves4.second[ii],2) ;
norm5 += rdelt * std::pow(rmesh_p[ii] * waves5.second[ii],2) ;
norm6 += rdelt * std::pow(rmesh_p[ii] * waves6.second[ii],2) ;
//normAsymp_s += rdelt * std::pow((exp(-bbetta_s * rmesh_p[ii]) * std::pow(rmesh_p[ii], -llambbda /( 2.0 * bbetta_s))) ,2);
//normAsymp_d += rdelt * std::pow((exp(-bbetta_d * rmesh_p[ii]) * std::pow(rmesh_p[ii], -llambbda /( 2.0 * bbetta_d))) ,2);
//normbob += rdelt * std::pow(rmesh_p[ii] * initiate.WaveArray[ii],2);
}
/////////////////////// ADDING CODE FOR SPECTRAL FUNCTION FOLDING WITH SKYRME ////////////////////////
int index=initiate.index_from_LJ(L,J);
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 );
const prop_t &propE = prop_vec.at(index);
const mesh_t &emesh = emesh_vec.at(index);
std::vector< double > bspec = initiate.spectral_strength( L, J, rmesh, emesh_vec, prop_vec );
mesh_t energym = initiate.get_lj_emesh(L,J,emesh_vec );
eigen_t bound_info = initiate.find_boundstate( rmesh, estart, N, L, J, tol );
std::vector< double > &QPF = bound_info.second;
double QPE = bound_info.first;
double S = initiate.sfactor( rmesh, QPE, L, J, QPF );
std::vector< double > chd = initiate.charge_density(rmesh, Emax, emesh_vec, prop_vec, bound_levels);
vector <double> pdist = initiate.point_distribution(rmesh_p,Emax,emesh_vec,prop_vec,bound_levels);
matrix_t d_mtx( rmesh.size(), rmesh.size() ); // density matrix
d_mtx.clear();
//making it so that wavefunction takes skyrme wavefunction as the input and finds the skyrme spectral function
std::ifstream filein("waves/upp12.txt");
double skyrme[rmesh.size()];
std::string line;
double part=0;
double part2=0;
for(int i=0;i<rmesh.size();i++){
part += chd[i] * rdelt * pow(rmesh[i],2) * 4 * M_PI;
part2 += pdist[i] * rdelt * pow(rmesh[i],2) * 4 * M_PI;
}
cout<<"Particle Number = "<<part<<endl;
cout<<"Particle Number2 = "<<part2<<endl;
int iii;
iii=0;
while(getline(filein,line)){
skyrme[iii]=atof(line.c_str());
iii++;
}
filein.close();
int esize;
esize=emesh.size();
std::vector<double> spec;
std::vector<double> spec2;
std::vector <double> dom0,dom1,dom2,dom3,dom4,dom5,dom6;
double dwave0,dwave1,dwave2,dwave3,dwave4,dwave5,dwave6;
for(int i=0;i<rmesh.size();i++){
dwave0=rmesh[i]*waves0.second[i]/norm0;
dom0.push_back(dwave0);
dwave1=rmesh[i]*waves1.second[i]/norm1;
dom1.push_back(dwave1);
dwave2=rmesh[i]*waves2.second[i]/norm2;
dom2.push_back(dwave2);
dwave3=rmesh[i]*waves3.second[i]/norm3;
dom3.push_back(dwave3);
dwave4=rmesh[i]*waves4.second[i]/norm4;
dom4.push_back(dwave4);
dwave5=rmesh[i]*waves5.second[i]/norm5;
dom5.push_back(dwave5);
dwave6=rmesh[i]*waves6.second[i]/norm6;
dom6.push_back(dwave6);
}
//Remember that propE is actually G*r*r'*rdelt
for(unsigned int n=0;n<emesh.size();++n){
double spf=0.0;
double spf2=0.0;
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 * rmesh[i] * rmesh[j] * rdelt);
d_mtx(i,j) += Edelt * imag(propE[n](i,j)) / M_PI;
spf -= rdelt * skyrme[i] * skyrme[j] *imag( propE[n]( i, j ) ) / M_PI;
spf2 -= rdelt * dom0[i]*dom0[j] *imag( propE[n]( i, j ) ) / M_PI;
//spf -= rmesh[i] * rmesh[j] * rdelt / M_PI
// * QPF[i] * QPF[j] * imag( propE[n]( i, j ) );
}
}
spec.push_back(spf);
spec2.push_back(spf2);
}
std::ofstream fmtx("waves/dmtx.txt");
for(int i=0;i<rmesh.size();i++){
for(int j=0;j<rmesh.size();j++){
fmtx<<d_mtx(i,j)<<" ";
}
fmtx<<endl;
}
fmtx.close();
std::vector <eigen_t> eig = initiate.real_eigvecs(d_mtx);
double norme=0.0;
double norm=0.0;
double eigsum=0.0;
double maxeig=0.0;
norm0=0,norm1=0,norm2=0,norm3=0,norm4=0,norm5=0,norm6=0;
for(int i=0;i<rmesh.size();++i){
norm0 += rdelt * pow( eig[0].second[i],2);
norm1 += rdelt * pow( eig[1].second[i],2);
norm2 += rdelt * pow( eig[2].second[i],2);
norm3 += rdelt * pow( eig[3].second[i],2);
norm4 += rdelt * pow( eig[4].second[i],2);
}
double occ=0.0;
for (int i=0;i<rmesh.size();++i){
for (int j=0;j<rmesh.size();++j){
occ += rdelt*rdelt * d_mtx(i,j) * eig[N].second[i]/std::sqrt(norm) * eig[N].second[j]/std::sqrt(norm) * pow(rmesh[i],2) * pow(rmesh[j],2);
}
}
//cout<<"QP OCCUPATION NUMBER = "<<initiate.occupation(rmesh,d_mtx,QPF)<<endl;
//cout<<"occupation number = "<<occ<<endl;
ofstream fval("waves/i13 2.txt");
fval<<eig[0].first*-1<<std::endl;
fval<<eig[1].first*-1<<std::endl;
fval<<eig[2].first*-1<<endl;
fval<<eig[3].first*-1<<endl;
fval<<eig[4].first*-1<<endl;
std::ofstream feig("waves/eig.out");
//std::cout<<"Here is an eigenvector"<<std::endl;
double esum=0.0;
for(int i=0;i<rmesh.size();++i){
//want to give R(r), so print out u(r)/r
feig<<rmesh[i]<<" "<<eig[0].second[i]/sqrt(norm0)/rmesh[i];
feig<<" "<<eig[1].second[i]/sqrt(norm1)/rmesh[i];
feig<<" "<<eig[2].second[i]/sqrt(norm2)/rmesh[i];
feig<<" "<<eig[3].second[i]/sqrt(norm3)/rmesh[i];
feig<<" "<<eig[4].second[i]/sqrt(norm4)/rmesh[i]<<endl;;
// esum += rdelt*pow(rmesh[i]*eig[N].second[i]/sqrt(norme),2);
}
//std::cout<<"esum = "<<esum<<std::endl;
//This is where I will find rhobar, ask houssein how to put in clebsch gordon and spherical harmonics
double dens=0.0;
int nt=50;
int np=25;
double dt=2*M_PI/nt;
double dp=M_PI/np;
for(int i=0;i<rmesh.size();i++){
for(int j=0;j<nt;j++){
for(int k=0;k<np;k++){
dens+= rdelt*rdelt * skyrme[i]*skyrme[i] * chd[i]; //* spherical harmonics and clebsch gordon * sin(theta)
}
}
}
std::vector< double > s_of_Eqh = initiate.spectral_strength_QH( L, J, rmesh, emesh_vec, prop_vec, QPF);
std::ofstream fden("waves/chd.out");
ofstream fpoint("waves/p.out");
std::ofstream fileout("waves/spec.out");
std::ofstream files("waves/skyrme.out");
std::ofstream fileq("waves/quasi.out");
std::ofstream filef("waves/fold.out");
std::ofstream filed("waves/dom.out");
std::ofstream filer("waves/r.out");
//std::ofstream filep("waves/prop.out");
for(int i=0;i<rmesh.size();i++){
files<<skyrme[i]<<endl;
fileq<<QPF[i]<<endl;
filer<<rmesh[i]<<" "<<rmesh_p[i]<<endl;
fden<<rmesh[i]<<" "<<chd[i]<<endl;
fpoint<<rmesh[i]<<" "<<pdist[i]<<endl;
}
for(int i=0;i<bspec.size();i++){
fileout<<energym[i].first<<" "<<energym[i].second<<" "<<spec[i]<<endl;
filed<<energym[i].first<<" "<<energym[i].second<<" "<<spec2[i]<<endl;
filef<<energym[i].first<<" "<<energym[i].second<<" "<<s_of_Eqh[i]<<endl;
}
filed.close();
filer.close();
filef.close();
fileq.close();
files.close();
fileout.close();
/////////// END OF ADDED CODE ///////////////////////////////////////
////////
//normalizing wavefunctions at 4.008 to s wave to compare the asymptotic behaviour and energy
//the value of s at 4.008 is .023309//d is .132997 , s_asymp is .000271922 , d_asymp i s .000336918
/////////
for(int ii=0;ii<rmesh.size();++ii){
filee<<dom0[ii]/rmesh[ii]<<" "<<dom1[ii]<<" "<<dom2[ii]<<" "<<dom3[ii]<<" "<<dom4[ii]<<" "<<dom5[ii]<<std::endl;
}
//std::cout <<"Es =" << waves_s.first << " " << "Ed= " << waves_d.first <<std::endl;
//std::cout << zp0 << " " << tz<<" "<<norm_s<<" "<< norm_d<<" "<< normAsymp_s<<" norm bob=" << normbob<< std::endl;
//std::cout <<"Elower = "<< Elower <<" " << "Eupper = " << Eupper<<std::endl;
filee.close();
std::cout<<"Spectral Factor = "<<S<<endl;
std::cout<<"Quasi-hole Energy = "<<QPE<<endl;
return 0;
}
int Mesh2::load(const string & filename)
{
int bin;
int ver,inm,dim;
int lf=filename.size()+20;
KN<char> fileb(lf),filef(lf);
char * pfile;
strcpy(filef,filename.c_str());
strcpy(fileb,filef);
strcat(filef,".mesh");
strcat(fileb,".meshb");
if( (inm=GmfOpenMesh(pfile=fileb, GmfRead,&ver,&dim)) )
bin=true;
else if( (inm=GmfOpenMesh(pfile=filef, GmfRead,&ver,&dim)) )
bin=false;
else
{ cerr << " Erreur ouverture file " << (char *) fileb << " " << (char *) filef << endl;
return 1;
}
int nv,nt,neb;
nv = GmfStatKwd(inm,GmfVertices);
nt = GmfStatKwd(inm,GmfTriangles);
neb=GmfStatKwd(inm,GmfEdges);
this->set(nv,nt,neb);
if(verbosity)
cout << pfile <<": ver " << ver << ", d "<< dim << ", nt " << nt << ", nv " << nv << " nbe: = " << nbe << endl;
if(dim != Rd::d) {
cerr << "Err dim == " << dim << " != " << Rd::d << endl;
return 2; }
if( nv<=0 && nt <=0 ) {
cerr << " missing data "<< endl;
return 3;
}
int iv[4],lab;
float cr[3];
// read vertices
GmfGotoKwd(inm,GmfVertices);
int mxlab=0;
int mnlab=0;
for(int i=0;i<nv;++i)
{
if(ver<2) {
GmfGetLin(inm,GmfVertices,&cr[0],&cr[1],&lab);
vertices[i].x=cr[0];
vertices[i].y=cr[1];
// vertices[i].z=cr[2];
}
else
GmfGetLin(inm,GmfVertices,&vertices[i].x,&vertices[i].y,&lab);
vertices[i].lab=lab;
mxlab= max(mxlab,lab);
mnlab= min(mnlab,lab);
}
// /* read mesh triangles */
//if(mnlab==0 &&mxlab==0 )
{
mes=0;
GmfGotoKwd(inm,GmfTriangles);
for(int i=0;i<nt;++i)
{
GmfGetLin(inm,GmfTriangles,&iv[0],&iv[1],&iv[2],&lab);
for (int j=0;j<3;++j)
iv[j]--;
this->elements[i].set(this->vertices,iv,lab);
mes += this->elements[i].mesure();
}
}
/* read mesh segement */
mesb=0;
GmfGotoKwd(inm,GmfEdges);
for(int i=0;i<nbe;++i)
{
GmfGetLin(inm,GmfEdges,&iv[0],&iv[1],&lab);
assert( iv[0]>0 && iv[0]<=nv && iv[1]>0 && iv[1]<=nv);
for (int j=0;j<2;j++) iv[j]--;
this->borderelements[i].set(vertices,iv,lab);
mesb += this->borderelements[i].mesure();
}
GmfCloseMesh(inm);
if(verbosity>1) cout << " mesure : "<< mes << " border mesure : " << mesb<< endl;
return(0); // OK
}
