bifacial-radiance 0.5.1__py2.py3-none-any.whl

bifacial_radiance/HPCScripts/Other Examples (unorganized)/PuertoRico_2.py

@@ -0,0 +1,166 @@
+import numpy as np
+import os
+import pandas as pd
+import time
+import math
+from itertools import chain
+import bifacial_radiance
+from dask.distributed import Client
+from math import sin, cos, radians
+
+
+# Run simulation using the given timestamp 
+def simulate_single(xgap=None, numpanels = None, sensorx=None,
+                   test_folder_fmt=None, weather_file=None):    
+
+    ft2m = 0.3048
+    hub_height = 8.0 * ft2m
+    y = 1
+    pitch = 0.001 # y * np.cos(np.radians(tilt))+D
+    ygap = 0.15
+    tilt = 18
+
+    sim_name = ('Coffee_'+str(numpanels)+'up_'+
+                str(round(xgap,1))+'_xgap_'+str(sensorx)+'posx')
+
+    # Verify test_folder exists before creating radiance obj
+    test_folder = test_folder_fmt.format(f'{numpanels}', 
+                                        f'{round(xgap,1)}',f'{sensorx:03}')
+
+    if not os.path.exists(test_folder):
+        os.makedirs(test_folder)
+
+    lat = 18.202142
+    lon = -66.759187
+    albedo = 0.25 # Grass value from Torres Molina, "Measuring UHI in Puerto Rico" 18th LACCEI 
+                # International Multi-Conference for Engineering, Education, and Technology
+    x = 1.64      
+
+    azimuth = 180
+    if numpanels == 3:
+        nMods = 9
+    if numpanels == 4:
+        nMods = 7
+    nRows = 1
+    moduletype = 'PR_'+str(numpanels)+'up_'+str(round(xgap,1))+'xgap'
+
+    hpc = False
+
+    demo = bifacial_radiance.RadianceObj(sim_name,str(test_folder))  
+    demo.setGround(albedo)
+    demo.readWeatherFile(weather_file)
+
+    sceneDict = {'tilt':tilt,'pitch':pitch,'hub_height':hub_height,'azimuth':azimuth, 'nMods': nMods, 'nRows': nRows} 
+    scene = demo.makeScene(moduletype=moduletype,sceneDict=sceneDict, hpc=hpc, radname = sim_name)
+
+    demo.genCumSky()
+
+    octfile = demo.makeOct(filelist = demo.getfilelist(), octname = demo.basename, hpc=hpc)  
+    analysis = bifacial_radiance.AnalysisObj(octfile=octfile, name=sim_name)
+
+    ii = 1
+    jj = 1
+    
+    simplesim=False
+    if simplesim:
+        sensorsy_front = 20  
+        sensorsy_back = 1
+        sensorsx_front = 1
+        sensorsx_back = 1
+    else:
+        sensorsy_front = 100
+        sensorsy_back = 100
+        sensorsx_front = 1
+        sensorsx_back = 1
+
+    frontscan, backscan = analysis.moduleAnalysis(scene, sensorsy_front=sensorsy_front,
+                                                        sensorsx_front=sensorsx_front,
+                                                        sensorsy_back=sensorsy_back,
+                                                        sensorsx_back=sensorsx_back)
+    xinc = 0.05
+    frontscan['xstart'] = -1+sensorx*xinc
+    backscan['xstart'] = -1+sensorx*xinc
+
+    frontdict, backdict = analysis.analysis(octfile = octfile, name = 'xloc_'+str(sensorx), 
+                                            frontscan=frontscan, backscan=backscan)
+
+ 
+    frontdict, backdict = analysis.analysis(octfile = octfile, name = 'xloc_'+str(sensorx), 
+                                            frontscan=frontscan, backscan=backscan)
+
+    results = 1
+
+
+
+    print("***** Finished simulation for "+ str(sim_name))
+
+    results=1
+    return results
+
+
+
+def run_simulations_dask(xgaps, numpanelss, sensorsxs, kwargs):
+    # Create client
+    
+    scheduler_file = '/scratch/sayala/dask_testing/scheduler.json'
+    client = Client(scheduler_file=scheduler_file)
+    
+    # Iterate over inputs
+    futures = []
+    
+    for nn in range (0, len(numpanelss)):
+        numpanels = numpanelss[nn]
+        for xx in range (0, len(xgaps)):
+            xgap = xgaps[xx]
+            for ii in sensorsxs:
+                futures.append(client.submit(simulate_single, xgap=xgap, numpanels=numpanels, sensorx=ii,**kwargs))
+
+    # Get results for all simulations
+    res = client.gather(futures)
+    
+    # Close all dask workers and scheduler
+    try:
+    	client.shutdown()
+    except:
+        pass
+
+    # Close client
+    client.close()
+
+    res = 'FINISHED!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
+    return res
+
+if __name__ == "__main__":
+    # Define locations within file system
+
+    weather_file = '/scratch/sayala/JORDAN/PRI_Mercedita.AP.785203_TMY3.epw'
+    test_folder_fmt = '/scratch/sayala/JORDAN/PUERTO_RICO_NEW_P2/numpanels_{}_xgap_{}_Posx_{}'
+    
+   
+    # Define inputs    
+    kwargs = {
+        'weather_file': weather_file,
+        'test_folder_fmt': test_folder_fmt
+    }
+    
+#    indices = np.array(list(range(2881, 6552)))
+    ft2m = 0.3048
+    lat = 18.202142
+
+    # Loops
+
+    # simplesim
+    simplesim=False
+    if simplesim:
+        xgaps = np.array([3, 4])*ft2m
+        numpanelss = np.array([3, 4])
+        sensorsxs = 2
+    else:
+        xgaps = np.array([3, 4, 6, 9, 12, 15, 18, 21]) * ft2m
+        numpanelss = np.array([3, 4])
+        sensorsxs = np.array(list(range(0, 41 )))   
+
+    # Specify method for running simulation
+    use_dask = True
+    if use_dask:
+        run_simulations_dask(xgaps, numpanelss, sensorsxs, kwargs)

