コード例 #1
0
def PowerCurveParametricExample1():
    """ Example to run a set of FAST simulations to determine a power curve.
    In this example, the WS, RPM and Pitch are set within a for loop.
    If the controller and generator are active, these are just "initial conditions".
    Additional parameters may be set by adjusting the BaseDict.

    This script is based on a reference directory which contains a reference main input file (.fst)
    Everything is copied to a working directory.
    The different fast inputs are generated based on a list of dictionaries, named `PARAMS`.
    For each dictionary:
       - they keys are "path" to a input parameter, e.g. `EDFile|RotSpeed`  or `TMax`.
           These should correspond to whater name of the variable is used in the FAST inputs files.
       - they values are the values corresponding to this parameter
    """
    # --- Parameters for this script
    FAST_EXE  = os.path.join(MyDir, '../../../data/openfast.exe') # Location of a FAST exe (and dll)
    ref_dir   = os.path.join(MyDir, '../../../data/NREL5MW/')     # Folder where the fast input files are located (will be copied)
    main_file = 'Main_Onshore_OF2.fst'               # Main file in ref_dir, used as a template
    work_dir  = '_NREL5MW_PowerCurveParametric/'     # Output folder (will be created)

    # --- Defining the parametric study  (list of dictionnaries with keys as FAST parameters)
    WS    = [3,5,7,9 ,11,13,15]
    RPM   = [5,6,7,10,10,10,10] # initial conditions
    PITCH = [0,0,0,0 ,5 ,10,15] # initial conditions
    BaseDict = {'TMax': 100, 'DT': 0.01, 'DT_Out': 0.1}
    #BaseDict = case_gen.paramsNoController(BaseDict)
    #BaseDict = case_gen.paramsStiff(BaseDict)
    #BaseDict = case_gen.paramsNoGen(BaseDict)
    PARAMS=[]
    for wsp,rpm,pitch in zip(WS,RPM,PITCH): # NOTE: same length of WS and RPM otherwise do multiple for loops
        p=BaseDict.copy()
        p['EDFile|RotSpeed']       = rpm
        p['EDFile|BlPitch(1)']     = pitch
        p['EDFile|BlPitch(2)']     = pitch
        p['EDFile|BlPitch(3)']     = pitch
        p['InflowFile|HWindSpeed'] = wsp
        p['InflowFile|WindType']   = 1 # Setting steady wind
        p['__name__']              = 'ws{:04.1f}'.format(p['InflowFile|HWindSpeed'])
        PARAMS.append(p)

    # --- Generating all files in a workdir
    fastFiles=case_gen.templateReplace(PARAMS, ref_dir, work_dir, removeRefSubFiles=True, main_file=main_file)
    print(fastFiles)

    # --- Creating a batch script just in case
    runner.writeBatch(os.path.join(work_dir,'_RUN_ALL.bat'), fastFiles,fastExe=FAST_EXE)
    # --- Running the simulations
    print('>>> Running {} simulations in {} ...'.format(len(fastFiles), work_dir))
    runner.run_fastfiles(fastFiles, fastExe=FAST_EXE, parallel=True, showOutputs=False, nCores=2)

    # --- Simple Postprocessing
    outFiles = [os.path.splitext(f)[0]+'.outb' for f in fastFiles]

    avg_results = postpro.averagePostPro(outFiles,avgMethod='constantwindow',avgParam=10, ColMap = {'WS_[m/s]':'Wind1VelX_[m/s]'},ColSort='WS_[m/s]')
    print('>>> Average results:')
    print(avg_results)
    avg_results.to_csv('_PowerCurve1.csv',sep='\t',index=False)
