Update app.py

app.py

@@ -976,55 +976,49 @@ with tab2:
                 SimVar = 1
                 Sim_Winners = []
                 fp_array = FinalPortfolio.values
+                
                 if insert_port == 1:
                     up_array = CleanPortfolio.values
+                
+                # Pre-vectorize functions
+                vec_projection_map = np.vectorize(maps_dict['Projection_map'].__getitem__)
+                vec_stdev_map = np.vectorize(maps_dict['STDev_map'].__getitem__)
+                
+                if insert_port == 1:
+                    vec_up_projection_map = np.vectorize(up_dict['Projection_map'].__getitem__)
+                    vec_up_stdev_map = np.vectorize(up_dict['STDev_map'].__getitem__)
                 st.write('Simulating contest on frames')
                 while SimVar <= Sim_size:
-                    try:
-                        fp_random = fp_array[np.random.choice(fp_array.shape[0], Contest_Size-len(CleanPortfolio), replace=False)]
-                        
-                        smple_arrays1 = np.c_[fp_random, 
-                                              np.sum(np.random.normal(
-                                                  loc = np.vectorize(maps_dict['Projection_map'].__getitem__)(fp_random[:,:-5]),
-                                                  scale = np.vectorize(maps_dict['STDev_map'].__getitem__)(fp_random[:,:-5])),
-                                                  axis=1)]
-                        try:
-                            smple_arrays2 = np.c_[up_array, 
-                                                  np.sum(np.random.normal(
-                                                      loc = np.vectorize(up_dict['Projection_map'].__getitem__)(up_array[:,:-5]),
-                                                      scale = np.vectorize(up_dict['STDev_map'].__getitem__)(up_array[:,:-5])),
-                                                      axis=1)]
-                        except:
-                            pass
-                        try:
-                            smple_arrays = np.vstack((smple_arrays1, smple_arrays2))
-                        except:
-                            smple_arrays = smple_arrays1
-                        final_array = smple_arrays[smple_arrays[:, 7].argsort()[::-1]]
-                        best_lineup = final_array[final_array[:, -1].argsort(kind='stable')[::-1][:1]]
-                        Sim_Winners.append(best_lineup)
-                        SimVar += 1
+                    
+                    if insert_port == 1:
+                        fp_random = fp_array[np.random.choice(fp_array.shape[0], Contest_Size-len(CleanPortfolio))]
+                    elif insert_port == 0:
+                        fp_random = fp_array[np.random.choice(fp_array.shape[0], Contest_Size)]
                         
-                    except:
-                        FieldStrength += (strength_grow + ((30 - len(Teams_used)) * .001))
-                        FinalPortfolio3, maps_dict3 = get_correlated_portfolio_for_sim(Total_Runs * field_split)
-                        FinalPortfolio4, maps_dict4 = get_uncorrelated_portfolio_for_sim(Total_Runs * field_split)
-                        FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio3], axis=0)
-                        FinalPortfolio = pd.concat([FinalPortfolio, FinalPortfolio4], axis=0)
-                        try:
-                            FinalPortfolio = FinalPortfolio.drop_duplicates(subset = ['Projection', 'Ownership'],keep = 'last').reset_index(drop = True)
-                        except:
-                            FinalPortfolio = FinalPortfolio.drop_duplicates(subset = ['Projection', 'Own'],keep = 'last').reset_index(drop = True)
-                        maps_dict.update(maps_dict3)
-                        maps_dict.update(maps_dict4)
-                        del FinalPortfolio3
-                        del maps_dict3
-                        del FinalPortfolio4
-                        del maps_dict4
-                        fp_array = FinalPortfolio.values
-                        if insert_port == 1:
-                            up_array = CleanPortfolio.values
-                        SimVar = SimVar
+                    sample_arrays1 = np.c_[
+                        fp_random, 
+                        np.sum(np.random.normal(
+                            loc=vec_projection_map(fp_random[:, :-5]),
+                            scale=vec_stdev_map(fp_random[:, :-5])),
+                        axis=1)
+                    ]
+            
+                    if insert_port == 1:
+                        sample_arrays2 = np.c_[
+                            up_array, 
+                            np.sum(np.random.normal(
+                                loc=vec_up_projection_map(up_array[:, :-5]),
+                                scale=vec_up_stdev_map(up_array[:, :-5])),
+                            axis=1)
+                        ]
+                        sample_arrays = np.vstack((sample_arrays1, sample_arrays2))
+                    else:
+                        sample_arrays = sample_arrays1
+            
+                    final_array = sample_arrays[sample_arrays[:, 10].argsort()[::-1]]
+                    best_lineup = final_array[final_array[:, -1].argsort(kind='stable')[::-1][:1]]
+                    Sim_Winners.append(best_lineup)
+                    SimVar += 1
                 st.write('Contest simulation complete')
         
                 Sim_Winner_Frame = pd.DataFrame(np.concatenate(Sim_Winners), columns=FinalPortfolio.columns.tolist() + ['Fantasy'])