bifacial_radiance/HPCScripts/Other Examples (unorganized)/PuertoRico_Original.py

@@ -0,0 +1,195 @@
+import numpy as np
+import os
+import pandas as pd
+import time
+import math
+from itertools import chain
+import bifacial_radiance
+from dask.distributed import Client
+from math import sin, cos, radians
+
+
+# Run simulation using the given timestamp 
+def simulate_single(clearance_height=None, xgap=None,
+                   tilt = None, D = None,
+                   test_folder_fmt=None, weather_file=None):    
+
+    ft2m = 0.3048
+    y = 1
+    pitch = y * np.cos(np.radians(tilt))+D
+
+    sim_name = ('Coffee_ch_'+str(round(clearance_height,1))+
+                '_xgap_'+str(round(xgap,1))+\
+                '_tilt_'+str(round(tilt,1))+
+                '_pitch_'+str(round(pitch,1)))
+
+    # Verify test_folder exists before creating radiance obj
+    test_folder = test_folder_fmt.format(f'{clearance_height}', 
+                                        f'{xgap}',
+                                        f'{tilt}',
+                                        f'{pitch}')
+
+    if not os.path.exists(test_folder):
+        os.makedirs(test_folder)
+
+    lat = 18.202142
+    lon = -66.759187
+    albedo = 0.25 # Grass value from Torres Molina, "Measuring UHI in Puerto Rico" 18th LACCEI 
+                # International Multi-Conference for Engineering, Education, and Technology
+    x = 1.64      
+
+    azimuth = 180
+    nMods = 20
+    nRows = 7
+    numpanels = 1
+    moduletype = 'PR_'+str(round(xgap,1))
+
+    hpc = False
+
+    demo = bifacial_radiance.RadianceObj(sim_name,str(test_folder))  
+    demo.setGround(albedo)
+    demo.readWeatherFile(weather_file)
+
+    sceneDict = {'tilt':tilt,'pitch':pitch,'clearance_height':clearance_height,'azimuth':azimuth, 'nMods': nMods, 'nRows': nRows} 
+    scene = demo.makeScene(moduletype=moduletype,sceneDict=sceneDict, hpc=hpc, radname = sim_name)
+
+    text = ''
+
+    tree_albedo = 0.165 # Wikipedia [0.15-0.18]
+    trunk_x = 0.8 * ft2m
+    trunk_y = trunk_x
+    trunk_z = 1 * ft2m
+
+    tree_x = 3 * ft2m
+    tree_y = tree_x
+    tree_z = 4 * ft2m
+
+    for ii in range(0,3):
+        coffeeplant_x = (x+xgap)/2 + (x+xgap)*ii
+        for jj in range(0,3):
+            coffeeplant_y = pitch/2 + pitch*jj
+            name = 'tree'+str(ii)+str(jj)
+            text = '! genrev litesoil tube{}tree t*{} {} 32 | xform -t {} {} {}'.format('head'+str(ii)+str(jj),tree_z, tree_x/2.0, 
+                                                                                                -trunk_x/2.0 + coffeeplant_x, 
+                                                                                                -trunk_x/2.0 + coffeeplant_y, trunk_z)
+            text += '\r\n! genrev litesoil tube{}tree t*{} {} 32 | xform -t {} {} 0'.format('trunk'+str(ii)+str(jj),trunk_z, trunk_x/2.0, 
+                                                                                                -trunk_x/2.0 + coffeeplant_x, 
+                                                                                                -trunk_x/2.0 + coffeeplant_y)
+    
+            customObject = demo.makeCustomObject(name,text)
+            demo.appendtoScene(radfile=scene.radfiles, customObject=customObject, text="!xform -rz 0")
+    demo.genCumSky()
+
+    octfile = demo.makeOct(filelist = demo.getfilelist(), octname = demo.basename, hpc=hpc)  
+    analysis = bifacial_radiance.AnalysisObj(octfile=octfile, name=sim_name)
+
+
+    ii = 1
+    jj = 1
+    coffeeplant_x = (x+xgap)/2 + (x+xgap)*ii 
+    coffeeplant_y = pitch/2 + pitch*jj
+    frontscan, backscan = analysis.moduleAnalysis(scene=scene, sensorsy=1)
+
+    treescan_south = frontscan.copy()
+    treescan_north = frontscan.copy()
+    treescan_east = frontscan.copy()
+    treescan_west = frontscan.copy()
+    
+    treescan_south['xstart'] = coffeeplant_x
+    treescan_south['ystart'] = coffeeplant_y  - tree_x/2.0 - 0.05
+    treescan_south['zstart'] = tree_z
+    treescan_south['orient'] = '0 1 0'
+
+    treescan_north['xstart'] = coffeeplant_x
+    treescan_north['ystart'] = coffeeplant_y  + tree_x/2.0 + 0.05
+    treescan_north['zstart'] = tree_z
+    treescan_north['orient'] = '0 -1 0'
+
+    treescan_east['xstart'] = coffeeplant_x + tree_x/2.0 + 0.05
+    treescan_east['ystart'] = coffeeplant_y 
+    treescan_east['zstart'] = tree_z
+    treescan_east['orient'] = '-1 0 0'
+
+    treescan_west['xstart'] = coffeeplant_x - tree_x/2.0 - 0.05
+    treescan_west['ystart'] = coffeeplant_y 
+    treescan_west['zstart'] = tree_z
+    treescan_west['orient'] = '1 0 0'
+
+    groundscan = frontscan.copy() 
+    groundscan['xstart'] = coffeeplant_x
+    groundscan['ystart'] = coffeeplant_y
+    groundscan['zstart'] = 0.05
+    groundscan['orient'] = '0 0 -1'
+    analysis.analysis(octfile, name=sim_name+'_North&South', frontscan=treescan_north, backscan=treescan_south)
+    analysis.analysis(octfile, name=sim_name+'_East&West', frontscan=treescan_east, backscan=treescan_west)
+
+
+    print("***** Finished simulation for "+ str(sim_name))
+
+    results=1
+    return results
+
+
+
+def run_simulations_dask(clearance_heights, xgaps, Ds, tilts, kwargs):
+    # Create client
+    
+    scheduler_file = '/scratch/sayala/dask_testing/scheduler.json'
+    client = Client(scheduler_file=scheduler_file)
+    
+    # Iterate over inputs
+    futures = []
+    
+    for ch in range (0, len(clearance_heights)):
+        clearance_height = clearance_heights[ch]
+        for xx in range (0, len(xgaps)):
+            xgap = xgaps[xx]
+            for tt in range (0, len(tilts)):
+                tilt = tilts[tt]
+                for dd in range (0, len(Ds)):
+                    D = Ds[dd]
+                    futures.append(client.submit(simulate_single, clearance_height=clearance_height,
+                                                            xgap=xgap, tilt=tilt, D=D, **kwargs))
+
+    # Get results for all simulations
+    res = client.gather(futures)
+    
+    # Close all dask workers and scheduler
+    try:
+    	client.shutdown()
+    except:
+        pass
+
+    # Close client
+    client.close()
+
+    res = 'FINISHED!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
+    return res
+
+if __name__ == "__main__":
+    # Define locations within file system
+
+    weather_file = '/scratch/sayala/JORDAN/PRI_Mercedita.AP.785203_TMY3.epw'
+    test_folder_fmt = '/scratch/sayala/JORDAN/PUERTO_RICO/CH_{}_xgap_{}_tilt_{}_pitch_{}'
+    
+   
+    # Define inputs    
+    kwargs = {
+        'weather_file': weather_file,
+        'test_folder_fmt': test_folder_fmt
+    }
+    
+#    indices = np.array(list(range(2881, 6552)))
+    ft2m = 0.3048
+    lat = 18.202142
+
+    # Loops
+    clearance_heights = np.array([6.0, 8.0, 10.0])* ft2m
+    xgaps = np.array([2, 3, 4]) * ft2m
+    Ds = np.array([2, 3, 4]) * ft2m    # D is a variable that represents the spacing between rows, not-considering the collector areas.
+    tilts = [round(lat), 10]
+
+    # Specify method for running simulation
+    use_dask = True
+    if use_dask:
+        run_simulations_dask(clearance_heights, xgaps, Ds, tilts, kwargs)

