Dkunb

50 Reputation

3 Badges

3 years, 175 days

MaplePrimes Activity


These are replies submitted by Dkunb

@acer I am trying to reproduce the graph e.1 and e.2) in the paper.  In the equation in the code, alpha = omega*T, gamma(gg)=Delta /T and  beta=d/T. N means negativity. If N greater than 0, it is possible to harvest entanglement (red color in the left figure.) and if N is less than equal to 0, it is not possible to harvest entanglement (the gray color in the left figure.) delta is sigma/T  and Lambda is Lambda*T

@acer  On the left side figure, the red color means N>0 and grey color means N<=0

@acer The dashed line can be ignorable because I have not understood it well.The coloring is based on the scaling of the result of N function (*10^-11 lambda^2 --- see the color bar on the right in the figure.)- I think I need to generate Matrix (or array)of N to know the scale. And gamma (looks like r in my figure) is your gg. I want to know how to write the code to represent the graph like that. 

I am sorry that my English is not good to explain clearly. And I am very new to Maple.

PS) Could you also explain why you set up return value 10^10 in MyHandler? I try to understand your code so I can learn to write code in Maple. It is easier for me to learn from the example codes.

Thank you very much for your help!

@acer Thank you so much! How can I write the codes for the following plots based on N function?

@acer  I do not see any evalf(L) in your codes and If I generated Matrix of N it showed the integral form of L.

@acer Thank you again.

I run my codes and yours (I used my original L because F would be varied .)


 

restart;

with(plots):

 

F:=kappa->kappa;

proc (kappa) options operator, arrow; kappa end proc

(1)

f:=(alpha,delta)->exp(-abs(F(kappa))^2*(1+delta^2)/2-abs(F(kappa))*alpha)/abs(F(kappa));

proc (alpha, delta) options operator, arrow; exp(-(1/2)*abs(F(kappa))^2*(1+delta^2)-abs(F(kappa))*alpha)/abs(F(kappa)) end proc

(2)

L:=(alpha,delta,Lambda)->(lambda^2*exp(-alpha^2/2)/4)*(Int(f(alpha,delta),kappa= -infinity..-Lambda)+Int(f(alpha,delta),kappa= Lambda..infinity));

proc (alpha, delta, Lambda) options operator, arrow; (1/4)*lambda^2*exp(-(1/2)*alpha^2)*(Int(f(alpha, delta), kappa = -infinity .. -Lambda)+Int(f(alpha, delta), kappa = Lambda .. infinity)) end proc

(3)

CodeTools:-Usage(evalf(L(4,1,0.001)));

memory used=1.63MiB, alloc change=0 bytes, cpu time=31.00ms, real time=19.00ms, gc time=0ns

 

0.8209373770e-3*lambda^2

(4)

g:=(beta,delta)->exp(-I*kappa*beta-abs(F(kappa))^2*(1+delta^2)/2)/abs(F(kappa));

proc (beta, delta) options operator, arrow; exp(-I*kappa*beta-(1/2)*abs(F(kappa))^2*(1+delta^2))/abs(F(kappa)) end proc

(5)

E:=(omega,gamma)->exp(I*omega*gamma)*(1-erf((gamma+I*omega)/sqrt(2)));

proc (omega, gamma) options operator, arrow; exp(I*omega*gamma)*(1-erf((gamma+I*omega)/sqrt(2))) end proc

(6)

J:=(alpha,delta,Lambda,beta,gamma)->(lambda^2*exp(-alpha^2/2)/8)*abs(Int(g(beta,delta)*(E(abs(F(kappa)),gamma)+E(abs(F(kappa)),-gamma)),kappa=-infinity..-Lambda)+Int(g(beta,delta)*(E(abs(F(kappa)),gamma)+E(abs(F(kappa)),-gamma)),kappa=Lambda..infinity));

proc (alpha, delta, Lambda, beta, gamma) options operator, arrow; (1/8)*lambda^2*exp(-(1/2)*alpha^2)*abs(Int(g(beta, delta)*(E(abs(F(kappa)), gamma)+E(abs(F(kappa)), -gamma)), kappa = -infinity .. -Lambda)+Int(g(beta, delta)*(E(abs(F(kappa)), gamma)+E(abs(F(kappa)), -gamma)), kappa = Lambda .. infinity)) end proc

(7)

CodeTools:-Usage(evalf(J(4,1,0.001,8,3)));

memory used=0.62GiB, alloc change=141.00MiB, cpu time=4.70s, real time=4.72s, gc time=812.50ms

 

0.7304273935e-3*lambda^2

(8)

N := (beta,alpha)-> (J(alpha,1,0.001,beta,3)-L(alpha,1,0.001))/\lambda^2;

proc (beta, alpha) options operator, arrow; (J(alpha, 1, 0.1e-2, beta, 3)-L(alpha, 1, 0.1e-2))/lambda^2 end proc

