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)