コード例 #2
0
def main():
    # --- Main Parameters
    ref_dir = os.path.join(
        MyDir, '../../../data/NREL5MW/'
    )  # Folder where the fast input files are located (will be copied)
    FAST_EXE = os.path.join(
        MyDir,
        '../../../data/openfast.exe')  # Location of a FAST exe (and dll)
    main_file = 'Main_Onshore_OF2.fst'  # Main file in ref_dir, used as a template
    work_dir = '_NREL5MW_ParametricExcel/'  # Output folder (will be created)
    parametricFile = 'ParametricExcel.xlsx'  # Excel file containing set of parameters

    # --- Reading Excel file, converting it to a list of dictionaries, and generate input files
    dfs = io.excel_file.ExcelFile(parametricFile).toDataFrame()
    df = dfs[list(dfs.keys())[0]]
    PARAMS = df.to_dict('records')
    print(df)
    fastFiles = case_gen.templateReplace(PARAMS,
                                         ref_dir,
                                         outputDir=work_dir,
                                         removeRefSubFiles=True,
                                         removeAllowed=False,
                                         main_file=main_file)

    # --- Running fast simulations
    print('>>> Running {} simulations in {} ...'.format(
        len(fastFiles), work_dir))
    runner.writeBatch(os.path.join(work_dir, '_RUN_ALL.bat'),
                      fastFiles,
                      fastExe=FAST_EXE)
    runner.run_fastfiles(fastFiles,
                         showOutputs=False,
                         fastExe=FAST_EXE,
                         nCores=4)

    # --- Postpro - Computing averages at the end of the simluation
    print('>>> Postprocessing...')
    outFiles = [os.path.splitext(f)[0] + '.outb' for f in fastFiles]
    ColKeepStats = [
        'RotSpeed_[rpm]', 'BldPitch1_[deg]', 'RtAeroCp_[-]', 'RtAeroCt_[-]',
        'Wind1VelX_[m/s]'
    ]
    result = postpro.averagePostPro(outFiles,
                                    avgMethod='constantwindow',
                                    avgParam=5,
                                    ColKeep=ColKeepStats,
                                    ColSort='RotSpeed_[rpm]')
    result.to_csv('ParametricExcel_Summary.csv', sep='\t', index=False)
    print('Average values saved to _ParametricExcel_Summary.csv')
コード例 #3
0
def PowerCurveParametricExample2():
    """ Example to run a set of FAST simulations to determine a power curve.
    In this example, the WS, RPM and Pitch are set within a for loop.
    If the controller and generator are active, these are just "initial conditions".
    Additional parameters may be set by adjusting the BaseDict.

    This script is based on a reference directory which contains a reference main input file (.fst)
    Everything is copied to a working directory.
    The different fast inputs are generated based on a list of dictionaries, named `PARAMS`.
    For each dictionary:
       - they keys are "path" to a input parameter, e.g. `EDFile|RotSpeed`  or `TMax`.
           These should correspond to whater name of the variable is used in the FAST inputs files.
       - they values are the values corresponding to this parameter
    """
    # --- Parameters for this script
    FAST_EXE  = os.path.join(MyDir, '../../../data/openfast.exe') # Location of a FAST exe (and dll)
    ref_dir   = os.path.join(MyDir, '../../../data/NREL5MW/')     # Folder where the fast input files are located (will be copied)
    main_file = 'Main_Onshore_OF2.fst'                # Main file in ref_dir, used as a template
    work_dir  = '_NREL5MW_PowerCurveParametric2/'     # Output folder (will be created)
    out_Ext   = '.outb' # Output extension

    # --- Defining the parametric study  (list of dictionnaries with keys as FAST parameters)
    WS    = [3,5,7,9 ,11,13,15]
    RPM   = [5,6,7,10,10,10,10] 
    PITCH = [0,0,0,0 ,5 ,10,15] 
    BaseDict = {'TMax': 10, 'DT': 0.01, 'DT_Out': 0.1}
    PARAMS = case_gen.paramsWS_RPM_Pitch(WS, RPM, PITCH, baseDict=BaseDict, flatInputs=True)

    # --- Generating all files in a workdir
    fastFiles = case_gen.templateReplace(PARAMS, ref_dir, work_dir, removeRefSubFiles=True, removeAllowed=True, main_file=main_file)

    # --- Creating a batch script just in case
    runner.writeBatch(os.path.join(work_dir,'_RUN_ALL.bat'), fastFiles,fastExe=FAST_EXE)

    # --- Running the simulations
    runner.run_fastfiles(fastFiles, fastExe=FAST_EXE, parallel=True, showOutputs=False, nCores=2)

    # --- Simple Postprocessing
    outFiles = [os.path.splitext(f)[0]+out_Ext for f in fastFiles]
    avg_results = postpro.averagePostPro(outFiles,avgMethod='constantwindow',avgParam=10, ColMap = {'WS_[m/s]':'Wind1VelX_[m/s]'},ColSort='WS_[m/s]')
    print('>>> Average results:')
    print(avg_results)
    avg_results.to_csv('_PowerCurve2.csv',sep='\t',index=False)
