avaframe 2.0a0__tar.gz → 2.0a3__tar.gz

{avaframe-2.0a0 → avaframe-2.0a3}/.coveragerc

@@ -7,3 +7,4 @@ sigterm = true
 omit = */test_*
        */__init__.py
        */run*
+       */out3Plot/out*

{avaframe-2.0a0 → avaframe-2.0a3}/.github/workflows/runTestSinglePython.yml

@@ -20,16 +20,16 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-    - uses: prefix-dev/setup-pixi@v0.8.3
-      with:
-        cache: false
-    - name: Pixi run pytest
-      run: |
-        pixi run pytest -ra --cov --cov-report=xml --cov-report lcov:cov.info --cov-config=.coveragerc
-    - uses: qltysh/qlty-action/coverage@main
-      with:
-        coverage-token: ${{secrets.QLTY_COVERAGE_TOKEN}}
-        files: cov.info
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - uses: prefix-dev/setup-pixi@v0.9.1
+        with:
+          cache: false
+      - name: Pixi run pytest
+        run: |
+          pixi run pytest -ra --cov --cov-report=xml --cov-report lcov:cov.info --cov-config=.coveragerc
+      - uses: qltysh/qlty-action/coverage@main
+        with:
+          coverage-token: ${{secrets.QLTY_COVERAGE_TOKEN}}
+          files: cov.info

