Sign upLogin

avaframe/AvaFrame

View on GitHub
Star

Showing 280 of 937 total issues

Function plotProbMap has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
Open

def plotProbMap(avaDir, inDir, cfgFull, demPlot=False):
    """ plot probability maps including contour lines

        Parameters
        ----------
Severity: Minor
Found in avaframe/out3Plot/statsPlots.py - About 3 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function writeReport has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
Open

def writeReport(outDir, reportDictList, reportOneFile, plotDict='', standaloneReport=False,
                reportName='fullSimulationReport'):
    """ Write a report in markdown format for simulations, saved to outDir

        Parameters
Severity: Minor
Found in avaframe/log2Report/generateReport.py - About 3 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function updateCfgRange has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
Open

def updateCfgRange(cfg, cfgProb, varName, varDict):
    """ update cfg with a range for parameters in cfgProb

        Parameters
        -----------
Severity: Minor
Found in avaframe/ana4Stats/probAna.py - About 3 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function animationPlot has 93 lines of code (exceeds 30 allowed). Consider refactoring.
Open

def animationPlot(demData, data, cellSize, resType, cfgRangeTime, mtiInfo, timeStep):
    """3 panel plot: result in x,y, result in s, l, tt diagram

    Parameters
    -----------
Severity: Major
Found in avaframe/out3Plot/outDistanceTimeAnalysis.py - About 3 hrs to fix

    Function generatePlot has 88 lines of code (exceeds 30 allowed). Consider refactoring.
    Open

    def generatePlot(dataDict, avaName, outDir, cfg, plotDict, crossProfile=True):
    """ Create comparison plots of two ascii datasets

        This function creates two plots, one plot with four panels with, first dataset, second dataset,
        the absolute difference of the two datasets and the absolute difference capped to a smaller range
    Severity: Major
    Found in avaframe/out3Plot/outQuickPlot.py - About 3 hrs to fix

      Function visuComparison has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
      Open

      def visuComparison(rasterTransfo, inputs, pathDict):
    """
    Plot and save the comparison between current simulation and Reference
    in the runout area
      Severity: Minor
      Found in avaframe/out3Plot/outAIMEC.py - About 3 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function checkCfgFrictionModel has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
      Open

      def checkCfgFrictionModel(cfg, relVolume=''):
    """ check which friction model is chosen and if friction model parameters are of valid type
        if samosATAuto - check if

        relVolume < volClassSmall - set frictModel=samosATSmall
      Severity: Minor
      Found in avaframe/com1DFA/checkCfg.py - About 3 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function makeSimDF has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
      Open

      def makeSimDF(inputDir, avaDir='', simID='simID'):
    """ Create a  dataFrame that contains all info on simulations

        this can then be used to filter simulations for example
      Severity: Minor
      Found in avaframe/in3Utils/fileHandlerUtils.py - About 3 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function initializeParticles has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
      Open

      def initializeParticles(cfg, releaseLine, dem, inputSimLines="", logName="", relThField=""):
    """Initialize DFA simulation

    Create particles and fields dictionary according to config parameters
    release raster and dem
      Severity: Minor
      Found in avaframe/com1DFA/com1DFA.py - About 3 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function updateThicknessCfg has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
      Open

      def updateThicknessCfg(inputSimFiles, cfgInitial):
    """add available release scenarios to ini file and
    set thickness values in ini files

    Parameters
      Severity: Minor
      Found in avaframe/in1Data/getInput.py - About 3 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function makeSimFromResDF has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
      Open

      def makeSimFromResDF(avaDir, comModule, inputDir='', simName=''):
    """ Create a  dataFrame that contains all info on simulations in output/comModule/peakFiles

        One line for each simulation - so all peakfiles that belong to one simulation are listed in one line
        that corresponds to that simulation
      Severity: Minor
      Found in avaframe/in3Utils/fileHandlerUtils.py - About 3 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function extractMaxValues has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
      Open

      def extractMaxValues(inputDir, avaDir, varPar, restrictType='', nameScenario='', parametersDict=''):
    """ Extract max values of result parameters and save to dictionary

        - optionally restrict data of peak fields by defining which result parameter with restrictType,
          provide nameScenario and a parametersDict to filter simulations
      Severity: Minor
      Found in avaframe/ana4Stats/getStats.py - About 3 hrs to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function plotDamBreakSummary has 80 lines of code (exceeds 30 allowed). Consider refactoring.
      Open

      def plotDamBreakSummary(
    avalancheDir,
    timeList,
    fieldsList,
    fieldHeader,
      Severity: Major
      Found in avaframe/out3Plot/outAna1Plots.py - About 3 hrs to fix

        Function applyCfgOverride has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.
        Open

        def applyCfgOverride(cfgToOverride, cfgWithOverrideParameters, module, addModValues=False):
    """override configuration parameter values with the values provided in cfgWithOverrideParameters[modName_override]
    if addModValues True update the cfgWithOverrideParameters with the values for all parameters that are not
    provided in the override parameters
        Severity: Minor
        Found in avaframe/in3Utils/cfgHandling.py - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function setThicknessValueFromVariation has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.
        Open

        def setThicknessValueFromVariation(key, cfg, simType, row):
    """ set thickness value for thickness parameter for all features if multiple according to
        desired variation

        Parameters
        Severity: Minor
        Found in avaframe/com1DFA/deriveParameterSet.py - About 2 hrs to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        File com2AB.py has 329 lines of code (exceeds 300 allowed). Consider refactoring.
        Open

        """
    Main module for Alpha beta

"""
        Severity: Minor
        Found in avaframe/com2AB/com2AB.py - About 2 hrs to fix

          Function getSimTypeList has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
          Open

          def getSimTypeList(standardCfg, simTypeList, inputSimFiles):
    """Define available simulation types of requested types

    Parameters
    -----------
          Severity: Minor
          Found in avaframe/com1DFA/com1DFA.py - About 2 hrs to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function exportFields has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
          Open

          def exportFields(cfg, Tsave, fieldsList, dem, outDir, logName):
    """export result fields to Outputs directory according to result parameters and time step
    that can be specified in the configuration file

    Parameters
          Severity: Minor
          Found in avaframe/com1DFA/com1DFA.py - About 2 hrs to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function extractFrontAndMeanValuesTT has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
          Open

          def extractFrontAndMeanValuesTT(cfgRangeTime, flowF, demHeader, mtiInfo):
    """ extract avalanche front and mean values of flow parameter result field
        used for colorcoding range-time diagram

        Parameters
          Severity: Minor
          Found in avaframe/ana5Utils/distanceTimeAnalysis.py - About 2 hrs to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function generateCom1DFAPathPlot has 67 lines of code (exceeds 30 allowed). Consider refactoring.
          Open

          def generateCom1DFAPathPlot(avalancheDir, cfgPath, avaProfileMass, dem, parabolicFit, splitPoint, simName):
    """ Make energy test analysis and plot results

    Parameters
    -----------
          Severity: Major
          Found in avaframe/out3Plot/outCom3Plots.py - About 2 hrs to fix
            Severity
            Category
            Status
            Source
            Language