コード例 #4
0
def run_linearization():
    """ Example to run a set of OpenFAST simulations (linearizations)

    This script uses a reference directory (`ref_dir`) which contains a reference input file (.fst)
    1) The reference directory is copied to a working directory (`out_dir`).
    2) All the fast input files are generated in this directory based on a list of dictionaries (`PARAMS`).
    For each dictionary in this list:
       - The keys are "path" to a input parameter, e.g. `EDFile|RotSpeed`  or `FAST|TMax`.
         These should correspond to the variables used in the FAST inputs files.
       - The values are the values corresponding to this parameter
    For instance:
         PARAMS[0]['DT']                    = 0.01
         PARAMS[0]['EDFile|RotSpeed']       = 5
         PARAMS[0]['InflowFile|HWindSpeed'] = 10

    3) The simulations are run, successively distributed on `nCores` CPUs.
    4) The output files are read, and averaged based on a method (e.g. average over a set of periods,
        see averagePostPro in postpro for the different averaging methods).
       A pandas DataFrame is returned

    """
    # --- Parameters for this script
    of_dir           = '/home/equon/WEIS/local'
    this_dir         = os.path.dirname(__file__)
    ref_dir          = '../OpenFAST'   # Folder where the fast input files are located (will be copied)
    out_dir          = os.path.join(this_dir,'outputs')     # Output folder (will be created)
    main_file        = 'NREL-1p7-103.fst'  # Main file in ref_dir, used as a template
    FAST_EXE         = os.path.join(of_dir,'bin/openfast') # Location of a FAST exe (and dll)

    # --- Read outputs from OF power curve to get operating points (EWQ)
    #op = pd.read_csv('../NREL-1.7-103_openfast.csv').set_index('Wind1VelX_[m/s]')
    op = pd.read_csv('../NREL-1.7-103_openfast.csv').set_index('rotor speed [RPM]')
    op = op.loc[op['Wind1VelX_[m/s]'] <= 11]
    GenTorque = op['generator torque [kN-m]'] * 1000.
    minRotSpeed = op.index[0]

    # --- Defining the parametric study  (list of dictionnaries with keys as FAST parameters)
    LinStart = 600.0
    BaseDict = {'TMax': 660.0}
    BaseDict = case_gen.paramsLinearTrim(BaseDict)   # Run linear trim case
    print(BaseDict)

    RotSpeeds = np.arange(0,17)

    PARAMS=[]
    for i,rpm in enumerate(RotSpeeds): 
        p=BaseDict.copy()

        GenTq = np.interp(rpm, GenTorque.index, GenTorque, left=1e-9)

        # Turn off aero
        p['CompAero']   = 0
        p['CompInflow'] = 0
        
        # Turn on all pertinent structural DOFs
        p['EDFile|FlapDOF1'] = 'True'
        p['EDFile|FlapDOF2'] = 'True'
        p['EDFile|EdgeDOF'] = 'True'
        p['EDFile|DrTrDOF'] = 'True'
        p['EDFile|GenDOF'] = 'False' #'True'
        p['EDFile|TwFADOF1'] = 'True'
        p['EDFile|TwFADOF2'] = 'True'
        p['EDFile|TwSSDOF1'] = 'True'
        p['EDFile|TwSSDOF2'] = 'True'

        # rated generator speed, torque, control params
        #p['ServoFile|VS_RtGnSp'] = 1429.36707 * .9 # Rated generator speed [RPM]
        #p['ServoFile|VS_RtTq'] = 12389.06909 # Rated torque, from DISCON.IN [Nm]
        #p['ServoFile|VS_Rgn2K'] = 0.006851918024 # Generator torque const, from DISCON.IN [Nm/RPM^2]
        #p['ServoFile|VS_SlPc']   = 10.

        # const generator torque
        # https://github.com/OpenFAST/openfast/issues/478#issuecomment-649819664
        #p['ServoFile|VS_RtTq'] = np.interp(rpm, GenTorque.index, GenTorque, left=1e-9)
        p['ServoFile|VS_RtTq'] = GenTq
        p['ServoFile|VS_RtGnSp'] = 1e-9
        p['ServoFile|VS_Rgn2K'] = 1e-9
        p['ServoFile|VS_SlPc'] = 1e-9

        # Operating conditions
        p['EDFile|RotSpeed'] = rpm
        p['EDFile|BlPitch(1)'] = 0.0
        p['EDFile|BlPitch(2)'] = 0.0
        p['EDFile|BlPitch(3)'] = 0.0

        # Set number of linearizations
        #p['TrimCase'] = 2
        p['CalcSteady'] = 'False'
        #p['OutFmt'] = 'E20.12'
        if rpm > 0:
            p['NLinTimes'] = 36
            LinTimes = np.linspace(LinStart, LinStart+60./rpm, num=p['NLinTimes'], endpoint=False)
            p['LinTimes'] = np.array_str(LinTimes, max_line_width=9000, precision=3)[1:-1]
        else:
            p['NLinTimes'] = 1
            p['LinTimes'] = f'{LinStart:.3f}'
            p['TMax'] = LinStart

        # Set case name
        p['__name__'] = f'{i:03d}_{rpm:.1f}rpm'
        PARAMS.append(p)

    # --- Generating all files in a output directory
    fastfiles=case_gen.templateReplace(PARAMS,ref_dir,outputDir=out_dir,removeRefSubFiles=True,main_file=main_file, oneSimPerDir=False)
    print(fastfiles)

    # --- Creating a batch script just in case
    #runner.writeBatch(os.path.join(out_dir,'_RUN_ALL.bat'),fastfiles,fastExe=FAST_EXE)

    # --- Running the simulations
    if parallel_flag:
        nCores = min(len(RotSpeeds), os.cpu_count())
        runner.run_fastfiles(fastfiles,fastExe=FAST_EXE,parallel=True,showOutputs=True,nCores=nCores)
    else:
        #runner.run_fastfiles(fastfiles,fastExe=FAST_EXE,parallel=False,showOutputs=True) # causes error when calling wait()
        runner.run_fastfiles(fastfiles,fastExe=FAST_EXE,parallel=True,showOutputs=True,nCores=1)

    # --- Simple Postprocessing
    # (averaging each signal over the last period for each simulation)
    outFiles = [os.path.splitext(f)[0]+'.outb' for f in fastfiles]
    # avg_results = postpro.averagePostPro(outFiles, avgMethod='periods', avgParam=1, ColMap = {'WS_[m/s]':'Wind1VelX_[m/s]'},ColSort='WS_[m/s]')
    # avg_results.drop('Time_[s]',axis=1, inplace=True)

    return outFiles
