39103642

Build Type

appveyor

Committed by GitHub

Commit Message

<a href="https://github.com/suavecode/SUAVE/commit/<a class=hub.com/suavecode/SUAVE/commit/28e91f2dfa78c06c882a30388f180fb3dd5e1300">28e91f2df<a href="https://github.com/suavecode/SUAVE/commit/28e91f2dfa78c06c882a30388f180fb3dd5e1300">">Merge </a><a class="double-link" href="https://github.com/suavecode/SUAVE/commit/<a class="double-link" href="https://github.com/suavecode/SUAVE/commit/c44eafe6d5a3ac6910ab676a2dcc7e01b73ca4bb">c44eafe6d</a>">c44eafe6d</a><a href="https://github.com/suavecode/SUAVE/commit/28e91f2dfa78c06c882a30388f180fb3dd5e1300"> into 0fea4f6dd">0fea4f6dd</a>

Pull Request Pull Request #437: Feature super corrections

Run Details

24335 of 27155 relevant lines covered (89.62%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.18

/trunk/SUAVE/Components/Energy/Networks/Propulsor_Surrogate.py

## @ingroup Components-Energy-Networks
# Propulsor_Surrogate.py
#
# Created:  Mar 2017, E. Botero
# Modified: Jan 2020, T. MacDonald
#           May 2021, E. Botero

# ----------------------------------------------------------------------
#  Imports
# ----------------------------------------------------------------------

# suave imports
import SUAVE

# package imports
import numpy as np
from copy import deepcopy
from SUAVE.Components.Propulsors.Propulsor import Propulsor
from SUAVE.Methods.Utilities.Cubic_Spline_Blender import Cubic_Spline_Blender

from SUAVE.Core import Data
import sklearn
from sklearn import gaussian_process
from sklearn.gaussian_process.kernels import RationalQuadratic, ConstantKernel, RBF, Matern
from sklearn import neighbors
from sklearn import svm, linear_model

# ----------------------------------------------------------------------
#  Network
# ----------------------------------------------------------------------

## @ingroup Components-Energy-Networks
class Propulsor_Surrogate(Propulsor):
    """ This is a way for you to load engine data from a source.
        A .csv file is read in, a surrogate made, that surrogate is used during the mission analysis.
        
        You need to use build surrogate first when setting up the vehicle to make this work.
        
        Assumptions:
        The input format for this should be Altitude, Mach, Throttle, Thrust, SFC
        
        Source:
        None
    """        
    def __defaults__(self):
        """ This sets the default values for the network to function
        
            Assumptions:
            None
            
            Source:
            N/A
            
            Inputs:
            None
            
            Outputs:
            None
            
            Properties Used:
            N/A
        """          
        self.nacelle_diameter         = None
        self.engine_length            = None
        self.number_of_engines        = None
        self.tag                      = 'Engine_Deck_Surrogate'
        self.input_file               = None
        self.sfc_surrogate            = None
        self.thrust_surrogate         = None
        self.thrust_angle             = 0.0
        self.areas                    = Data()
        self.surrogate_type           = 'gaussian'
        self.altitude_input_scale     = 1.
        self.thrust_input_scale       = 1.
        self.sfc_anchor               = None
        self.sfc_anchor_scale         = 1.
        self.sfc_anchor_conditions    = np.array([[1.,1.,1.]])
        self.thrust_anchor            = None
        self.thrust_anchor_scale      = 1.
        self.thrust_anchor_conditions = np.array([[1.,1.,1.]])
        self.sfc_rubber_scale         = 1.
        self.use_extended_surrogate   = False
        self.sealevel_static_thrust   = 0.0
        self.negative_throttle_values = False
   
    # manage process with a driver function
    def evaluate_thrust(self,state):
        """ Calculate thrust given the current state of the vehicle
        
            Assumptions:
            None
            
            Source:
            N/A
            
            Inputs:
            state [state()]
            
            Outputs:
            results.thrust_force_vector [newtons]
            results.vehicle_mass_rate   [kg/s]
            
            Properties Used:
            Defaulted values
        """            
        
        # Unpack the surrogate
        sfc_surrogate = self.sfc_surrogate
        thr_surrogate = self.thrust_surrogate
        
        # Unpack the conditions
        conditions = state.conditions
        # rescale altitude for proper surrogate performance
        altitude   = conditions.freestream.altitude/self.altitude_input_scale
        mach       = conditions.freestream.mach_number
        throttle   = conditions.propulsion.throttle
        
        cond = np.hstack([altitude,mach,throttle])
           
        if self.use_extended_surrogate:
            lo_blender = Cubic_Spline_Blender(0, .01)
            hi_blender = Cubic_Spline_Blender(0.99, 1)            
            sfc = self.extended_sfc_surrogate(sfc_surrogate, cond, lo_blender, hi_blender)
            thr = self.extended_thrust_surrogate(thr_surrogate, cond, lo_blender, hi_blender)
        else:
            sfc = sfc_surrogate.predict(cond)
            thr = thr_surrogate.predict(cond)

        sfc = sfc*self.sfc_input_scale*self.sfc_anchor_scale
        thr = thr*self.thrust_input_scale*self.thrust_anchor_scale
       
        F    = thr
        mdot = thr*sfc*self.number_of_engines
        
        if self.negative_throttle_values == False:
            F[throttle<=0.]    = 0.
            mdot[throttle<=0.] = 0.
           
        # Save the output
        results = Data()
        results.thrust_force_vector = self.number_of_engines * F * [np.cos(self.thrust_angle),0,-np.sin(self.thrust_angle)]
        results.vehicle_mass_rate   = mdot
   
        return results          
    
    def build_surrogate(self):
        """ Build a surrogate. Multiple options for models are available including:
            -Gaussian Processes
            -KNN
            -SVR
            
            Assumptions:
            None
            
            Source:
            N/A
            
            Inputs:
            state [state()]
            
            Outputs:
            self.sfc_surrogate    [fun()]
            self.thrust_surrogate [fun()]
            
            Properties Used:
            Defaulted values
        """          
       
        # file name to look for
        file_name = self.input_file
       
        # Load the CSV file
        my_data = np.genfromtxt(file_name, delimiter=',')
       
        # Remove the header line
        my_data = np.delete(my_data,np.s_[0],axis=0)
       
        # Clean up to remove redundant lines
        b = np.ascontiguousarray(my_data).view(np.dtype((np.void, my_data.dtype.itemsize * my_data.shape[1])))
        _, idx = np.unique(b, return_index=True)
       
        my_data = my_data[idx]                
               
   
        xy  = my_data[:,:3] # Altitude, Mach, Throttle
        thr = np.transpose(np.atleast_2d(my_data[:,3])) # Thrust
        sfc = np.transpose(np.atleast_2d(my_data[:,4]))  # SFC
        
        self.altitude_input_scale = np.max(xy[:,0])
        self.thrust_input_scale   = np.max(thr)
        self.sfc_input_scale      = np.max(sfc)
        
        # normalize for better surrogate performance
        xy[:,0] /= self.altitude_input_scale
        thr     /= self.thrust_input_scale
        sfc     /= self.sfc_input_scale
       
       
        # Pick the type of process
        if self.surrogate_type  == 'gaussian':
            gp_kernel = Matern()
            regr_sfc = gaussian_process.GaussianProcessRegressor(kernel=gp_kernel)
            regr_thr = gaussian_process.GaussianProcessRegressor(kernel=gp_kernel)      
            thr_surrogate = regr_thr.fit(xy, thr)
            sfc_surrogate = regr_sfc.fit(xy, sfc)  
           
        elif self.surrogate_type  == 'knn':
            regr_sfc = neighbors.KNeighborsRegressor(n_neighbors=1,weights='distance')
            regr_thr = neighbors.KNeighborsRegressor(n_neighbors=1,weights='distance')
            sfc_surrogate = regr_sfc.fit(xy, sfc)
            thr_surrogate = regr_thr.fit(xy, thr)  
   
        elif self.surrogate_type  == 'svr':
            regr_thr = svm.SVR(C=500.)
            regr_sfc = svm.SVR(C=500.)
            sfc_surrogate  = regr_sfc.fit(xy, sfc)
            thr_surrogate  = regr_thr.fit(xy, thr)    
           
        elif self.surrogate_type == 'linear':
            regr_thr = linear_model.LinearRegression()
            regr_sfc = linear_model.LinearRegression()          
            sfc_surrogate  = regr_sfc.fit(xy, sfc)
            thr_surrogate  = regr_thr.fit(xy, thr)
            
        else:
            raise NotImplementedError('Selected surrogate method has not been implemented')
       
       
        if self.thrust_anchor is not None:
            cons = deepcopy(self.thrust_anchor_conditions)
            cons[0,0] /= self.altitude_input_scale
            base_thrust_at_anchor = thr_surrogate.predict(cons)
            self.thrust_anchor_scale = self.thrust_anchor/(base_thrust_at_anchor*self.thrust_input_scale)
            
        if self.sfc_anchor is not None:
            cons = deepcopy(self.sfc_anchor_conditions)
            cons[0,0] /= self.altitude_input_scale
            base_sfc_at_anchor = sfc_surrogate.predict(cons)
            self.sfc_anchor_scale = self.sfc_anchor/(base_sfc_at_anchor*self.sfc_input_scale)
       
        # Save the output
        self.sfc_surrogate    = sfc_surrogate
        self.thrust_surrogate = thr_surrogate   
        
    def extended_thrust_surrogate(self, thr_surrogate, cond, lo_blender, hi_blender):
        """ Fixes thrust values outside of the standard throttle range in order to provide
            reasonable values outside of the typical surrogate coverage area. 
            
            Assumptions:
            None
            
            Source:
            N/A
            
            Inputs:
            thr_surrogate     - Trained sklearn surrogate that outputs a scaled thrust value
            cond              - nx3 numpy array with input conditions for the surrogate
            lo_blender        - Cubic spline blending class that is used at the low throttle cutoff
            hi_blender        - Cubic spline blending class that is used at the high throttle cutoff
            
            Outputs:
            T                 [nondim]
            
            Properties Used:
            None
        """            
        # initialize
        cond_zero_eta      = deepcopy(cond)
        cond_one_eta       = deepcopy(cond)
        cond_zero_eta[:,2] = 0
        cond_one_eta[:,2]  = 1
        
        min_thrs = thr_surrogate.predict(cond_zero_eta)
        max_thrs = thr_surrogate.predict(cond_one_eta)
        dTdetas  = max_thrs - min_thrs
        
        etas          = cond[:,2]
        mask_low      = etas < 0
        mask_lo_blend = np.logical_and(etas >= 0, etas < 0.01)
        mask_mid      = np.logical_and(etas >= 0.01, etas < 0.99)
        mask_hi_blend = np.logical_and(etas >= 0.99, etas < 1)
        mask_high     = etas >= 1
        
        etas = np.atleast_2d(etas).T
        T = np.zeros_like(etas)
        
        # compute thrust
        T[mask_low] = min_thrs[mask_low] + etas[mask_low]*dTdetas[mask_low]
        
        if np.sum(mask_lo_blend) > 0:
            lo_weight = lo_blender.compute(etas[mask_lo_blend])
            T[mask_lo_blend] = (min_thrs[mask_lo_blend] + etas[mask_lo_blend]*dTdetas[mask_lo_blend])*lo_weight + \
                               thr_surrogate.predict(cond[mask_lo_blend])*(1-lo_weight)
        
        if np.sum(mask_mid) > 0:
            T[mask_mid] = thr_surrogate.predict(cond[mask_mid])
        
        if np.sum(mask_hi_blend) > 0:
            hi_weight = hi_blender.compute(etas[mask_hi_blend])
            T[mask_hi_blend] = thr_surrogate.predict(cond[mask_hi_blend])*hi_weight + \
                               (max_thrs[mask_hi_blend] + (etas[mask_hi_blend]-1)*dTdetas[mask_hi_blend])*(1-hi_weight)
        
        T[mask_high] = max_thrs[mask_high] + (etas[mask_high]-1)*dTdetas[mask_high]
        
        return T
    
    def extended_sfc_surrogate(self, sfc_surrogate, cond, lo_blender, hi_blender):
        """ Fixes sfc values outside of the standard throttle range in order to provide
            reasonable values outside of the typical surrogate coverage area. 
            
            Assumptions:
            None
            
            Source:
            N/A
            
            Inputs:
            sfc_surrogate     - Trained sklearn surrogate that outputs a scaled sfc value
            cond              - nx3 numpy array with input conditions for the surrogate
            lo_blender        - Cubic spline blending class that is used at the low throttle cutoff
            hi_blender        - Cubic spline blending class that is used at the high throttle cutoff
            
            Outputs:
            sfcs              [nondim]
            
            Properties Used:
            None
        """           
        # initialize
        cond_zero_eta      = deepcopy(cond)
        cond_one_eta       = deepcopy(cond)
        cond_zero_eta[:,2] = 0
        cond_one_eta[:,2]  = 1  
        
        etas          = cond[:,2]
        mask_low      = etas < 0
        mask_lo_blend = np.logical_and(etas >= 0, etas < 0.01)
        mask_mid      = np.logical_and(etas >= 0.01, etas < 0.99)
        mask_hi_blend = np.logical_and(etas >= 0.99, etas < 1)
        mask_high     = etas >= 1 
        
        etas = np.atleast_2d(etas).T
        sfcs = np.zeros_like(etas)
        
        # compute sfc
        if np.sum(mask_low) > 0:
            sfcs[mask_low] = sfc_surrogate.predict(cond_zero_eta[mask_low])
        
        if np.sum(mask_lo_blend) > 0:
            lo_weight = lo_blender.compute(etas[mask_lo_blend])
            sfcs[mask_lo_blend] = sfc_surrogate.predict(cond_zero_eta[mask_lo_blend])*lo_weight + \
                               sfc_surrogate.predict(cond[mask_lo_blend])*(1-lo_weight)
        
        if np.sum(mask_mid) > 0:
            sfcs[mask_mid] = sfc_surrogate.predict(cond[mask_mid])
        
        if np.sum(mask_hi_blend) > 0:
            hi_weight = hi_blender.compute(etas[mask_hi_blend])
            sfcs[mask_hi_blend] = sfc_surrogate.predict(cond[mask_hi_blend])*hi_weight + \
                               sfc_surrogate.predict(cond_one_eta[mask_hi_blend])*(1-hi_weight)
        
        if np.sum(mask_high) > 0:
            sfcs[mask_high] = sfc_surrogate.predict(cond_one_eta[mask_high])
            
        return sfcs   

1	## @ingroup Components-Energy-Networks
2	# Propulsor_Surrogate.py
3	#
4	# Created: Mar 2017, E. Botero
5	# Modified: Jan 2020, T. MacDonald
6	# May 2021, E. Botero
7
8	# ----------------------------------------------------------------------
9	# Imports
10	# ----------------------------------------------------------------------
11
12	# suave imports
13	import SUAVE	1✔
14
15	# package imports
16	import numpy as np	1✔
17	from copy import deepcopy	1✔
18	from SUAVE.Components.Propulsors.Propulsor import Propulsor	1✔
19	from SUAVE.Methods.Utilities.Cubic_Spline_Blender import Cubic_Spline_Blender	1✔
20
21	from SUAVE.Core import Data	1✔
22	import sklearn	1✔
23	from sklearn import gaussian_process	1✔
24	from sklearn.gaussian_process.kernels import RationalQuadratic, ConstantKernel, RBF, Matern	1✔
25	from sklearn import neighbors	1✔
26	from sklearn import svm, linear_model	1✔
27
28	# ----------------------------------------------------------------------
29	# Network
30	# ----------------------------------------------------------------------
31
32	## @ingroup Components-Energy-Networks
33	class Propulsor_Surrogate(Propulsor):	1✔
34	""" This is a way for you to load engine data from a source.
35	A .csv file is read in, a surrogate made, that surrogate is used during the mission analysis.
36
37	You need to use build surrogate first when setting up the vehicle to make this work.
38
39	Assumptions:
40	The input format for this should be Altitude, Mach, Throttle, Thrust, SFC
41
42	Source:
43	None
44	"""
45	def __defaults__(self):	1✔
46	""" This sets the default values for the network to function
47
48	Assumptions:
49	None
50
51	Source:
52	N/A
53
54	Inputs:
55	None
56
57	Outputs:
58	None
59
60	Properties Used:
61	N/A
62	"""
63	self.nacelle_diameter = None	1✔
64	self.engine_length = None	1✔
65	self.number_of_engines = None	1✔
66	self.tag = 'Engine_Deck_Surrogate'	1✔
67	self.input_file = None	1✔
68	self.sfc_surrogate = None	1✔
69	self.thrust_surrogate = None	1✔
70	self.thrust_angle = 0.0	1✔
71	self.areas = Data()	1✔
72	self.surrogate_type = 'gaussian'	1✔
73	self.altitude_input_scale = 1.	1✔
74	self.thrust_input_scale = 1.	1✔
75	self.sfc_anchor = None	1✔
76	self.sfc_anchor_scale = 1.	1✔
77	self.sfc_anchor_conditions = np.array([[1.,1.,1.]])	1✔
78	self.thrust_anchor = None	1✔
79	self.thrust_anchor_scale = 1.	1✔
80	self.thrust_anchor_conditions = np.array([[1.,1.,1.]])	1✔
81	self.sfc_rubber_scale = 1.	1✔
82	self.use_extended_surrogate = False	1✔
83	self.sealevel_static_thrust = 0.0	1✔
84	self.negative_throttle_values = False	1✔
85
86	# manage process with a driver function
87	def evaluate_thrust(self,state):	1✔
88	""" Calculate thrust given the current state of the vehicle
89
90	Assumptions:
91	None
92
93	Source:
94	N/A
95
96	Inputs:
97	state [state()]
98
99	Outputs:
100	results.thrust_force_vector [newtons]
101	results.vehicle_mass_rate [kg/s]
102
103	Properties Used:
104	Defaulted values
105	"""
106
107	# Unpack the surrogate
108	sfc_surrogate = self.sfc_surrogate	1✔
109	thr_surrogate = self.thrust_surrogate	1✔
110
111	# Unpack the conditions
112	conditions = state.conditions	1✔
113	# rescale altitude for proper surrogate performance
114	altitude = conditions.freestream.altitude/self.altitude_input_scale	1✔
115	mach = conditions.freestream.mach_number	1✔
116	throttle = conditions.propulsion.throttle	1✔
117
118	cond = np.hstack([altitude,mach,throttle])	1✔
119
120	if self.use_extended_surrogate:	1✔
121	lo_blender = Cubic_Spline_Blender(0, .01)	1✔
122	hi_blender = Cubic_Spline_Blender(0.99, 1)	1✔
123	sfc = self.extended_sfc_surrogate(sfc_surrogate, cond, lo_blender, hi_blender)	1✔
124	thr = self.extended_thrust_surrogate(thr_surrogate, cond, lo_blender, hi_blender)	1✔
125	else:
126	sfc = sfc_surrogate.predict(cond)	1✔
127	thr = thr_surrogate.predict(cond)	1✔
128
129	sfc = sfcself.sfc_input_scaleself.sfc_anchor_scale	1✔
130	thr = thrself.thrust_input_scaleself.thrust_anchor_scale	1✔
131
132	F = thr	1✔
133	mdot = thrsfcself.number_of_engines	1✔
134
135	if self.negative_throttle_values == False:	1✔
136	F[throttle<=0.] = 0.	1✔
137	mdot[throttle<=0.] = 0.	1✔
138
139	# Save the output
140	results = Data()	1✔
141	results.thrust_force_vector = self.number_of_engines * F * [np.cos(self.thrust_angle),0,-np.sin(self.thrust_angle)]	1✔
142	results.vehicle_mass_rate = mdot	1✔
143
144	return results	1✔
145
146	def build_surrogate(self):	1✔
147	""" Build a surrogate. Multiple options for models are available including:
148	-Gaussian Processes
149	-KNN
150	-SVR
151
152	Assumptions:
153	None
154
155	Source:
156	N/A
157
158	Inputs:
159	state [state()]
160
161	Outputs:
162	self.sfc_surrogate [fun()]
163	self.thrust_surrogate [fun()]
164
165	Properties Used:
166	Defaulted values
167	"""
168
169	# file name to look for
170	file_name = self.input_file	1✔
171
172	# Load the CSV file
173	my_data = np.genfromtxt(file_name, delimiter=',')	1✔
174
175	# Remove the header line
176	my_data = np.delete(my_data,np.s_[0],axis=0)	1✔
177
178	# Clean up to remove redundant lines
179	b = np.ascontiguousarray(my_data).view(np.dtype((np.void, my_data.dtype.itemsize * my_data.shape[1])))	1✔
180	_, idx = np.unique(b, return_index=True)	1✔
181
182	my_data = my_data[idx]	1✔
183
184
185	xy = my_data[:,:3] # Altitude, Mach, Throttle	1✔
186	thr = np.transpose(np.atleast_2d(my_data[:,3])) # Thrust	1✔
187	sfc = np.transpose(np.atleast_2d(my_data[:,4])) # SFC	1✔
188
189	self.altitude_input_scale = np.max(xy[:,0])	1✔
190	self.thrust_input_scale = np.max(thr)	1✔
191	self.sfc_input_scale = np.max(sfc)	1✔
192
193	# normalize for better surrogate performance
194	xy[:,0] /= self.altitude_input_scale	1✔
195	thr /= self.thrust_input_scale	1✔
196	sfc /= self.sfc_input_scale	1✔
197
198
199	# Pick the type of process
200	if self.surrogate_type == 'gaussian':	1✔
201	gp_kernel = Matern()	1✔
202	regr_sfc = gaussian_process.GaussianProcessRegressor(kernel=gp_kernel)	1✔
203	regr_thr = gaussian_process.GaussianProcessRegressor(kernel=gp_kernel)	1✔
204	thr_surrogate = regr_thr.fit(xy, thr)	1✔
205	sfc_surrogate = regr_sfc.fit(xy, sfc)	1✔
206
207	elif self.surrogate_type == 'knn':	1✔
208	regr_sfc = neighbors.KNeighborsRegressor(n_neighbors=1,weights='distance')	×
209	regr_thr = neighbors.KNeighborsRegressor(n_neighbors=1,weights='distance')	×
210	sfc_surrogate = regr_sfc.fit(xy, sfc)	×
211	thr_surrogate = regr_thr.fit(xy, thr)	×
212
213	elif self.surrogate_type == 'svr':	1✔
214	regr_thr = svm.SVR(C=500.)	×
215	regr_sfc = svm.SVR(C=500.)	×
216	sfc_surrogate = regr_sfc.fit(xy, sfc)	×
217	thr_surrogate = regr_thr.fit(xy, thr)	×
218
219	elif self.surrogate_type == 'linear':	1✔
220	regr_thr = linear_model.LinearRegression()	1✔
221	regr_sfc = linear_model.LinearRegression()	1✔
222	sfc_surrogate = regr_sfc.fit(xy, sfc)	1✔
223	thr_surrogate = regr_thr.fit(xy, thr)	1✔
224
225	else:
226	raise NotImplementedError('Selected surrogate method has not been implemented')
227
228
229	if self.thrust_anchor is not None:	1✔
230	cons = deepcopy(self.thrust_anchor_conditions)	×
231	cons[0,0] /= self.altitude_input_scale	×
232	base_thrust_at_anchor = thr_surrogate.predict(cons)	×
233	self.thrust_anchor_scale = self.thrust_anchor/(base_thrust_at_anchor*self.thrust_input_scale)	×
234
235	if self.sfc_anchor is not None:	1✔
236	cons = deepcopy(self.sfc_anchor_conditions)	×
237	cons[0,0] /= self.altitude_input_scale	×
238	base_sfc_at_anchor = sfc_surrogate.predict(cons)	×
239	self.sfc_anchor_scale = self.sfc_anchor/(base_sfc_at_anchor*self.sfc_input_scale)	×
240
241	# Save the output
242	self.sfc_surrogate = sfc_surrogate	1✔
243	self.thrust_surrogate = thr_surrogate	1✔
244
245	def extended_thrust_surrogate(self, thr_surrogate, cond, lo_blender, hi_blender):	1✔
246	""" Fixes thrust values outside of the standard throttle range in order to provide
247	reasonable values outside of the typical surrogate coverage area.
248
249	Assumptions:
250	None
251
252	Source:
253	N/A
254
255	Inputs:
256	thr_surrogate - Trained sklearn surrogate that outputs a scaled thrust value
257	cond - nx3 numpy array with input conditions for the surrogate
258	lo_blender - Cubic spline blending class that is used at the low throttle cutoff
259	hi_blender - Cubic spline blending class that is used at the high throttle cutoff
260
261	Outputs:
262	T [nondim]
263
264	Properties Used:
265	None
266	"""
267	# initialize
268	cond_zero_eta = deepcopy(cond)	1✔
269	cond_one_eta = deepcopy(cond)	1✔
270	cond_zero_eta[:,2] = 0	1✔
271	cond_one_eta[:,2] = 1	1✔
272
273	min_thrs = thr_surrogate.predict(cond_zero_eta)	1✔
274	max_thrs = thr_surrogate.predict(cond_one_eta)	1✔
275	dTdetas = max_thrs - min_thrs	1✔
276
277	etas = cond[:,2]	1✔
278	mask_low = etas < 0	1✔
279	mask_lo_blend = np.logical_and(etas >= 0, etas < 0.01)	1✔
280	mask_mid = np.logical_and(etas >= 0.01, etas < 0.99)	1✔
281	mask_hi_blend = np.logical_and(etas >= 0.99, etas < 1)	1✔
282	mask_high = etas >= 1	1✔
283
284	etas = np.atleast_2d(etas).T	1✔
285	T = np.zeros_like(etas)	1✔
286
287	# compute thrust
288	T[mask_low] = min_thrs[mask_low] + etas[mask_low]*dTdetas[mask_low]	1✔
289
290	if np.sum(mask_lo_blend) > 0:	1✔
291	lo_weight = lo_blender.compute(etas[mask_lo_blend])	1✔
292	T[mask_lo_blend] = (min_thrs[mask_lo_blend] + etas[mask_lo_blend]dTdetas[mask_lo_blend])lo_weight + \	1✔
293	thr_surrogate.predict(cond[mask_lo_blend])*(1-lo_weight)
294
295	if np.sum(mask_mid) > 0:	1✔
296	T[mask_mid] = thr_surrogate.predict(cond[mask_mid])	1✔
297
298	if np.sum(mask_hi_blend) > 0:	1✔
299	hi_weight = hi_blender.compute(etas[mask_hi_blend])	1✔
300	T[mask_hi_blend] = thr_surrogate.predict(cond[mask_hi_blend])*hi_weight + \	1✔
301	(max_thrs[mask_hi_blend] + (etas[mask_hi_blend]-1)dTdetas[mask_hi_blend])(1-hi_weight)
302
303	T[mask_high] = max_thrs[mask_high] + (etas[mask_high]-1)*dTdetas[mask_high]	1✔
304
305	return T	1✔
306
307	def extended_sfc_surrogate(self, sfc_surrogate, cond, lo_blender, hi_blender):	1✔
308	""" Fixes sfc values outside of the standard throttle range in order to provide
309	reasonable values outside of the typical surrogate coverage area.
310
311	Assumptions:
312	None
313
314	Source:
315	N/A
316
317	Inputs:
318	sfc_surrogate - Trained sklearn surrogate that outputs a scaled sfc value
319	cond - nx3 numpy array with input conditions for the surrogate
320	lo_blender - Cubic spline blending class that is used at the low throttle cutoff
321	hi_blender - Cubic spline blending class that is used at the high throttle cutoff
322
323	Outputs:
324	sfcs [nondim]
325
326	Properties Used:
327	None
328	"""
329	# initialize
330	cond_zero_eta = deepcopy(cond)	1✔
331	cond_one_eta = deepcopy(cond)	1✔
332	cond_zero_eta[:,2] = 0	1✔
333	cond_one_eta[:,2] = 1	1✔
334
335	etas = cond[:,2]	1✔
336	mask_low = etas < 0	1✔
337	mask_lo_blend = np.logical_and(etas >= 0, etas < 0.01)	1✔
338	mask_mid = np.logical_and(etas >= 0.01, etas < 0.99)	1✔
339	mask_hi_blend = np.logical_and(etas >= 0.99, etas < 1)	1✔
340	mask_high = etas >= 1	1✔
341
342	etas = np.atleast_2d(etas).T	1✔
343	sfcs = np.zeros_like(etas)	1✔
344
345	# compute sfc
346	if np.sum(mask_low) > 0:	1✔
347	sfcs[mask_low] = sfc_surrogate.predict(cond_zero_eta[mask_low])	1✔
348
349	if np.sum(mask_lo_blend) > 0:	1✔
350	lo_weight = lo_blender.compute(etas[mask_lo_blend])	1✔
351	sfcs[mask_lo_blend] = sfc_surrogate.predict(cond_zero_eta[mask_lo_blend])*lo_weight + \	1✔
352	sfc_surrogate.predict(cond[mask_lo_blend])*(1-lo_weight)
353
354	if np.sum(mask_mid) > 0:	1✔
355	sfcs[mask_mid] = sfc_surrogate.predict(cond[mask_mid])	1✔
356
357	if np.sum(mask_hi_blend) > 0:	1✔
358	hi_weight = hi_blender.compute(etas[mask_hi_blend])	1✔
359	sfcs[mask_hi_blend] = sfc_surrogate.predict(cond[mask_hi_blend])*hi_weight + \	1✔
360	sfc_surrogate.predict(cond_one_eta[mask_hi_blend])*(1-hi_weight)
361
362	if np.sum(mask_high) > 0:	1✔
363	sfcs[mask_high] = sfc_surrogate.predict(cond_one_eta[mask_high])	1✔
364
365	return sfcs	1✔

suavecode / SUAVE / 39103642

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous