Esempio n. 1
0
    def __init__(self,Target_Lift, N = 10, verbose=0):
        """Initialization of DLLM component.
        DLLM component use target lift capability of DLLM kernel
            @param Target_Lift : the targeted lift value (float)
            @param N : integer. Number of discrete section on 1/2 wing
            @param verbose : integer : verbosity level
        """
        try :
            float(Target_Lift)
        except:
            raise ValueError('You MUST define a float target lift value, get '+str(Target_Lift)+' instead.')

        self.Target_Lift = Target_Lift
        self.N = N
        self.OC = None
        self.rtwist = np.zeros(N)
        self.__display_wing_param = True
        self.__verbose = verbose
        self.__wing_param = None
        super(DLLMOpenMDAOComponent, self).__init__()        
        self.OC = OperatingCondition(tag='DLLMOC', atmospheric_model='ISA')
        self.__set_OC_values()
        self.__set_wing_param()
        self.__DLLM = DLLMTargetLift('test', self.__wing_param,
                                   self.OC, verbose=self.__verbose)
        self.__DLLM.set_target_Lift(Target_Lift)
        self.__DLLM.run_direct()
        self.__DLLM.run_post()
Esempio n. 2
0
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
#  http://github.com/TBD
#
# Imports
import numpy
from DLLM.DLLMGeom.wing_param import Wing_param
from DLLM.DLLMKernel.DLLMTargetLift import DLLMTargetLift
from MDOTools.OC.operating_condition import OperatingCondition

OC = OperatingCondition('cond1', atmospheric_model='ISA')
OC.set_Mach(0.8)
OC.set_AoA(3.5)
OC.set_altitude(10000.)
OC.set_T0_deg(15.)
OC.set_P0(101325.)
OC.set_humidity(0.)
OC.compute_atmosphere()

wing_param = Wing_param('test_param', geom_type='Broken', n_sect=40)
wing_param.build_wing()
wing_param.set_value('span', 34.1)
wing_param.set_value('sweep', 34.)
wing_param.set_value('break_percent', 33.)
wing_param.set_value('root_chord', 6.1)
wing_param.set_value('break_chord', 4.6)
Esempio n. 3
0
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
# 
#  https://github.com/matthieu-meaux/DLLM.git
#
# @author : Matthieu MEAUX
#
# Imports
from MDOTools.OC.operating_condition import OperatingCondition
from DLLM.DLLMGeom.wing_broken import Wing_Broken
from DLLM.DLLMKernel.DLLMTargetCl import DLLMTargetCl

OC=OperatingCondition('cond1', atmospheric_model='ISA')
OC.set_Mach(0.8)
OC.set_AoA(3.0)
OC.set_altitude(10000.)
OC.set_T0_deg(15.)
OC.set_P0(101325.)
OC.set_humidity(0.)
OC.compute_atmosphere()

wing_param=Wing_Broken('broken_wing',n_sect=20)
wing_param.import_BC_from_file('input_parameters.par')
wing_param.build_linear_airfoil(OC, AoA0=0.0, set_as_ref=True)
wing_param.build_airfoils_from_ref()
wing_param.update()
wing_param.plot()
Esempio n. 4
0
class DLLMWrapper():
    ERROR_MSG = 'ERROR in DLLMWrapper.'
    WARNING_MSG = 'WARNING in DLLMWrapper.'
    POS_SOLVER = ['Solver','TargetCl','TargetLift']
    POS_FMT = ['list','numpy']

    def __init__(self, tag):
        """
        Wrapper for the DLLM solver
        """
        self.__tag          = tag

        self.__OC           = None # Operating condition
        self.__wing_param   = None # Wing_param class
        self.__DLLM_solver  = None # DLLM Solver class
        
        self.__config_dict  = None
        
        self.__out_format   = 'list'
        self.__grad_format  = 'list'
        
        self.__AoA_id       = 'AoA'
        
        self.__F_list       = None
        self.__F_list_grad  = None
        
    #-- Accessors
    def get_OC(self):
        return self.__OC
    
    def get_wing_param(self):
        return self.__wing_param
    
    def get_DLLM_solver(self):
        return self.__DLLM_solver
    
    def get_tags_x0_and_bounds(self):
        tags=self.__wing_param.get_dv_id_list()
        x0=self.__wing_param.get_dv_array()
        bounds=self.__wing_param.get_bounds_array()
        return tags,x0,bounds
    
    def get_x0_and_bounds(self):
        x0=self.__wing_param.get_dv_array()
        bounds=self.__wing_param.get_bounds_array()
        return x0,bounds
    
    def get_x0(self):
        return self.get_x()
    
    def get_x(self):
        x=self.__wing_param.get_dv_array()
        return x
    
    def get_F_list_names(self):
        return self.__DLLM_solver.get_F_list_names()
    
    def get_F_list(self):
        return self.__F_list
    
    def get_F_list_grad(self):
        return self.__F_list_grad
    
    def get_F_list_and_grad(self):
        return self.__F_list, self.__F_list_grad
        
    #-- Setters
    def set_AoA_id(self, AoA_id):
        self.__AoA_id = AoA_id
        
    def set_out_format(self, format):
        WARNING_MSG=self.WARNING_MSG+'set_out_format: '
        if format not in self.POS_FMT:
            print WARNING_MSG+'format = '+str(format)+' not in '+str(self.POS_FMT)+'. Set to default out format = list'
            format='list'
        self.__out_format = format
    
    def set_grad_format(self, format):
        WARNING_MSG=self.WARNING_MSG+'set_grad_format: '
        if format not in self.POS_FMT:
            print WARNING_MSG+'format = '+str(format)+' not in '+str(self.POS_FMT)+'. Set to default grad format = list'
            format='list'
        self.__grad_format = format
    
    #-- Public methods
    def configure(self, config_dict):
        self.__config_dict = config_dict
        self.__config_OC()
        self.__config_param()
        self.__config_DLLM()
        
    def run(self, x):
        self.__wing_param.update_from_x_list(x)
        self.__DLLM_solver.set_wing_param(self.__wing_param)
        F_list=self.analysis()
        return F_list
    
    def run_grad(self, x):
        self.__wing_param.update_from_x_list(x)
        self.__DLLM_solver.set_wing_param(self.__wing_param)
        F_list_grad=self.analysis_grad()
        return F_list_grad
    
    def run_and_grad(self, x):
        self.__wing_param.update_from_x_list(x)
        self.__DLLM_solver.set_wing_param(self.__wing_param)
        F_list,F_list_grad = self.analysis_and_grad()
        return F_list,F_list_grad
    
    def analysis(self):
        print self.__wing_param
        self.__DLLM_solver.run_direct()
        self.__DLLM_solver.run_post()
        F_list = self.__DLLM_solver.get_F_list()
        if self.__out_format == 'list':
            F_list=F_list.tolist()
        self.__F_list = F_list
        return F_list
    
    def analysis_grad(self):
        print self.__wing_param
        self.__DLLM_solver.run_direct()
        self.__DLLM_solver.run_post()
        self.__DLLM_solver.run_adjoint()
        F_list_grad=self.__DLLM_solver.get_dF_list_dchi()
        if self.__grad_format == 'numpy':
            F_list_grad=numpy.array(F_list_grad)
        self.__F_list_grad = F_list_grad
        return F_list_grad
    
    def analysis_and_grad(self):
        print self.__wing_param
        self.__DLLM_solver.run_direct()
        self.__DLLM_solver.run_post()
        self.__DLLM_solver.run_adjoint()
        F_list = self.__DLLM_solver.get_F_list()
        F_list_grad=self.__DLLM_solver.get_dF_list_dchi()
        if self.__out_format == 'list':
            F_list=F_list.tolist()
        if self.__grad_format == 'numpy':
            F_list_grad=numpy.array(F_list_grad)
        self.__F_list = F_list
        self.__F_list_grad = F_list_grad
        return F_list,F_list_grad
    
    def export_results(self):
        fid=open(self.__tag+'.res.dat','w')
        res=[self.__F_list,self.__F_list_grad]
        cPickle.dump(res, fid)
        fid.close()
        
    def import_results(self):
        fid=open(self.__tag+'.res.dat','r')
        res=cPickle.load(fid)
        fid.close()
        self.__F_list=res[0]
        self.__F_list_grad=res[1]
        
    #-- Private methods
    def __config_OC(self):
        self.__OC = OperatingCondition(self.__tag+'.OC')
        self.__OC.config_from_dict(self.__config_dict)
        
    def __config_param(self):
        input_keys=self.__config_dict.keys()
        
        geom_type_key=self.__tag+'.param.geom_type'
        if geom_type_key in input_keys:
            geom_type = self.__config_dict[geom_type_key]
        else:
            geom_type= 'Broken'
            
        n_sect_key=self.__tag+'.param.n_sect'
        if n_sect_key in input_keys:
            n_sect = self.__config_dict[n_sect_key]
        else:
            n_sect = 20
            
        self.__wing_param = Wing_param(self.__tag+'.param',geom_type=geom_type,n_sect=n_sect)
        self.__wing_param.set_AoA_id(self.__AoA_id)
        self.__wing_param.config_from_dict(self.__OC, self.__config_dict)
        
    def __config_DLLM(self):
        WARNING_MSG=self.WARNING_MSG+'__config_DLLM: '
        input_keys=self.__config_dict.keys()
        type_key = self.__tag+'.DLLM.type'
        type = self.__config_dict[type_key]
        
        if type not in self.POS_SOLVER:
            print WARNING_MSG+'solver_type = '+str(type)+' not in '+str(self.POS_SOLVER)+'. Set to default solver_type = Solver'
            type='Solver'
            
        if   type == 'Solver':
            self.__DLLM_solver = DLLMSolver(self.__tag,self.__wing_param,self.__OC)          
        elif type == 'TargetCl':
            self.__DLLM_solver = DLLMTargetCl(self.__tag,self.__wing_param,self.__OC)
            target_Cl_key = self.__tag+'.DLLM.target_Cl'
            target_Cl = self.__config_dict[target_Cl_key]
            self.__DLLM_solver.set_target_Cl(target_Cl)
        elif type == 'TargetLift':
            self.__DLLM_solver = DLLMTargetLift(self.__tag,self.__wing_param,self.__OC)
            target_Lift_key = self.__tag+'.DLLM.target_Lift'
            target_Lift = self.__config_dict[target_Lift_key]
            self.__DLLM_solver.set_target_Lift(target_Lift)
        
        method_key = self.__tag+'.DLLM.method'
        if method_key in input_keys:
            method = self.__config_dict[method_key]
            self.__DLLM_solver.set_method(method)  
            
        relax_factor_key = self.__tag+'.DLLM.relax_factor'
        if relax_factor_key in input_keys:
            relax_factor = self.__config_dict[relax_factor_key]
            self.__DLLM_solver.set_relax_factor(relax_factor)
        
        stop_residual_key = self.__tag+'.DLLM.stop_residual'
        if stop_residual_key in input_keys:
            stop_residual = self.__config_dict[stop_residual_key]
            self.__DLLM_solver.set_stop_residual(stop_residual)
        
        max_iterations_key = self.__tag+'.DLLM.max_iterations'
        if max_iterations_key in input_keys:
            max_iterations = self.__config_dict[max_iterations_key]
            self.__DLLM_solver.set_max_iterations(max_iterations)
        
        gamma_file_name_key = self.__tag+'.DLLM.gamma_file_name'
        if gamma_file_name_key in input_keys:
            gamma_file_name = self.__config_dict[gamma_file_name_key]
            self.__DLLM_solver.set_gamma_file_name(gamma_file_name)
            
        F_list_names_key = self.__tag+'.DLLM.F_list_names'
        if F_list_names_key in input_keys:
            F_list_names = self.__config_dict[F_list_names_key]
            self.__DLLM_solver.set_F_list_names(F_list_names)
                
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
# 
#  http://github.com/TBD
#
from DLLM.DLLMGeom.wing_param import Wing_param
from MDOTools.OC.operating_condition import OperatingCondition
import numpy
import string

OC=OperatingCondition('cond1')

OC.set_altitude(3000.)
OC.set_T0_deg(15.)
OC.set_P0(101325.)
OC.set_humidity(0.)

nsect=50

