tsam 2.3.7__py3-none-any.whl → 2.3.9__py3-none-any.whl

tsam/utils/durationRepresentation.py

@@ -31,10 +31,11 @@ def durationRepresentation(
     # make pd.DataFrame each row represents a candidate, and the columns are defined by two levels: the attributes and
     # the time steps inside the candidates.
     columnTuples = []
-    for i in range(int(candidates.shape[1] / timeStepsPerPeriod)):
+    num_attributes = int(candidates.shape[1] / timeStepsPerPeriod)
+    for i in range(num_attributes):
         for j in range(timeStepsPerPeriod):
             columnTuples.append((i, j))
-    candidates = pd.DataFrame(
+    candidates_df = pd.DataFrame(
         candidates, columns=pd.MultiIndex.from_tuples(columnTuples)
     )
 
@@ -43,54 +44,56 @@ def durationRepresentation(
     # inner-cluster variance is smaller and the variance across the typical periods' mean values is higher
     if distributionPeriodWise:
         clusterCenters = []
+
         for clusterNum in np.unique(clusterOrder):
-            indice = np.where(clusterOrder == clusterNum)
-            noCandidates = len(indice[0])
-            clean_index = []
-
-            clusterCenter = []
-            # get a clean index depending on the size
-            for y in candidates.columns.levels[1]:
-                for x in range(noCandidates):
-                    clean_index.append((x, y))
-            for a in candidates.columns.levels[0]:
-                # get all the values of a certain attribute and cluster
-                candidateValues = candidates.loc[indice[0], a]
-                # sort all values
-                sortedAttr = candidateValues.stack(
-                    future_stack=True,
-                ).sort_values()
-                # reindex and arrange such that every sorted segment gets represented by its mean
-                sortedAttr.index = pd.MultiIndex.from_tuples(clean_index)
-                representationValues = sortedAttr.unstack(level=0).mean(axis=1)
-                # respect max and min of the attributes
-                if representMinMax:
-                    representationValues.loc[0] = sortedAttr.values[0]
-                    representationValues.loc[representationValues.index[-1]] = (
-                        sortedAttr.values[-1]
-                    )
+            indice = np.where(clusterOrder == clusterNum)[0]
+            noCandidates = len(indice)
 
-                # get the order of the representation values such that euclidean distance to the candidates is minimized
-                order = candidateValues.mean().sort_values().index
-                # arrange
-                representationValues.index = order
-                representationValues.sort_index(inplace=True)
+            # Skip empty clusters
+            if len(indice) == 0:
+                continue     
+            
+            # This list will hold the representative values for each attribute
+            clusterCenter_parts = [] 
 
-                # add to cluster center
-                clusterCenter = np.append(clusterCenter, representationValues.values)
+            for a in candidates_df.columns.levels[0]:
 
-            clusterCenters.append(clusterCenter)
+                candidateValues_np = candidates_df.loc[indice, a].values
+
+                # flatten the 2D array (candidates, timesteps) into a 1D array and sort it.
+                sorted_flat_values = np.sort(candidateValues_np.flatten())
+
+                # reshape the sorted values and calculate the mean for each representative time step.
+                representationValues_np = sorted_flat_values.reshape(timeStepsPerPeriod, noCandidates).mean(axis=1)
+
+                # respect max and min of the attributes
+                if representMinMax:
+                    representationValues_np[0] = sorted_flat_values[0]
+                    representationValues_np[-1] = sorted_flat_values[-1]
+
+                # get the order of the representation values such that euclidean distance
+                # to the candidates' mean profile is minimized.
+                mean_profile_order = np.argsort(candidateValues_np.mean(axis=0))
+                
+                # Create an empty array to place the results in the correct order
+                final_representation_for_attr = np.empty_like(representationValues_np)
+                final_representation_for_attr[mean_profile_order] = representationValues_np
+                
+                # add to cluster center
+                clusterCenter_parts.append(final_representation_for_attr)
 
+            clusterCenters.append(np.concatenate(clusterCenter_parts))
+    
     else:
         clusterCentersList = []
-        for a in candidates.columns.levels[0]:
+        for a in candidates_df.columns.levels[0]:
             meanVals = []
             clusterLengths = []
             for clusterNum in np.unique(clusterOrder):
                 indice = np.where(clusterOrder == clusterNum)
                 noCandidates = len(indice[0])
                 # get all the values of a certain attribute and cluster
-                candidateValues = candidates.loc[indice[0], a]
+                candidateValues = candidates_df.loc[indice[0], a]
                 # calculate centroid of each cluster and append to list
                 meanVals.append(candidateValues.mean())
                 # make a list of weights of each cluster for each time step within the period
@@ -113,7 +116,7 @@ def durationRepresentation(
             order = meansAndWeightsSorted.index
             # sort all values of the original time series
             sortedAttr = (
-                candidates.loc[:, a]
+                candidates_df.loc[:, a]
                 .stack(
                     future_stack=True,
                 )

{tsam-2.3.7.dist-info → tsam-2.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsam
-Version: 2.3.7
+Version: 2.3.9
 Summary: Time series aggregation module (tsam) to create typical periods
 Author-email: Leander Kotzur <leander.kotzur@googlemail.com>, Maximilian Hoffmann <maximilian.hoffmann@julumni.fz-juelich.de>
 Maintainer-email: Julian Belina <j.belina@fz-juelich.de>

{tsam-2.3.7.dist-info → tsam-2.3.9.dist-info}/RECORD

@@ -4,13 +4,13 @@ tsam/periodAggregation.py,sha256=h9CC06jBLNyyaFTMRynGUMN87fOH3NdSEug6EcTsKGA,547
 tsam/representations.py,sha256=2NL1wanBhGreCeJ8jh0aNdIx05YXEyyMJmMAVFS5-T4,7133
 tsam/timeseriesaggregation.py,sha256=UdsjsP8RAwmdBHq0wJwB2HfUai538NYRQkK31TR9dBM,57125
 tsam/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tsam/utils/durationRepresentation.py,sha256=psjUTrLxr5eqBeSZzzRIUWEEfzMa5b30zPRmxwx2IBg,9713
+tsam/utils/durationRepresentation.py,sha256=mPUmK1Q_0gIQ0GBl-NQK4seXLfX02AsrDAU2UolrwJM,9796
 tsam/utils/k_maxoids.py,sha256=0PyaHQMA8vtV_SuQOZ0qdcGFK46aUvOiMSQofjGkjBQ,4415
 tsam/utils/k_medoids_contiguity.py,sha256=xSN9xT61oc2CPxYERhugR9hDkVCb2o8POvAiLLgrey8,5925
 tsam/utils/k_medoids_exact.py,sha256=CW6BLQV2eTYtMxDmo97-6hY1HljxcvkPVrL4DQPN5IQ,7178
 tsam/utils/segmentation.py,sha256=y8TPv1KEqf6ByOz7TRywm3WC9ZPhGiWvhwAcQbFibt4,6132
-tsam-2.3.7.dist-info/licenses/LICENSE.txt,sha256=XEzEzumoCmdJzcp5gKT6UOtKrkH-SiGpxVbIfihkNK4,1224
-tsam-2.3.7.dist-info/METADATA,sha256=8EoMezCMgt3iUNiHXB1MqN9FRm-ROEMFmZ4EAIWv6Xo,15412
-tsam-2.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tsam-2.3.7.dist-info/top_level.txt,sha256=MFI15PnPuMv8F1hTAOXbjGu41z-l6dJbnK69WlIQNcM,5
-tsam-2.3.7.dist-info/RECORD,,
+tsam-2.3.9.dist-info/licenses/LICENSE.txt,sha256=XEzEzumoCmdJzcp5gKT6UOtKrkH-SiGpxVbIfihkNK4,1224
+tsam-2.3.9.dist-info/METADATA,sha256=rFczPzsNRAGeYOqnhvswQrNeurdHI4P9FzaUbniQMUs,15412
+tsam-2.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tsam-2.3.9.dist-info/top_level.txt,sha256=MFI15PnPuMv8F1hTAOXbjGu41z-l6dJbnK69WlIQNcM,5
+tsam-2.3.9.dist-info/RECORD,,