IO/Postpro/tools: updates from welib

Author: ebranlard

pyFAST/airfoils/DynamicStall.py

@@ -42,7 +42,8 @@ class Polar(object):
     """
 
     def __init__(self, filename=None, alpha=None, cl=None, cd=None, cm=None, Re=None, 
-            compute_params=False, radians=None, fformat='auto', verbose=False):
+            compute_params=False, radians=None, cl_lin_method='max',
+            fformat='auto', verbose=False):
         """Constructor
 
         Parameters
@@ -118,9 +119,9 @@ def __init__(self, filename=None, alpha=None, cl=None, cd=None, cm=None, Re=None
 
         # NOTE: method needs to be in harmony for linear_slope and the one used in cl_fully_separated
         if compute_params:
-            self._linear_slope, self._alpha0 = self.cl_linear_slope(method="max")
+            self._linear_slope, self._alpha0 = self.cl_linear_slope(method=cl_lin_method)
             if not self._cl_fs_lock:
-                self.cl_fully_separated()
+                self.cl_fully_separated(method=cl_lin_method)
             if not self._cl_inv_lock:
                 self.cl_inv = self._linear_slope * (self.alpha - self._alpha0)
 
@@ -136,6 +137,9 @@ def __repr__(self):
         s+=' - _alpha0:            {} [{}]\n'.format(self._alpha0, sunit)
         s+=' - _linear_slope:      {} [1/{}]\n'.format(self._linear_slope, sunit)
         s+='Derived parameters:\n'
+        s+=' * cl_inv             : array of size {} \n'.format(len(self.alpha))
+        s+=' * cl_fs              : array of size {} \n'.format(len(self.alpha))
+        s+=' * fs                 : array of size {} \n'.format(len(self.alpha))
         s+=' * cl_lin (UNSURE)    : array of size {} \n'.format(len(self.alpha))
         s+='Functional parameters:\n'
         s+=' * alpha0 :            {} [{}]\n'.format(self.alpha0(),sunit)
@@ -280,10 +284,6 @@ def cl_lin(self): # TODO consider removing
         #    self._linear_slope,self._alpha0=self.cl_linear_slope()
         #return self._linear_slope*(self.alpha-self._alpha0)
 
-
-
-
-
     @classmethod
     def fromfile(cls, filename, fformat='auto', compute_params=False, to_radians=False):
         """Constructor based on a filename
@@ -1058,6 +1058,7 @@ def cl_fully_separated(self, method='max'):
         if not self._fs_lock:
             fs = (self.cl - cl_fs) / (cl_inv - cl_fs + 1e-10)
             fs[np.where(fs < 1e-15)] = 0
+            fs[np.where(fs > 1)] = 1
             # Storing
             self.fs = fs
         self.cl_fs = cl_fs
@@ -1534,6 +1535,7 @@ def cl_linear_slope(alpha, cl, window=None, method="max", nInterp=721, inputInRa
       - alpha: angle of attack in radians
       - Cl   : lift coefficient
       - window: [alpha_min, alpha_max]: region when linear slope is sought
+      - method: 'max', 'optim', 'leastsquare', 'leastsquare_constraint'
       
     OUTPUTS:
       - Cl_alpha, alpha0: lift slope (1/rad) and angle of attack (rad) of zero lift

pyFAST/airfoils/Polar.py

@@ -0,0 +1,2 @@
+from .Polar import *
+from .DynamicStall import *

pyFAST/airfoils/__init__.py

@@ -11,27 +11,33 @@
 def main_correction3D(test=False):
     polarFile_in = os.path.join(MyDir,'../data/DU21_A17.csv')
 
-    r_over_R     = 0.2
-    chord_over_r = 3./5.
-    tsr          = 10
+    r_over_R     = 0.2   # spanwise location [-]
+    chord_over_r = 3./5. # chord divided by local radius [-]
+    tsr          = 10    # tip speed ratio [-]
 
     polar = Polar(polarFile_in, compute_params=True, verbose=False)
-    #ADpol = polar.toAeroDyn(polarFile_AD)
+    #ADpol = polar.toAeroDyn(polarFile_AD) # Optional, write to AeroDyn format
     polar3D= polar.correction3D(r_over_R, chord_over_r, tsr)
 
+    # --- Plot
+    fig,ax = plt.subplots(1, 1, sharey=False, figsize=(6.4,4.8)) # (6.4,4.8)
+    fig.subplots_adjust(left=0.12, right=0.95, top=0.95, bottom=0.11, hspace=0.20, wspace=0.20)
+    ax.plot(polar.alpha, polar.cl     ,'k-'  , label= r'2D polar')
+    ax.plot(polar3D.alpha, polar3D.cl , '-'  , label= r'3D corrected')
+    ax.plot(polar.alpha, polar.cl_inv ,'k--' , label= r'inviscid')
+    ax.tick_params(direction='in', top=True, right=True)
+    ax.set_xlabel(r'Angle of attack, $\alpha$ [deg]')
+    ax.set_ylabel(r'Lift coefficient, $C_l$ [-]')
+    ax.set_title(r'Airfoils - 3D correction')
+    ax.set_xlim([-50,50])
+    ax.set_ylim([-1.5,2])
+    ax.legend()
+
     return polar, polar3D
 
+polar,polar3D = main_correction3D()
 
 if __name__ == '__main__':
-    polar,polar3D = main_correction3D()
-
-    import matplotlib.pyplot as plt
-    plt.plot(polar.alpha, polar.cl       , label= 'cl')
-    plt.plot(polar3D.alpha, polar3D.cl   , label= 'cl 3d')
-    plt.plot(polar.alpha, polar.cl_inv   , label= 'cl inv')
-    plt.ylim([-1.5,2])
-    plt.legend()
     plt.show()
-
 if __name__ == '__test__':
-    polar,polar3D = main_correction3D()
+    pass

pyFAST/airfoils/examples/correction3D.py

@@ -11,10 +11,7 @@
 import pyFAST.input_output.fast_input_file as fi
 import pyFAST.case_generation.runner as runner
 import pyFAST.input_output.postpro as postpro
-from pyFAST.input_output.fast_wind_file import FASTWndFile
-from pyFAST.input_output.rosco_performance_file import ROSCOPerformanceFile
-from pyFAST.input_output.csv_file import CSVFile
-
+from pyFAST.input_output.fast_wind_file import FASTWndFilefrom pyFAST.input_output.rosco_performance_file import ROSCOPerformanceFilefrom pyFAST.input_output.csv_file import CSVFile
 # --------------------------------------------------------------------------------}
 # --- Template replace 
 # --------------------------------------------------------------------------------{
@@ -150,11 +147,7 @@ def replaceRecurse(templatename_or_newname, FileKey, ParamKey, ParamValue, Files
                 ext = os.path.splitext(templatefilename)[-1]
                 newfilename_full = os.path.join(wd,strID+ext)
                 newfilename      = strID+ext
-                if dryRun:
-                    newfilename = os.path.join(workDir, newfilename)
-                    obj=type('DummyClass', (object,), {'filename':newfilename})
-                    return newfilename, {'Root':obj}
-            else:
+                if dryRun:                    newfilename = os.path.join(workDir, newfilename)                    obj=type('DummyClass', (object,), {'filename':newfilename})                    return newfilename, {'Root':obj}            else:
                 newfilename, newfilename_full = rebaseFileName(templatefilename, workDir, strID)
             #print('--------------------------------------------------------------')
             #print('TemplateFile    :', templatefilename)
@@ -172,8 +165,12 @@ def replaceRecurse(templatename_or_newname, FileKey, ParamKey, ParamValue, Files
             Key    = NewFileKey_or_Key
             #print('Setting', FileKey, '|',Key, 'to',ParamValue)
             if Key=='OutList':
-                OutList=f[Key]
-                f[Key] = addToOutlist(OutList, ParamValue)
+                if len(ParamValue)>0:
+                    if len(ParamValue[0])==0:
+                        f[Key] = ParamValue # We replace
+                    else:
+                        OutList=f[Key]
+                        f[Key] = addToOutlist(OutList, ParamValue) # we insert
             else:
                 f[Key] = ParamValue
         else:
@@ -229,14 +226,21 @@ def replaceRecurse(templatename_or_newname, FileKey, ParamKey, ParamValue, Files
             removeFASTOuputs(wd)
         if os.path.exists(wd) and removeAllowed:
             shutil.rmtree(wd, ignore_errors=False, onerror=handleRemoveReadonlyWin)
-        copyTree(templateDir, wd)
-        if removeAllowed:
-            removeFASTOuputs(wd)
+        templateDir = os.path.normpath(templateDir)
+        wd          = os.path.normpath(wd)
+        # NOTE: need some special handling if path are the sames
+        if templateDir!=wd:
+            copyTree(templateDir, wd)
+            if removeAllowed:
+                removeFASTOuputs(wd)
 
 
     TemplateFiles=[]
     files=[]
+    nTot=len(PARAMS)
     for ip,(wd,p) in enumerate(zip(workDirS,PARAMS)):
+        if np.mod(ip+1,1000)==0:
+            print('File {:d}/{:d}'.format(ip,nTot))
         if '__index__' not in p.keys():
             p['__index__']=ip
 
@@ -248,16 +252,12 @@ def replaceRecurse(templatename_or_newname, FileKey, ParamKey, ParamValue, Files
             if k =='__index__' or k=='__name__':
                 continue
             new_mainFile, Files = replaceRecurse(main_file_base, '', k, v, Files, strID, wd, TemplateFiles)
-            if dryRun:
-                break
-
+            if dryRun:                break
         # --- Writting files
         for k,f in Files.items():
             if k=='Root':
                 files.append(f.filename)
-            if not dryRun:
-                f.write()
-
+            if not dryRun:                f.write()
     # --- Remove extra files at the end
     if removeRefSubFiles:
         TemplateFiles, nCounts = np.unique(TemplateFiles, return_counts=True)

pyFAST/case_generation/case_gen.py

@@ -195,8 +195,40 @@ def run_fast(input_file, fastExe=None, wait=True, showOutputs=False, showCommand
     return run_cmd(input_file, fastExe, wait=wait, showOutputs=showOutputs, showCommand=showCommand)
 
 
-def writeBatch(batchfile, fastfiles, fastExe=None, nBatches=1, pause=False, flags='', flags_after=''):
-    """ Write batch file, everything is written relative to the batch file"""
+def writeBatch(batchfile, fastfiles, fastExe=None, nBatches=1, pause=False, flags='', flags_after='',
+        run_if_ext_missing=None,
+        discard_if_ext_present=None,
+        dispatch=False,
+        stdOutToFile=False,
+        echo=True):
+    """ Write one or several batch file, all paths are written relative to the batch file directory.
+    The batch file will consist of lines of the form:
+         [CONDITION] EXE [FLAGS] FILENAME [FLAGS_AFTER]
+
+    INPUTS:
+    - batchfile: path of the batch file to be written. 
+                 If several files are requested (using nBatches) _i is inserted before the extension
+    - nBatches: split into nBatches files.
+    - pause: insert a pause statement at the end so that batch file is not closed after execution
+    - flags: flags (string) to be placed between the executable and the filename
+    - flags_after: flags (string) to be placed after the filename
+    - run_if_ext_missing: add a line in the batch file so that the command is only run if
+                          the file `f.EXT` is missing, where .EXT is specified in run_if_ext_missing
+                          If None, the command is always run
+    - discard_if_ext_present: similar to run_if_ext_missing, but this time, the lines are not written to the batch file
+                          The test for existing outputs is done before writing the batch file
+    - dispatch: if True, the input files are dispatched (the first nBatches files are dispathced on the nBatches)
+    - stdOutToFile: if True, the output of the command is redirected to filename.stdout
+
+    example:
+       writeBatch('dir/MyBatch.bat', ['dir/c1.fst','dir/c2.fst'], 'op.exe', flags='-v', run_if_ext_missing='.outb')
+
+       will generate a file with the following content:
+         if not exist c1.outb (../of.exe c1.fst) else (echo "Skipping c1.fst")
+         if not exist c2.outb (../of.exe c2.fst) else (echo "Skipping c2.fst")
+
+
+    """
     if fastExe is None:
         fastExe=FAST_EXE
     fastExe_abs   = os.path.abspath(fastExe)
@@ -207,20 +239,54 @@ def writeBatch(batchfile, fastfiles, fastExe=None, nBatches=1, pause=False, flag
         flags=' '+flags
     if len(flags_after)>0:
         flags_after=' '+flags_after
+
+    # Remove commandlines if outputs are already present
+    if discard_if_ext_present:
+        outfiles = [os.path.splitext(f)[0] + discard_if_ext_present for f in fastfiles]
+        nIn=len(fastfiles)
+        fastfiles =[f for f,o in zip(fastfiles,outfiles) if not os.path.exists(o)]
+        nMiss=len(fastfiles)
+        if nIn>nMiss:
+            print('[INFO] WriteBatch: discarding simulations, only {}/{} needed'.format(nMiss, nIn))
+
+
     def writeb(batchfile, fastfiles):
         with open(batchfile,'w') as f:
+            if not echo:
+                if os.name == 'nt':
+                    f.write('@echo off\n')
             for ff in fastfiles:
                 ff_abs = os.path.abspath(ff)
                 ff_rel = os.path.relpath(ff_abs, batchdir)
-                l = fastExe_rel + flags + ' '+ ff_rel + flags_after
-                f.write("{:s}\n".format(l))
+                cmd = fastExe_rel + flags + ' '+ ff_rel + flags_after
+                if stdOutToFile:
+                    stdout = os.path.splitext(ff_rel)[0]+'.stdout'
+                    cmd += ' > ' +stdout
+                if run_if_ext_missing is not None:
+                    # TODO might be windows only
+                    ff_out = os.path.splitext(ff_rel)[0] + run_if_ext_missing
+                    if os.name == 'nt':
+                        cmd = 'if not exist {} ({}) else (echo Skipping {})'.format(ff_out, cmd, ff_rel)
+                    else:
+                        cmd = 'if [[ ! -f {} ]] ; then {}; else echo Skipping {} ; fi'.format(ff_out, cmd, ff_rel)
+                f.write("{:s}\n".format(cmd))
             if pause:
-                f.write("pause\n") # windows only..
+                f.write("pause\n") # might be windows only..
+
+
 
     if nBatches==1:
         writeb(batchfile, fastfiles)
         return batchfile
     else:
+
+        if dispatch:
+            # TODO this can probably be done with a one liner
+            fastfiles2=[]
+            for i in range(nBatches):
+                fastfiles2+=fastfiles[i::nBatches]
+            fastfiles = fastfiles2
+
         splits = np.array_split(fastfiles,nBatches)
         base, ext = os.path.splitext(batchfile)
         batchfiles=[]