bifacial_radiance/HPCScripts/Other Examples (unorganized)/basic_module_sampling.py

@@ -0,0 +1,154 @@
+import numpy as np
+import os
+import pandas as pd
+import time
+import math
+from itertools import chain
+from itertools import product
+import bifacial_radiance
+from dask.distributed import Client
+import math
+
+# Generate spectra for DNI, DHI and albedo using smarts
+
+# Run simulation using the given timestamp and wavelength
+def simulate_single(daydate=None, posx=None, moduleWith=None, results_folder_fmt=None, weather_file=None):    
+    
+     # Verify test_folder exists                                        
+    if moduleWith:
+        results_folder_fmt = '/scratch/sayala/RadianceScenes/BasicSimulations/Gendaylit1axis/WithResults/Day_{}_Posx_{}'
+        custname = '_WITH_'+'pos_'+str(posx)
+        moduletype = 'Prism Solar Bi60 landscape With' #for with case
+
+    else:
+        results_folder_fmt = '/scratch/sayala/RadianceScenes/BasicSimulations/Gendaylit1axis/WithoutResults/Day_{}_Posx_{}'
+        custname = '_WITHOUT_'+'pos_'+str(posx)
+        moduletype = 'FirstSolar Imaginary Without'
+
+    test_folder = results_folder_fmt.format(f'{daydate}', f'{str(posx)}')      
+    if not os.path.exists(test_folder):
+        os.makedirs(test_folder)
+
+
+    # Variables that stay the same
+    #Main Variables needed throughout
+    albedo = 0.2
+    sim_general_name = 'bifacial_example'
+    lat = 39.742
+    lon = -105.179
+    #moduletype = 'Prism Solar Bi60 landscape'
+
+    gcr = 0.35
+    hub_height = 1.35
+
+    nMods = 20
+    nRows = 10
+    hpc = True
+    cumulativesky = False
+
+    limit_angle = 60
+    backtrack = True
+    
+    simplesim = False
+    if simplesim: 
+        sensorsy = 1
+    else:
+        sensorsy = 40
+
+    sim_name = sim_general_name+'_'+str(daydate)
+    demo = bifacial_radiance.RadianceObj(sim_name,str(test_folder))  
+    demo.setGround(albedo)
+    metdata = demo.readWeatherFile(weather_file, coerce_year=2021)
+    sceneDict = {'gcr':gcr,'hub_height':hub_height, 'nMods': nMods, 'nRows': nRows} 
+    trackerdict = demo.set1axis(limit_angle = limit_angle, backtrack = backtrack, gcr = gcr, cumulativesky = cumulativesky)
+
+    # Restrict trackerdict here
+    #foodict = {k: v for k, v in trackerdict.items() if k.startswith('21'+'_'+day_date)}
+    #trackerdict = demo.gendaylit1axis(trackerdict = foodict)
+    trackerdict = demo.gendaylit1axis(startdate=daydate, enddate=daydate)
+    trackerdict = demo.makeScene1axis(moduletype=moduletype,sceneDict=sceneDict, cumulativesky=cumulativesky, hpc=hpc) #makeScene creates a .rad file with 20 modules per row, 7 rows.
+    trackerdict = demo.makeOct1axis(customname = sim_name, hpc=hpc)
+    #demo.analysis1axis(customname = sim_name, hpc=hpc)
+
+    frame_thickness = 0.01
+    mod_x=1
+    modscanBack = {}
+
+    modscanBack['ystart']  = mod_x/2.0 - (frame_thickness + 0.001) - 0.005*posx # (adding frame thicknes plus 1 mm so it does not overlay exactly) 
+
+    demo.analysis1axis(singleindex=daydate+'_00', modscanfront=modscanBack, 
+                       modscanback=modscanBack, sensorsy = sensorsy, 
+                       customname = custname) 
+                        #customname ommitted for test (journal)
+        
+    results = 1
+
+    return results
+
+
+def run_simulations_dask(daylist, posxs, moduleWiths,  kwargs):
+    # Create client
+    
+    scheduler_file = '/scratch/sayala/dask_testing/scheduler.json'
+    client = Client(scheduler_file=scheduler_file)
+    
+    # Iterate over inputs
+    futures = []
+    
+    # Add Iterations HERE
+
+    for daydate in daylist:
+        for posx in posxs:
+            for moduleWith in moduleWiths:
+                futures.append(client.submit(simulate_single, daydate=daydate, posx=posx, moduleWith=moduleWith, **kwargs)) 
+
+    # Get results for all simulations
+    res = client.gather(futures)
+    
+    # Close all dask workers and scheduler
+    try:
+    	client.shutdown()
+    except:
+        pass
+
+    # Close client
+    client.close()
+
+    res = 'FINISHED!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
+    return res
+
+
+if __name__ == "__main__":
+    # Define locations within file system
+
+    weather_file = '/home/sayala/WeatherFiles/SRRL_WeatherFile_TMY3_60_2020_FIXED.csv'  
+
+    With = True
+#    weather_file = '/home/sarefeen/WeatherFiles/SRRL_WeatherFile_TMY3_60_2020.csv'  
+
+
+
+    # Define inputs    
+    kwargs = {
+        'weather_file': weather_file,
+      #  'results_folder_fmt': results_folder_fmt
+    }
+    
+    import datetime
+        
+    moduleWiths = [True, False]
+     
+    # daylist = ['21_04_29_06', '21_04_29_07', '21_04_29_08', '21_04_29_09',
+    #            '21_04_29_10', '21_04_29_11', '21_04_29_12', '21_04_29_13', '21_04_29_14',
+    #            '21_04_29_15', '21_04_29_16', '21_04_29_17', '21_04_29_18']
+    
+    
+    daylist = ['21_04_29_11']
+    
+   # posxs = np.array(list(range(0, 200)))    
+    posxs = np.array(list(range(0, 200)))   
+
+    # Pass variables being looped on, and kwargs
+    run_simulations_dask(daylist, posxs, moduleWiths, kwargs)
+
+    print("*********** DONE ************")