コード例 #5
0
def writeLinearizationFiles(main_fst,
                            workDir,
                            operatingPointsFile,
                            nPerPeriod=36,
                            baseDict=None,
                            tStart=100,
                            LinInputs=0,
                            LinOutputs=0):
    """
    Write FAST inputs files for linearization, to a given directory `workDir`.


    INPUTS:
      - main_fst: path to an existing  .fst file
                  This file (and the ones it refers to) will be used as templates.
                  Values of the templates can be modified using `baseDict`.
                  The parent directory of the main fst file will be copied to `workDir`.
      - workDir: directory (will be created) where the simulation files will be generated

      - operatingPointsFile: csv file containing operating conditions
      - nPerPeriod : number of linearization points per rotation (usually 12 or 36)
      - baseDict : a dictionary of inputs files keys to be applied to all simulations
                   Ignored if not provided.
                   e.g. baseDict={'DT':0.01, 'EDFile|ShftTilt':-5, 'InflowFile|PLexp':0.0}
                   see templateReplaceGeneral.
      - tStart: time at which the linearization will start. 
                When triming option is not available, this needs to be sufficiently large for
                the rotor to reach an equilibrium
      - LinInputs:  linearize wrt. inputs (see OpenFAST documentation). {0,1,2, default:1}
      - LinOutputs: linearize wrt. outputs (see OpenFAST documentation). {0,1, default:0}

    OUTPUTS:
       - list of fst files created
    """
    # --- Optional values
    if baseDict is None:
        baseDict = dict()

    # --- Checking main fst file
    fst = FASTInputFile(main_fst)
    hasTrim = 'TrimCase' in fst.keys()
    if fst['CompServo'] == 1:
        print('[WARN] For now linearization is done without controller.')
        baseDict['CompServo'] = 0

    # --- Reading operating points
    OP = readOperatingPoints(operatingPointsFile)

    # --- Generating list of parameters that vary based on the operating conditions provided
    PARAMS = []
    for i, op in OP.iterrows():
        # Extract operating conditions (TODO, handling of missing fields)
        ws = op['WindSpeed_[m/s]']
        rpm = op['RotorSpeed_[rpm]']
        pitch = op['PitchAngle_[deg]']
        filename = op['Filename_[-]']
        # TODO gen trq or Tower top displacement

        # Determine linearization times based on RPM and nPerPeriod
        Omega = rpm / 60 * 2 * np.pi
        if abs(Omega) < 0.001:
            LinTimes = [tStart]
            Tmax = tStart + 1
        else:
            T = 2 * np.pi / Omega
            LinTimes = np.linspace(tStart, tStart + T, nPerPeriod + 1)[:-1]
            Tmax = tStart + 1.01 * T
        # --- Creating "linDict", dictionary of changes to fast input files for linearization
        linDict = dict()
        linDict['__name__'] = os.path.splitext(filename)[0]
        # --- Main fst options
        linDict['TMax'] = Tmax
        linDict['TStart'] = 0
        if abs(ws) < 0.001:
            linDict['CompAero'] = 0
            linDict['CompInflow'] = 0
        # --- Linearization options
        linDict['Linearize'] = True
        linDict['NLinTimes'] = len(LinTimes)
        linDict['LinTimes'] = list(LinTimes)
        linDict['OutFmt'] = '"ES20.12E3"'  # Important for decent resolution
        linDict[
            'LinInputs'] = LinInputs  # 0: none, 1: standard, 2: to get full linearizations
        linDict['LinOutputs'] = LinOutputs  # 0: none, 1: based on outlist
        # --- New Linearization options
        # TrimCase - Controller parameter to be trimmed {1:yaw; 2:torque; 3:pitch} [used only when CalcSteady=True]
        # TrimTol - Tolerance for the rotational speed convergence [>eps] [used only when CalcSteady=True]
        # TrimGain - Proportional gain for the rotational speed error (rad/(rad/s) or Nm/(rad/s)) [>0] [used only when CalcSteady=True]
        # Twr_Kdmp - Damping factor for the tower (N/(m/s)) [>=0] [used only when CalcSteady=True]
        # Bld_Kdmp - Damping factor for the blade (N/(m/s)) [>=0] [used only when CalcSteady=True]
        # --- Mode shape vizualization options
        if hasTrim:
            linDict['WrVTK'] = 3
            linDict['VTK_type'] = 1
            linDict['VTK_fields'] = True
            linDict['VTK_fps'] = 30
        else:
            linDict['WrVTK'] = 0
        # --- Aero options
        linDict['AeroFile|WakeMod'] = 1  # Needed for linearization
        linDict['AeroFile|AFAeroMod'] = 1  # Needed for linearization
        linDict['AeroFile|FrozenWake'] = True  # Needed for linearization
        # --- Inflow options
        linDict['InflowFile|WindType'] = 1
        linDict['InflowFile|HWindSpeed'] = ws
        # --- ElastoDyn options
        linDict['EDFile|BlPitch(1)'] = pitch
        linDict['EDFile|BlPitch(2)'] = pitch
        linDict['EDFile|BlPitch(3)'] = pitch
        linDict['EDFile|RotSpeed'] = rpm
        #linDict['EDFile|TTDspFA']    = tt
        # --- Servo options

        # --- Merging linDict dictionary with user override inputs
        for k, v in baseDict.items():
            if k in linDict and v != linDict[k]:
                print('Overriding key {} with value {} (previous value {})'.
                      format(k, v, linDict[k]))
            linDict[k] = v

        PARAMS.append(linDict)

    # --- Generating all files in a workDir
    refDir = os.path.dirname(main_fst)
    main_file = os.path.basename(main_fst)
    fastfiles = templateReplace(PARAMS,
                                refDir,
                                outputDir=workDir,
                                removeRefSubFiles=True,
                                main_file=main_file)

    return fastfiles
