def merit( g0 ) : try: pot = scubic.sc(allIR = s0, \ allGR = g0, \ allIRw = wL, \ allGRw = wC ) # The lda within the optimization loop is told to ignore errors # of the density distribution going beyond the extents. # This will be checked after the optmization is done. lda0 = lda.lda(potential = pot, Temperature = T_Er,\ a_s=a_s, globalMu='halfMott', extents=extents,\ ignoreExtents=True, select='htse' ) etaFstar = penalty( lda0.etaF_star , 5 ) if 'Number' in kwargs.keys(): return etaFstar * Npenalty( lda0.Number) else: return etaFstar except Exception as e : negslope = 'Bottom of the band has a negative slope' posslope = 'Radial density profile along 111 has a positive slope' threshol = 'Chemical potential exceeds the evaporation threshold' thresh100= 'Chemical potential exceeds the bottom of the band along 100' if negslope in e.message: return 1e4 # this is caused by too much green # return large value to asign penalty elif posslope in e.message: return 1e4 # this is caused by too much green # as the chemical potential comes to close # to the threshold and atoms accumulate on # the beams # return large value to asign penalty elif threshol in e.message: return 1e4 # this is caused by too much green # the chemical potential is above the evap th. # return large value to asign penalty elif thresh100 in e.message: return 1e4 # this is caused by too much green # the chemical potential is above the bottom of # the band along 100 # return large value to asign penalty elif 'vanish' in e.message : # this is is caused by insufficient extents print "extents = %.1f"% extents raise else: raise
def merit(g0): try: pot = scubic.sc(allIR = s0, \ allGR = g0, \ allIRw = wL, \ allGRw = wC ) # The lda within the optimization loop is told to ignore errors # of the density distribution going beyond the extents. # This will be checked after the optmization is done. lda0 = lda.lda(potential = pot, Temperature = T_Er,\ a_s=a_s, globalMu='halfMott', extents=extents,\ ignoreExtents=True, select='htse' ) etaFstar = penalty(lda0.etaF_star, 5) if 'Number' in kwargs.keys(): return etaFstar * Npenalty(lda0.Number) else: return etaFstar except Exception as e: negslope = 'Bottom of the band has a negative slope' posslope = 'Radial density profile along 111 has a positive slope' threshol = 'Chemical potential exceeds the evaporation threshold' thresh100 = 'Chemical potential exceeds the bottom of the band along 100' if negslope in e.message: return 1e4 # this is caused by too much green # return large value to asign penalty elif posslope in e.message: return 1e4 # this is caused by too much green # as the chemical potential comes to close # to the threshold and atoms accumulate on # the beams # return large value to asign penalty elif threshol in e.message: return 1e4 # this is caused by too much green # the chemical potential is above the evap th. # return large value to asign penalty elif thresh100 in e.message: return 1e4 # this is caused by too much green # the chemical potential is above the bottom of # the band along 100 # return large value to asign penalty elif 'vanish' in e.message: # this is is caused by insufficient extents print "extents = %.1f" % extents raise else: raise
def get_trap_results( **kwargs ): """ If the parameters for the trap are known, the trap results can be obtained directly with this function """ s0 = kwargs.get('s0', 7. ) wL = kwargs.get('wL', 47. ) wC = kwargs.get('wC', 40. ) alpha = wL/wC a_s = kwargs.get('a_s', 650. ) T_Er= kwargs.get('T_Er', 0.2 ) extents = kwargs.get('extents', 40.) gOptimal = kwargs.get('g0',4.304) potOpt = scubic.sc( allIR=s0, allGR=gOptimal, allIRw=wL, allGRw=wC ) ldaOpt = lda.lda( potential = potOpt, Temperature=T_Er, \ a_s=a_s, globalMu='halfMott', extents=extents) return [ gOptimal, ldaOpt.EtaEvap, ldaOpt.Number, \ ldaOpt.Entropy/ldaOpt.Number, ldaOpt.getRadius(), ldaOpt.getRadius()/wL, ldaOpt.DeltaEvap ]
def get_trap_results(**kwargs): """ If the parameters for the trap are known, the trap results can be obtained directly with this function """ s0 = kwargs.get('s0', 7.) wL = kwargs.get('wL', 47.) wC = kwargs.get('wC', 40.) alpha = wL / wC a_s = kwargs.get('a_s', 650.) T_Er = kwargs.get('T_Er', 0.2) extents = kwargs.get('extents', 40.) gOptimal = kwargs.get('g0', 4.304) potOpt = scubic.sc(allIR=s0, allGR=gOptimal, allIRw=wL, allGRw=wC) ldaOpt = lda.lda( potential = potOpt, Temperature=T_Er, \ a_s=a_s, globalMu='halfMott', extents=extents) return [ gOptimal, ldaOpt.EtaEvap, ldaOpt.Number, \ ldaOpt.Entropy/ldaOpt.Number, ldaOpt.getRadius(), ldaOpt.getRadius()/wL, ldaOpt.DeltaEvap ]
def single_spi(**kwargs): savedir = kwargs.pop('savedir', None) numlist = kwargs.pop('numlist', [1.2e5, 1.3e5, 1.4e5, 1.5e5, 1.6e5]) mulist = kwargs.pop('mulist', [-0.15, -0.075, 0., 0.10, 0.18]) bestForce = kwargs.pop('bestForce', -1) s = kwargs.pop('params_s', 7.) g = kwargs.pop('params_g', 3.666) wIR = kwargs.pop('params_wIR', 47.) wGR = kwargs.pop('params_wGR', 47./1.175) direc = '111' mu0 = 'halfMott' aS = kwargs.pop('params_aS', 300.) Tdens = kwargs.pop('params_Tdens', 0.6) Tspi = kwargs.pop('params_Tspi', 0.6) extents = kwargs.pop('extents', 30.) spiextents = kwargs.pop('spiextents', 25.) sthextents = kwargs.pop('sthextents', 30.) entextents = kwargs.pop('entextents', 25.) finegrid = kwargs.pop('finegrid', False) sarr = np.array([[s], [s], [s]]) bands = scubic.bands3dvec(sarr, NBand=0) t0 = np.mean((bands[1] - bands[0])/12.) # tunneling 0 in recoils Tdens_Er = Tdens*t0 Tspi_Er = Tspi*t0 print "========================================" print " Single Spi" print " gr={:0.3f}, aS={:03d}".format(g, int(aS)) print " Tdens={:0.2f}, Tspi={:0.2f}".format(Tdens, Tspi) select = 'qmc' spis = [] for tag, muPlus in enumerate(mulist): numgoal = numlist[tag] print print "num = %.3g, muPlus = %.3f" % (numgoal, muPlus) pot = scubic.sc(allIR=s, allGR=g, allIRw=wIR, allGRw=wGR) lda0 = lda.lda(potential=pot, Temperature=Tdens_Er, a_s=aS, extents=extents, Natoms=numgoal, halfMottPlus=muPlus,\ # globalMu=mu0, halfMottPlus=muPlus,\ verbose=True, \ select=select,\ ignoreExtents=False, ignoreSlopeErrors=True, \ ignoreMuThreshold=True) spibulk, spi, sthbulk, sth, r111, n111, U111, t111, mut111, \ entrbulk, entr111,\ lda_num, density111, k111, k111htse_list = \ lda0.getBulkSpi(Tspi=Tspi, inhomog=True, spiextents=spiextents, sthextents=sthextents, entextents=entextents, do_k111=False) if finegrid: r111_fine, spi111_fine, n111_fine, k111_fine, mu111_Er = \ lda0.getSpiFineGrid(Tspi=Tspi, numpoints=320, inhomog=True, spiextents=spiextents, entextents=entextents) else: r111_fine, spi111_fine, n111_fine, k111_fine, mu111_Er = \ None, None, None, None, None spis.append({ 'gr': g, 'muPlus': muPlus, 'SpiBulk': spibulk, 'spi111': spi, 'SthBulk': sthbulk, 'sth111': sth, 'r111': r111, 'n111': n111, 'U111': U111, 'mut111': mut111, 't111': t111, 'entrbulk': entrbulk, 'entr111': entr111, 'k111': k111, 'k111htse_list': k111htse_list, 'Number': lda0.Number, 'ldanum': lda_num,\ # dens111 is the one obtained from QMC 'dens111': density111,\ 'Tdens': Tdens,\ 'Tspi': Tspi,\ 'aS': aS,\ 'savedir': savedir,\ 'r111_fine': r111_fine,\ 'spi111_fine': spi111_fine,\ 'n111_fine': n111_fine,\ 'k111_fine': k111_fine,\ 'mu111_Er': mu111_Er,\ 'v0111': lda0.pot.S0(lda0.X111, lda0.Y111, lda0.Z111)[0] }) # Figure to check inhomogeneity only run if temperature is high if Tspi > 0.85 and Tdens > 0.85: fig111, binresult, peak_dens, radius1e, peak_t, output = \ lda.CheckInhomog(lda0, closefig=True, n_ylim=(-0.1, 2.0)) figfname = savedir + 'Inhomog/{:0.3f}gr_{:03d}_{}_T{:0.4f}Er.png'.\ format(g, tag, select, Tspi) figfname = kwargs.pop('params_figfname', figfname) fig111.savefig(figfname, dpi=300) print print "Atom number = {:5.3g}".format(spis[0]['Number']) print "Entropy = {:0.2f}".format(spis[0]['entrbulk']) plot_spis( spis, bestForce=bestForce, \ # kwargs **kwargs) return spis[bestForce]
def dmu_dr( rpoints, **kwargs ): s = kwargs.pop('params_s', 7.) g = kwargs.pop('params_g', 3.666) wIR = kwargs.pop('params_wIR', 47.) wGR = kwargs.pop('params_wGR', 47./1.175) extents = kwargs.pop('params_extents', 31.) direc = '111' mu0 = 'halfMott' muBrent = kwargs.pop('params_muBrent',(-0.2,0.3)) muBrentShift = kwargs.pop('params_muBrentShift', 0.) aS = kwargs.pop('params_aS', 300.) muPlus = kwargs.pop('params_muPlus', 0.00 ) Natoms = kwargs.pop('params_Natoms', None) select = 'nlce' #print #print "muPlus = ", muPlus pot = scubic.sc(allIR=s, allGR=g, allIRw=wIR, allGRw=wGR) Tlist = kwargs.pop('Tlist', [0.036]) outdict = {} for TT, Tval in enumerate(Tlist): print TT, sys.stdout.flush() logger.warning('working on Tval = {:0.4f}'.format(Tval) ) if Natoms is None: lda0 = lda.lda(potential = pot, Temperature=Tval, a_s=aS, \ override_npoints = 240,\ extents=extents, \ globalMu=mu0, halfMottPlus=muPlus,\ verbose=False, \ select = select,\ ignoreExtents=False, ignoreSlopeErrors=True, \ ignoreMuThreshold=True) else: lda0 = lda.lda(potential = pot, Temperature=Tval, a_s=aS, \ override_npoints = 240,\ extents=extents, \ Natoms = Natoms,\ muBrent=muBrent, muBrentShift=muBrentShift,\ verbose=False, \ select = select,\ ignoreExtents=False, ignoreSlopeErrors=True, \ ignoreMuThreshold=True) r111, n111 = lda0.getDensity( lda0.globalMu, lda0.T) localMu_t = lda0.get_localMu_t( lda0.globalMu ) localMu_t_f = extrap1d( interp1d( r111, localMu_t ) ) dmu_dr = deriv( rpoints, localMu_t_f ) dmu_dr111 = deriv( r111, localMu_t_f ) t0 = lda0.tunneling_111.min() # Need to also get the value of T/t0 and the overall S/N _spibulk, _spi, _r111, _n111, _U111, _t111, _entrbulk, _entr111,\ _lda_num, _density111, _k111, _k111htse_list = \ lda0.getBulkSpi(Tspi=Tval/t0, inhomog=True, \ spiextents=extents, entextents=extents, do_k111=False) Tdict = { 'r111':r111 ,\ 'n111':n111 ,\ 'Ut111':lda0.onsite_111 / lda0.tunneling_111 ,\ 'localMu_t':localMu_t ,\ 'dmu_dr': dmu_dr ,\ 'dmu_dr111': dmu_dr111 ,\ 'num':lda0.Number,\ 'T/t0': Tval/t0 ,\ 'S/N':_entrbulk ,\ } outdict[ Tval ] = Tdict return outdict
def Spi_vs_N( aS=200., Spi_inhomog=False, Tspi=0.9, \ savedir='dataplots/VaryN_Spi', \ mulist =[-0.15, -0.075, 0., 0.10, 0.18], bestForce = -1 , spiextents = 25., entextents = 25., finegrid = False, ): s = 7. g = 3.666 wIR = 47. wGR = 47./1.175 T = 0.035 extents = 30. direc = '111' mu0 = 'halfMott' spis = [] select = 'nlce' for tag, muPlus in enumerate(mulist): print print "muPlus = ", muPlus pot = scubic.sc(allIR=s, allGR=g, allIRw=wIR, allGRw=wGR) lda0 = lda.lda(potential = pot, Temperature=T, a_s=aS, \ extents=extents, \ globalMu=mu0, halfMottPlus=muPlus,\ verbose=True, \ select = select,\ ignoreExtents=False, ignoreSlopeErrors=True, \ ignoreMuThreshold=True) spibulk, spi, r111, n111, U111, t111, entrbulk, entr111,\ lda_num, density111 = \ lda0.getBulkSpi(Tspi=Tspi, inhomog=Spi_inhomog, \ spiextents=spiextents, entextents=entextents) if finegrid: r111_fine, spi111_fine, n111_fine = lda0.getSpiFineGrid( Tspi=Tspi, numpoints=320,\ inhomog=Spi_inhomog, spiextents=spiextents, entextents=entextents ) else: r111_fine, spi111_fine, n111_fine = None, None, None spis.append( {'SpiBulk':spibulk,\ 'spi111':spi,\ 'r111':r111,\ 'n111':n111,\ 'U111':U111,\ 't111':t111,\ 'entrbulk':entrbulk,\ 'entr111':entr111,\ 'Number':lda0.Number,\ 'ldanum':lda_num,\ 'dens111':density111,\ 'Tn':T,\ 'Tspi':Tspi,\ 'aS':aS,\ 'savedir':savedir,\ 'r111_fine':r111_fine,\ 'spi111_fine':spi111_fine,\ 'n111_fine':n111_fine,\ } ) # Figure to check inhomogeneity fig111, binresult, peak_dens, radius1e, peak_t, output = \ lda.CheckInhomog( lda0, closefig = True, n_ylim=(-0.1,2.0) ) ; figfname = savedir + 'Inhomog/{:0.3f}gr_{:03d}_{}_T{:0.4f}Er.png'.\ format(g,tag,select,T) fig111.savefig(figfname, dpi=300) plot_spis( spis, inhomog=Spi_inhomog, bestForce=bestForce) return spis[bestForce]
def optimal_FixedRadius( **kwargs ) : """ This function takes fixed values of s0, wL, wC and finds the value of green that would be required to make a sample with a radius that is a fixed fraction of the lattice beam waist. The value of the fraction is hardcoded in the function """ fraction = 0.32 s0 = kwargs.get('s0', 7. ) wL = kwargs.get('wL', 47. ) wC = kwargs.get('wC', 40. ) alpha = wL/wC a_s = kwargs.get('a_s', 650. ) T_Er= kwargs.get('T_Er', 0.2 ) extents = kwargs.get('extents', 40.) def merit( g0 ) : try: pot = scubic.sc(allIR = s0, \ allGR = g0, \ allIRw = wL, \ allGRw = wC ) # The lda within the optimization loop is told to ignore errors # of the density distribution going beyond the extents. # This will be checked after the optmization is done. lda0 = lda.lda(potential = pot, Temperature = T_Er,\ a_s=a_s, globalMu='halfMott', extents=extents,\ ignoreExtents=True ) return (fraction*wL - lda0.getRadius())**2. #return fraction - lda0.getRadius()/wL except Exception as e : negslope = 'Bottom of the band has a negative slope' posslope = 'Radial density profile along 111 has a positive slope' threshol = 'Chemical potential exceeds the evaporation threshold' thresh100= 'Chemical potential exceeds the bottom of the band along 100' if negslope in e.message: return 1e6 # this is caused by too much green # return large value to asign penalty elif posslope in e.message: return 1e6 # this is caused by too much green # as the chemical potential comes to close # to the threshold and atoms accumulate on # the beams # return large value to asign penalty elif threshol in e.message: return 1e6 # this is caused by too much green # the chemical potential is above the evap th. # return large value to asign penalty elif thresh100 in e.message: return 1e6 # this is caused by too much green # the chemical potential is above the bottom of # the band along 100 # return large value to asign penalty elif 'vanish' in e.message : # this is is caused by insufficient extents print "extents = %.1f"% extents raise else: raise #print "Fail at g0=%.2f"% g0 #raise g0bounds = (1., min(s0, (4.*s0-2.*np.sqrt(s0))/(4.*(alpha**2.)) ) ) #(x, res) = brentq( merit, g0bounds[0], g0bounds[1] ) #gOptimal = x res = minimize_scalar( merit, bounds=g0bounds, tol=1e-4, \ method='bounded' ) gOptimal = res.x #print "gOpt=%.2f"%gOptimal potOpt = scubic.sc( allIR=s0, allGR=gOptimal, allIRw=wL, allGRw=wC ) ldaOpt = lda.lda( potential = potOpt, Temperature=T_Er, \ a_s=a_s, globalMu='halfMott', extents=extents) return [ gOptimal, ldaOpt.EtaEvap, ldaOpt.Number, \ ldaOpt.Entropy/ldaOpt.Number, ldaOpt.getRadius(), ldaOpt.getRadius()/wL ]
def optimal( **kwargs ) : """ This function takes fixed values of s0, wL, wC and optimizes the evaporation figure of merit, eta_F, by using the green compensation as a variable. """ s0 = kwargs.get('s0', 7. ) wL = kwargs.get('wL', 47. ) wC = kwargs.get('wC', 40. ) alpha = wL/wC a_s = kwargs.get('a_s', 650. ) T_Er= kwargs.get('T_Er', 0.2 ) extents = kwargs.get('extents', 40.) if 'Number' in kwargs.keys(): N0 = kwargs['Number'] def Npenalty( Num ): p = 4. if Num > N0: return np.exp( (Num - N0)/1e5 )**p else: return 1. def penalty(x,p): """ This function is used to penalyze EtaF < 1 , which amounts to spilling out along the lattice beams. """ if x < 1.: return np.exp(-(x-1.))**p else: return x #return np.piecewise(x, [x < 1., x >= 1.], \ # [lambda x: , lambda x: x]) def merit( g0 ) : try: pot = scubic.sc(allIR = s0, \ allGR = g0, \ allIRw = wL, \ allGRw = wC ) # The lda within the optimization loop is told to ignore errors # of the density distribution going beyond the extents. # This will be checked after the optmization is done. lda0 = lda.lda(potential = pot, Temperature = T_Er,\ a_s=a_s, globalMu='halfMott', extents=extents,\ ignoreExtents=True, select='htse' ) etaFstar = penalty( lda0.etaF_star , 5 ) if 'Number' in kwargs.keys(): return etaFstar * Npenalty( lda0.Number) else: return etaFstar except Exception as e : negslope = 'Bottom of the band has a negative slope' posslope = 'Radial density profile along 111 has a positive slope' threshol = 'Chemical potential exceeds the evaporation threshold' thresh100= 'Chemical potential exceeds the bottom of the band along 100' if negslope in e.message: return 1e4 # this is caused by too much green # return large value to asign penalty elif posslope in e.message: return 1e4 # this is caused by too much green # as the chemical potential comes to close # to the threshold and atoms accumulate on # the beams # return large value to asign penalty elif threshol in e.message: return 1e4 # this is caused by too much green # the chemical potential is above the evap th. # return large value to asign penalty elif thresh100 in e.message: return 1e4 # this is caused by too much green # the chemical potential is above the bottom of # the band along 100 # return large value to asign penalty elif 'vanish' in e.message : # this is is caused by insufficient extents print "extents = %.1f"% extents raise else: raise #print "Fail at g0=%.2f"% g0 #raise g0bounds = (0., min(s0,s0/(alpha**2.))) res = minimize_scalar( merit, bounds=g0bounds, tol=4e-2, \ method='bounded' ) gOptimal = res.x #print "gOpt=%.2f"%gOptimal potOpt = scubic.sc( allIR=s0, allGR=gOptimal, allIRw=wL, allGRw=wC ) ldaOpt = lda.lda( potential = potOpt, Temperature=T_Er, \ a_s=a_s, globalMu='halfMott', extents=extents) return [ gOptimal, ldaOpt.EtaEvap, ldaOpt.Number, \ ldaOpt.Entropy/ldaOpt.Number, ldaOpt.getRadius(), ldaOpt.getRadius()/wL, ldaOpt.DeltaEvap ]
def optimal_FixedRadius(**kwargs): """ This function takes fixed values of s0, wL, wC and finds the value of green that would be required to make a sample with a radius that is a fixed fraction of the lattice beam waist. The value of the fraction is hardcoded in the function """ fraction = 0.32 s0 = kwargs.get('s0', 7.) wL = kwargs.get('wL', 47.) wC = kwargs.get('wC', 40.) alpha = wL / wC a_s = kwargs.get('a_s', 650.) T_Er = kwargs.get('T_Er', 0.2) extents = kwargs.get('extents', 40.) def merit(g0): try: pot = scubic.sc(allIR = s0, \ allGR = g0, \ allIRw = wL, \ allGRw = wC ) # The lda within the optimization loop is told to ignore errors # of the density distribution going beyond the extents. # This will be checked after the optmization is done. lda0 = lda.lda(potential = pot, Temperature = T_Er,\ a_s=a_s, globalMu='halfMott', extents=extents,\ ignoreExtents=True ) return (fraction * wL - lda0.getRadius())**2. #return fraction - lda0.getRadius()/wL except Exception as e: negslope = 'Bottom of the band has a negative slope' posslope = 'Radial density profile along 111 has a positive slope' threshol = 'Chemical potential exceeds the evaporation threshold' thresh100 = 'Chemical potential exceeds the bottom of the band along 100' if negslope in e.message: return 1e6 # this is caused by too much green # return large value to asign penalty elif posslope in e.message: return 1e6 # this is caused by too much green # as the chemical potential comes to close # to the threshold and atoms accumulate on # the beams # return large value to asign penalty elif threshol in e.message: return 1e6 # this is caused by too much green # the chemical potential is above the evap th. # return large value to asign penalty elif thresh100 in e.message: return 1e6 # this is caused by too much green # the chemical potential is above the bottom of # the band along 100 # return large value to asign penalty elif 'vanish' in e.message: # this is is caused by insufficient extents print "extents = %.1f" % extents raise else: raise #print "Fail at g0=%.2f"% g0 #raise g0bounds = (1., min(s0, (4. * s0 - 2. * np.sqrt(s0)) / (4. * (alpha**2.)))) #(x, res) = brentq( merit, g0bounds[0], g0bounds[1] ) #gOptimal = x res = minimize_scalar( merit, bounds=g0bounds, tol=1e-4, \ method='bounded' ) gOptimal = res.x #print "gOpt=%.2f"%gOptimal potOpt = scubic.sc(allIR=s0, allGR=gOptimal, allIRw=wL, allGRw=wC) ldaOpt = lda.lda( potential = potOpt, Temperature=T_Er, \ a_s=a_s, globalMu='halfMott', extents=extents) return [ gOptimal, ldaOpt.EtaEvap, ldaOpt.Number, \ ldaOpt.Entropy/ldaOpt.Number, ldaOpt.getRadius(), ldaOpt.getRadius()/wL ]
def optimal(**kwargs): """ This function takes fixed values of s0, wL, wC and optimizes the evaporation figure of merit, eta_F, by using the green compensation as a variable. """ s0 = kwargs.get('s0', 7.) wL = kwargs.get('wL', 47.) wC = kwargs.get('wC', 40.) alpha = wL / wC a_s = kwargs.get('a_s', 650.) T_Er = kwargs.get('T_Er', 0.2) extents = kwargs.get('extents', 40.) if 'Number' in kwargs.keys(): N0 = kwargs['Number'] def Npenalty(Num): p = 4. if Num > N0: return np.exp((Num - N0) / 1e5)**p else: return 1. def penalty(x, p): """ This function is used to penalyze EtaF < 1 , which amounts to spilling out along the lattice beams. """ if x < 1.: return np.exp(-(x - 1.))**p else: return x #return np.piecewise(x, [x < 1., x >= 1.], \ # [lambda x: , lambda x: x]) def merit(g0): try: pot = scubic.sc(allIR = s0, \ allGR = g0, \ allIRw = wL, \ allGRw = wC ) # The lda within the optimization loop is told to ignore errors # of the density distribution going beyond the extents. # This will be checked after the optmization is done. lda0 = lda.lda(potential = pot, Temperature = T_Er,\ a_s=a_s, globalMu='halfMott', extents=extents,\ ignoreExtents=True, select='htse' ) etaFstar = penalty(lda0.etaF_star, 5) if 'Number' in kwargs.keys(): return etaFstar * Npenalty(lda0.Number) else: return etaFstar except Exception as e: negslope = 'Bottom of the band has a negative slope' posslope = 'Radial density profile along 111 has a positive slope' threshol = 'Chemical potential exceeds the evaporation threshold' thresh100 = 'Chemical potential exceeds the bottom of the band along 100' if negslope in e.message: return 1e4 # this is caused by too much green # return large value to asign penalty elif posslope in e.message: return 1e4 # this is caused by too much green # as the chemical potential comes to close # to the threshold and atoms accumulate on # the beams # return large value to asign penalty elif threshol in e.message: return 1e4 # this is caused by too much green # the chemical potential is above the evap th. # return large value to asign penalty elif thresh100 in e.message: return 1e4 # this is caused by too much green # the chemical potential is above the bottom of # the band along 100 # return large value to asign penalty elif 'vanish' in e.message: # this is is caused by insufficient extents print "extents = %.1f" % extents raise else: raise #print "Fail at g0=%.2f"% g0 #raise g0bounds = (0., min(s0, s0 / (alpha**2.))) res = minimize_scalar( merit, bounds=g0bounds, tol=4e-2, \ method='bounded' ) gOptimal = res.x #print "gOpt=%.2f"%gOptimal potOpt = scubic.sc(allIR=s0, allGR=gOptimal, allIRw=wL, allGRw=wC) ldaOpt = lda.lda( potential = potOpt, Temperature=T_Er, \ a_s=a_s, globalMu='halfMott', extents=extents) return [ gOptimal, ldaOpt.EtaEvap, ldaOpt.Number, \ ldaOpt.Entropy/ldaOpt.Number, ldaOpt.getRadius(), ldaOpt.getRadius()/wL, ldaOpt.DeltaEvap ]