def extrapolate_m2tanh_sections(P,dPdx,x_core_stop,x_ped_start,x_ped_stop,x_sol_start,dpsi_ds=1): #for some parts of the profile generation, we need to extrapolate certain #segments of the profiles #this creates linearly extrapolated functions for the core, pedestal #and buffer region # x_core_stop: x where core stops # x_ped_start : x where pedestal starts # x_ped_stop : x where pedestal stops # x_sol_start: x where sol starts slope_core_stop = dpsi_ds * dPdx(x_core_stop) slope_ped_start = dpsi_ds * dPdx(x_ped_start) slope_ped_stop = dpsi_ds * dPdx(x_ped_stop) slope_sol_start = dpsi_ds * dPdx(x_sol_start) value_core_stop = P(x_core_stop) value_ped_start = P(x_ped_start) value_ped_stop = P(x_ped_stop) value_sol_start = P(x_sol_start) #create extrapolations after_core = lambda x: value_core_stop + slope_core_stop*(x-x_core_stop) before_ped = lambda x: value_ped_start + slope_ped_start*(x-x_ped_start) after_ped = lambda x: value_ped_stop + slope_ped_stop*(x-x_ped_stop) before_sol = lambda x: value_sol_start + slope_sol_start*(x-x_sol_start) ddx_after_core = lambda x: slope_core_stop ddx_before_ped = lambda x: slope_ped_start ddx_after_ped = lambda x: slope_ped_stop ddx_before_sol = lambda x: slope_sol_start #NOTE: SMOOTHNESS OF TRANSITION A PROBLEM. # mtanh transition function pair_list = [[0,0]] core_funclist = [P,after_core] core_derivlist = [dPdx,ddx_after_core] core_pointlist = [x_core_stop] (core,ddx_core) = derivative_bezier_transition(core_funclist,core_derivlist,core_pointlist,pair_list) pair_list = [[0,0],[0,0]] ped_funclist = [before_ped,P,after_ped] ped_derivlist = [ddx_before_ped,dPdx,ddx_after_ped] ped_pointlist = [x_ped_start,x_ped_stop] (ped,ddx_ped) = derivative_bezier_transition(ped_funclist,ped_derivlist,ped_pointlist,pair_list) pair_list = [[0,0]] sol_funclist = [before_sol,P] sol_derivlist = [ddx_before_sol,dPdx] sol_pointlist = [x_sol_start] (sol,ddx_sol) = derivative_bezier_transition(sol_funclist,sol_derivlist,sol_pointlist,pair_list) return (core,ped,sol,ddx_core,ddx_ped,ddx_sol)
def generate_ne_profile(simul,**kwargs): global neHatPre global dneHatPredpsi # for use in d-He scan where the electron profile is fixed if "nScale_"+species[e_index] in kwargs.keys(): neScale=kwargs["nScale_"+species[e_index]] else: neScale=1.0 nePed=neScale*kwargs["nped_"+species[e_index]] neCoreGrad=neScale*kwargs["dnCoredx_"+species[e_index]]*dxdpsiN_at_a nepedGrad=neScale*kwargs["dnpeddx_"+species[e_index]]*dxdpsiN_at_a neSOLGrad=neScale*kwargs["dnSOLdx_"+species[e_index]]*dxdpsiN_at_a if mtanh: (neHat,dneHatds) = generate_m2tanh_profile(nePed,neCoreGrad,nepedGrad,neSOLGrad,psiMaxPed-psiMinPed,psiMinPed) (core,ped,sol,ddx_core,ddx_ped,ddx_sol) = extrapolate_m2tanh_sections(neHat,dneHatds,psiMin,psiMinPed,psiMaxPed,psiMax) neHatPre = core dneHatPredpsi = ddx_core else: neHatPre =(lambda psiN: (nePed-neCoreGrad*(psiMinPed-psiMin) + neCoreGrad* (psiN-psiMin))) neHatPed =(lambda psiN: (nePed + nepedGrad* (psiN-psiMinPed))) neHatAft =(lambda psiN: (nePed+nepedGrad*(psiMaxPed-psiMinPed) + neSOLGrad* (psiN-psiMaxPed))) dneHatPredpsi = (lambda psiN: neCoreGrad + psiN*0) dneHatPeddpsi = (lambda psiN: nepedGrad + psiN*0) dneHatAftdpsi = (lambda psiN: neSOLGrad + psiN*0) nelist=[neHatPre,neHatPed,neHatAft] dnedpsiList = [dneHatPredpsi,dneHatPeddpsi,dneHatAftdpsi] (neHat,dneHatdpsi)=derivative_bezier_transition(nelist,dnedpsiList,psiList,pairList) dneHatds = lambda x : dneHatdpsi(x) return (neHat,dneHatds)
def generate_nonuniform_grid_bezier(inputFilename,psi1,psi2,slope12,smoothness): #Calculates psi(psiN), where psiN is uniform and psi is nonuniform #psi1, psi2: psi points between which to use denser grid #slope12: slope between corresponding psiN1, psiN2 points inputs = perfectInput(inputFilename) Npsi = inputs.Npsi psiAHat = inputs.psiAHat #psiAHat for a would-be uniform map psiN = inputs.psi #array of uniform grid points psiNMin = inputs.psiMin psiNMax = inputs.psiMax #slope01, slope23: slope outside tighter grid section. Assumed equal slope01 = slope12*(psiAHat*(psiNMax - psiNMin) - (psi2-psi1))/(slope12*(psiNMax - psiNMin) - (psi2-psi1)) slope23=slope01 # psiN points corresponding to psi1, psi2 psiN1 = psiNMin + (psi1 - psiAHat*psiNMin)/slope01 psiN2 = psiNMax - (psiAHat*psiNMax - psi2)/slope23 #create linear functions to transition between inner = (lambda psiN: (psiAHat*psiNMin + slope01*(psiN-psiNMin))) middle = (lambda psiN: inner(psiN1) + slope12*(psiN-psiN1)) outer = (lambda psiN: middle(psiN2) + slope23*(psiN-psiN2)) derivativeInner = (lambda psiN: slope01) derivativeMiddle = (lambda psiN: slope12) derivativeOuter = (lambda psiN: slope23) #generate end points for bezier curve from smoothness parameter #smoothness of 1 gives endpoints of transitions in the middle of the pedestal #so that it just has time to transition to middle linear function distance = smoothness*(psiN2-psiN1)/2 psiNList = [psiN1,psiN2] pair1=[distance, distance] pair2=[distance, distance] pairList=[pair1,pair2] splineList=[inner,middle,outer] derivativeSplineList = [derivativeInner,derivativeMiddle,derivativeOuter] #calculate nonuniform grid points array #psi=bezier_transition(splineList,psiNList,pairList,psiN) psi,dpsidpsiN=derivative_bezier_transition(splineList,derivativeSplineList,psiNList,pairList,psiN) create_psiAHat_of_Npsi("psiAHat.h5",Npsi,dpsidpsiN(psiN),psi(psiN)) return (psi,dpsidpsiN)
def generate_etai_profile(Delta,omega,**kwargs): etaiHatPre =(lambda psiN: (niPed+ niCoreGrad* (psiN-psiMinPed))) detaiHatPredpsi =(lambda psiN: niCoreGrad + 0*psiN) if mtanh: #PhiTopPoint=psiMax/2.0 + psiMaxPed/2.0 PhiTopPoint=psiMaxPed width = (psiMaxPed - psiMinPed) prefactor=1.0 PhiTop=prefactor*(TiHatPed(PhiTopPoint)/Zs[main_index])*numpy.log(etaiHatPre(PhiTopPoint)*1.0/niHatAft(PhiTopPoint))*(2.0*omega/Delta) etaiHatAft =(lambda psiN: niHatAft(psiN)*numpy.exp(PhiTop*Zs[main_index]/TiHatAft(psiN))) detaiHatAftdpsi = (lambda psiN: (dniHatAftdpsi(psiN) - niHatAft(psiN)*PhiTop*Zs[main_index]*dTiHatAftdpsi(psiN)/(TiHatAft(psiN))**2)*numpy.exp(PhiTop*Zs[main_index]/TiHatAft(psiN))) (etaiHat,detaiHatds) = derivative_m3tanh_transition([etaiHatPre,etaiHatAft],[detaiHatPredpsi,detaiHatAftdpsi],psiMaxPed,width) #DEBUG PLOT if verbose: plot_psi = numpy.linspace(psiMin,psiMax) plt.hold(True) plt.plot(plot_psi,etaiHat(plot_psi)) plt.plot(plot_psi,etaiHatPre(plot_psi)) plt.plot(plot_psi,etaiHatAft(plot_psi)) plt.show() else: if specialeta: etaiHatPed =(lambda psiN: (niPed+2*niCoreGrad* (psiN-psiMinPed))) detaiHatPeddpsi =(lambda psiN: 2*niCoreGrad + 0*psiN) else: etaiHatPed =(lambda psiN: (niPed+ niCoreGrad* (psiN-psiMinPed))) detaiHatPeddpsi =(lambda psiN: niCoreGrad + 0*psiN) PhiTopPoint=psiMaxPed prefactor=1.0 PhiTop=prefactor*(TiHatPed(PhiTopPoint)/Zs[main_index])*numpy.log(etaiHatPed(PhiTopPoint)*1.0/niHatPed(PhiTopPoint))*(2.0*omega/Delta) etaiHatAft =(lambda psiN: niHatAft(psiN)*numpy.exp(PhiTop*Zs[main_index]/TiHatAft(psiN))) detaiHatAftdpsi = (lambda psiN: (dniHatAftdpsi(psiN) - niHatAft(psiN)*PhiTop*Zs[main_index]*dTiHatAftdpsi(psiN)/(TiHatAft(psiN))**2)*numpy.exp(PhiTop*Zs[main_index]/TiHatAft(psiN))) etailist=[etaiHatPre,etaiHatPed,etaiHatAft] detaidpsilist=[detaiHatPredpsi,detaiHatPeddpsi,detaiHatAftdpsi] (etaiHat,detaiHatds) =derivative_bezier_transition(etailist,detaidpsilist,psiList,pairList) return (etaiHat,detaiHatds)
def generate_etaz_profile(Delta,omega,**kwargs): imp_conc=kwargs["imp_conc"] if specialeta==True: gradScale=4.0725 etazHatInner=(lambda psiN: imp_conc*(niPed+niCoreGrad*(psiN-psiMinPed))) etazHatMiddle=(lambda psiN: imp_conc*(niPed-gradScale*niCoreGrad*(psiN-psiMinPed))) etazHatOuter=(lambda psiN: imp_conc*(niPed-gradScale*niCoreGrad*(psiMaxPed-psiMinPed) + niCoreGrad* (psiN-psiMaxPed))) detazHatInnerdpsi=(lambda psiN: imp_conc*niCoreGrad) detazHatMiddledpsi=(lambda psiN: -imp_conc*gradScale*niCoreGrad) detazHatOuterdpsi=(lambda psiN: imp_conc*niCoreGrad) etailist=[etazHatInner,etazHatMiddle,etazHatOuter] detaidpsilist = [detazHatInnerdpsi,detazHatMiddledpsi,detazHatOuterdpsi] (etazHat,detazHatdpsi) = derivative_bezier_transition(etailist,psiList[:1]+psiList[-1:],pairList[:1]+pairList[-1:]) detazHatds = lambda x : detazHatdpsi(x) else: etazHat=lambda x : imp_conc*(niPed+niCoreGrad*(x-psiMinPed)) detazHatds = lambda x: imp_conc*niCoreGrad + 0*x #add 0*x to make it return ndarray when x is one. return (etazHat,detazHatds)
def generate_ni_profile(**kwargs): # for use in d-He scan where the electron profile varies global niPed global niCoreGrad global niHatPed global niHatAft global dniHatAftdpsi if "nScale_"+species[main_index] in kwargs.keys(): niScale=kwargs["nScale_"+species[main_index]] else: niScale=1.0 niPed=niScale*kwargs["nped_"+species[main_index]] niCoreGrad=niScale*kwargs["dnCoredx_"+species[main_index]]*dxdpsiN_at_a nipedGrad=niScale*kwargs["dnpeddx_"+species[main_index]]*dxdpsiN_at_a niSOLGrad=niScale*kwargs["dnSOLdx_"+species[main_index]]*dxdpsiN_at_a # generate n_i if mtanh: (niHat,dniHatds) = generate_m2tanh_profile(niPed,niCoreGrad,nipedGrad,niSOLGrad,psiMaxPed-psiMinPed,psiMinPed) (core,ped,sol,ddx_core,ddx_ped,ddx_sol) = extrapolate_m2tanh_sections(niHat,dniHatds,psiMin,psiMinPed,psiMaxPed,psiMax) niHatPed = ped niHatAft = sol dniHatAftdpsi = ddx_sol else: niHatPre =(lambda psiN: (niPed + niCoreGrad*(psiN-psiMinPed))) niHatPed =(lambda psiN: (niPed + nipedGrad* (psiN-psiMinPed))) niHatAft =(lambda psiN: (niPed+nipedGrad*(psiMaxPed-psiMinPed) + niSOLGrad* (psiN-psiMaxPed))) dniHatPredpsi = (lambda psiN: niCoreGrad + 0*psiN) dniHatPeddpsi = (lambda psiN: nipedGrad + 0*psiN) dniHatAftdpsi = (lambda psiN: niSOLGrad + 0*psiN) nilist=[niHatPre,niHatPed,niHatAft] dnidpsiList = [dniHatPredpsi,dniHatPeddpsi,dniHatAftdpsi] (niHat,dniHatds)=derivative_bezier_transition(nilist,dnidpsiList,psiList,pairList) return (niHat,dniHatds)
psiMaxPed = psiMinPed + 0.0338173602865 #Tpeds[e_index],TCoreGrads[e_index],TpedGrads[e_index],TSOLGrads[e_index],psiMaxPed-psiMinPed,psiMinPed X_ped,dXdr_core,dXdr_ped,dXdr_sol,ped_width,ped_pos =0.9, -1.77423664921, -17.7423664921, -1.77423664921, 0.0338173602865, 0.94927395957 P,dPdx = generate_m2tanh_profile(X_ped,dXdr_core,dXdr_ped,dXdr_sol,ped_width,ped_pos) (core,ped,sol,ddx_core,ddx_ped,ddx_sol) = extrapolate_m2tanh_sections(P,dPdx,xlo,ped_pos+ped_width/2,ped_pos+ped_width/2,xhi) a_ped = X_ped + dXdr_core * ped_width/2.0 a_sol = X_ped + (dXdr_ped - dXdr_sol/2.0) * ped_width X_sol = X_ped + dXdr_ped * ped_width #ped = lambda x: X_ped + dXdr_ped * (x - ped_pos) flist = [core,ped,sol] ddx_flist = [ddx_core,ddx_ped,ddx_sol] pointlist = [psiMinPed,psiMaxPed] offset = (psiMaxPed-psiMinPed)*0.2 pairList=[[offset,offset],[offset,offset]] P2,dP2dx = derivative_bezier_transition(flist,ddx_flist,pointlist,pairList) THatPre =(lambda psiN: (X_ped + dXdr_core*(psiN-psiMinPed))) THatPed =(lambda psiN: (X_ped + dXdr_ped*(psiN-psiMinPed))) THatAft =(lambda psiN: (X_ped + dXdr_ped*(psiMaxPed-psiMinPed) + dXdr_sol*(psiN-psiMaxPed))) dTHatPredpsi = (lambda psiN: dXdr_core + 0*psiN) dTHatPeddpsi = (lambda psiN: dXdr_ped + 0*psiN) dTHatAftdpsi = (lambda psiN: dXdr_sol + 0*psiN) Tlist=[THatPre,THatPed,THatAft] dTdpsiList = [dTHatPredpsi,dTHatPeddpsi,dTHatAftdpsi] P3,dP3dx = derivative_bezier_transition(Tlist,dTdpsiList,pointlist,pairList) plt.title("linear extrapolation") plt.subplot(2, 1, 1) ax=plt.gca() ax.axvline(x=ped_pos+ped_width/2,color='k',linestyle=':')
def generate_T_profiles(**kwargs): global TiHatPed global TiHatAft global dTiHatAftdpsi #THats = numpy.zeros((Nspecies,Npsi)) #dTHatdpsis = numpy.zeros((Nspecies,Npsi)) THats = [None]*Nspecies dTHatdpsis = [None]*Nspecies dTHatdss = [None]*Nspecies TScale=[0]*Nspecies Tpeds=[0]*Nspecies TCoreGrads=[0]*Nspecies TpedGrads=[0]*Nspecies TSOLGrads=[0]*Nspecies #Pre,Ped,Aft will contain functions describe T in core, ped and outwards. THatPre=[0]*Nspecies THatPed=[0]*Nspecies THatAft=[0]*Nspecies dTHatPredpsi=[0]*Nspecies dTHatPeddpsi=[0]*Nspecies dTHatAftdpsi=[0]*Nspecies #reading T related parameters for i in range(Nspecies): if "TScale_"+species[i] in kwargs.keys(): TScale[i]=kwargs["TScale_"+species[i]] else: TScale[i]=1.0 Tpeds[i]=TScale[i]*kwargs["Tped_"+species[i]] TCoreGrads[i]=TScale[i]*kwargs["dTCoredx_"+species[i]]*dxdpsiN_at_a TpedGrads[i]=TScale[i]*kwargs["dTpeddx_"+species[i]]*dxdpsiN_at_a TSOLGrads[i]=TScale[i]*kwargs["dTSOLdx_"+species[i]]*dxdpsiN_at_a TSOLGrads[i]=TScale[i]*kwargs["dTSOLdx_"+species[i]]*dxdpsiN_at_a TScale=numpy.array(TScale) Tpeds=numpy.array(Tpeds) TCoreGrads=numpy.array(TCoreGrads) TSOLGrads=numpy.array(TSOLGrads) TpedGrads=numpy.array(TpedGrads) if mtanh: for i in range(Nspecies): (THats[i],dTHatdss[i]) = generate_m2tanh_profile(Tpeds[i],TCoreGrads[i],TpedGrads[i],TSOLGrads[i],psiMaxPed-psiMinPed,psiMinPed) (core,ped,sol,ddx_core,ddx_ped,ddx_sol) = extrapolate_m2tanh_sections(THats[main_index],dTHatdss[main_index],psiMin,psiMinPed,psiMaxPed,psiMax) TiHatPed = ped TiHatAft = sol dTiHatAftdpsi = ddx_sol else: #Generating functions from the parameters for i in range(Nspecies): THatPre[i] =(lambda psiN,i=i: (Tpeds[i] + TCoreGrads[i]*(psiN-psiMinPed))) THatPed[i] =(lambda psiN,i=i: (Tpeds[i] + TpedGrads[i]*(psiN-psiMinPed))) THatAft[i] =(lambda psiN,i=i: (Tpeds[i] + TpedGrads[i]*(psiMaxPed-psiMinPed) + TSOLGrads[i]*(psiN-psiMaxPed))) dTHatPredpsi[i] = (lambda psiN,i=i: TCoreGrads[i]) dTHatPeddpsi[i] = (lambda psiN,i=i: TpedGrads[i]) dTHatAftdpsi[i] = (lambda psiN,i=i: TSOLGrads[i]) Tlist=[THatPre[i],THatPed[i],THatAft[i]] dTdpsiList = [dTHatPredpsi[i],dTHatPeddpsi[i],dTHatAftdpsi[i]] (THats[i],dTHatdpsis[i])=derivative_bezier_transition(Tlist,dTdpsiList,psiList,pairList) dTHatdss[i]=lambda x,i=i: dTHatdpsis[i](x) TiHatPed = THatPed[main_index] TiHatAft = THatAft[main_index] dTiHatAftdpsi = dTHatAftdpsi[main_index] return (THats,dTHatdss)
def generate_T_profiles_sameflux(nt,nb,breakpoint_shift,**kwargs): global TiHatPed global TiHatAft global dTiHatAftdpsi #THats = numpy.zeros((Nspecies,Npsi)) #dTHatdpsis = numpy.zeros((Nspecies,Npsi)) THats = [None]*Nspecies dTHatdpsis = [None]*Nspecies dTHatdss = [None]*Nspecies TScale=[0]*Nspecies Tpeds=[0]*Nspecies TCoreGrads=[0]*Nspecies TpedGrads=[0]*Nspecies TSOLGrads=[0]*Nspecies #Pre,Ped,Aft will contain functions describe T in core, ped and outwards. THatPre=[0]*Nspecies THatPed=[0]*Nspecies THatAft=[0]*Nspecies dTHatPredpsi=[0]*Nspecies dTHatPeddpsi=[0]*Nspecies dTHatAftdpsi=[0]*Nspecies #reading T related parameters for i in range(Nspecies): if "TScale_"+species[i] in kwargs.keys(): TScale[i]=kwargs["TScale_"+species[i]] else: TScale[i]=1.0 Tpeds[i]=TScale[i]*kwargs["Tped_"+species[i]] TCoreGrads[i]=TScale[i]*kwargs["dTCoredx_"+species[i]]*dxdpsiN_at_a TpedGrads[i]=TScale[i]*kwargs["dTpeddx_"+species[i]]*dxdpsiN_at_a TSOLGrads[i]=TScale[i]*kwargs["dTSOLdx_"+species[i]]*dxdpsiN_at_a TScale=numpy.array(TScale) Tpeds=numpy.array(Tpeds) TCoreGrads=numpy.array(TCoreGrads) TSOLGrads=numpy.array(TSOLGrads) TpedGrads=numpy.array(TpedGrads) if mtanh: transition_length = 1*(psiMaxPed-psiMinPed) (THats[main_index],dTHatdss[main_index]) = match_heat_flux_proxy(Tpeds[main_index],TCoreGrads[main_index],TpedGrads[main_index],TSOLGrads[main_index],transition_length,psiMinPed,nt,nb,psiMin,psiMax) (core,ped,sol,ddx_core,ddx_ped,ddx_sol) = extrapolate_m2tanh_sections(THats[main_index],dTHatdss[main_index],psiMin,psiMinPed,psiMaxPed,psiMax) TiHatPed = ped TiHatAft = sol dTiHatAftdpsi = ddx_sol if Nspecies >= 2: (THats[e_index],dTHatdss[e_index]) = generate_m2tanh_profile(Tpeds[e_index],TCoreGrads[e_index],TpedGrads[e_index],TSOLGrads[e_index],psiMaxPed-psiMinPed,psiMinPed) else: breakpoint=psiMinPed + breakpoint_shift Tp=Tpeds[main_index] + TCoreGrads[main_index] *(breakpoint-psiMinPed) if (TCoreGrads[main_index] != TSOLGrads[main_index]) and (TPedGrads[main_index] != TSOLGrads[main_index]): print "generate_compatible_profiles: Warning: sameflux option uses the Core T gradients of the main species everywhere" dTdpsi=TCoreGrads[main_index] d1=breakpoint - psiMin d2=psiMax - breakpoint f=lambda x : x*(Tp-d1*x)**(3.0/2.0) - (nb*1.0/nt)*(Tp + dTdpsi*d2)**(3.0/2.0)*dTdpsi dTdpsiTop=scipy.optimize.fsolve(f,0)[0] #[0] since returns an numpy.ndarray dTdpsiBot=dTdpsi THatPre[main_index] =(lambda psiN: (Tpeds[main_index] + dTdpsiTop*(psiN-breakpoint))) THatPed[main_index] =(lambda psiN: (Tpeds[main_index] + dTdpsiBot*(psiN-breakpoint))) THatAft[main_index] =(lambda psiN: (Tpeds[main_index] + dTdpsiBot*(psiN-breakpoint))) dTHatPredpsi[main_index] =(lambda psiN: dTdpsiTop + 0*psiN) dTHatPeddpsi[main_index] =(lambda psiN: dTdpsiBot + 0*psiN) dTHatAftdpsi[main_index] =(lambda psiN: dTdpsiBot + 0*psiN) Tlist=[THatPre[main_index],THatPed[main_index]] dTdpsilist=[dTHatPredpsi[main_index],dTHatPeddpsi[main_index]] (THats[main_index],dTHatdpsis[main_index])=derivative_bezier_transition(Tlist,dTdpsilist,[breakpoint],pairList[:-1]) dTHatdss[main_index]= lambda x : dTHatdpsis[main_index](x) #T2=simul.TBar*bezier_transition(Tlist,[breakpoint],pairList[:-1],numpy.array([psiMidPed]))[0] TiHatPed = THatPed[main_index] TiHatAft = THatAft[main_index] dTiHatAftdpsi = dTHatAftdpsi[main_index] if Nspecies >= 2: #T_e: THatPre[e_index] =(lambda psiN: (Tpeds[e_index] + TCoreGrads[e_index]*(psiN-psiMinPed))) THatPed[e_index] =(lambda psiN: (Tpeds[e_index] + TpedGrads[e_index]*(psiN-psiMinPed))) THatAft[e_index] =(lambda psiN: (Tpeds[e_index] + TpedGrads[e_index]*(psiMaxPed-psiMinPed) + TSOLGrads[e_index]*(psiN-psiMaxPed))) dTHatPredpsi[e_index] = (lambda psiN: TCoreGrads[e_index] + 0*psiN) dTHatPeddpsi[e_index] = (lambda psiN: TpedGrads[e_index] + 0*psiN) dTHatAftdpsi[e_index] = (lambda psiN: TSOLGrads[e_index] + 0*psiN) Tlist=[THatPre[e_index],THatPed[e_index],THatAft[e_index]] dTdpsiList = [dTHatPredpsi[e_index],dTHatPeddpsi[e_index],dTHatAftdpsi[e_index]] (THats[e_index],dTHatdpsis[e_index])=derivative_bezier_transition(Tlist,dTdpsiList,psiList,pairList) dTHatdss[e_index]=lambda x : dTHatdpsis[e_index](x) if Nspecies == 3: THats[imp_index]=THats[main_index] #dTHatdpsis[imp_index]=dTHatdpsis[main_index] dTHatdss[imp_index]=dTHatdss[main_index] return (THats,dTHatdss)