コード例 #6
0
def ParametricExample():
    """ Example to run a set of OpenFAST simulations (parametric study)

    This script uses a reference directory (`ref_dir`) which contains a reference input file (.fst)
    1) The reference directory is copied to a working directory (`out_dir`).
    2) All the fast input files are generated in this directory based on a list of dictionaries (`PARAMS`).
    For each dictionary in this list:
       - The keys are "path" to a input parameter, e.g. `EDFile|RotSpeed`  or `FAST|TMax`.
         These should correspond to the variables used in the FAST inputs files.
       - The values are the values corresponding to this parameter
    For instance:
         PARAMS[0]['DT']                    = 0.01
         PARAMS[0]['EDFile|RotSpeed']       = 5
         PARAMS[0]['InflowFile|HWindSpeed'] = 10

    3) The simulations are run, successively distributed on `nCores` CPUs.
    4) The output files are read, and averaged based on a method (e.g. average over a set of periods,
        see averagePostPro in postpro for the different averaging methods).
       A pandas DataFrame is returned

    """
    # --- Parameters for this script
    ref_dir = 'NREL5MW/'  # Folder where the fast input files are located (will be copied)
    out_dir = 'NREL5MW_Parametric/'  # Output folder (will be created)
    main_file = 'Main_Onshore_OF2.fst'  # Main file in ref_dir, used as a template
    FAST_EXE = 'openfast2.3_x64s.exe'  # Location of a FAST exe (and dll)

    # --- Defining the parametric study  (list of dictionnaries with keys as FAST parameters)
    WS = [3, 5, 6, 7]
    RPM = [10, 12, 13, 15]
    BaseDict = {'TMax': 10, 'DT': 0.01, 'DT_Out': 0.1}
    BaseDict = case_gen.paramsNoController(BaseDict)  # Remove the controller
    #BaseDict = case_gen.paramsControllerDLL(BaseDict) # Activate the controller
    #BaseDict = case_gen.paramsStiff(BaseDict)         # Make the turbine stiff (except generator)
    #BaseDict = case_gen.paramsNoGen(BaseDict)         # Remove the Generator DOF
    PARAMS = []
    for i, (wsp, rpm) in enumerate(
            zip(WS, RPM)
    ):  # NOTE: same length of WS and RPM otherwise do multiple for loops
        p = BaseDict.copy()
        #p['AeroFile|TwrAero']       = True
        #p['EDFile|BldFile(1)|AdjBlMs'] =1.1
        #p['EDFile|BldFile(2)|AdjBlMs'] =1.1
        #p['EDFile|BldFile(3)|AdjBlMs'] =1.1
        p['EDFile|RotSpeed'] = rpm
        p['InflowFile|HWindSpeed'] = wsp
        p['InflowFile|WindType'] = 1  # Setting steady wind
        p['__name__'] = '{:03d}_ws{:04.1f}_om{:04.2f}'.format(
            i, p['InflowFile|HWindSpeed'], p['EDFile|RotSpeed'])
        PARAMS.append(p)
        i = i + 1
    # --- Generating all files in a output directory
    fastfiles = case_gen.templateReplace(PARAMS,
                                         ref_dir,
                                         outputDir=out_dir,
                                         removeRefSubFiles=True,
                                         main_file=main_file,
                                         oneSimPerDir=False)
    print(fastfiles)

    # --- Creating a batch script just in case
    runner.writeBatch(os.path.join(out_dir, '_RUN_ALL.bat'),
                      fastfiles,
                      fastExe=FAST_EXE)
    # --- Running the simulations
    runner.run_fastfiles(fastfiles,
                         fastExe=FAST_EXE,
                         parallel=True,
                         showOutputs=False,
                         nCores=4)

    # --- Simple Postprocessing
    # (averaging each signal over the last period for each simulation)
    outFiles = [os.path.splitext(f)[0] + '.outb' for f in fastfiles]
    avg_results = postpro.averagePostPro(
        outFiles,
        avgMethod='periods',
        avgParam=1,
        ColMap={'WS_[m/s]': 'Wind1VelX_[m/s]'},
        ColSort='WS_[m/s]')
    avg_results.drop('Time_[s]', axis=1, inplace=True)
    print(avg_results)
    return avg_results