wing_param=Wing_param('test_param',geom_type='Elliptic',n_sect=nsect)
wing_param.set_distrib_type('cos_law')
wing_param.build_wing()
wing_param.set_value('span',40.)
wing_param.set_value('root_chord',4.)
wing_param.set_value('root_height',0.0)
wing_param.set_value('tip_height',0.0)
Esempio n. 6
0
class DLLMWrapper():
    ERROR_MSG = 'ERROR in DLLMWrapper.'
    WARNING_MSG = 'WARNING in DLLMWrapper.'
    POS_SOLVER = ['Solver','TargetCl','TargetLift']
    POS_FMT = ['list','numpy']

    def __init__(self, tag):
        """
        Wrapper for the DLLM solver
        """
        self.__tag          = tag

        self.__OC           = None # Operating condition
        self.__wing_param   = None # Wing_param class
        self.__DLLM_solver  = None # DLLM Solver class
        
        self.__config_dict  = None
        
        self.__out_format   = 'list'
        self.__grad_format  = 'list'
        
        self.__AoA_id       = 'AoA'
        
        self.__F_list       = None
        self.__F_list_grad  = None
        
    #-- Accessors
    def get_OC(self):
        return self.__OC
    
    def get_wing_param(self):
        return self.__wing_param
    
    def get_DLLM_solver(self):
        return self.__DLLM_solver
    
    def get_tags_x0_and_bounds(self):
        tags=self.__wing_param.get_dv_id_list()
        x0=self.__wing_param.get_dv_array()
        bounds=self.__wing_param.get_bounds_array()
        return tags,x0,bounds
    
    def get_x0_and_bounds(self):
        x0=self.__wing_param.get_dv_array()
        bounds=self.__wing_param.get_bounds_array()
        return x0,bounds
    
    def get_x0(self):
        return self.get_x()
    
    def get_x(self):
        x=self.__wing_param.get_dv_array()
        return x
    
    def get_F_list_names(self):
        return self.__DLLM_solver.get_F_list_names()
    
    def get_F_list(self):
        return self.__F_list
    
    def get_F_list_grad(self):
        return self.__F_list_grad
    
    def get_F_list_and_grad(self):
        return self.__F_list, self.__F_list_grad
        
    #-- Setters
    def set_AoA_id(self, AoA_id):
        self.__AoA_id = AoA_id
        
    def set_out_format(self, format):
        WARNING_MSG=self.WARNING_MSG+'set_out_format: '
        if format not in self.POS_FMT:
            print WARNING_MSG+'format = '+str(format)+' not in '+str(self.POS_FMT)+'. Set to default out format = list'
            format='list'
        self.__out_format = format
    
    def set_grad_format(self, format):
        WARNING_MSG=self.WARNING_MSG+'set_grad_format: '
        if format not in self.POS_FMT:
            print WARNING_MSG+'format = '+str(format)+' not in '+str(self.POS_FMT)+'. Set to default grad format = list'
            format='list'
        self.__grad_format = format
    
    #-- Public methods
    def configure(self, config_dict):
        self.__config_dict = config_dict
        self.__config_OC()
        self.__config_param()
        self.__config_DLLM()
        
    def run(self, x):
        self.__wing_param.update_from_x_list(x)
        self.__DLLM_solver.set_wing_param(self.__wing_param)
        F_list=self.analysis()
        return F_list
    
    def run_grad(self, x):
        self.__wing_param.update_from_x_list(x)
        self.__DLLM_solver.set_wing_param(self.__wing_param)
        F_list_grad=self.analysis_grad()
        return F_list_grad
    
    def run_and_grad(self, x):
        self.__wing_param.update_from_x_list(x)
        self.__DLLM_solver.set_wing_param(self.__wing_param)
        F_list,F_list_grad = self.analysis_and_grad()
        return F_list,F_list_grad
    
    def analysis(self):
        print self.__wing_param
        self.__DLLM_solver.run_direct()
        self.__DLLM_solver.run_post()
        F_list = self.__DLLM_solver.get_F_list()
        if self.__out_format == 'list':
            F_list=F_list.tolist()
        self.__F_list = F_list
        return F_list
    
    def analysis_grad(self):
        print self.__wing_param
        self.__DLLM_solver.run_direct()
        self.__DLLM_solver.run_post()
        self.__DLLM_solver.run_adjoint()
        F_list_grad=self.__DLLM_solver.get_dF_list_dchi()
        if self.__grad_format == 'numpy':
            F_list_grad=numpy.array(F_list_grad)
        self.__F_list_grad = F_list_grad
        return F_list_grad
    
    def analysis_and_grad(self):
        print self.__wing_param
        self.__DLLM_solver.run_direct()
        self.__DLLM_solver.run_post()
        self.__DLLM_solver.run_adjoint()
        F_list = self.__DLLM_solver.get_F_list()
        F_list_grad=self.__DLLM_solver.get_dF_list_dchi()
        if self.__out_format == 'list':
            F_list=F_list.tolist()
        if self.__grad_format == 'numpy':
            F_list_grad=numpy.array(F_list_grad)
        self.__F_list = F_list
        self.__F_list_grad = F_list_grad
        return F_list,F_list_grad
    
    def export_results(self):
        fid=open(self.__tag+'.res.dat','w')
        res=[self.__F_list,self.__F_list_grad]
        cPickle.dump(res, fid)
        fid.close()
        
    def import_results(self):
        fid=open(self.__tag+'.res.dat','r')
        res=cPickle.load(fid)
        fid.close()
        self.__F_list=res[0]
        self.__F_list_grad=res[1]
        
    #-- Private methods
    def __config_OC(self):
        self.__OC = OperatingCondition(self.__tag+'.OC')
        self.__OC.config_from_dict(self.__config_dict)
        
    def __config_param(self):
        input_keys=self.__config_dict.keys()
        
        geom_type_key=self.__tag+'.param.geom_type'
        if geom_type_key in input_keys:
            geom_type = self.__config_dict[geom_type_key]
        else:
            geom_type= 'Broken'
            
        n_sect_key=self.__tag+'.param.n_sect'
        if n_sect_key in input_keys:
            n_sect = self.__config_dict[n_sect_key]
        else:
            n_sect = 20
            
        self.__wing_param = Wing_param(self.__tag+'.param',geom_type=geom_type,n_sect=n_sect)
        self.__wing_param.set_AoA_id(self.__AoA_id)
        self.__wing_param.config_from_dict(self.__OC, self.__config_dict)
        
    def __config_DLLM(self):
        WARNING_MSG=self.WARNING_MSG+'__config_DLLM: '
        input_keys=self.__config_dict.keys()
        type_key = self.__tag+'.DLLM.type'
        type = self.__config_dict[type_key]
        
        if type not in self.POS_SOLVER:
            print WARNING_MSG+'solver_type = '+str(solve_type)+' not in '+str(self.POS_SOLVER)+'. Set to default solver_type = Solver'
            type='Solver'
            
        if   type == 'Solver':
            self.__DLLM_solver = DLLMSolver(self.__tag,self.__wing_param,self.__OC)          
        elif type == 'TargetCl':
            self.__DLLM_solver = DLLMTargetCl(self.__tag,self.__wing_param,self.__OC)
            target_Cl_key = self.__tag+'.DLLM.target_Cl'
            target_Cl = self.__config_dict[target_Cl_key]
            self.__DLLM_solver.set_target_Cl(target_Cl)
        elif type == 'TargetLift':
            self.__DLLM_solver = DLLMTargetLift(self.__tag,self.__wing_param,self.__OC)
            target_Lift_key = self.__tag+'.DLLM.target_Lift'
            target_Lift = self.__config_dict[target_Lift_key]
            self.__DLLM_solver.set_target_Lift(target_Lift)
        
        method_key = self.__tag+'.DLLM.method'
        if method_key in input_keys:
            method = self.__config_dict[method_key]
            self.__DLLM_solver.set_method(method)  
            
        relax_factor_key = self.__tag+'.DLLM.relax_factor'
        if relax_factor_key in input_keys:
            relax_factor = self.__config_dict[relax_factor_key]
            self.__DLLM_solver.set_relax_factor(relax_factor)
        
        stop_residual_key = self.__tag+'.DLLM.stop_residual'
        if stop_residual_key in input_keys:
            stop_residual = self.__config_dict[stop_residual_key]
            self.__DLLM_solver.set_stop_residual(stop_residual)
        
        max_iterations_key = self.__tag+'.DLLM.max_iterations'
        if max_iterations_key in input_keys:
            max_iterations = self.__config_dict[max_iterations_key]
            self.__DLLM_solver.set_max_iterations(max_iterations)
        
        gamma_file_name_key = self.__tag+'.DLLM.gamma_file_name'
        if gamma_file_name_key in input_keys:
            gamma_file_name = self.__config_dict[gamma_file_name_key]
            self.__DLLM_solver.set_gamma_file_name(gamma_file_name)
            
        F_list_names_key = self.__tag+'.DLLM.F_list_names'
        if F_list_names_key in input_keys:
            F_list_names = self.__config_dict[F_list_names_key]
            self.__DLLM_solver.set_F_list_names(F_list_names)
                
