bool scigraphics::painter::canSepareteXcoordsF( fcoord X1, fcoord X2 ) const
{
double ApproxStepX = 1.0 / (double)PlotRectangle.width();
if ( std::fabs(X1-X2) < ApproxStepX/3.0 )
return true;
return canSeparatePointsF( fpoint(X1,0), fpoint(X2,0) );
}
void scigraphics::axisTicksY::drawOneTick( painter &Painter, const scale &Scale, number Value )
{
double FLength = std::fabs( Painter.wcoord2fcoordX( getTickLength() ) - Painter.wcoord2fcoordX( 0 ) );
fcoord Y = Scale.numberToFraction( Value );
fcoord X0 = BaseX;
fcoord X1 = X0 + ( BaseX < 0.5 ? +1 : -1 ) * FLength;
Painter.drawLineF( fpoint(X0,Y), fpoint(X1,Y), getTickStyle() );
}
scigraphics::fpoint scigraphics::painter::wpoint2fpoint( wpoint Pt ) const
{
if ( PlotRectangle.width() <= 0 || PlotRectangle.height() <= 0 )
return fpoint(0,0);
fcoord X = wcoord2fcoordX( Pt.x() );
fcoord Y = wcoord2fcoordY( Pt.y() );
return fpoint( X, Y );
}
void scigraphics::axisTicksX::drawOneTick( painter &Painter, const scale &Scale, number Value )
{
double FLength = std::fabs( Painter.wcoord2fcoordY( getTickLength() ) - Painter.wcoord2fcoordY( 0 ) );
fcoord X = Scale.numberToFraction( Value );
fcoord Y0 = BaseY;
fcoord Y1 = Y0 + ( BaseY < 0.5 ? +1 : -1 ) * FLength;
Painter.drawLineF( fpoint(X,Y0), fpoint(X,Y1), getTickStyle() );
}
void scigraphics::axisLabelsX::drawOneLabel( painter &Painter, const scale &Scale, number Value ) const
{
fcoord X = Scale.numberToFraction( Value );
std::string Text = getNumberStyle().numberText( Value );
unsigned Flags = ( BaseY < 0.5 ) ? painter::HCenter|painter::VUp : painter::HCenter|painter::VDown;
int Shift = ( BaseY < 0.5 ? +1 : -1 ) * (-3);
// std::cout << "axisTicksX: draw " << Text << " crd " << Coord << " clr " << getTextStyle().getColor().name() << std::endl;
Painter.drawTextF( Text, fpoint(X,BaseY), Flags, getTextStyle(), 0, Shift );
}
void scigraphics::axisLabelsY::drawOneLabel( painter &Painter, const scale &Scale, number Value ) const
{
fcoord Y = Scale.numberToFraction( Value );
std::string Text = getNumberStyle().numberText( Value );
unsigned Flags = ( BaseX < 0.5 ) ? painter::HRight|painter::VCenter : painter::HLeft|painter::VCenter;
int Shift = ( BaseX < 0.5 ? +1 : -1 ) * 6;
Painter.drawTextF( Text, fpoint(BaseX,Y), Flags, getTextStyle(), Shift, 0 );
// std::cout << "axisLabelsY::drawOneLabel: " << Text << " - " << BaseX << " " << Y << " " << Shift << std::endl;
}
int do_change_status(char *svc, char *status, pid_t * pid, int sock2,
int action)
{
int tmp;
ssize_t(*fpoint) (int, void *, size_t);
if(action == ACT_SERV) {
fpoint = read;
} else {
fpoint = (ssize_t(*)(int, void *, size_t)) write;
tmp = strlen(svc);
}
if(fpoint(sock2, &tmp, sizeof(tmp)) == -1) { /* length */
perror(MSG_ERR_IO);
return 0;
}
if(tmp > PATH_MAX) {
return 0;
}
if(fpoint(sock2, svc, tmp) == -1) { /* write service name */
perror(MSG_ERR_IO);
return 0;
}
if(fpoint(sock2, status, sizeof(*status)) == -1) { /* status */
perror(MSG_ERR_IO);
return 0;
}
if(fpoint(sock2, pid, sizeof(*pid)) == -1) { /* PID */
perror(MSG_ERR_IO);
return 0;
}
return tmp;
}
int Synthesizer::update_params()
{
fpoint sec = fpoint(sample_idx) / Fs;
progress_sec = sec - last_phoneme_sec;
if(phoneme_idx == 0 || progress_sec > duration)
{
if((unsigned)++phoneme_idx >= phonemes.size() - 1)
{
return sample_idx;
}
last_phoneme_sec = sec;
last_phoneme_sample_idx = sample_idx;
progress_sec = 0;
phoneme_transition();
if(samples.empty()) samples.push_back(0);
}
return -1;
}
// #include"reaction.h"
int main()
{
////////Input Parameters of the potential (fit parameters) /////
//This finds the natural orbits, and also the actual density
std::string parameters_filename="Input.inp";
NuclearParameters Nu = read_nucleus_parameters( "Input/pca40.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;
double rStart = .05;
double rmax = 12.;
double ham_pts = 720;
double rdelt = rmax / ham_pts;
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
//creating boundspace object
boundRspace initiate(rmax , ham_pts , Ef, ph_gap , lmax , Nu.Z , zp0 , Nu.A , pott);
double tol=.01;
double estart=Ef;
double Emax=2*-4.7;
double Emin=-200.0+Emax;
// Create momentum space grid
std::vector<double> kmesh;
std::vector<double> kweights;
double const kmax = 5.0;
int const kpts = ham_pts;
kmesh.resize( kpts );
kweights.resize( kpts );
GausLeg( 0., kmax, kmesh, kweights );
///// Making rmesh///
vector<double> rmesh= initiate.make_rmesh();
vector <double> rmesh_p = initiate.make_rmesh_point();
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 );
vector <double> pdist = initiate.point_distribution(rmesh,Emax,emesh_vec,prop_vec,bound_levels);
vector <double> kdist = initiate.point_dist_k(rmesh,Emax,emesh_vec,prop_vec,bound_levels);
double part=0;
double kpart=0;
double nat=0.0;
double occ=0.0;
double J;
double p_part=0;
double k_part=0;
vector <double> natden;
natden.assign(rmesh.size(),0);
vector<double> p_dist;
p_dist.assign( rmesh.size(), 0 );
vector<double> k_dist;
k_dist.assign( kmesh.size(), 0 );
for(int L=0;L<lmax+1;L++){
for(int s=0;s<2;s++){
J=L-0.5+s;
if(J<0){
s=1;
J=0.5;
}
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";
}
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";
}
// Create Bessel Function matrix in k and r
matrix_t bess_mtx( kmesh.size(), rmesh.size() );
bess_mtx.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 );
}
}
cout<<"eigenvalues now"<<endl;
cout<<"L = "<<L<<", J = "<<J<<endl;
int index=initiate.index_from_LJ(L,J);
const prop_t &propE = prop_vec.at(index);
const mesh_t &emesh = emesh_vec.at(index);
matrix_t d_mtx( rmesh.size(), rmesh.size() ); // density matrix
d_mtx.clear();
const lj_eigen_t &levels = bound_levels.at( index );
cout<<"levels.size() = "<<levels.size()<<endl;
//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;
}
}
}
for ( unsigned int N = 0; N < levels.size(); ++N ){
if ( ( levels[N].first <= Ef ) &&
( levels[N].first > Emax ) ) {
// Quasiparticle energy
double QPE = levels[N].first;
// Quasiparticle wavefunction
const std::vector<double> &QPF = levels[N].second;
// Spectroscopic Factor
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;
}
}
cout << "added to charge density "<<N<<" "<< L << " " << J << " " << QPE << " "<< S << std::endl;
} // endif
} // End loop over N
vector <eigen_t> eig = initiate.real_eigvecs(d_mtx);
string dest = "waves/";
string eiglab = dest + "eig" + llab+jlab+".txt";
ofstream fval(eiglab.c_str());
double Nmax=10;
for(int N=0;N<Nmax;N++){
double spot = rmesh.size()-N-1;
double norm=0;
for(int i=0;i<rmesh.size();++i){
norm += rdelt * pow( eig[spot].second[i],2);
}
if(eig[spot].second[0]<0){
for(int i=0;i<rmesh.size();i++){
eig[spot].second[i] *= -1.0;
}
}
//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(norm) / rmesh[ir]
* pow(rmesh_p[ir],2);
}
knat[ik] = kn;
}
double normk = 0;
for(int i=0;i<kmesh.size();i++){
normk += kweights[i] * pow(knat[i]*kmesh[i],2);
}
//for(int i=0;i<kmesh.size();i++){
//knat[i] = knat[i]/sqrt(normk);
//}
occ += eig[spot].first*(2*J+1);
for(int i=0;i<rmesh.size();i++){
natden[i] += eig[spot].first*pow(eig[spot].second[i]/rmesh[i]/sqrt(norm),2)*(2*J+1)/(4*M_PI);
k_dist[i] += eig[spot].first * pow(knat[i],2) * (2*J+1) / (4*M_PI);
}
string Nlab;
ostringstream convert;
convert << N;
Nlab = convert.str();
string veclab = dest + "eig" + llab + jlab + Nlab + ".txt";
std::ofstream feig(veclab.c_str());
fval<<eig[spot].first<<endl;
//cout<<eig[spot].first<<endl;
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(norm)/rmesh[i]<<endl;
//feig<<kmesh[i]<<" "<<knat[i]<<endl;
}
} //ending loop over N
} //ending loop over s
} //ending loop over L
ofstream fdenr("waves/natden.txt");
ofstream fdenk("waves/natdenk.txt");
ofstream kden("waves/denk.txt");
ofstream fpoint("waves/pdist.txt");
ofstream kpoint("waves/kdist.txt");
for(int i=0;i<rmesh.size();i++){
nat += natden[i] * rdelt_p * pow(rmesh_p[i],2) * 4*M_PI;
part += pdist[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;
fpoint<<rmesh_p[i]<<" "<<pdist[i]<<endl;
}
for(int i=0;i<kmesh.size();i++){
kpart += kdist[i] * kweights[i] * pow(kmesh[i],2) * 4 * M_PI;
k_part += k_dist[i] * kweights[i] * pow(kmesh[i],2) * 4 * M_PI;
}
for(int i=0;i<kmesh.size();i++){
fdenk<<kmesh[i]<<" "<<k_dist[i]/k_part<<endl;
kpoint<<kmesh[i]<<" "<<kdist[i]<<endl;
}
cout<<"Particle Number from dist (r) = "<<part<<endl;
cout<<"Particle Number from dist (k) = "<<kpart<<endl;
cout<<"particle number from natural (r) = "<<nat<<endl;
cout<<"particle number from natural (k) = "<<k_part<<endl;
}
void scigraphics::axisY::draw( painter &Painter )
{
Painter.drawLineF( fpoint(BaseX,0), fpoint(BaseX,1), getLineStyle() );
}
void scigraphics::axisX::draw( painter &Painter )
{
Painter.drawLineF( fpoint(0,BaseY), fpoint(1,BaseY), getLineStyle() );
}
// #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;
}
std::vector<float> Synthesizer::generate_frame()
{
// shift the signal left to get space for the new signal
sig = sig.shift(R);
for(int i = 0; i < R; i++)
{
sample_idx++;
if(update_params() >= 0 || finished)
{
finished = true;
break;
}
fpoint in = samples[sample_idx - last_phoneme_sample_idx];
// append the signal at the end
sig[L - R + i] = in;
}
// apply analysis window
std::valarray<complex> seg = sig * window, tmp(L);
fft(seg);
auto env = spectral_envelope(seg);
//for(auto a : env) std::cout << std::fixed << a << ",";
//std::cout << "\n\n";
const fpoint expect = 2 * M_PI / Ov;
// frequency between two bins
const fpoint bin_freq = fpoint(Fs) / L;
std::valarray<fpoint> tmp_mag(L / 2 + 1);
std::valarray<fpoint> tmp_frq(L / 2 + 1);
for(unsigned i = 0; i <= L / 2; i++)
{
// compute magnitude and phase
fpoint magn = abs(seg[i]) * 2;
fpoint phas = arg(seg[i]);
// compute phase difference
fpoint pdiff = phas - last_phase[i];
last_phase[i] = phas;
// subtract expected phase difference
pdiff -= i * expect;
// map delta phase into +/- Pi interval
pdiff -= 2 * M_PI * floor(pdiff / (2 * M_PI) + 0.5);
// get deviation from bin frequency from the +/- Pi interval
fpoint fdev = Ov * pdiff / (2 * M_PI);
// compute the k-th partials' true frequency
fpoint true_freq = i * bin_freq + fdev * bin_freq;
// store magnitude and true frequency in analysis arrays
tmp_mag[i] = magn;
tmp_frq[i] = true_freq;
}
// copy buffers
std::valarray<fpoint> seg_mag(L / 2 + 1);
std::valarray<fpoint> seg_frq(L / 2 + 1);
// pitch shifting
fpoint pitch_shift = 1.5;
for (unsigned i = 0; i <= L / 2; i++)
{
unsigned index = i * pitch_shift;
if (index <= L / 2)
{
seg_mag[index] += tmp_mag[i];// / env[i];
seg_frq[index] = tmp_frq[i] * pitch_shift;
}
}
// synthesis
for (unsigned i = 0; i <= L / 2; i++)
{
// get magnitude and true frequency from synthesis arrays
fpoint mag = seg_mag[i];
fpoint frq = seg_frq[i];
// subtract bin mid frequency
frq -= i * bin_freq;
// get bin deviation from freq deviation
frq /= bin_freq;
// take osamp into account
frq = 2 * M_PI * frq / Ov;
// add the overlap phase advance back in
frq += i * expect;
// accumulate delta phase to get bin phase
sum_phase[i] += frq;
fpoint phase = sum_phase[i];
// get real and imag part
seg[i] = std::polar(mag, phase);
seg[L - i - 1] = 0;
}
ifft(seg);
ova = ova.shift(R) + seg * window;
std::vector<float> out(R, 0);
for(unsigned i = 0; i < R; i++)
{
out[i] = (float)clamp(-1, 1, ova[i].real());
}
return out;
}
