Python test driver for quasiconvexity tests

quasiconvexity-micromorphic-testsuite/quasiconvexity-micromorphic-testsuite.py

+import subprocess
+
+numLevels = 3
+
+c = 1
+
+processList = []
+
+for L_c in [1,10,100]:
+
+    for x0 in [0.2, 0.5, 2]:
+
+        LOGFILE = "./quasiconvexity_micromorphic_" + str(numLevels) + "_" + str(L_c) + "_" + str(x0) + ".log"
+
+        ##  run the actual simulation
+        proc = subprocess.Popen("./quasiconvexity-test-micromorphic quasiconvexity-circle-magic.parset"
+                                           + " -materialParameters.c " + str(c)
+                                           + " -L_c " + str(L_c)
+                                           + " -x0 " + str(x0)
+                                           + " -numLevels " + str(numLevels)
+                                           + " | tee " + LOGFILE, shell=True)
+        processList.append(proc)
+
+        # Wait for all simulation subprocesses before proceeding to the error measurement step
+        #exit_codes = [proc.wait() for p in processList]
+
+
+

quasiconvexity-micromorphic-testsuite/render-quasiconvexity-test-results.py

+#### import the simple module from the paraview
+from paraview.simple import *
+
+# For pattern matching
+import re
+
+#### disable automatic camera reset on 'Show'
+paraview.simple._DisableFirstRenderCameraReset()
+
+# get the material library
+materialLibrary1 = GetMaterialLibrary()
+
+# Render result
+def renderResult(filePrefix, texFile):
+
+    # ----------------------------------------------------------------
+    # setup views used in the visualization
+    # ----------------------------------------------------------------
+
+    # Create a new 'Render View'
+    renderView1 = CreateView('RenderView')
+    renderView1.ViewSize = [1000, 695]
+    renderView1.InteractionMode = '2D'
+    renderView1.AxesGrid = 'GridAxes3DActor'
+    renderView1.StereoType = 'Crystal Eyes'
+    renderView1.CameraPosition = [0.0, 0.0, 10000.0]
+    renderView1.CameraFocalDisk = 1.0
+    renderView1.CameraParallelScale = 1.4142135623730951
+    renderView1.BackEnd = 'OSPRay raycaster'
+    renderView1.OSPRayMaterialLibrary = materialLibrary1
+
+    SetActiveView(None)
+
+    # ----------------------------------------------------------------
+    # setup view layouts
+    # ----------------------------------------------------------------
+
+    # create new layout object 'Layout #1'
+    layout1 = CreateLayout(name='Layout #1')
+    layout1.AssignView(0, renderView1)
+    layout1.SetSize(1247, 695)
+
+    # ----------------------------------------------------------------
+    # restore active view
+    SetActiveView(renderView1)
+    # ----------------------------------------------------------------
+
+    # ----------------------------------------------------------------
+    # setup the data processing pipelines
+    # ----------------------------------------------------------------
+
+    # create a new 'XML Unstructured Grid Reader'
+    data = XMLUnstructuredGridReader(registrationName=filePrefix + ".vtu", FileName=['/home/sander/dune/dune-elasticity/quasiconvexity-micromorphic-testsuite/' + filePrefix + ".vtu"])
+    data.CellArrayStatus = ['determinant', 'K']
+    data.TimeArray = 'None'
+
+    # ----------------------------------------------------------------
+    # setup the visualization in view 'renderView1'
+    # ----------------------------------------------------------------
+
+    # show data from 'data'
+    dataDisplay = Show(data, renderView1, 'UnstructuredGridRepresentation')
+
+    determinantRange = data.CellData[0].GetRange()   # Let's hope this is determinant
+    texFile.write("det range: " + str(determinantRange[0]) + ",  " + str(determinantRange[1]) + "\n\n")
+
+    KRange = data.CellData[1].GetRange()   # Let's hope this is K
+    texFile.write("K range: " + str(KRange[0]) + ",  " + str(KRange[1]) + "\n\n")
+
+    # get color transfer function/color map for 'determinant'
+    #determinantLUT = GetColorTransferFunction('determinant')
+    #determinantLUT.RGBPoints = [-0.016938600689172745, 0.231373, 0.298039, 0.752941, 0.8577657174319029, 0.865003, 0.865003, 0.865003, 1.7324700355529785, 0.705882, 0.0156863, 0.14902]
+    #determinantLUT.ScalarRangeInitialized = 1.0
+    determinantLUT = MakeBlueToRedLT(determinantRange[0], determinantRange[1])
+    KLUT = MakeBlueToRedLT(KRange[0], KRange[1])
+
+
+    # get opacity transfer function/opacity map for 'determinant'
+    determinantPWF = GetOpacityTransferFunction('determinant')
+    determinantPWF.Points = [-0.016938600689172745, 0.0, 0.5, 0.0, 1.7324700355529785, 1.0, 0.5, 0.0]
+    determinantPWF.ScalarRangeInitialized = 1
+
+    # trace defaults for the display properties.
+    dataDisplay.Representation = 'Surface'
+    dataDisplay.ColorArrayName = ['CELLS', 'determinant']
+    dataDisplay.LookupTable = determinantLUT
+    dataDisplay.SelectTCoordArray = 'None'
+    dataDisplay.SelectNormalArray = 'None'
+    dataDisplay.SelectTangentArray = 'None'
+    dataDisplay.OSPRayScaleFunction = 'PiecewiseFunction'
+    dataDisplay.SelectOrientationVectors = 'None'
+    dataDisplay.ScaleFactor = 0.2
+    dataDisplay.SelectScaleArray = 'determinant'
+    dataDisplay.GaussianRadius = 0.01
+    dataDisplay.SetScaleArray = [None, '']
+    dataDisplay.ScaleTransferFunction = 'PiecewiseFunction'
+    dataDisplay.OpacityArray = [None, '']
+    dataDisplay.OpacityTransferFunction = 'PiecewiseFunction'
+    dataDisplay.DataAxesGrid = 'GridAxesRepresentation'
+    dataDisplay.PolarAxes = 'PolarAxesRepresentation'
+
+    # setup the color legend parameters for each legend in this view
+
+    # get color legend/bar for determinantLUT in view renderView1
+    determinantLUTColorBar = GetScalarBar(determinantLUT, renderView1)
+    determinantLUTColorBar.Title = 'determinant'
+    determinantLUTColorBar.ComponentTitle = ''
+
+    # set color bar visibility
+    determinantLUTColorBar.Visibility = 1
+
+    # show color legend
+    dataDisplay.SetScalarBarVisibility(renderView1, True)
+
+    Render()
+
+    #save screenshot
+    WriteImage(filePrefix + "-det.png")
+
+    # Render again, showing the K value
+    determinantLUTColorBar.Visibility = 0
+    dataDisplay.ColorArrayName = ['CELLS', 'K']
+    dataDisplay.LookupTable = KLUT
+
+    # get color legend/bar for determinantLUT in view renderView1
+    determinantLUTColorBar = GetScalarBar(KLUT, renderView1)
+    determinantLUTColorBar.Title = 'K'
+    determinantLUTColorBar.ComponentTitle = ''
+
+    # set color bar visibility
+    determinantLUTColorBar.Visibility = 1
+
+    # show color legend
+    dataDisplay.SetScalarBarVisibility(renderView1, True)
+
+    Render()
+
+    #save screenshot
+    WriteImage(filePrefix + "-K.png")
+
+    # ----------------------------------------------------------------
+    # setup color maps and opacity mapes used in the visualization
+    # note: the Get..() functions create a new object, if needed
+    # ----------------------------------------------------------------
+
+    # ----------------------------------------------------------------
+    # restore active source
+    SetActiveSource(data)
+    # ----------------------------------------------------------------
+
+
+    if __name__ == '__main__':
+        # generate extracts
+        SaveExtracts(ExtractsOutputDirectory='extracts')
+
+
+# Open output document and write LaTeX header
+texFile = open(r"quasiconvexity-test-micromorphic-results.tex","w+")
+
+texFile.write("\documentclass[a4paper,10pt]{article}\n")
+texFile.write("\\usepackage[utf8]{inputenc}\n")
+texFile.write("\\usepackage{graphicx}\n")
+texFile.write("\\usepackage{hyperref}\n")
+
+texFile.write("\\title{Minimizers of a micromorphically relaxed magic functional}\n")
+texFile.write("\\author{Oliver Sander}\n")
+
+texFile.write("\\begin{document}\n")
+
+texFile.write("\maketitle\n")
+
+levels = 3
+
+# Render the results
+for L_c in [1,10,100]:
+
+    for x0 in [0.2, 0.5, 2]:
+
+        # Start a new section
+        texFile.write("\\newpage\n")
+        texFile.write("\\section{$L_c = " + str(L_c) + "$, $x_0 = " + str(x0) + "$}\n")
+
+        # Get the energy values from the corresponding log file
+        logfilename = "quasiconvexity_micromorphic_" + str(levels) + "_" + str(L_c) + "_" + str(x0) + ".log"
+        logFile = open(logfilename)
+
+        for line in logFile:
+
+            # Search for the line with the energy of the homogeneous solution
+            if (re.search("Trust-Region Step Number: 0", line)):
+                initialRadius, initialEnergy = re.findall("-?\d+\.\d+", line)
+                if (initialEnergy):
+                    texFile.write("Homogeneous energy: " + str(initialEnergy) + "\n\n")
+
+            # Search for the final energy without regularization
+            if (re.search("Energy without regularization:", line)):
+                energy = re.findall("-?\d+\.\d+", line)
+                if (energy):
+                    texFile.write("Final energy without regularization: " + str(energy) + "\n\n")
+
+            # Search for the final energy with regularization
+            if (re.search("Energy with regularization:", line)):
+                energy = re.findall("-?\d+\.\d+", line)
+                if (energy):
+                    texFile.write("Final energy with regularization: " + str(energy) + "\n\n")
+
+        # Use ParaView to render the result
+        L_c_string = format(L_c, 'f')
+        x0_string = format(x0, 'f')
+        prefix = "quasiconvexity-test-micromorphic-result_" + L_c_string + "_" + x0_string
+        renderResult(prefix, texFile)
+
+        # Include the creates image into the tex file
+        texFile.write("\\begin{center}\n")
+        texFile.write("\\includegraphics[width=\\textwidth]{" + prefix + "-det}\n\n")
+        texFile.write("\\vspace{0.05\\textheight}\n\n")
+        texFile.write("\\includegraphics[width=\\textwidth]{" + prefix + "-K}\n")
+        texFile.write("\\end{center}\n")
+
+texFile.write("\end{document}\n")
+
+texFile.close()