Esempio n. 7
0
    def __init_wing_param(self):
        OC = OperatingCondition('cond1')
        OC.set_Mach(0.7)
        OC.set_AoA(3.0)
        OC.set_altitude(5000.)
        OC.set_T0_deg(20.)
        OC.set_P0(101325.)
        OC.set_humidity(0.)
        OC.compute_atmosphere()

        wing_param = Wing_param('test_param', geom_type='Broken', n_sect=20)
        wing_param.build_wing()
        wing_param.set_value('span', 34.1)
        wing_param.set_value('sweep', 32.)
        wing_param.set_value('break_percent', 33.)
        wing_param.set_value('root_chord', 6.1)
        wing_param.set_value('break_chord', 4.6)
        wing_param.set_value('tip_chord', 1.5)
        wing_param.set_value('root_height', 1.28)
        wing_param.set_value('break_height', 0.97)
        wing_param.set_value('tip_height', 0.33)
        wing_param.convert_to_design_variable('span', (10., 50.))
        wing_param.convert_to_design_variable('sweep', (0., 40.))
        wing_param.convert_to_design_variable('break_percent', (20., 40.))
        wing_param.convert_to_design_variable('root_chord', (5., 7.))
        wing_param.convert_to_design_variable('break_chord', (3., 5.))
        wing_param.convert_to_design_variable('tip_chord', (1., 2.))
        wing_param.convert_to_design_variable('root_height', (1., 1.5))
        wing_param.convert_to_design_variable('break_height', (0.8, 1.2))
        wing_param.convert_to_design_variable('tip_height', (0.2, 0.5))
        wing_param.build_linear_airfoil(OC,
                                        AoA0=-2.,
                                        Cm0=-0.1,
                                        set_as_ref=True)
        wing_param.build_airfoils_from_ref()
        wing_param.update()

        return wing_param
 def __init_wing_param(self):
     OC=OperatingCondition('cond1')
     OC.set_Mach(0.8)
     OC.set_AoA(3.5)
     OC.set_altitude(10000.)
     OC.set_T0_deg(15.)
     OC.set_P0(101325.)
     OC.set_humidity(0.)
     OC.compute_atmosphere()
     
     wing_param=Wing_Broken('broken_wing',n_sect=20)
     wing_param.import_BC_from_file('input_parameters.par')
     wing_param.build_linear_airfoil(OC, AoA0=0.0, set_as_ref=True)
     wing_param.build_airfoils_from_ref()
     wing_param.update()
     
     return OC,wing_param
Esempio n. 9
0
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
#  http://github.com/TBD
#
from DLLM.DLLMGeom.wing_param import Wing_param
from DLLM.DLLMKernel.DLLMSolver import DLLMSolver
from MDOTools.ValidGrad.FDValidGrad import FDValidGrad
from MDOTools.OC.operating_condition import OperatingCondition
import numpy

OC = OperatingCondition('cond1')
OC.set_Mach(0.6)  #.7
OC.set_AoA(6.0)  #3.
OC.set_altitude(10000.)  #5000
OC.set_T0_deg(20.)
OC.set_P0(101325.)
OC.set_humidity(0.)
OC.compute_atmosphere()

wing_param = Wing_param('test_param', geom_type='Broken', n_sect=20)
wing_param.build_wing()
wing_param.set_value('span', 34.1)
wing_param.set_value('sweep', 32.)  #32.
wing_param.set_value('break_percent', 33.)
wing_param.set_value('root_chord', 5.4)  #6.1
wing_param.set_value('break_chord', 4.6)  #4.6
Esempio n. 10
0
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
#  http://github.com/TBD
#
from DLLM.DLLMGeom.wing_param import Wing_param
from MDOTools.OC.operating_condition import OperatingCondition
import numpy
import string

OC = OperatingCondition('cond1', atmospheric_model='simple')

OC.set_altitude(10000.)
OC.set_T0_deg(15.)
OC.set_P0(101325.)
OC.set_humidity(0.)

wing_param = Wing_param('test_param', geom_type='Broken', n_sect=20)
wing_param.build_wing()
wing_param.set_value('span', 2.392)
#wing_param.set_value('sweep',34.)
wing_param.set_value('sweep', 26.7)
wing_param.set_value('break_percent', 33.)
wing_param.set_value('root_chord', 0.806)
wing_param.set_value('break_chord', 0.689)
wing_param.set_value('tip_chord', 0.451)
Esempio n. 11
0
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
# 
#  http://github.com/TBD
#
from DLLM.DLLMGeom.wing_param import Wing_param
from DLLM.DLLMKernel.DLLMSolver import DLLMSolver
from MDOTools.ValidGrad.FDValidGrad import FDValidGrad
from MDOTools.OC.operating_condition import OperatingCondition
import numpy

OC=OperatingCondition('cond1')
OC.set_Mach(0.6) #.7
OC.set_AoA(6.0) #3.
OC.set_altitude(10000.) #5000
OC.set_T0_deg(20.)
OC.set_P0(101325.)
OC.set_humidity(0.)
OC.compute_atmosphere()

wing_param=Wing_param('test_param',geom_type='Broken',n_sect=20)
wing_param.build_wing()
wing_param.set_value('span',34.1)
wing_param.set_value('sweep',32.) #32.
wing_param.set_value('break_percent',33.)
wing_param.set_value('root_chord',5.4)#6.1
wing_param.set_value('break_chord',4.6)#4.6
Esempio n. 12
0
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
# 
#  http://github.com/TBD
#
from MDOTools.ValidGrad.FDValidGrad import FDValidGrad
from DLLM.DLLMGeom.wing_param import Wing_param
from MDOTools.OC.operating_condition import OperatingCondition

OC=OperatingCondition('cond1')
OC.set_Mach(0.7)
OC.set_AoA(3.0)
OC.set_altitude(5000.)
OC.set_T0_deg(20.)
OC.set_P0(101325.)
OC.set_humidity(0.)
OC.compute_atmosphere()

wing_param=Wing_param('test_param',geom_type='Broken',n_sect=20)
wing_param.build_wing()
wing_param.set_value('span',34.1)
wing_param.set_value('sweep',32.)
wing_param.set_value('break_percent',33.)
wing_param.set_value('root_chord',6.1)
wing_param.set_value('break_chord',4.6)
Esempio n. 13
0
import numpy as np
from DLLM.polarManager.RefCTAAirfoil import RefCTAAirfoil
from MDOTools.OC.operating_condition import OperatingCondition

#Mach = 0.79
#Cl = 0.21
#Altitude 35000 ft 