コード例 #7
0
def run_linearization():
    """ Example to run a set of OpenFAST simulations (linearizations)

    This script uses a reference directory (`ref_dir`) which contains a reference input file (.fst)
    1) The reference directory is copied to a working directory (`out_dir`).
    2) All the fast input files are generated in this directory based on a list of dictionaries (`PARAMS`).
    For each dictionary in this list:
       - The keys are "path" to a input parameter, e.g. `EDFile|RotSpeed`  or `FAST|TMax`.
         These should correspond to the variables used in the FAST inputs files.
       - The values are the values corresponding to this parameter
    For instance:
         PARAMS[0]['DT']                    = 0.01
         PARAMS[0]['EDFile|RotSpeed']       = 5
         PARAMS[0]['InflowFile|HWindSpeed'] = 10

    3) The simulations are run, successively distributed on `nCores` CPUs.
    4) The output files are read, and averaged based on a method (e.g. average over a set of periods,
        see averagePostPro in postpro for the different averaging methods).
       A pandas DataFrame is returned

    """
    # --- Parameters for this script
    of_dir = '/Users/dzalkind/Tools/openfast-dev'  # openfast dir, using dev branch as of Jan-14
    this_dir = os.path.dirname(__file__)
    ref_dir = '/Users/dzalkind/Tools/ROSCO_toolbox/Test_Cases/NREL-5MW'  # Folder where the fast input files are located (will be copied)
    out_dir = os.path.join(
        this_dir, 'NREL-5MW_Linear/')  # Output folder (will be created)
    main_file = 'NREL-5MW.fst'  # Main file in ref_dir, used as a template
    FAST_EXE = os.path.join(
        of_dir, 'install/bin/openfast')  # Location of a FAST exe (and dll)

    # --- Defining the parametric study  (list of dictionnaries with keys as FAST parameters)
    WS = [14, 16, 18]
    BaseDict = {'TMax': 600}
    BaseDict = case_gen.paramsLinearTrim(BaseDict)  # Run linear trim case

    PARAMS = []
    for i, wsp in enumerate(WS):
        p = BaseDict.copy()
        p['InflowFile|HWindSpeed'] = wsp
        p['InflowFile|WindType'] = 1  # Setting steady wind

        # Set DOFs
        p['EDFile|GenDOF'] = 'True'
        p['EDFile|FlapDOF1'] = 'True'
        p['EDFile|TwFADOF1'] = 'True'

        # NREL-5MW rated generator speed, torque, control params
        p['ServoFile|VS_RtGnSp'] = 1173 * .9
        p['ServoFile|VS_RtTq'] = 47402
        p['ServoFile|VS_Rgn2K'] = 0.0226
        p['ServoFile|VS_SlPc'] = 10.

        # Trim solution will converge to this rotor speed
        p['EDFile|RotSpeed'] = 12.1

        # Set number of linearizations
        p['NLinTimes'] = 12

        p['__name__'] = '{:03d}_ws{:04.1f}'.format(i,
                                                   p['InflowFile|HWindSpeed'])
        PARAMS.append(p)
        i = i + 1
    # --- Generating all files in a output directory
    fastfiles = case_gen.templateReplace(PARAMS,
                                         ref_dir,
                                         outputDir=out_dir,
                                         removeRefSubFiles=True,
                                         main_file=main_file,
                                         oneSimPerDir=False)
    print(fastfiles)

    # --- Creating a batch script just in case
    runner.writeBatch(os.path.join(out_dir, '_RUN_ALL.bat'),
                      fastfiles,
                      fastExe=FAST_EXE)
    # --- Running the simulations
    runner.run_fastfiles(fastfiles,
                         fastExe=FAST_EXE,
                         parallel=True,
                         showOutputs=True,
                         nCores=4)

    # --- Simple Postprocessing
    # (averaging each signal over the last period for each simulation)
    outFiles = [os.path.splitext(f)[0] + '.outb' for f in fastfiles]
    # avg_results = postpro.averagePostPro(outFiles, avgMethod='periods', avgParam=1, ColMap = {'WS_[m/s]':'Wind1VelX_[m/s]'},ColSort='WS_[m/s]')
    # avg_results.drop('Time_[s]',axis=1, inplace=True)

    return outFiles