bifacial_radiance/HPCScripts/Other Examples (unorganized)/compile_B.py

@@ -0,0 +1,162 @@
+import numpy as np
+import os
+import pandas as pd
+import time
+import math
+from itertools import chain
+import bifacial_radiance
+from dask.distributed import Client
+from math import sin, cos, radians
+
+
+# Run simulation using the given timestamp 
+def simulate_single(idx=None, test_folder_fmt=None, weather_file=None):    
+    
+    # Verify test_folder exists before creating radiance obj
+    test_folder = test_folder_fmt.format(f'{idx}')
+    if not os.path.exists(test_folder):
+        os.makedirs(test_folder)
+
+
+    # Input Values
+    radiance_name = 'JackSolar'
+    lat = 40.1217  # Given for the project site at Colorado
+    lon = -105.1310  # Given for the project site at Colorado
+    moduletype='CaseA'
+    numpanels = 1  # This site have 1 module in Y-direction
+    x = 1  
+    y = 2.4384 # 6ft 
+    zgap = 0.10 # no gap to torquetube.
+    torquetube = True
+    axisofrotationTorqueTube = True 
+    diameter = 0.15  # 15 cm diameter for the torquetube
+    tubetype = 'square'    # Put the right keyword upon reading the document
+    material = 'black'   # Torque tube of this material (0% reflectivity)
+
+    # Scene variables
+    nMods = 20
+    nRows = 7
+    hub_height = 2.4384 # meters
+    pitch = 5.1816 # meters      # Pitch is the known parameter 
+    albedo = 0.2  #'Grass'     # ground albedo
+    gcr = y/pitch
+
+    cumulativesky = False
+    limit_angle = 60 # tracker rotation limit angle
+    angledelta = 0.01 # we will be doing hourly simulation, we want the angle to be as close to real tracking as possible.
+    backtrack = True 
+
+    # START SIMULATION
+    rad_obj = bifacial_radiance.RadianceObj(radiance_name, str(test_folder))
+    
+    # Set ground
+    rad_obj.readWeatherFile(weather_file, label = 'center')
+    
+    # Query data from metadata for index of interest
+    foo=rad_obj.metdata.datetime[idx]
+    dni = rad_obj.metdata.dni[idx]
+    dhi = rad_obj.metdata.dhi[idx]
+    res_name = "irr_Jacksolar_"+str(foo.year)+"_"+str(foo.month)+"_"+str(foo.day)+"_"+str(foo.hour)+"_"+str(foo.minute)
+    
+    rad_obj.setGround(albedo)
+
+    # Set sky
+    solpos = rad_obj.metdata.solpos.iloc[idx]
+    zen = float(solpos.zenith)
+    azm = float(solpos.azimuth) - 180
+
+    if zen > 90:
+        print("Nightime ")
+        return
+
+    rad_obj.gendaylit2manual(dni, dhi, 90 - zen, azm)
+    
+    # Set tracker information
+    tilt = round(rad_obj.getSingleTimestampTrackerAngle(rad_obj.metdata, idx, gcr, limit_angle=65),1)
+
+    sceneDict = {'pitch': pitch, 'tilt': tilt, 'azimuth': 90, 'hub_height':hub_height, 'nMods':nMods, 'nRows': nRows}  
+
+    scene = rad_obj.makeScene(moduletype=moduletype,sceneDict=sceneDict)
+    octfile = rad_obj.makeOct(octname=res_name)  
+
+    sensorsx = 22
+    sensorsy = 105
+    module_scenex = x+0.01
+    extra_sampling_space_x = 0.10
+    spacingsensorsx = (module_scenex+extra_sampling_space_x)/(sensorsx-1)
+    startxsensors = (module_scenex+extra_sampling_space_x)/2
+    xinc = pitch/(sensorsy-1) 
+
+    analysis = bifacial_radiance.AnalysisObj()
+
+    frontscan, backscan = analysis.moduleAnalysis(scene, sensorsy=sensorsy)
+    
+    #LOCATION_APOGEES
+    for senx in range(0,sensorsx):
+        frontscan['zstart'] = 0
+        frontscan['xstart'] = 0
+        frontscan['orient'] = '0 0 -1'
+        frontscan['zinc'] = 0
+        frontscan['xinc'] = xinc
+        frontscan['ystart'] = startxsensors-spacingsensorsx*senx
+        frontdict, backdict = analysis.analysis(octfile = octfile, name = 'xloc_'+str(senx), 
+                                                frontscan=frontscan, backscan=backscan)
+
+    results = 1
+    
+    # Saving one value for front of module to calculate bifacial gain
+    frontscan, backscan = analysis.moduleAnalysis(scene, sensorsy=1)
+    frontdict, backdict = analysis.analysis(octfile = octfile, name = 'frontSide', 
+                                                frontscan=frontscan, backscan=backscan)
+
+    print("***** Finished simulation for "+ str(foo))
+
+    return results
+
+
+
+def run_simulations_dask(indices, kwargs):
+    # Create client
+    
+    scheduler_file = '/scratch/sayala/dask_testing/scheduler.json'
+    client = Client(scheduler_file=scheduler_file)
+    
+    # Iterate over inputs
+    futures = []
+    
+    for idx in indices:
+            futures.append(client.submit(simulate_single, idx=idx, **kwargs))
+
+    # Get results for all simulations
+    res = client.gather(futures)
+    
+    # Close all dask workers and scheduler
+    try:
+    	client.shutdown()
+    except:
+        pass
+
+    # Close client
+    client.close()
+
+    res = 'FINISHED!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
+    return res
+
+if __name__ == "__main__":
+    # Define locations within file system
+
+    weather_file = '/scratch/sayala/JORDAN/USA_CO_Boulder-Broomfield-Jefferson.County.AP.724699_TMY3.epw'
+    test_folder_fmt = '/scratch/sayala/JORDAN/JackSolar_CaseC/Hour_{}'
+    
+    
+    # Define inputs    
+    kwargs = {
+        'weather_file': weather_file,
+        'test_folder_fmt': test_folder_fmt
+    }
+    
+    indices = np.array(list(range(2881, 6552)))
+    # Specify method for running simulation
+    use_dask = True
+    if use_dask:
+        run_simulations_dask(indices, kwargs)