OC=OperatingCondition('Cond_RefCTA',atmospheric_model='ISA')
OC.set_Mach(0.79)
OC.set_AoA(3.5)
OC.set_altitude_feet(35000.)
OC.set_T0_deg(15.)
OC.set_P0(101325.)
OC.set_humidity(0.)
OC.compute_atmosphere()

print OC

RefCTA_AF = RefCTAAirfoil(OC)
RefCTA_AF.set_y_def_list([0.,1.520, 3.800, 6.080, 9.120, 12.160, 15.200, 18.240, 19.000])
RefCTA_AF.set_file_def_list(['section0.dat','section1.dat','section2.dat','section3.dat','section4.dat','section5.dat','section6.dat','section7.dat','section8.dat'])

RefCTA_AF.init_interpolators()
RefCTA_AF.set_y_pos(-5.1)
RefCTA_AF.init_interp_factors()
AoA = 2.*np.pi/180.
RefCTA_AF.compute(AoA, 0.79)
Esempio n. 14
0
class DLLMWrapper():
    ERROR_MSG = 'ERROR in DLLMWrapper.'
    WARNING_MSG = 'WARNING in DLLMWrapper.'
    POS_SOLVER = ['Solver','TargetCl','TargetLift']
    POS_FMT = ['list','numpy']

    def __init__(self, tag, verbose=1):
        """
        Wrapper for the DLLM solver
        """
        self.__tag          = tag

        self.__verbose      = verbose
        self.__OC           = None # Operating condition
        self.__wing_param   = None # Wing_param class
        self.__DLLM_solver  = None # DLLM Solver class
        
        self.__config_dict  = None
        
        self.__out_format   = 'list'
        self.__grad_format  = 'list'
        
        self.__AoA_id       = 'AoA'
        
        self.__F_list       = None
        self.__F_list_grad  = None
        
    #-- Accessors
    def get_OC(self):
        return self.__OC
    
    def get_wing_param(self):
        return self.__wing_param
    
    def get_DLLM_solver(self):
        return self.__DLLM_solver
    
    def get_tags_x0_and_bounds(self):
        tags=self.__wing_param.get_dv_id_list()
        x0=self.__wing_param.get_dv_array()
        bounds=self.__wing_param.get_bounds_array()
        return tags,x0,bounds
    
    def get_x0_and_bounds(self):
        x0=self.__wing_param.get_dv_array()
        bounds=self.__wing_param.get_bounds_array()
        return x0,bounds
    
    def get_x0(self):
        return self.get_x()
    
    def get_x(self):
        x=self.__wing_param.get_dv_array()
        return x
    
    def get_F_list_names(self):
        return self.__DLLM_solver.get_F_list_names()
    
    def get_F_list(self):
        return self.__F_list
    
    def get_F_list_grad(self):
        return self.__F_list_grad
    
    def get_F_list_and_grad(self):
        return self.__F_list, self.__F_list_grad
    
    def get_F_value(self, F_id):
        index = self.get_F_list_names().index(F_id)
        return self.get_F_list()[index]
        
    #-- Setters
    def set_AoA_id(self, AoA_id):
        self.__AoA_id = AoA_id
        
    def set_out_format(self, format):
        WARNING_MSG=self.WARNING_MSG+'set_out_format: '
        if format not in self.POS_FMT:
            print WARNING_MSG+'format = '+str(format)+' not in '+str(self.POS_FMT)+'. Set to default out format = list'
            format='list'
        self.__out_format = format
    
    def set_grad_format(self, format):
        WARNING_MSG=self.WARNING_MSG+'set_grad_format: '
        if format not in self.POS_FMT:
            print WARNING_MSG+'format = '+str(format)+' not in '+str(self.POS_FMT)+'. Set to default grad format = list'
            format='list'
        self.__grad_format = format
    
    #-- Public methods
    def config_from_file(self, filename):
        # Open file
        f    = open(filename, "r")
            
        # Load input file into data dictionary
        config_dict = json.loads(f.read())
        
        # Close input file
        f.close()
        
        self.configure(config_dict)
        
    def configure(self, config_dict):
        self.__config_dict = config_dict
        self.__config_OC()
        self.__config_param()
        self.__config_DLLM()
        
    def run(self, x):
        self.__wing_param.update_from_x_list(x)
        self.__DLLM_solver.set_geom(self.__wing_param)
        F_list=self.analysis()
        return F_list
    
    def run_grad(self, x):
        self.__wing_param.update_from_x_list(x)
        self.__DLLM_solver.set_geom(self.__wing_param)
        F_list_grad=self.analysis_grad()
        return F_list_grad
    
    def run_and_grad(self, x):
        self.__wing_param.update_from_x_list(x)
        self.__DLLM_solver.set_geom(self.__wing_param)
        F_list,F_list_grad = self.analysis_and_grad()
        return F_list,F_list_grad
    
    def analysis(self):
        if self.__verbose > 0:
            print self.__wing_param
        self.__DLLM_solver.run_direct()
        self.__DLLM_solver.run_post()
        F_list = self.__DLLM_solver.get_F_list()
        self.__DLLM_solver.export_F_list()
        if self.__out_format == 'list':
            F_list=F_list.tolist()
        self.__F_list = F_list
        return F_list
    
    def analysis_grad(self):
        if self.__verbose > 0:
            print self.__wing_param
        self.__DLLM_solver.run_direct()
        self.__DLLM_solver.run_post()
        self.__DLLM_solver.run_adjoint()
        F_list_grad=self.__DLLM_solver.get_dF_list_dchi()
        self.__DLLM_solver.export_dF_list_dchi()
        if self.__grad_format == 'numpy':
            F_list_grad=numpy.array(F_list_grad)
        self.__F_list_grad = F_list_grad
        return F_list_grad
    
    def analysis_and_grad(self):
        if self.__verbose > 0:
            print self.__wing_param
        self.__DLLM_solver.run_direct()
        self.__DLLM_solver.run_post()
        self.__DLLM_solver.run_adjoint()
        F_list = self.__DLLM_solver.get_F_list()
        F_list_grad=self.__DLLM_solver.get_dF_list_dchi()
        self.__DLLM_solver.export_F_list()
        self.__DLLM_solver.export_dF_list_dchi()
        if self.__out_format == 'list':
            F_list=F_list.tolist()
        if self.__grad_format == 'numpy':
            F_list_grad=numpy.array(F_list_grad)
        self.__F_list = F_list
        self.__F_list_grad = F_list_grad
        return F_list,F_list_grad
    
    def export_results(self):
        fid=open(self.__tag+'.res.dat','w')
        res=[self.__F_list,self.__F_list_grad]
        cPickle.dump(res, fid)
        fid.close()
        
    def import_results(self):
        fid=open(self.__tag+'.res.dat','r')
        res=cPickle.load(fid)
        fid.close()
        self.__F_list=res[0]
        self.__F_list_grad=res[1]
        
    #-- Private methods
    def __config_OC(self):
        """
        Set up the 
        """
        self.__OC = OperatingCondition(self.__tag+'.OC')
        self.__OC.config_from_dict(self.__config_dict)
        
    def __config_param(self):
        """
        Set up the __wing_param attribute.
        -The class associated to __wing_param depends on the chosen parameterization type
        -The method needs to be updated if a new parameterization is implemented
        """
        input_keys=self.__config_dict.keys()
        
        geom_type_key=self.__tag+'.param.geom_type'
        if geom_type_key in input_keys:
            geom_type = self.__config_dict[geom_type_key]
        else:
            geom_type= 'Broken'
            
        n_sect_key=self.__tag+'.param.n_sect'
        if n_sect_key in input_keys:
            n_sect = self.__config_dict[n_sect_key]
        else:
            n_sect = 20
        
        if   geom_type == 'Broken':
            self.__wing_param = Wing_Broken(self.__tag+'.param', n_sect=n_sect)
        elif geom_type == 'Elliptic':
            self.__wing_param = Wing_Elliptic(self.__tag+'.param', n_sect=n_sect)
        elif geom_type == 'Straight':
            self.__wing_param = Wing_Straight(self.__tag+'.param', n_sect=n_sect)
            
        self.__wing_param.set_AoA_id(self.__AoA_id)
        self.__wing_param.set_common_OC(self.__OC)
        self.__wing_param.config_from_dict(self.__config_dict)
        
    def __config_DLLM(self):
        ERROR_MSG=self.ERROR_MSG+'__config_DLLM: '
        input_keys=self.__config_dict.keys()
        type_key = self.__tag+'.DLLM.type'
        stype = self.__config_dict[type_key]
        
        if stype not in self.POS_SOLVER:
            raise Exception,ERROR_MSG+'solver_type = '+str(type)+' not in '+str(self.POS_SOLVER)+'. Set to default solver_type = '+str(type)

        if self.__verbose > 0:
            print 'Solver type = ',stype            
        if   stype == 'Solver':
            self.__DLLM_solver = DLLMSolver(self.__tag,self.__wing_param,self.__OC)          
        elif stype == 'TargetCl':
            self.__DLLM_solver = DLLMTargetCl(self.__tag,self.__wing_param,self.__OC)
            target_Cl_key = self.__tag+'.DLLM.target_Cl'
            target_Cl = self.__config_dict[target_Cl_key]
            self.__DLLM_solver.set_target_Cl(target_Cl)
        elif stype == 'TargetLift':
            self.__DLLM_solver = DLLMTargetLift(self.__tag,self.__wing_param,self.__OC)
            target_Lift_key = self.__tag+'.DLLM.target_Lift'
            target_Lift = self.__config_dict[target_Lift_key]
            self.__DLLM_solver.set_target_Lift(target_Lift)
        
        method_key = self.__tag+'.DLLM.method'
        if method_key in input_keys:
            method = self.__config_dict[method_key]
            self.__DLLM_solver.set_method(method)  
            
        relax_factor_key = self.__tag+'.DLLM.relax_factor'
        if relax_factor_key in input_keys:
            relax_factor = self.__config_dict[relax_factor_key]
            self.__DLLM_solver.set_relax_factor(relax_factor)
        
        stop_residual_key = self.__tag+'.DLLM.stop_residual'
        if stop_residual_key in input_keys:
            stop_residual = self.__config_dict[stop_residual_key]
            self.__DLLM_solver.set_stop_residual(stop_residual)
        
        max_iterations_key = self.__tag+'.DLLM.max_iterations'
        if max_iterations_key in input_keys:
            max_iterations = self.__config_dict[max_iterations_key]
            self.__DLLM_solver.set_max_iterations(max_iterations)
        
        gamma_file_name_key = self.__tag+'.DLLM.gamma_file_name'
        if gamma_file_name_key in input_keys:
            gamma_file_name = self.__config_dict[gamma_file_name_key]
            self.__DLLM_solver.set_gamma_file_name(gamma_file_name)
            
        F_list_names_key = self.__tag+'.DLLM.F_list_names'
        if F_list_names_key in input_keys:
            F_list_names = self.__config_dict[F_list_names_key]
            self.__DLLM_solver.set_F_list_names(F_list_names)
                