{avaframe-2.0a0 → avaframe-2.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avaframe
-Version: 2.0a0
+Version: 2.0a3
 Summary: The Open Avalanche Framework
 Author-email: AvaFrame Contributors <felix@avaframe.org>
 License-Expression: EUPL-1.2
@@ -15,7 +15,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: numpy
+Requires-Dist: numpy<2.0
+Requires-Dist: salib<1.5.1
 Requires-Dist: matplotlib
 Requires-Dist: pyshp
 Requires-Dist: scipy
@@ -33,7 +34,6 @@ Requires-Dist: rasterio
 Requires-Dist: contextily
 Requires-Dist: geopandas
 Requires-Dist: fiona
-Requires-Dist: salib
 Dynamic: license-file
 
 **The AvaFrame documentation is hosted on ReadTheDocs: http://docs.avaframe.org**

avaframe-2.0a3/avaframe/RELEASE-VERSION.txt

@@ -0,0 +1 @@
+2.0a3

{avaframe-2.0a0 → avaframe-2.0a3}/avaframe/ana1Tests/energyLineTestCfg.ini

@@ -40,8 +40,8 @@ tSteps = 0:2
 #+++++++++SNOW properties
 #+++++Release thickness++++
 # True if release thickness should be read from shapefile file; if False - relTh read from ini file
-relThFromShp = False
-# release thickness (only considered if relThFromShp=False)
+relThFromFile = False
+# release thickness (only considered if relThFromFile=False)
 relTh = 1
 
 #++++++++++++Time stepping parameters

{avaframe-2.0a0 → avaframe-2.0a3}/avaframe/ana1Tests/rotationTestCfg.ini

@@ -44,8 +44,8 @@ tSteps = 0:2
 #+++++++++SNOW properties
 #+++++Release thickness++++
 # True if release thickness should be read from shapefile file; if False - relTh read from ini file
-relThFromShp = False
-# release thickness (only considered if relThFromShp=False)
+relThFromFile = False
+# release thickness (only considered if relThFromFile=False)
 relTh = 1
 
 #++++++++++++Time stepping parameters

{avaframe-2.0a0 → avaframe-2.0a3}/avaframe/ana1Tests/simiSolTest.py

@@ -943,7 +943,7 @@ def getReleaseThickness(avaDir, cfg, demFile):
     X1 = X / cos
     Y1 = Y
     relTh = Hini * (1 - X1 * X1 / (L_x * L_x) - Y * Y / (L_y * L_y))
-    # relTh = np.where(relTh < 0, 0, relTh)
+    relTh = np.where(relTh < 0, 0, relTh)
 
     relDict = {
         "relTh": relTh,
@@ -959,11 +959,12 @@ def getReleaseThickness(avaDir, cfg, demFile):
     polyline = {}
     polyline["x"] = L_x * np.cos(alpha) * cos
     polyline["y"] = L_x * np.sin(alpha)
-    relFileName = demFile.parent / "REL" / "rel1.shp"
+    fU.makeADir(demFile.parent / "RELShp")
+    relFileName = demFile.parent / "RELShp" / "rel1.shp"
     shpConv.writeLine2SHPfile(polyline, "rel1", str(relFileName))
 
     # write relTh to file
-    relThPath = demFile.parent / "RELTH"
+    relThPath = demFile.parent / "REL"
     fU.makeADir(relThPath)
     relThFileName = relThPath / "releaseThickness.asc"
     headerRelTh = {

{avaframe-2.0a0 → avaframe-2.0a3}/avaframe/ana3AIMEC/aimecTools.py

@@ -101,8 +101,13 @@ def readAIMECinputs(avalancheDir, pathDict, defineRunoutArea, dirName='com1DFA')
 
     referenceTypes = {"referenceLine": "LINE", "referencePolygon": "POLY",'referencePoint': 'POINT'}
     for refType in referenceTypes:
-        referenceFile, availableFile = gI.getAndCheckInputFiles(referenceDir, 'REFDATA', referenceTypes[refType],
-                                                                fileExt="shp", fileSuffix=referenceTypes[refType])
+        referenceFile, availableFile, _ = gI.getAndCheckInputFiles(
+            referenceDir,
+            "REFDATA",
+            referenceTypes[refType],
+            fileExt="shp",
+            fileSuffix=referenceTypes[refType],
+        )
         if availableFile == 'Yes':
             # add file paths to pathDict
             pathDict[refType] = [referenceFile]
@@ -977,34 +982,57 @@ def computeRunOut(cfgSetup, rasterTransfo, resAnalysisDF, transformedRasters, si
     if lindex.any():
         cUpper = min(lindex)
         cLower = max(lindex)
+        runoutFound = True
     else:
         log.warning('No max values > threshold found. threshold = %4.2f, too high?' % thresholdValue)
         cUpper = 0
         cLower = 0
+        runoutFound = False
     # search in mean values
     lindex = np.nonzero(PResCrossMean > thresholdValue)[0]
     if lindex.any():
         cUpperm = min(lindex)
         cLowerm = max(lindex)
+        flagMeanFound = True
     else:
         log.warning('No average values > threshold found. threshold = %4.2f, too high?' % thresholdValue)
         cUpperm = 0
         cLowerm = 0
-    resAnalysisDF.loc[simRowHash, 'sRunout'] = scoord[cLower]
-    index = np.nanargmax(PResRasters[cLower, :])
-    resAnalysisDF.loc[simRowHash, 'lRunout'] = lcoord[index]
-    resAnalysisDF.loc[simRowHash, 'xRunout'] = gridx[cLower, index]
-    resAnalysisDF.loc[simRowHash, 'yRunout'] = gridy[cLower, index]
+        flagMeanFound = False
+
+    if runoutFound:
+        resAnalysisDF.loc[simRowHash, "sRunout"] = scoord[cLower]
+        index = np.nanargmax(PResRasters[cLower, :])
+        resAnalysisDF.loc[simRowHash, "lRunout"] = lcoord[index]
+        resAnalysisDF.loc[simRowHash, "xRunout"] = gridx[cLower, index]
+        resAnalysisDF.loc[simRowHash, "yRunout"] = gridy[cLower, index]
+        resAnalysisDF.loc[simRowHash, "runoutAngle"] = np.rad2deg(
+            np.arctan((zThalweg[cUpper] - zThalweg[cLower]) / (scoord[cLower] - scoord[cUpper]))
+        )
+    else:
+        resAnalysisDF.loc[simRowHash, "sRunout"] = np.nan
+        resAnalysisDF.loc[simRowHash, "lRunout"] = np.nan
+        resAnalysisDF.loc[simRowHash, "xRunout"] = np.nan
+        resAnalysisDF.loc[simRowHash, "yRunout"] = np.nan
+        resAnalysisDF.loc[simRowHash, "runoutAngle"] = np.nan
+
     resAnalysisDF.loc[simRowHash, 'deltaSXY'] = scoord[cLower] - scoord[cUpper]
-    resAnalysisDF.loc[simRowHash, 'runoutAngle'] = np.rad2deg(np.arctan((zThalweg[cUpper] - zThalweg[cLower]) /
-                                                                        (scoord[cLower] - scoord[cUpper])))
-    resAnalysisDF.loc[simRowHash, 'zRelease'] = zThalweg[cUpper]
-    resAnalysisDF.loc[simRowHash, 'zRunout'] = zThalweg[cLower]
-    resAnalysisDF.loc[simRowHash, 'sMeanRunout'] = scoord[cLowerm]
-    resAnalysisDF.loc[simRowHash, 'xMeanRunout'] = x[cLowerm]
-    resAnalysisDF.loc[simRowHash, 'yMeanRunout'] = y[cLowerm]
+
+    if flagMeanFound:
+        resAnalysisDF.loc[simRowHash, "zRunout"] = zThalweg[cLower]
+        resAnalysisDF.loc[simRowHash, "sMeanRunout"] = scoord[cLowerm]
+        resAnalysisDF.loc[simRowHash, "xMeanRunout"] = x[cLowerm]
+        resAnalysisDF.loc[simRowHash, "yMeanRunout"] = y[cLowerm]
+    else:
+        resAnalysisDF.loc[simRowHash, "zRunout"] = np.nan
+        resAnalysisDF.loc[simRowHash, "sMeanRunout"] = np.nan
+        resAnalysisDF.loc[simRowHash, "xMeanRunout"] = np.nan
+        resAnalysisDF.loc[simRowHash, "yMeanRunout"] = np.nan
+
+    resAnalysisDF.loc[simRowHash, "zRelease"] = zThalweg[cUpper]
     resAnalysisDF.loc[simRowHash, 'elevRel'] = zThalweg[cUpper]
     resAnalysisDF.loc[simRowHash, 'deltaZ'] = zThalweg[cUpper] - zThalweg[cLower]
+    resAnalysisDF.loc[simRowHash, "runoutFound"] = runoutFound
 
     return resAnalysisDF
 
@@ -1268,9 +1296,18 @@ def analyzeArea(rasterTransfo, resAnalysisDF, simRowHash, newRasters, cfg, pathD
     inputs['simName'] = simName
 
     compPlotPath = None
-    if simRowHash != refSimRowHash and cfgPlots.getboolean('extraPlots'):
+    if (
+        simRowHash != refSimRowHash
+        and cfgPlots.getboolean("extraPlots")
+        and resAnalysisDF.loc[simRowHash, "runoutFound"]
+    ):
         # only plot comparisons of simulations to reference
         compPlotPath = outAimec.visuComparison(rasterTransfo, inputs, pathDict)
+    elif not resAnalysisDF.loc[simRowHash, "runoutFound"] and cfgPlots.getboolean("extraPlots"):
+        log.warning(
+            "ContourComparisonToReference plot not generated as only 0 values for comparison simulation: %s"
+            % resAnalysisDF.loc[simRowHash, "simName"]
+        )
     # add contourlines to contourDict
     contourDict = outAimec.fetchContourLines(rasterTransfo, inputs, cfgSetup.getfloat('thresholdValue'), contourDict)
 
@@ -1553,9 +1590,13 @@ def addFieldsToDF(inputsDF):
                  'sMeanRunout', 'xMeanRunout', 'yMeanRunout', 'elevRel', 'deltaZ', 'refSim_Diff_sRunout',
                  'refSim_Diff_lRunout', 'dataType', 'runoutLineDiff_line_RMSE', 'runoutLineDiff_poly_RMSE']
 
-    emptyStrFields = ['runoutLineDiff_line_pointsNotFoundInSim',
-                 'runoutLineDiff_line_pointsNotFoundInRef', 'runoutLineDiff_poly_pointsNotFoundInSim',
-                 'runoutLineDiff_poly_pointsNotFoundInRef']
+    emptyStrFields = [
+        "runoutLineDiff_line_pointsNotFoundInSim",
+        "runoutLineDiff_line_pointsNotFoundInRef",
+        "runoutLineDiff_poly_pointsNotFoundInSim",
+        "runoutLineDiff_poly_pointsNotFoundInRef",
+        "runoutFound",
+    ]
 
     for item in nanFields:
         inputsDF = pd.concat([inputsDF, pd.DataFrame({item: np.nan}, index=inputsDF.index)], axis=1).copy()
@@ -1769,11 +1810,22 @@ def analyzeDiffsRunoutLines(cfgSetup, runoutLine, refDataTransformed, resAnalysi
             refLineStr = '%d/%d' % (refLineNoPoints, runoutLineAllPoints)
 
             # compute RMSE between runout line and refLine
-            RMSE = np.sqrt(np.sum(diffNoNans**2)/len(diffNoNans))
+            # set RMSE to nan if no runout line found for sim to compare to reference
+            if np.all(np.isnan(runoutLine["s"])):
+                RMSE = np.nan
+            else:
+                RMSE = np.sqrt(np.sum(diffNoNans**2) / len(diffNoNans))
 
             # plot differences in runout lines
-            outAimec.plotRunoutLineComparisonToReference(cfgSetup, refLine, runoutLine, pathDict, simName, runoutStr,
-                                                         refLineStr, RMSE, diffNoNans)
+            if len(np.where((np.isnan(runoutLine["s"]) == False))[0]) > 0:
+                outAimec.plotRunoutLineComparisonToReference(
+                    cfgSetup, refLine, runoutLine, pathDict, simName, runoutStr, refLineStr, RMSE, diffNoNans
+                )
+            else:
+                log.warning(
+                    "No runout line found for simulation: %s, not creating comparison to reference plot"
+                    % simName
+                )
 
             resAnalysisDF.at[simRowHash, 'runoutLineDiff_%s_pointsNotFoundInSim' % refLine['type']] = runoutStr
             resAnalysisDF.at[simRowHash, 'runoutLineDiff_%s_pointsNotFoundInRef' % refLine['type']] = refLineStr
@@ -1782,4 +1834,4 @@ def analyzeDiffsRunoutLines(cfgSetup, runoutLine, refDataTransformed, resAnalysi
         else:
             log.info('For reference data type %s, runout line comparison is not available' % refLine['type'])
 
-    return resAnalysisDF
+    return resAnalysisDF

{avaframe-2.0a0 → avaframe-2.0a3}/avaframe/ana3AIMEC/ana3AIMEC.py

@@ -352,16 +352,29 @@ def postProcessAIMEC(cfg, rasterTransfo, pathDict, resAnalysisDF, newRasters, ti
                     resAnalysisDF['runoutLineDiff_poly'] = np.nan
                     resAnalysisDF['runoutLineDiff_poly'] = resAnalysisDF['runoutLineDiff_line'].astype(object)
 
-                    # add max, min and std values of result fields
-            resAnalysisDF.at[simRowHash, resType + 'FieldMax'] = np.nanmax(rasterData['rasterData'])
-            # for mean and min values and std, only take peak field values != 0
-            maskedRaster = np.where(rasterData['rasterData'] < cfgSetup.getfloat('minValueField'), np.nan, rasterData['rasterData'])
-            resAnalysisDF.at[simRowHash, resType + 'FieldMin'] = np.nanmin(maskedRaster)
-            resAnalysisDF.at[simRowHash, resType + 'FieldMean'] = np.nanmean(maskedRaster)
-            resAnalysisDF.at[simRowHash, resType + 'FieldStd'] = np.nanstd(maskedRaster)
+            # only extract values if nonzero values found in rasterData; if only 0 values set to 0
+            if np.any(rasterData["rasterData"]):
+                # add max, min and std values of result fields
+                resAnalysisDF.at[simRowHash, resType + "FieldMax"] = np.nanmax(rasterData["rasterData"])
+                # for mean and min values and std, only take peak field values != 0
+                maskedRaster = np.where(
+                    rasterData["rasterData"] < cfgSetup.getfloat("minValueField"),
+                    np.nan,
+                    rasterData["rasterData"],
+                )
+                resAnalysisDF.at[simRowHash, resType + "FieldMin"] = np.nanmin(maskedRaster)
+                resAnalysisDF.at[simRowHash, resType + "FieldMean"] = np.nanmean(maskedRaster)
+                resAnalysisDF.at[simRowHash, resType + "FieldStd"] = np.nanstd(maskedRaster)
+            else:
+                resAnalysisDF.at[simRowHash, resType + "FieldMax"] = 0.0
+                resAnalysisDF.at[simRowHash, resType + "FieldMin"] = 0.0
+                resAnalysisDF.at[simRowHash, resType + "FieldMean"] = 0.0
+                resAnalysisDF.at[simRowHash, resType + "FieldStd"] = 0.0
 
             # analyze all fields
-            resAnalysisDF = aimecTools.analyzeField(simRowHash, rasterTransfo, newRaster, resType, resAnalysisDF)
+            resAnalysisDF = aimecTools.analyzeField(
+                simRowHash, rasterTransfo, newRaster, resType, resAnalysisDF
+            )
 
     # compute runout based on runoutResType
     resAnalysisDF = aimecTools.computeRunOut(cfgSetup, rasterTransfo, resAnalysisDF, newRasters, simRowHash)

{avaframe-2.0a0 → avaframe-2.0a3}/avaframe/ana4Stats/probAna.py

@@ -99,8 +99,9 @@ def cfgFilesGlobalApproach(avaDir, cfgProb, modName, outDir):
         plotDir = avaDir / "Outputs" / "ana4Stats" / "plots"
         if len(paramValuesD["names"]) == 2:
             sP.plotSample(paramValuesD, plotDir, releaseScenario=releaseScenario)
-        elif len(paramValuesD["varParNamesInitial"]) == 2:
-            sP.plotThSampleFromVals(paramValuesD, plotDir)
+        elif "varParNamesInitial" in paramValuesD.keys():
+            if len(paramValuesD["varParNamesInitial"]) == 2:
+                sP.plotThSampleFromVals(paramValuesD, plotDir)
         else:
             log.debug("More or less than two parameters have been varied - no plot of sample available")
 
@@ -314,11 +315,11 @@ def checkParameterSettings(cfg, varParList):
             log.error(message)
             raise AssertionError(message)
         elif varPar in ["entTh", "relTh", "secondaryRelTh"]:
-            thFromShp = varPar + "FromShp"
+            thFromFile = varPar + "FromFile"
             # check if reference settings have already variation of varPar
             _ = checkForNumberOfReferenceValues(cfg["GENERAL"], varPar)
             # check if th read from shp file
-            if cfg["GENERAL"].getboolean(thFromShp):
+            if cfg["GENERAL"].getboolean(thFromFile):
                 thReadFromShp.append(varPar)
 
     return True, thReadFromShp