def main_routine (baseDir="./",configPath="./python/parameter.cfg",generationType="r"): print "#################################################################" print "#################################################################" print "### optimal control #############################################" print "### preparation of smallest overlap functional ##################" print "#################################################################" print "#################################################################" ### globals for functional variation global time, cavityRead, cavityMemo, \ nRead, nDown, nUp, nWrite, dimH, \ cfg, \ h0, hc_up, hc_down, hs_up, hs_down, hsep, \ weight_up, weight_down, sepZeroWeight, \ normUp, normDown, normRead, \ hole, \ iteration tmpDir=baseDir+"tmp/" # parser.add_argument("--cfg" , help="config path") ### check for arguments, g: generate data, r: read data ### ### read config file ### print ("load from config file: " + configPath) configParser = cp.ConfigParser() configParser.read(configPath) print (configParser.sections()) cfg=configParser.__dict__['_sections'].copy() #for src, target in cfg['NVSETUP'].items(): # print(src + " : " + target) nRead =int(cfg['OCFourier']['{read_harmonic}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) nDown =nRead+nWrite nUp =nDown+nWrite nTimeRead =int(cfg['OCTime']['{read_timecnt}']) dimH =nRead + 2*nWrite normRead =float(cfg['OCConstraints']['{amplitude_read}']) normDown =float(cfg['OCConstraints']['{amplitude_down}']) normUp =float(cfg['OCConstraints']['{amplitude_up}']) name_readwrite = IOHelper.getNameReadWrite(**cfg) name_vector = IOHelper.getVectorOverlap(**cfg) ### read config file ### ### prepare data with fortran ### cmd = "mkdir -p " + tmpDir print (tmpDir) call(cmd.split()) replace_in_file('./python/py.parNvCenter.F95' , tmpDir +'parNvCenter.F95', **cfg['NVSETUP']) replace_in_file('./python/py.parSmallestOverlap.F95', tmpDir +'parSmallestOverlap.F95', **cfg['OCFourier']) replace_in_file(tmpDir +'parSmallestOverlap.F95', tmpDir +'parSmallestOverlap.F95', **cfg['OCConstraints']) replace_in_file(tmpDir +'parSmallestOverlap.F95', tmpDir +'parSmallestOverlap.F95', **cfg['OCTime']) replace_in_file(tmpDir +'parSmallestOverlap.F95', tmpDir +'parSmallestOverlap.F95', **cfg['FILES']) #write config file with open(cfg['FILES']['{prefix}']+"parameter.cfg", 'wb') as configfile: configParser.write(configfile) cmd = "mv "+tmpDir+"parSmallestOverlap.F95 "+baseDir+"srcOptCntrl/parSmallestOverlap.F95" call(cmd.split()) cmd = "mv "+tmpDir+"parNvCenter.F95 "+baseDir+"srcNv/parNvCenter.F95" call(cmd.split()) print ("compile fortran routines") cmd = "./scripts/ifort-generateHarmonics.sh " + baseDir call(cmd.split()) print ("invoke " +baseDir +"generateHarmonics") cmd = baseDir+"generateHarmonics" generateHarmonics = Popen(cmd.split(), stdin=PIPE) cmd = "echo " + generationType generateInput = Popen(cmd.split(), stdout=generateHarmonics.stdin) output = generateHarmonics.communicate()[0] generateInput.wait() ### prepare data with fortran ### ### read data for functional variation ### __,cavityMemo,cavityRead =IOHelper.harmonics_readwrite(**cfg) time =IOHelper.functionaltimes_readwrite(**cfg) h0,hs_down,hs_up,hc_down,hc_up,hsep=IOHelper.read_MtrxOverlap(**cfg['FILES']) hole =IOHelper.read_HoleData(**cfg['FILES']) ### read data for functional variation ### ### functional variation ### print ("\nstart minimization: ") varMax = 20 varStep = 1 success = False #constraints for constraintWeightDown and constraintWeightUp funcTime =float(time['tfunc']) weight_down=float(cfg ['OCConstraints']['{temporal_weight_down}'])*funcTime/2.0 weight_up =float(cfg ['OCConstraints']['{temporal_weight_up}'])*funcTime/2.0 minContraints= ( {'type' : 'ineq', 'fun' : constraintNormRead }, {'type' : 'eq', 'fun' : constraintNormDown }, {'type' : 'eq', 'fun' : constraintNormUp }, {'type' : 'eq', 'fun' : constraintWeightDown }, {'type' : 'eq', 'fun' : constraintWeightUp }, # {'type' : 'eq', 'fun' : constraintRealMaxCoefficient }, {'type' : 'ineq', 'fun' : constraintZeroStartDown }, {'type' : 'ineq', 'fun' : constraintZeroStartUp }, {'type' : 'ineq', 'fun' : constraintPartialOverlap }, {'type' : 'ineq', 'fun' : constraintStoreUp }, {'type' : 'ineq', 'fun' : constraintStoreDownIneq }, # # {'type' : 'ineq', 'fun' : constraintSeperateZero }, # {'type' : 'eq', 'fun' : constraintStoreDown }, # {'type' : 'eq', 'fun' : constraintHoleValue }, # {'type' : 'eq', 'fun' : constraintHoleSlope }, # {'type' : 'eq', 'fun' : constraintHoleCurv }, ) while varStep < varMax and not success : gamma0=initGamma0() x,x0 =initx(gamma0) # print (" calculate sepzero to initialize vector x (method=SLSQP):") # iteration=1 # res=minimize(seperateZeroStore, #seperateZero, # smallestAbsoluteOverlap, # x0, #res.x, # method='SLSQP', # constraints=sepzeroContraints, # tol=cfg['OCConstraints']['{tol_sepzero}'], # options={'maxiter' : 25000, 'disp' : True}, # callback=monitor # ) # x0=res.x # sepZeroWeight = res.fun # funcTime =float(time['tfunc']) # weight=float(cfg ['OCConstraints']['{temporal_weight_limit}']) # sepZeroWeight=weight*funcTime/2e0 print (" calculate smallest overlap of absolute values (method=SLSQP):") iteration=1 res=minimize(seperateZero, #smallestOverlapSeperateZero, # smallestOverlapSeperatePeaks, #smallestComplxOverlap, # smallestAbsoluteOverlap, # smallestOverlapSeperateZeroPartial, # x0, method='SLSQP', constraints=minContraints, tol=cfg['OCConstraints']['{tol_classic}'], options={'maxiter' : 25000, 'disp' : True}, callback=monitor ) success=res.success gamma=getGamma(res.x) print ("") print (" current norm(aplhaR) = " +str(sp.linalg.norm(gamma[ :nRead]))) print (" current norm(aplhaD) = " +str(sp.linalg.norm(gamma[nRead:nDown]))) print (" current norm(aplhaU) = " +str(sp.linalg.norm(gamma[nDown:nUp ]))) print (" current partial Olap = " +str(partialOverlap(res.x))) # print (" current hole(value) = " +str(constraintHoleValue(res.x))) # print (" current hole(slope) = " +str(constraintHoleSlope(res.x))) # print (" current hole(value) = " +str(constraintHoleCurv(res.x))) varStep+=1 if (success): print ("\ndone with minimization, succeeded:") else: print ("\ndone with minimization, no success:") sp.savetxt(name_vector,sp.array([gamma.real,gamma.conj().imag]).T) # [real(gamma), imag(gamma)].conj() cmd=baseDir+"generateOptimized" call(cmd.split())
def main_routine (writeBase=8.0,writeCnt=1,readBase=2.0,readCnt=1,datPath="dat/",prefix="pa",destPath="../parallel/",gentype="c",funcCfg=0): """ Parameters: ----------- --writeBase: maximum value of writing time interval in multiples of Pi/{base_rabi}. (float) --wirteCnt: number of different writing intervals from 1.0 to writeBase times Pi/{base_rabi} (int) --readBase: maximum value of reading time interval in multiples of Pi/{base_rabi}. (float) --readCnt: number of different reading intervals from 1.0 to readBase times Pi/{base_rabi} (int) --destPath: directory where output files are generated (for every parameter setting of writeBase/writeCnt, readBase/readCnt a corresponding subdirectory is created) (string) --gentype : type of data generation --> g : generate data with modNv r : read data with modNv and c : collect data and produce 3d plot of reading area """ dWrite = sp.array(range(0,writeCnt)) dRead = sp.array(range(0,readCnt)) if (writeCnt == 1): write_base = sp.ones([readCnt])*writeBase else: write_base = (1.0+(writeBase-1.0)/float(writeCnt-1)*dWrite[:]) if (readCnt == 1): read_base = sp.ones([writeCnt])*readBase else: read_base = (1.0+(readBase-1.0)/float(readCnt-1)*dRead[:]) print read_base # print (write_base) # print (read_base) if (gentype=="g" or gentype=="r"): # generate pool = multiprocessing.Pool(processes=multiprocessing.cpu_count()) results = [ pool.apply_async(run_single_job, args=(wb,rb,datPath,prefix,destPath,gentype,funcCfg)) for wb,rb in zip(write_base, read_base) ] results = [ p.get() for p in results ] pool.terminate() elif (gentype=="c"): # collect configPath="./python/parameter.cfg" print ("load from config file: " + configPath) configParser = cp.ConfigParser() configParser.read(configPath) cfg=configParser.__dict__['_sections'].copy() nRead =int(cfg['OCFourier']['{read_harmonic}']) nWrite=int(cfg['OCFourier']['{write_harmonic}']) timeCntWrite = int(cfg['OCTime']['{write_timecnt}']) timeCntRead = int(cfg['OCTime']['{read_timecnt}']) timeCnt = timeCntRead+timeCntWrite omega_c=float(cfg['NVSETUP']['{omega_c}'])*2.0*sp.pi omega_r=float(cfg['OCFourier']['{base_rabi}'])/1e6 tUnit =sp.pi/(2.0*sp.pi*1e3*omega_r) filelist=[] div =10.0 # readCnt = 17 cavity=sp.zeros((2,readCnt,timeCntRead)) time =sp.zeros(timeCnt) wb=write_base[-1] # choose last element errCnt=[] name_optimized=cfg['FILES']['{name_optimized}'] name_readwrite=IOHelper.getNameReadWrite(**cfg) for rb in range(readCnt): newDir=dest(destPath,wb,read_base[rb]) cfg['FILES']['{prefix}'] = newDir+datPath+prefix+name_readwrite+name_optimized try: filename=cfg['FILES']['{prefix}']+"cavityMode_read_down"+cfg['FILES']['{postfix}'] print filename time,real,imag = sp.loadtxt(filename).T cavity[0,rb,:] = real[timeCntWrite:timeCntWrite+timeCntRead]**2+imag[timeCntWrite:timeCntWrite+timeCntRead]**2 except: errCnt.append("down: {:8.4f}\n".format(read_base[rb])) try: filename=cfg['FILES']['{prefix}']+"cavityMode_read_up"+cfg['FILES']['{postfix}'] time,real,imag = sp.loadtxt(filename).T cavity[1,rb,:] = real[timeCntWrite:timeCntWrite+timeCntRead]**2+imag[timeCntWrite:timeCntWrite+timeCntRead]**2 except: errCnt.append("up: {:8.4f}\n".format(read_base[rb])) if (len(errCnt) != 0): print ("can't read some files:\n" + str(errCnt)) print ("generating color map") # read funtional times t2, t3 newDir=dest(destPath,wb,read_base.max()) cfg['FILES']['{prefix}']=newDir+datPath+prefix functime =IOHelper.functionaltimes_readwrite(**cfg) ti=float(functime['ti'])/omega_c/tUnit # in nano seconds ti_i = int(functime['idx_ti'])-1 tf=float(functime['tf'])/omega_c/tUnit # in nano seconds tf_i = int(functime['idx_tf']) functimeX =sp.array([1.0,readBase]) functimeY =sp.array([(tf+ti)/2.0,tf]) cutShortX =sp.array([1.0,1.0]) cutLargeX =sp.array([readBase,readBase]) cutShortY =sp.array([writeBase,writeBase+readBase/2.0]) cutLargeY =sp.array([writeBase,writeBase+readBase]) functimeZ =sp.array([-1.5,-1.5]) functimeYMid=sp.array([ti + (tf-ti)/4.0,ti+ (tf-ti)/2.0]) # read funtional times t2, t3 # define the grid over which the function should be plotted (xx and yy are matrices) xx, yy = sp.meshgrid(sp.linspace(1.0,readBase,readCnt), sp.linspace(ti,tf,tf_i-ti_i)) zz0 = cavity[0,:,ti_i:tf_i].T/cavity[:,:,ti_i:tf_i].max() zz1 = cavity[1,:,ti_i:tf_i].T/cavity[:,:,ti_i:tf_i].max() # xx, yy = sp.meshgrid(sp.linspace(1.0,readBase,readCnt), # sp.linspace(time[timeCntRead/div]/tUnit,time[-1]/tUnit,timeCntRead/div)) # zz1 = cavity[0,:,:].T/cavity[:,:,:].max() # zz1 = cavity[1,:,:].T/cavity[:,:,:].max() font = { 'fontsize' : 26, 'verticalalignment' : 'top', 'horizontalalignment' : 'center' } # cm('font', **font) # rc('text', usetex=True) fig = plt.figure() # ax = fig.gca(projection='3d') fig0 = fig.add_subplot(121, projection='3d') fig0.plot_surface(xx, yy, zz0, rstride=10, cstride=5, cmap=cm.Blues, alpha=0.5,zorder=11.0,vmin=-0.25, vmax=1) fig0.contourf(xx, yy, zz0, zdir='z', offset=-1.5, cmap=cm.Blues,vmin=-0.25, vmax=1) fig0.plot(functimeX, functimeY, functimeZ,'k--',zorder=10.0) fig0.plot(functimeX, functimeYMid, functimeZ,'k--',zorder=10.0) fig0.plot(cutShortX, cutShortY, functimeZ,'m-',linewidth=2.5,zorder=10.0) fig0.plot(cutLargeX, cutLargeY, functimeZ,'g-',linewidth=2.5,zorder=10.0) fig0.set_title("a) state \"0\"", **font) fig0.set_xlabel("$\Delta T_{\cal F} \, / \, \\frac{T_R}{2}$", **font) fig0.set_ylabel("$t \, / \, \\frac{T_R}{2}$", **font) fig0.set_zlabel("$\left|A(t)\\right|^2 \, / \, \left|A_{max}(t)\\right|^2$", **font) fig0.set_zlim(-1.5, 1.0) fig1 = fig.add_subplot(122, projection='3d') fig1.plot_surface(xx, yy, zz1, rstride=10, cstride=5, cmap=cm.Reds, alpha=0.5,zorder=11.0,vmin=-0.25, vmax=1) fig1.contourf(xx, yy, zz1, zdir='z', offset=-1.5, cmap=cm.Reds,vmin=-0.25, vmax=1) fig1.plot(functimeX, functimeY, functimeZ,'k--',zorder=10.0) fig1.plot(functimeX, functimeYMid, functimeZ,'k--',zorder=10.0) fig1.plot(cutShortX, cutShortY, functimeZ,'m-',linewidth=2.5,zorder=10.0) fig1.plot(cutLargeX, cutLargeY, functimeZ,'g-',linewidth=2.5,zorder=10.0) fig1.set_title("b) state \"1\"", **font) fig1.set_xlabel("$\Delta T_{\cal F} \, / \, \\frac{T_R}{2}$", **font) fig1.set_ylabel("$t \, / \, \\frac{T_R}{2}$", **font) fig1.set_zlabel("$\left|A(t)\\right|^2 \, / \, \left|A_{max}(t)\\right|^2$", **font) fig1.set_zlim(-1.5, 1.0) # plt.subplot(1, 2, 1) # plt.pcolor(xx,yy,zz0) # plt.axis([xx.min(),xx.max(),yy.min(),yy.max()]) # plt.plot(functimeX,functimeY, 'w', linewidth=2) # plt.plot(functimeX,functimeYMid, 'w-', linewidth=2) # plt.title("time bin state \"0\"") # plt.xlabel("$T_{functional} \, / \, \\frac{\pi}{\Omega_R[MHz]}$", **font) # plt.ylabel("$t \, / \, \\frac{\pi}{\Omega_R[MHz]}$", **font) # plt.subplot(1, 2, 2) # plt.pcolor(xx,yy,zz1) # plt.axis([xx.min(),xx.max(),ti,tf]) # plt.plot(functimeX,functimeY, 'w', linewidth=2) # plt.plot(functimeX,functimeYMid, 'w-', linewidth=2) # plt.title("time bin sstate \"1\"") # plt.xlabel("$T_{functional} \, / \, \\frac{\pi}{\Omega_R[MHz]}$", **font) # plt.colorbar(label="$\left|A_{0,/1}(t)\\right|^2 \, / \, max(\left|A(t))\\right|^2$") plt.show() else: print ("option unkown: gentype="+gentype)
def main_routine (wd="./",cfg="./python/parameter.cfg",generationType="p",\ toMinimize =2,\ cavityMatch=1,\ silent=0,\ useBeta=0,\ cutoff=10000,dimGrid=11,id0=0,id1=1,id2=2,pltId='funval',pltLim=1000,pltBins=40,myCmap="brg"): print "#################################################################" print "#################################################################" print "### optimal control #############################################" print "### memory pulse evaluation #####################################" print "#################################################################" print "#################################################################" ### globals for functional variation global cons, fun, dim, conf conf['toMinimize'] =toMinimize conf['cavityMatch']=cavityMatch conf['silent'] =silent if (useBeta == 0): conf['useBeta'] = False else: conf['useBeta'] = True conf['id0'] =id0 conf['id1'] =id1 conf['id2'] =id2 conf['cutoff'] =cutoff ### globals for functional variation ### generate working environment ### print ("### working directory: " + wd) tmpDir = wd+"tmp/" cmd = "mkdir -p " + tmpDir call(cmd.split()) ### generate working environment ### ### read config file ### print ("### load config file: " + cfg) configParser = cp.ConfigParser() configParser.read(cfg) print (configParser.sections()) cfg=configParser.__dict__['_sections'].copy() conf['MEConstraints'] = cfg['MEConstraints'].copy() conf['FITNESS']= cfg['FITNESS'].copy() conf['FITNESS']['{mutationrate}']=sp.zeros([conf['entries']]) conf['FITNESS']['{mutationrate}'][conf['funval']] =cfg['FITNESS']['{mut_functional}'] conf['FITNESS']['{mutationrate}'][conf['fidelity_down']]=cfg['FITNESS']['{mut_fidelity_down}'] conf['FITNESS']['{mutationrate}'][conf['fidelity_up']] =cfg['FITNESS']['{mut_fidelity_up}'] conf['FITNESS']['{mutationrate}'][conf['memolap']] =cfg['FITNESS']['{mut_memolap}'] conf['FITNESS']['{mutationrate}'][conf['alpha']] =cfg['FITNESS']['{mut_alpha}'] conf['FITNESS']['{mutationrate}'][conf['beta']] =cfg['FITNESS']['{mut_beta}'] conf['FITNESS']['{mutationrate}'][conf['success']] =cfg['FITNESS']['{mut_success}'] cons['alpha_norm']=float(cfg['MEConstraints']["{storage_amplitude}"]) cons['beta_low'] =float(cfg['MEConstraints']["{limit_low_beta}"]) cons['beta_top'] =float(cfg['MEConstraints']["{limit_top_beta}"]) cons['chi2_Tol'] =float(cfg['MEConstraints']['{tol_chi2}']) dim['alpha']=int(cfg['MEFourier']['{storage_harmonic}']) dim['total']=dim['alpha']+3 prefix =cfg['FILES']['{prefix}'] postfix =cfg['FILES']['{postfix}'] name_optimized=cfg['FILES']['{name_optimized}'] name_spin =cfg['FILES']['{name_spin}'] name_cavity =cfg['FILES']['{name_cavity}'] cfg['dim_grid'] =dimGrid name_readwrite=IOHelper.getNameReadWrite(**cfg) name_storage =IOHelper.getNameStorage (**cfg) name_varinit =IOHelper.getNameInitialVariation (**cfg) myTime =IOHelper.functionaltimes_readwrite(**cfg) # reads time and updates cfg: # cfg['METime']['{fidelity_ti}'] = myTime['idx_ti'] # cfg['METime']['{fidelity_tf}'] = myTime['idx_tf'] gridPhi =sp.linspace(0.0, 2.0*sp.pi, num=2*dimGrid-1) gridTheta =sp.linspace(0.0, sp.pi, num=dimGrid) minfun =sp.zeros([len(gridPhi),len(gridTheta),conf['entries']+3]) if (generationType == "p"): print "## read from file: " + name_varinit raw = sp.loadtxt(name_varinit) minfun = raw.reshape(len(gridPhi),len(gridTheta),conf['entries']+3) for i in sp.arange(0,len(gridPhi),1): for j in sp.arange(0,len(gridTheta),1): minfun[i,j,conf['fitness']] = MemoryPulseFunctional.fitnessFunction(minfun[i,j,:]) else: ### prepare and complie fortran routines ### print ("### prepare fortran routines") replace_in_file('./python/py.parNvCenter.F95' , tmpDir +'parNvCenter.F95' , **cfg['NVSETUP']) replace_in_file('./python/py.parMemoryPulse.F95', tmpDir +'parMemoryPulse.F95', **cfg['MEFourier']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['OCFourier']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['MESpin']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['MEConstraints']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['OCConstraints']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['METime']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['OCTime']) replace_in_file(tmpDir +'parMemoryPulse.F95' , tmpDir +'parMemoryPulse.F95', **cfg['FILES']) #write config file with open(prefix+"parameter.cfg", 'wb') as configfile: configParser.write(configfile) ### read config file ### print ("### compile fortran routines") cmd = "mv "+tmpDir+"parMemoryPulse.F95 "+wd+"srcOptCntrl/parMemoryPulse.F95" call(cmd.split()) cmd = "mv "+tmpDir+"parNvCenter.F95 "+wd+"srcNv/parNvCenter.F95" call(cmd.split()) cmd = "./scripts/ifort-memoryHarmonics.sh " + wd call(cmd.split()) print ("### invoke fortran routines") print ("### generation Type: " + generationType) cmd = wd+"memoryHarmonics" # location of executable fortran program generateHarmonics = Popen(cmd.split(), stdin=PIPE) # run fortran program with piped standard input cmd = "echo " + generationType # communication with fortran-routine: chose action -> read or generate generateInput = Popen(cmd.split(), stdout=generateHarmonics.stdin) # send action to fortran program output = generateHarmonics.communicate()[0] generateInput.wait() ### prepare and complie fortran routines ### ### read data for functional variation ### cons['cavityT2_down'], \ cons['cavityT2_up'] = IOHelper.read_CavityMemory (**cfg['FILES']) fun ['mtrxBeta_up'], \ cons['vecT2_up'] , \ cons['fidelity_up'], \ cons['mtrxMemOlap'] = IOHelper.read_MtrxMemory("up", **cfg['FILES']) fun ['mtrxBeta_down'], \ cons['vecT2_down'] , \ cons['fidelity_down'], \ __ = IOHelper.read_MtrxMemory("down", **cfg['FILES']) ### read data for functional variation ### ### functional variation ### print ("\n### start minimization: ") print ("### on initial "+ str(sp.shape(minfun)[0])+"x"+str(sp.shape(minfun)[1]) + "-grid (phi,theta) on sphere") mincnt=0 cntPhi =0 t0=0 tcnt=len(gridTheta) for phi in gridPhi[0:len(gridPhi)-1]: theta_i=0 if(cntPhi > 0): t0=1 tcnt=len(gridTheta)-1 theta_i=1 ### parallel evaluation with <cpu_count()> cores ################################### pool = multiprocessing.Pool(processes=multiprocessing.cpu_count()) results = [ pool.apply_async(evaluateSphericalVariation, args=(phi,theta,cntPhi,cntTheta)) for theta,cntTheta in zip(gridTheta[t0:tcnt],sp.arange(t0,tcnt,1)) ] for p in results: myResult,i,j =p.get() minfun[i,j,:]=myResult #kill multiprocessing pool !!! pool.terminate() ### parallel evaluation with <cpu_count()> cores ################################### ### sequentiell evaluateion 1 core ################################################# # for theta in gridTheta[t0:tcnt]: # minfun[cntPhi,theta_i,:],__,__=MemoryPulseFunctional.evaluateSphericalVariation (phi,theta,cntPhi,theta_i) # theta_i+=1 ### sequentiell evaluateion 1 core ################################################# cntPhi=cntPhi+1 # end for phi minfun[ :, 0,:]=minfun[0, 0,:] # theta=0 : same vector on unit-sphere minfun[ :,-1,:]=minfun[0,-1,:] # theta=pi : same vector on unit-sphere minfun[-1, :,:]=minfun[0, :,:] # periodic print "\n### write to file: " + name_varinit sp.savetxt(name_varinit,minfun.reshape((len(gridPhi)*len(gridTheta),conf['entries']+3)),\ header=' alpha0['+str(id0)+']; alpha0['+str(id1)+']; alpha0['+str(id2)+'];'\ +' fitness; success; norm[alpha]; abs[beta]; memolap; fidelity_up; fidelity_down; minfun') print "#################################################################" print "#################################################################" font = { 'fontsize' : 26, } mytitle=MemoryPulseFunctional.getName(pltId) ### prepare surface_plot ############################################################### x = outer(cos(gridPhi), sin(gridTheta)) y = outer(sin(gridPhi), sin(gridTheta)) z = outer(ones(size(gridPhi)), cos(gridTheta)) myDensity=sp.zeros([len(gridPhi),len(gridTheta)]) for i in sp.arange(0,len(gridPhi),1): for j in sp.arange(0,len(gridTheta),1): if (minfun[i,j,conf[pltId]] >= pltLim): myDensity[i,j] = pltLim+1 else: myDensity[i,j] = minfun[i,j,conf[pltId]] # "afmhot", "hot", "terrain", "brg" cm = plt.cm.get_cmap(myCmap) myColors = cm(myDensity/pltLim) ### prepare surface_plot ############################################################### ### prepare colormap ################################################################### fig0_colors=sp.linspace(0,pltLim,pltBins) ### prepare colormap ################################################################### ### prepare histogram ################################################################## yHist,xHist = sp.histogram(myDensity.flatten(),pltBins) # xSpan = pltxHist.max()-xHist.min() # Color = [cm(((ix-xHist.min())/xSpan)) for ix in xHist] Color = [cm(((ix)/pltLim)) for ix in xHist] ### prepare histogram ################################################################## ### calculate fittest solutions ######################################################## cntFit = 0 for i in sp.arange(0,len(gridPhi),1): for j in sp.arange(0,len(gridTheta),1): if minfun[i,j,conf['fitness']] != 0.0 : cntFit+=1 if (minfun[i,j,conf[pltId]] >= pltLim): myDensity[i,j] = pltLim else: myDensity[i,j] = minfun[i,j,conf[pltId]] if (cntFit > 0): fitAlpha =sp.zeros([cntFit,int(cfg['MEFourier']['{storage_harmonic}'])]) cntFit = 0 for i in sp.arange(0,len(gridPhi),1): for j in sp.arange(0,len(gridTheta),1): if minfun[i,j,conf['fitness']] != 0.0 : print minfun[i,j,3:] fitAlpha[cntFit,conf['id0']]=minfun[i,j,0] fitAlpha[cntFit,conf['id1']]=minfun[i,j,1] fitAlpha[cntFit,conf['id2']]=minfun[i,j,2] cntFit+=1 name_fittest=IOHelper.getNameInitialFittest(**cfg) print "\n### write fittest to file: " + name_fittest sp.savetxt(name_fittest,fitAlpha,\ header='# alpha0[0] ... alpha0[n]') print "### fitness counter: {0:} of {1:}".format(cntFit,sp.shape(minfun)[0]*sp.shape(minfun)[1]) ### calculate fittest solutions ######################################################## fig = plt.figure() ### plot surface_plot ################################################################## fig3D = fig.add_subplot(131, projection='3d') surf = fig3D.plot_surface(x, y, z, rstride=1, cstride=1,facecolors=myColors) fig3D.plot(cos(gridPhi), sin(gridPhi), zs=0, zdir='z',lw=0.5, color="black") fig3D.plot(cos(gridPhi), sin(gridPhi), zs=0, zdir='x',lw=0.5, color="black") fig3D.set_xlabel("$\\alpha_{:}$".format(id0), **font) fig3D.set_ylabel("$\\alpha_{:}$".format(id1), **font) fig3D.set_zlabel("$\\alpha_{:}$".format(id2), **font) fig3D.set_title("a) 4d-plot of "+mytitle, fontsize = 20) ### plot surface_plot ################################################################## ### plot colormap ###################################################################### fig0 = fig.add_subplot(132) fig0.invert_yaxis() cp0=fig0.contourf(gridPhi/sp.pi,gridTheta/sp.pi,minfun[:,:,conf[pltId]].T,fig0_colors,cmap=cm) plt.colorbar(cp0) fig0.set_xlabel("$\phi/\pi$", **font) fig0.set_ylabel("$\\theta/\pi$", **font) fig0.set_title("b) map of "+mytitle, fontsize = 20) ### plot colormap ###################################################################### ### plot histogram ##################################################################### figBar=fig.add_subplot(133) figBar.bar(xHist[:-1],yHist,color=Color,width=xHist[1]-xHist[0]) figBar.set_xlim([0,pltLim]) figBar.set_ylim([0,max(yHist[0:len(yHist)-1])]) figBar.set_xlabel(mytitle, fontsize=20) figBar.set_ylabel("count", fontsize=20) figBar.set_title("c) histogram", fontsize = 20) ### plot histogram ##################################################################### plt.show()