Esempio n. 15
0
 def __config_OC(self):
     """
     Set up the 
     """
     self.__OC = OperatingCondition(self.__tag+'.OC')
     self.__OC.config_from_dict(self.__config_dict)
Esempio n. 16
0
 def __init_OC(self):
     OC=OperatingCondition('cond1')
     OC.set_Mach(0.7)
     OC.set_AoA(3.0)
     OC.set_altitude(5000.)
     OC.set_T0_deg(20.)
     OC.set_P0(101325.)
     OC.set_humidity(0.)
     OC.compute_atmosphere()
     return OC
Esempio n. 17
0
 def __init_wing_param(self):
     OC=OperatingCondition('cond1')
     OC.set_Mach(0.7)
     OC.set_AoA(3.0)
     OC.set_altitude(5000.)
     OC.set_T0_deg(20.)
     OC.set_P0(101325.)
     OC.set_humidity(0.)
     OC.compute_atmosphere()
     
     wing_param=Wing_param('test_param',geom_type='Broken',n_sect=20)
     wing_param.build_wing()
     wing_param.set_value('span',34.1)
     wing_param.set_value('sweep',32.)
     wing_param.set_value('break_percent',33.)
     wing_param.set_value('root_chord',6.1)
     wing_param.set_value('break_chord',4.6)
     wing_param.set_value('tip_chord',1.5)
     wing_param.set_value('root_height',1.28)
     wing_param.set_value('break_height',0.97)
     wing_param.set_value('tip_height',0.33)
     wing_param.convert_to_design_variable('span',(10.,50.))
     wing_param.convert_to_design_variable('sweep',(0.,40.))
     wing_param.convert_to_design_variable('break_percent',(20.,40.))
     wing_param.convert_to_design_variable('root_chord',(5.,7.))
     wing_param.convert_to_design_variable('break_chord',(3.,5.))
     wing_param.convert_to_design_variable('tip_chord',(1.,2.))
     wing_param.convert_to_design_variable('root_height',(1.,1.5))
     wing_param.convert_to_design_variable('break_height',(0.8,1.2))
     wing_param.convert_to_design_variable('tip_height',(0.2,0.5))
     wing_param.build_linear_airfoil(OC, AoA0=-2., Cm0=-0.1, set_as_ref=True)
     wing_param.build_airfoils_from_ref()
     wing_param.update()
     
     return wing_param