(9)

 

 

 

 

 

 

CodeTools:-Usage(contourplot(evalf(N(beta,alpha)), beta=0..10,alpha=0..10,grid=[25,25]));

memory used=138.77GiB, alloc change=1.21GiB, cpu time=16.96m, real time=15.89m, gc time=115.06s

 

 

 

 

 


 

Download Negativity_v2.mw
 

restart;

with(plots):

F:=kappa->kappa;

proc (kappa) options operator, arrow; kappa end proc

(1)

f:=(alpha,delta)->exp(-abs(F(kappa))^2*(1+delta^2)/2-abs(F(kappa))*alpha)/abs(F(kappa));

proc (alpha, delta) options operator, arrow; exp(-(1/2)*abs(F(kappa))^2*(1+delta^2)-abs(F(kappa))*alpha)/abs(F(kappa)) end proc

(2)

L:=(alpha,delta,Lambda) ->
  (lambda^2*exp(-alpha^2/2)/4)*(Int(f(alpha,delta),kappa= -infinity..-Lambda)+Int(f(alpha,delta),kappa= Lambda..infinity));

proc (alpha, delta, Lambda) options operator, arrow; (1/4)*lambda^2*exp(-(1/2)*alpha^2)*(Int(f(alpha, delta), kappa = -infinity .. -Lambda)+Int(f(alpha, delta), kappa = Lambda .. infinity)) end proc

(3)

#0.0008209373770*lambda^2
forget(evalf);
CodeTools:-Usage( evalf(L(4,1,0.001)) );

memory used=1.63MiB, alloc change=0 bytes, cpu time=15.00ms, real time=19.00ms, gc time=0ns

 

0.8209373770e-3*lambda^2

(4)

g:=(beta,delta)->exp(-I*kappa*beta-abs(F(kappa))^2*(1+delta^2)/2)/abs(F(kappa));

proc (beta, delta) options operator, arrow; exp(-I*kappa*beta-(1/2)*abs(F(kappa))^2*(1+delta^2))/abs(F(kappa)) end proc

(5)

E:=(omega,gg)->exp(I*omega*gg)*(1-erf((gg+I*omega)/sqrt(2)));

proc (omega, gg) options operator, arrow; exp(I*omega*gg)*(1-erf((gg+I*omega)/sqrt(2))) end proc

(6)

MyHandler := proc(operator,operands,default_value)
               NumericStatus( overflow = false );
               return 10^10;
             end proc:
ig1template := proc(kappa)
              NumericEventHandler(overflow = MyHandler);
              evalhf(__dummy); end proc:

igdum:='Re'(simplify(exp(-alpha^2/2)/8*(g(beta,delta)*(E(abs(F(kappa)),gg)+E(abs(F(kappa)),-gg))))):
J := subs(__igdum=igdum, proc(alpha,delta,Lambda,beta,gg) local ig;
  ig := subs(__dummy= __igdum, eval(ig1template));
  evalf(lambda^2*abs(Int(ig,-infinity..-Lambda,epsilon=1e-4,method=_d01amc)
                     +Int(ig,Lambda..infinity,epsilon=1e-4,method=_d01amc)));
end proc):

forget(evalf);
CodeTools:-Usage( J(4,1,0.001,8,3) );

memory used=60.12MiB, alloc change=0 bytes, cpu time=344.00ms, real time=343.00ms, gc time=0ns

 

0.7304272433e-3*lambda^2

(7)

N := (beta,alpha) -> (J(alpha,1,0.001,beta,3)-L(alpha,1,0.001))/lambda^2;

proc (beta, alpha) options operator, arrow; (J(alpha, 1, 0.1e-2, beta, 3)-L(alpha, 1, 0.1e-2))/lambda^2 end proc

(8)

forget(evalf);
CodeTools:-Usage(contourplot(N, 0..10, 0..10, grid=[25,25]));

memory used=20.15GiB, alloc change=108.00MiB, cpu time=2.13m, real time=2.13m, gc time=18.75s

 

 

 


 

Download Negativity_v1(2)_acc.mw

 

 

 

 

@acer Thank you so much!!

MyHandler := proc(operator,operands,default_value)
               NumericStatus( overflow = false );
               return 10^10;
             end proc:
ig1template := proc(kappa)
              NumericEventHandler(overflow = MyHandler);
              evalhf(__dummy); end proc:

Myhandler returns 10^10 and then NumericEventHandler(overflow=10^10)? I do not understand what the code is doing (especially number 10^10...).

Also how to do  parallelizing computation over a 2D Array (over beta and alpha values), and then using listcontplot?

Thank you so much again for your help.

@vv Thank you!

@Kitonum yes, I did restart. I am using Maple 2021. It might be related to some setting in Maple 2021??

@Kitonum 

I got the same issue when running your codes, too.  

@Kitonum Thank you so much! 

1 2 3 Page 3 of 3