Esempio n. 18
0
class DLLMOpenMDAOComponent(Component):
    # set up interface to the framework
    # pylint: disable-msg=E1101
    # Outputs of lifting line problem
    """OpenMDAO component for DLLM implementation
    """
    
    Lift = Float(iotype='out', desc='Lift')
    Drag = Float(iotype='out', desc='Drag')
    Drag_Pressure = Float(iotype='out', desc='Drag_Pressure')
    Drag_Induced = Float(iotype='out', desc='Drag_Induced')
    Drag_Wave = Float(iotype='out', desc='Drag_Wave')
    Drag_Friction = Float(iotype='out', desc='Drag_Friction')
    Cd = Float(iotype='out', desc='Cd')
    Cdp = Float(iotype='out', desc='Cdp')
    Cdi = Float(iotype='out', desc='Cdi')
    Cdw = Float(iotype='out', desc='Cdw')
    Cdf = Float(iotype='out', desc='Cdf')
    Cl = Float(iotype='out', desc='Cl')
    LoD = Float(iotype='out', desc='LoD')
    Sref = Float(iotype='out', desc='Sref')

    # Design variables of lifting line problem
    rtwist = Array([], desc='rtwist', iotype="in")
    span = Float(desc='span', default_value=34., iotype="in")
    sweep = Float(desc='sweep', default_value=34., iotype="in")
    break_percent = Float(desc='break_percent', default_value=33., iotype="in")
    root_chord = Float(desc='root_chord', default_value=6.1, iotype="in")
    break_chord = Float(desc='break_chord', default_value=4.6, iotype="in")
    tip_chord = Float(desc='tip_chord', default_value=1.5, iotype="in")
    root_height = Float(desc='root_height', default_value=1.28, iotype="in")
    break_height = Float(desc='break_height', default_value=0.97, iotype="in")
    tip_height = Float(desc='tip_height', default_value=0.33, iotype="in")
    # Operating conditions variables
    Mach = Float(iotype='in', default_value=0.7, desc='Mach')
    altitude = Float(iotype='in', default_value=10000., desc='Altitude')
    T0 = Float(iotype='in',default_value=OperatingCondition.T0,
        desc='Ground ISA ref Temperature')
    P0 = Float(iotype='in',default_value=OperatingCondition.P0,
        desc='Ground ISA ref Pressure')

    def __init__(self,Target_Lift, N = 10, verbose=0):
        """Initialization of DLLM component.
        DLLM component use target lift capability of DLLM kernel
            @param Target_Lift : the targeted lift value (float)
            @param N : integer. Number of discrete section on 1/2 wing
            @param verbose : integer : verbosity level
        """
        try :
            float(Target_Lift)
        except:
            raise ValueError('You MUST define a float target lift value, get '+str(Target_Lift)+' instead.')

        self.Target_Lift = Target_Lift
        self.N = N
        self.OC = None
        self.rtwist = np.zeros(N)
        self.__display_wing_param = True
        self.__verbose = verbose
        self.__wing_param = None
        super(DLLMOpenMDAOComponent, self).__init__()        
        self.OC = OperatingCondition(tag='DLLMOC', atmospheric_model='ISA')
        self.__set_OC_values()
        self.__set_wing_param()
        self.__DLLM = DLLMTargetLift('test', self.__wing_param,
                                   self.OC, verbose=self.__verbose)
        self.__DLLM.set_target_Lift(Target_Lift)
        self.__DLLM.run_direct()
        self.__DLLM.run_post()

    def __set_wing_param(self, wing_param_name='test_param'):
        """Method for wing parameters setting : design variables initial values and bounds
        @param wing_param_name : wing parametrization names
        """
        self.__set_wing_param_values(wing_param_name=wing_param_name)

        self.__set_wing_param_bounds()
        self.__wing_param.build_linear_airfoil(self.OC, AoA0=-2., Cm0=-0.1, set_as_ref=True)
        self.__wing_param.build_airfoils_from_ref()
        self.__wing_param.update()

        if self.__display_wing_param:
            self.__display_wing_param = False
            print self.__wing_param

    def __set_wing_param_values(self, wing_param_name='test_param'):
        """Method for wing parameters variables setting
        @param wing_param_name : wing parametrization names
        """
        self.__wing_param = Wing_param(wing_param_name,
                                     geom_type='Broken', n_sect=self.N * 2)
        self.__wing_param.build_wing()
        for i in xrange(self.N):
            self.__wing_param.set_value('rtwist%s' % i, 0.)
        for param in Wing_param.DISCRETE_ATTRIBUTES_LIST:
            self.__wing_param.set_value(param, getattr(self, param))

    def __set_wing_param_bounds(self):
        """Method for desing variables bounds settings
        Values are set to inf/-inf in DLLM component and their 'real' bounds
        are defined when optimization problem is set
        """
        for i in xrange(self.N):
            self.__wing_param.convert_to_design_variable(
                'rtwist%s' % i, (-float('inf'), float('inf')))
        for param in Wing_param.DISCRETE_ATTRIBUTES_LIST:
            self.__wing_param.convert_to_design_variable(param, (-float('inf'), float('inf')))
        return

    def __set_OC_values(self):
        """ Set default operating conditions"""
        self.OC.set_Mach(self.Mach)
        self.OC.set_altitude(self.altitude)
        self.OC.set_T0(self.T0)
        self.OC.set_P0(self.P0)
        self.OC.set_humidity(0.)
        self.OC.compute_atmosphere()
    
    def __update_wing_parame_values(self):
        for dv_id in self.__wing_param.get_dv_id_list():
            if dv_id.startswith('rtwist'):
                i_twist = int(dv_id.replace('rtwist', ''))
                self.__wing_param.set_value(dv_id, self.rtwist[i_twist])
            else:
                self.__wing_param.set_value(dv_id,getattr(self,dv_id))
        self.__wing_param.build_linear_airfoil(self.OC, AoA0=-2., Cm0=-0.1, set_as_ref=True)
        self.__set_wing_param_bounds()
        self.__wing_param.build_airfoils_from_ref()
        self.__wing_param.update()
        return

    def execute(self):
        """ Perform a DLLM computation with the """
        self.__update_wing_parame_values()        
        self.__set_OC_values()
        self.__DLLM.set_target_Lift(self.Target_Lift)
        self.__DLLM.run_direct()
        self.__DLLM.run_post()
        output = self.__DLLM.get_F_list()
        for f, f_name in zip(output, self.__DLLM.get_F_list_names()):
            setattr(self, f_name, f)

    def list_deriv_vars(self):
        """specify the inputs and outputs where derivatives are defined
        Specific treatment for twist : defined as rtwist0, rtwist1,... in DLLM
        but as an array rtwist in openmdao component"""

        out_dvid = []
        for dv_id in self.__wing_param.get_dv_id_list():
            if dv_id.startswith('rtwist0'):
                out_dvid.append('rtwist')
            elif not dv_id.startswith('rtwist'):
                out_dvid.append(dv_id)
        return tuple(out_dvid), tuple(self.__DLLM.get_F_list_names())

    def provideJ(self):
        """Calculate the Jacobian according inputs and outputs"""
        self.__DLLM.run_adjoint()
        return np.array(self.__DLLM.get_dF_list_dchi())

    def get_F_list(self):
        return self.__DLLM.get_F_list()

    def get_F_list_names(self):
        return self.__DLLM.get_F_list_names()
    
    def get_dv_array(self):
        return self.__wing_param.get_dv_array()
    
    def get_dv_id_list(self):
        return self.__wing_param.get_dv_id_list()
    
    def get_dv_info_list(self):
        return self.__wing_param.get_dv_info_list()
    
    def get_dv_value(self,dv_id):
        return self.get_dv_array()[self.get_dv_id_list().index(dv_id)]
Esempio n. 19
0
 def __init_OC(self):
     OC = OperatingCondition('cond1')
     OC.set_Mach(0.7)
     OC.set_AoA(3.0)
     OC.set_altitude(5000.)
     OC.set_T0_deg(20.)
     OC.set_P0(101325.)
     OC.set_humidity(0.)
     OC.compute_atmosphere()
     return OC
Esempio n. 20
0
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
#  http://github.com/TBD
#
from MDOTools.ValidGrad.FDValidGrad import FDValidGrad
from DLLM.DLLMGeom.wing_param import Wing_param
from DLLM.DLLMKernel.DLLMSolver import DLLMSolver
from MDOTools.OC.operating_condition import OperatingCondition
import numpy

OC = OperatingCondition("cond1")
OC.set_Mach(0.8)
OC.set_AoA(3.5)
OC.set_altitude(10000.0)
OC.set_T0_deg(15.0)
OC.set_P0(101325.0)
OC.set_humidity(0.0)
OC.compute_atmosphere()

wing_param = Wing_param("test_param", geom_type="Broken", n_sect=20)
wing_param.build_wing()
wing_param.set_value("span", 34.1)
wing_param.set_value("sweep", 34.0)
wing_param.set_value("break_percent", 33.0)
wing_param.set_value("root_chord", 6.1)
wing_param.set_value("break_chord", 4.6)
Esempio n. 21
0
 def __config_OC(self):
     self.__OC = OperatingCondition(self.__tag+'.OC')
     self.__OC.config_from_dict(self.__config_dict)
Esempio n. 22
0
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
# 
#  http://github.com/TBD
#
from MDOTools.ValidGrad.FDValidGrad import FDValidGrad
from DLLM.DLLMGeom.wing_param import Wing_param
from DLLM.DLLMKernel.DLLMTargetCl import DLLMTargetCl
from MDOTools.OC.operating_condition import OperatingCondition
import numpy
import sys

OC=OperatingCondition('cond1')
OC.set_Mach(0.3)
OC.set_AoA(0.)
OC.set_altitude(3000.)
OC.set_T0_deg(15.)
OC.set_P0(101325.)
OC.set_humidity(0.)
OC.compute_atmosphere()

wing_param=Wing_param('test_param',geom_type='Broken',n_sect=20)
wing_param.build_wing()
wing_param.set_value('span',3.)
wing_param.set_value('sweep',30.)
wing_param.set_value('break_percent',33.)
wing_param.set_value('root_chord',1.0)
wing_param.set_value('break_chord',1.0)
Esempio n. 23
0
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
#  http://github.com/TBD
#
from MDOTools.ValidGrad.FDValidGrad import FDValidGrad
from DLLM.DLLMGeom.wing_param import Wing_param
from DLLM.DLLMKernel.DLLMSolver import DLLMSolver
from MDOTools.OC.operating_condition import OperatingCondition
import numpy

OC = OperatingCondition('cond1')
OC.set_Mach(0.8)
OC.set_AoA(3.5)
OC.set_altitude(10000.)
OC.set_T0_deg(15.)
OC.set_P0(101325.)
OC.set_humidity(0.)
OC.compute_atmosphere()

wing_param = Wing_param('test_param', geom_type='Broken', n_sect=20)
wing_param.build_wing()
wing_param.set_value('span', 34.1)
wing_param.set_value('sweep', 34.)
wing_param.set_value('break_percent', 33.)
wing_param.set_value('root_chord', 6.1)
wing_param.set_value('break_chord', 4.6)
Esempio n. 24
0
# -*-mode: python; py-indent-offset: 4; tab-width: 8; coding: iso-8859-1 -*-
#  MDOTools (Multi-disciplinary Optimization Tools, open source software)
# 
#  Copyright (C) 2013-2015 Airbus Group SAS
# 
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
# 
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
# 
#  http://github.com/TBD
#
#  @author : Matthieu Meaux

from MDOTools.OC.operating_condition import OperatingCondition

OC=OperatingCondition('cond_tuto1')
OC.plot_atmosphere()
Esempio n. 25
0
#  GNU General Public License for more details.
# 
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
# 
#  http://github.com/TBD
#
from DLLM.DLLMGeom.wing_param import Wing_param
from DLLM.DLLMKernel.DLLMTargetCl import DLLMTargetCl
from MDOTools.OC.operating_condition import OperatingCondition
from MDOTools.ValidGrad.FDValidGrad import FDValidGrad
import numpy
import sys

OC=OperatingCondition('cond1')
OC.set_Mach(0.3)
OC.set_AoA(0.)
OC.set_altitude(3000.)
OC.set_T0_deg(15.)
OC.set_P0(101325.)
OC.set_humidity(0.)
OC.compute_atmosphere()

wing_param=Wing_param('test_param',geom_type='Broken',n_sect=20)
wing_param.build_wing()
wing_param.set_value('span',40.)
wing_param.set_value('sweep',0.)
wing_param.set_value('break_percent',33.)
wing_param.set_value('root_chord',1.0)
wing_param.set_value('break_chord',1.0)
Esempio n. 26
0
    def __init_wing_param(self):
        OC = OperatingCondition('cond1')
        OC.set_Mach(0.8)
        OC.set_AoA(3.5)
        OC.set_altitude(10000.)
        OC.set_T0_deg(15.)
        OC.set_P0(101325.)
        OC.set_humidity(0.)
        OC.compute_atmosphere()

        wing_param = Wing_param('test_param', geom_type='Broken', n_sect=20)
        wing_param.build_wing()
        wing_param.set_value('span', 34.1)
        wing_param.set_value('sweep', 34.)
        wing_param.set_value('break_percent', 33.)
        wing_param.set_value('root_chord', 6.1)
        wing_param.set_value('break_chord', 4.6)
        wing_param.set_value('tip_chord', 1.5)
        wing_param.set_value('root_height', 1.28)
        wing_param.set_value('break_height', 0.97)
        wing_param.set_value('tip_height', 0.33)
        wing_param.convert_to_design_variable('span', (10., 50.))
        wing_param.convert_to_design_variable('sweep', (0., 40.))
        wing_param.convert_to_design_variable('break_percent', (20., 40.))
        wing_param.convert_to_design_variable('root_chord', (5., 7.))
        wing_param.convert_to_design_variable('break_chord', (3., 5.))
        wing_param.convert_to_design_variable('tip_chord', (1., 2.))
        wing_param.convert_to_design_variable('root_height', (1., 1.5))
        wing_param.convert_to_design_variable('break_height', (0.8, 1.2))
        wing_param.convert_to_design_variable('tip_height', (0.2, 0.5))
        wing_param.build_meta_airfoil(OC,
                                      '../examples/MetaModelFixed.xml',
                                      relative_thickness=.12,
                                      camber=0.,
                                      Sref=1.,
                                      Lref=1.,
                                      sweep=.0,
                                      set_as_ref=True)
        wing_param.build_airfoils_from_ref()
        wing_param.update()

        return OC, wing_param