patme 0.4.4__tar.gz → 0.4.5__tar.gz

{patme-0.4.4 → patme-0.4.5}/PKG-INFO

@@ -1,8 +1,10 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: patme
-Version: 0.4.4
+Version: 0.4.5
 Summary: Utilities for software builds, documentation, cluster interaction, calling fem tools, logging, exceptions and simple geometric and mechanical operations.
 License: DLR 2025
+License-File: LICENSE
+License-File: LICENSES/MIT.txt
 Keywords: build,cluster,fem,log,exception
 Author: Sebastian Freund
 Author-email: sebastian.freund@dlr.de
@@ -16,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: importlib_metadata
 Requires-Dist: numpy (<2)
 Requires-Dist: scipy
@@ -37,6 +40,7 @@ SPDX-License-Identifier: MIT
 
 Utilities for basic software engineering, geometry, mechanics support and infrastructure handling.
 
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.15591827.svg)](https://doi.org/10.5281/zenodo.15591827) 
 [![pipeline status](https://gitlab.dlr.de/sy-stm/software/patme/badges/master/pipeline.svg)](https://gitlab.dlr.de/sy-stm/software/patme/-/commits/master)
 [![coverage report](https://gitlab.dlr.de/sy-stm/software/patme/badges/master/coverage.svg)](https://ggitlab.dlr.de/sy-stm/software/patme/-/commits/master)
 [![Latest Release](https://gitlab.dlr.de/sy-stm/software/patme/-/badges/release.svg)](https://gitlab.dlr.de/sy-stm/software/patme/-/releases)

{patme-0.4.4 → patme-0.4.5}/README.md

@@ -8,6 +8,7 @@ SPDX-License-Identifier: MIT
 
 Utilities for basic software engineering, geometry, mechanics support and infrastructure handling.
 
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.15591827.svg)](https://doi.org/10.5281/zenodo.15591827) 
 [![pipeline status](https://gitlab.dlr.de/sy-stm/software/patme/badges/master/pipeline.svg)](https://gitlab.dlr.de/sy-stm/software/patme/-/commits/master)
 [![coverage report](https://gitlab.dlr.de/sy-stm/software/patme/badges/master/coverage.svg)](https://ggitlab.dlr.de/sy-stm/software/patme/-/commits/master)
 [![Latest Release](https://gitlab.dlr.de/sy-stm/software/patme/-/badges/release.svg)](https://gitlab.dlr.de/sy-stm/software/patme/-/releases)

{patme-0.4.4 → patme-0.4.5}/pyproject.toml

@@ -4,7 +4,7 @@
 
 [project]
 name = "patme"
-version = "0.4.4"
+version = "0.4.5"
 description = "Utilities for software builds, documentation, cluster interaction, calling fem tools, logging, exceptions and simple geometric and mechanical operations."
 license = "DLR 2025"
 authors = [

{patme-0.4.4 → patme-0.4.5}/src/patme/femtools/fecall.py

@@ -70,6 +70,10 @@ class ResultLogFileChecker:
     def checkResultLogFile(self, jobName):
         """returns true if no specified errors are found"""
         errorFileName, errorPattern = self.getErrorFileAndErrorPattern(jobName)
+        if not os.path.exists(errorFileName):
+            log.info(f"{errorFileName} not found. Try {jobName}_err.log")
+            errorFileName = os.path.join(self.runDir, f"{jobName}_err.log")
+
         if not os.path.exists(errorFileName):
             log.error(f"Did not find given error file {errorFileName}")
             return None
@@ -117,6 +121,7 @@ class FECaller(ResultLogFileChecker, ClusterCaller):
         self.activateLicenseCheck = True
 
         self._useNumberOfCores = 2
+        self._jobName = os.path.basename(os.path.splitext(self.feFilename)[0])
 
     @staticmethod
     def isLicenseAvailable():
@@ -134,7 +139,7 @@ class FECaller(ResultLogFileChecker, ClusterCaller):
         :returns: True if there were no errors occured when calling the fe solver with the given input file
         """
         if not jobName:
-            jobName = os.path.splitext(os.path.basename(self.feFilename))[0]
+            jobName = self.jobName
 
         if doRemoteCall:
             try:
@@ -143,7 +148,7 @@ class FECaller(ResultLogFileChecker, ClusterCaller):
                 self.runRemote(copyFilesLocalToHost, jobName, **kwargs)
                 # check error file after remote files were copied to local machine
                 if not self.checkResultLogFile(jobName):
-                    doRemoteCall = False
+                    self.remoteCallFailed = True
                 else:
                     retVal = 8
 
@@ -184,25 +189,14 @@ class FECaller(ResultLogFileChecker, ClusterCaller):
             msg += f"Acutal path: {toolexe}"
             raise InternalError(msg)
 
-        toStderr = kwargs.pop("toStderr", None)
-        if toStderr and isinstance(toStderr, str):
-            toStderr = open(toStderr, "w+")
-        elif not toStderr:
-            toStderr = os.path.join(self.runDir, f"{jobName}_err.log")
-            toStderr = open(toStderr, "w+")
-
-        toStdout = kwargs.pop("toStdout", None)
-        if toStdout and isinstance(toStdout, str):
-            toStdout = open(toStdout, "w+")
-        elif not toStdout:
-            toStdout = os.path.join(self.runDir, f"{jobName}_out.log")
-            toStdout = open(toStdout, "w+")
+        toStderr = os.path.join(self.runDir, f"{jobName}_err.log")
+        toStdout = os.path.join(self.runDir, f"{jobName}_out.log")
 
         retVal = subprocess.call(
             self.localCmds,
             cwd=self.runDir,
-            stderr=toStderr,
-            stdout=toStdout,
+            stderr=open(toStderr, "w+"),
+            stdout=open(toStdout, "w+"),
             shell=self.localSubProcessSettings.get("shell", False),
         )
 
@@ -243,7 +237,17 @@ class FECaller(ResultLogFileChecker, ClusterCaller):
     def _setNumberOfCores(self, numCores):
         self._useNumberOfCores = numCores
 
+    def _getJobName(self):
+        if self._jobName is None:
+            self._jobName = os.path.basename(os.path.splitext(self.feFilename)[0])
+
+        return self._jobName
+
+    def _setJobName(self, jobName):
+        self._jobName = jobName
+
     useNumberOfCores = property(fget=_getNumberOfCores, fset=_setNumberOfCores)
+    jobName = property(fget=_getJobName, fset=_setJobName)
 
 
 class AnsysCaller(FECaller):
@@ -334,7 +338,7 @@ class AnsysCaller(FECaller):
         log.info("Check Ansys license availability.")
         return 1 <= availableFlexlmLicenseTokens(licenseServerString, ansysLicense)
 
-    def generateSolverSpecificRemoteCmds(self):
+    def generateSolverSpecificRemoteCmds(self, jobName):
         """doc"""
         baseFileInDir = os.path.basename(self.feFilename)
         base, _ = os.path.splitext(baseFileInDir)
@@ -457,7 +461,7 @@ class NastranCaller(FECaller):
         if platform.system() == "Linux":
             self.localCmds.insert(5, "batch=no")
 
-    def generateSolverSpecificRemoteCmds(self):
+    def generateSolverSpecificRemoteCmds(self, jobName):
         """doc"""
         baseFileInDir = os.path.basename(self.feFilename)
         if self.clusterName == "cara":
@@ -503,10 +507,10 @@ class AbaqusCaller(FECaller):
     """This class realizes an interface to Abaqus"""
 
     clusterAbaqusName = "abq2023"
+    solverName = "Abaqus"
 
     def __init__(self, **kwargs):
         FECaller.__init__(self, **kwargs)
-        self.solverName = "Abaqus"
         # eclipse adds some env variabels that do not work with abaqus
         os.environ.pop("PYTHONIOENCODING", None)
 
@@ -518,8 +522,8 @@ class AbaqusCaller(FECaller):
         os.makedirs(tmpScratchFilesPath, exist_ok=True)
 
         self.localCmds = [
-            abaqusPath,
-            "job=%s" % os.path.basename(os.path.splitext(self.feFilename)[0]),
+            kwargs.pop("abaqusPath", abaqusPath),
+            f"job={self.jobName}",
             "interactive",
             "-scratch",
             "abaqusScratch",
@@ -546,14 +550,14 @@ class AbaqusCaller(FECaller):
     def getErrorFileAndErrorPattern(self, jobName):
         """doc"""
         basePath = os.path.dirname(self.feFilename)
-        baseName = jobName if jobName else os.path.splitext(os.path.basename(self.feFilename))[0]
+        baseName = jobName if jobName else self.jobName
         useMsgFile = True
         if useMsgFile:
             filename = os.path.join(basePath, baseName + ".msg")
-            errorPattern = re.compile(r"\*{3}ERROR", RE_MULTILINE)
+            errorPattern = re.compile(r"\*{3}ERROR|Errno\s\d+", RE_MULTILINE)
         else:
             filename = os.path.join(basePath, baseName + ".dat")
-            errorPattern = re.compile(r"(error|Error)", RE_MULTILINE)
+            errorPattern = re.compile(r"(error|Error|Errno\s\d+)", RE_MULTILINE)
         return filename, errorPattern
 
     @staticmethod
@@ -578,14 +582,16 @@ class AbaqusCaller(FECaller):
         log.debug(f"Number of possible abaqus runs: {numLic}")
         return numLic
 
-    def generateSolverSpecificRemoteCmds(self):
+    def generateSolverSpecificRemoteCmds(self, jobName):
         """doc"""
         baseFileInDir = os.path.basename(self.feFilename)
         cmds = []
         if "cara" in self.clusterName:
             cmds += [
-                "module load env/easybuild",
-                "module load ABAQUS/2023",
+                "module load env/spack",
+                "module load rev/23.05_r8",
+                "module load abaqus/2023",
+                f"touch {jobName}.msg",
             ]
         cmds.append(
             f"{self.clusterAbaqusName} job={baseFileInDir} interactive -scratch abaqusScratch -cpus {self.useNumberOfCores}"
@@ -606,7 +612,8 @@ class AbaqusPythonCaller(AbaqusCaller):
 
     def __init__(self, **kwargs):
         AbaqusCaller.__init__(self, **kwargs)
-        self.solverName = "AbaqusPython"
+        cae = kwargs.pop("cae", False)
+        self.solverName = "AbaqusPython" if not cae else "AbaqusCaePython"
         # eclipse adds some env variabels that do not work with abaqus
         os.environ.pop("PYTHONIOENCODING", None)
 
@@ -614,34 +621,40 @@ class AbaqusPythonCaller(AbaqusCaller):
         if not self.pythonScriptPath:
             raise ImproperParameterError("python script was not given!")
 
-        pyArguments = kwargs.pop("arguments", [])
-
-        callParams = ["python", self.pythonScriptPath] + pyArguments
+        callParams = [abaqusPath]
+        if not cae:
+            callParams += ["python", self.pythonScriptPath]
+        else:
+            # instead of "noGUI" use "script" if cae should be opened in gui mode (it does not close automatically with "script")
+            callParams += ["cae", "noGUI=" + self.pythonScriptPath]
 
-        baseFile, _ = os.path.splitext(self.feFilename)
-        callParams += [">", f"{baseFile}.msg"]
+        callParams += kwargs.pop("arguments", [])
 
-        self.localCmds = [abaqusPath] + callParams
+        self.localCmds = callParams
 
-    def generateSolverSpecificRemoteCmds(self):
+    def generateSolverSpecificRemoteCmds(self, jobName):
         """doc"""
         baseFile, ext = os.path.splitext(os.path.basename(self.feFilename))
 
-        callParms = self.localCmds[1:]
         pyScriptBaseDir = os.path.dirname(self.pythonScriptPath)
         pyScriptBaseFile = os.path.basename(self.pythonScriptPath)
 
         if pyScriptBaseDir != self.runDir:
             shutil.copy(self.pythonScriptPath, self.runDir)
 
-        callParms[1] = pyScriptBaseFile
-        callParms[-1] = f"{baseFile}.msg"
+        callParms = self.localCmds[1:]
+        if "cae" in callParms[0]:
+            callParms[1] = "noGUI=" + pyScriptBaseFile
+        else:
+            callParms[1] = pyScriptBaseFile
 
         runScriptCmds = []
         if "cara" in self.clusterName:
             runScriptCmds += [
-                "module load env/easybuild",
-                "module load ABAQUS/2023",
+                "module load env/spack",
+                "module load rev/23.05_r8",
+                "module load abaqus/2023",
+                f"touch {jobName}.msg",
             ]
 
         runScriptCmds.append(f"basefile={baseFile}")
@@ -661,7 +674,7 @@ class AbaqusPythonCaller(AbaqusCaller):
         return runScriptCmds
 
 
-class AbaqusPythonCaeCaller(AbaqusCaller):
+class AbaqusPythonCaeCaller(AbaqusPythonCaller):
     """This class realizes an interface to AbaqusCAE to call a Python script in an specified directory with the specified
     input filename.
     :param pythonSkriptPath: name of Abaqus Python input file optionally with relative or absolute path
@@ -671,19 +684,8 @@ class AbaqusPythonCaeCaller(AbaqusCaller):
     """
 
     def __init__(self, **kwargs):
-        FECaller.__init__(self, **kwargs)
-        self.solverName = "AbaqusCaePython"
-        # eclipse adds some env variabels that do not work with abaqus
-        os.environ.pop("PYTHONIOENCODING", None)
-
-        pythonScriptPath = kwargs.pop("pythonSkriptPath", None)
-        if not pythonScriptPath:
-            raise ImproperParameterError("python script was not given!")
-
-        pyArguments = kwargs.pop("arguments", [])
-        # instead of "noGUI" use "script" if cae should be opened in gui mode (it does not close automatically with "script")
-
-        self.localCmds = [abaqusPath, "cae", "noGUI=" + pythonScriptPath] + pyArguments
+        kwargs["cae"] = True
+        AbaqusPythonCaller.__init__(self, **kwargs)
 
 
 class B2000ppCaller(FECaller):
@@ -695,6 +697,8 @@ class B2000ppCaller(FECaller):
         FECaller.__init__(self, **kwargs)
 
         b2000Run = shutil.which("b2000++")
+        if not b2000Run:
+            b2000Run = "b2000++"
 
         self.localCmds = [b2000Run, self.feFilename]
 
@@ -727,7 +731,7 @@ class B2000ppCaller(FECaller):
 
         return FECaller.runLocal(self, jobName, **kwargs)
 
-    def generateSolverSpecificRemoteCmds(self):
+    def generateSolverSpecificRemoteCmds(self, jobName):
         """doc"""
 
         baseFileInDir = os.path.basename(self.feFilename)
@@ -746,7 +750,11 @@ class B2000ppCaller(FECaller):
         if ext == ".bdf":
             runScriptCmds.append(f"b2convert_from_nas {baseFileInDir} {baseFile}.mdl")
 
-        runScriptCmds.append(f"b2000++ {baseFile}.mdl")
+        runScriptCmds += [
+            f"b2ip++ {baseFile}.mdl",
+            f"b2000++ {baseFile}.b2m",
+            f"mv {baseFile}.b2m/log.txt {jobName}.log",
+        ]
 
         if "b2mconv.py" in os.listdir(self.runDir):
 
@@ -756,27 +764,29 @@ class B2000ppCaller(FECaller):
 
     def getErrorFileAndErrorPattern(self, jobName):
         """doc"""
-        resDir = self.feFilename.replace(".mdl", ".b2m")
-        errorFile = os.path.join(resDir, "log.txt")
+        errorFile = os.path.join(self.runDir, f"{jobName}.log")
         if not os.path.exists(errorFile):
             errorFile = ""
 
-        return errorFile, re.compile("CRITICAL", RE_MULTILINE)
+        return errorFile, re.compile("CRITICAL|error|ERROR|Invalid", RE_MULTILINE)
 
 
 class B2000ModelToDatabase(B2000ppCaller):
+
+    solverName = "b2ip++"
+
     def __init__(self, **kwargs):
 
         B2000ppCaller.__init__(self, **kwargs)
-        self.solverName = "b2ip++"
 
         b2ipTool = shutil.which("b2ip++")
+        if not b2ipTool:
+            b2ipTool = "b2ip++"
 
         basename = os.path.basename(self.feFilename)
-        baseDir = os.path.dirname(self.feFilename)
         base, _ = os.path.splitext(basename)
 
-        workingDir = kwargs.pop("feWorkDir", baseDir)
+        workingDir = kwargs.pop("feWorkDir", os.path.dirname(self.feFilename))
         dbFile = os.path.join(workingDir, f"{base}.b2m")
 
         self.localCmds = [b2ipTool, self.feFilename, dbFile]
@@ -785,17 +795,18 @@ class B2000ModelToDatabase(B2000ppCaller):
         """doc"""
         return FECaller.runLocal(self, jobName, **kwargs)
 
-    def checkResultLogFile(self, jobName):
-        return True
-
 
 class B2000FromBDFConverter(B2000ppCaller):
+
+    solverName = "b2convert_from_nas"
+
     def __init__(self, **kwargs):
 
         B2000ppCaller.__init__(self, **kwargs)
-        self.solverName = "b2convert_from_nas"
 
         b2convTool = shutil.which("b2convert_from_nas")
+        if not b2convTool:
+            b2convTool = "b2convert_from_nas"
 
         toMdlFile = kwargs.pop("toMdlFile", None)
         if toMdlFile is None:
@@ -804,7 +815,7 @@ class B2000FromBDFConverter(B2000ppCaller):
 
         self.localCmds = [b2convTool, self.feFilename, toMdlFile]
 
-    def generateSolverSpecificRemoteCmds(self):
+    def generateSolverSpecificRemoteCmds(self, jobName):
         """doc"""
         baseFileInDir = os.path.basename(self.feFilename)
         baseFile, _ = os.path.splitext(baseFileInDir)
@@ -818,97 +829,79 @@ class B2000FromBDFConverter(B2000ppCaller):
         ]
         return runScriptCmds
 
-    def checkResultLogFile(self, jobName):
-        return True
 
+class OpenRadiossCaller(FECaller):
 
-class B2MToPickleConverterCARA(B2000ppCaller):
-
-    REMOTE_SCRIPT = "run_b2mToPickle.sh"
-    solverName = "b2mToPickle"
+    solverName = "OpenRadioss"
 
     def __init__(self, **kwargs):
-
-        B2000ppCaller.__init__(self, **kwargs)
-
-        self.pythonScriptPath = kwargs.pop("pythonScript", None)
-        if not self.pythonScriptPath:
-            raise Exception("python script was not given!")
-
-        pyArguments = kwargs.pop("arguments", [])
-
-        callParams = ["python", self.pythonScriptPath] + pyArguments
-
-        baseFile, _ = os.path.splitext(self.feFilename)
-        callParams += [">", f"{baseFile}.msg"]
-
-        self.localCmds = callParams
-
-    def generateSolverSpecificRemoteCmds(self):
         """doc"""
-        baseFileInDir = os.path.basename(self.feFilename)
-        baseFile, _ = os.path.splitext(baseFileInDir)
-
-        pyScriptBaseDir = os.path.dirname(self.pythonScriptPath)
-        pyScriptBaseFile = os.path.basename(self.pythonScriptPath)
-
-        if pyScriptBaseDir != self.runDir:
-            shutil.copy(self.pythonScriptPath, self.runDir)
+        FECaller.__init__(self, **kwargs)
+        self.__engineFile = self.feFilename.replace("0000.rad", "0001.rad")
+        if not os.path.exists(self.__engineFile):
+            raise FileNotFoundError(f"Engine file {self.__engineFile} does not exist")
 
-        callParms = self.localCmds[:]
-        callParms[1] = pyScriptBaseFile
-        callParms[-1] = f"{baseFile}.msg"
+        self.localCmds = []
+        self.remoteCmds = []
+        self.numThreadsOMP = kwargs.pop("numThreadsOMP", 2)
 
+    def generateSolverSpecificRemoteCmds(self, jobName):
+        """doc"""
         runScriptCmds = []
         if "cara" in self.clusterName:
-            runScriptCmds = [
+
+            runScriptCmds += [
                 "module load env/spack",
                 "module load rev/23.05_r8",
                 "module use /sw/DLR/FA/BS/STM/modulefiles",
-                "module load python-3.10",
-                "module load b2000++/4.6.3",
+                f"module load OpenRadioss",
+                f"export OMP_NUM_THREADS={self.numThreadsOMP}",
+                "export OMP_STACKSIZE=400m",
+                f"starter_linux64_gf -i {self.feFilename} -np 1 -nt {self.numThreadsOMP}",
+                f"engine_linux64_gf_ompi -i {self.__engineFile} -nt {self.numThreadsOMP}",
+                'find . -name "*A[0-9]*" -print0 | xargs -i -0 bash -c "anim_to_vtk_linux64_gf {} > {}.vtk"',
             ]
 
-        runScriptCmds += [" ".join(callParms)]
-        return runScriptCmds
+        else:
+            raise Exception("Unknown cluster name")
 
-    def checkResultLogFile(self, jobName):
-        return True
+        return runScriptCmds
 
 
 class AsterCaller(FECaller):
+
+    solverName = "Code-Aster"
+
     def __init__(self, **kwargs):
+
         FECaller.__init__(self, **kwargs)
-        self.solverName = "Code-Aster"
 
         asterBat = kwargs.pop("as_run_script", shutil.which("as_run"))
         if not asterBat:
             raise Exception("Cannot find as_run script to run a code aster study")
 
-        self.localCmds = [f"{asterBat} --run {self.feFilename}"]
+        self.localCmds = [asterBat, "--run", self.feFilename]
         self.remoteCmds = []
 
     def runLocal(self, jobName, **kwargs):
         """doc"""
         self.localCmds = [jobName if elem == "<jobName>" else elem for elem in self.localCmds]
 
-        if "win" in sys.platform:
-            cmd = self.localCmds[0]
-        else:
-            cmd = ";".join(self.localCmds)
-
+        cmd = " ".join(self.localCmds)
         log.info(f"call {self.solverName} locally ")
         log.debug(f"call {self.solverName} with the following command: {cmd}")
 
         if "win" in sys.platform:
-            as_run_file = re.search("(.*) --run", cmd).group(1)
+            as_run_file = self.localCmds[0]
             if not os.path.exists(as_run_file):
-                raise InternalError(
-                    "The given executable does not exist. Please enter the correct path to settings.py. "
-                    + f"Acutal path: {as_run_file}"
-                )
+                msg = "The given executable does not exist. "
+                msg += "Please enter the correct path to settings.py. "
+                msg += f"Acutal path: {as_run_file}"
+                raise InternalError(msg)
 
-        p = subprocess.Popen(cmd, cwd=self.runDir, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        p = subprocess.Popen(
+            self.localCmds, cwd=self.runDir, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
         output, output_err = p.communicate()
         p.wait()
 
@@ -940,9 +933,11 @@ class AsterCaller(FECaller):
 
 
 class VegaCaller(FECaller):
+
+    solverName = "Vega"
+
     def __init__(self, **kwargs):
         FECaller.__init__(self, **kwargs)
-        self.solverName = "Vega"
 
         vega_executable = kwargs.pop("vega_executable", shutil.which("vegapp"))
         if not vega_executable:
@@ -982,9 +977,6 @@ class VegaCaller(FECaller):
         versions = re.findall(r"(?<=vers : )([\w\._-]+)", res, re.RegexFlag.MULTILINE)
         return versions
 
-    def checkResultLogFile(self, jobName):
-        return True
-
     @staticmethod
     def isLicenseAvailable():
         """

{patme-0.4.4 → patme-0.4.5}/src/patme/geometry/coordinatesystem.py

@@ -291,6 +291,15 @@ class Transformation(np.ndarray):
         elif other.shape[0] == 4:
             return np.array(np.dot(self, other))
 
+        elif other.shape[1] == 3:
+            other = np.insert(other, 3, 1, axis=1)
+            other = np.transpose(other)
+            return np.transpose(np.array(np.dot(self, other)))[:, :3]
+
+        elif other.shape[1] == 4:
+            other = np.transpose(other)
+            return np.transpose(np.array(np.dot(self, other)))
+
         # elif other.shape[1] == 3:
         #    other = np.insert(other, 3, 1, axis=1)
         #    return np.array(self @ other.T).T[:,:3]

{patme-0.4.4 → patme-0.4.5}/src/patme/mechanics/material.py

@@ -181,6 +181,12 @@ class MaterialDefinition:
         self.specificHeatDefaultTemp = 20 + 273.15
         """Default temperature for specificHeat"""
 
+        self.GIc = None
+        """Energy release rate mode I"""
+
+        self.GIIc = None
+        """Energy release rate mode II"""
+
         self.setStrength(kwargs.pop("strength", {s: 0.0 for s in self.strengthValues}))
 
         for key in kwargs:
@@ -359,7 +365,7 @@ class MaterialDefinition:
             ]
         )
 
-        redStiffVecGlo = np.mat(transM) * np.mat(redStiffVec)
+        redStiffVecGlo = np.asmatrix(transM) * np.asmatrix(redStiffVec)
         redStiffMatGlo = np.array(
             [
                 [redStiffVecGlo[0, 0], redStiffVecGlo[1, 0], redStiffVecGlo[2, 0]],
@@ -376,7 +382,8 @@ class MaterialDefinition:
 
         return redStiffMatGlo
 
-    def getSpecificHeat(self, T=None):
+    @property
+    def specificHeat(self, T=None):
         if T is None:
             T = self.specificHeatDefaultTemp
         return self.specificHeatFunction(T)
@@ -465,11 +472,11 @@ class MaterialDefinition:
         newMaterialDefinition._savedModuli = {}
         newMaterialDefinition._kPlaneStressCondition = None
 
-        stiff = np.mat(newMaterialDefinition.stiffnessMatrix)
+        stiff = np.asmatrix(newMaterialDefinition.stiffnessMatrix)
 
         c = np.cos(np.radians(orientationAngle))
         s = np.sin(np.radians(orientationAngle))
-        trafoMinv = np.mat(
+        trafoMinv = np.asmatrix(
             np.array(
                 [
                     [c**2.0, s**2.0, 0.0, 0.0, 0.0, -2 * s * c],
@@ -522,7 +529,8 @@ class MaterialDefinition:
         """returns the thermal expansion coefficients in directions XX YY XY"""
         return np.array([self.thermalExpansionCoeff[0], self.thermalExpansionCoeff[3], self.thermalExpansionCoeff[1]])
 
-    def _getkPlaneStressCondition(self):
+    @property
+    def kPlaneStressCondition(self):
         """doc"""
         if self._kPlaneStressCondition is not None:
             return self._kPlaneStressCondition
@@ -543,15 +551,18 @@ class MaterialDefinition:
 
         return self._kPlaneStressCondition
 
-    def _getIsIsotrop(self):
+    @property
+    def isIsotrop(self):
         """:return: True if MaterialDefinition is isotrop. This is calculated by means of the stiffness matrix."""
         return abs((self.stiffnessMatrix[0, 1] / self.stiffnessMatrix[1, 2]) - 1) < epsilon
 
-    def _getIsOrthotrop(self):
+    @property
+    def isOrthotrop(self):
         """:return: True if MaterialDefinition is orthotrop. This is calculated by means of the stiffness matrix."""
         return not np.any(self.stiffnessMatrix[3:, :3])
 
-    def _getStiffnessInvariants(self):
+    @property
+    def stiffnessInvariants(self):
         """doc"""
 
         reducedStiffness = np.array(
@@ -575,13 +586,79 @@ class MaterialDefinition:
 
         return np.dot(coefficientMatrix, reducedStiffness)
 
-    stiffnessInvariants = property(fget=_getStiffnessInvariants)
-    kPlaneStressCondition = property(fget=_getkPlaneStressCondition)
-    """see MaterialDefinition._kPlaneStressCondition"""
+    def getInSituStrength(self, isOuterPly, plyThickness, beta=2.98e-8):
+        """Calculate in situ strength for sigma22t(R22), "sigma22c", "tau"
 
-    isIsotrop = property(fget=_getIsIsotrop)
-    isOrthotrop = property(fget=_getIsOrthotrop)
-    specificHeat = property(fget=getSpecificHeat)
+        :param isOuterPly: flag if the ply is an outer ply
+        :param plyThickness: thickness of the ply
+        :param beta: nonlinear shear response parameter. Default value from IM7-8552
+        :return: 2-tuple: in situ transverse tension strength, in situ longitudinal shear strength
+        """
+        moduli = self.moduli
+        E11, E22, G12, NU12, NU21 = moduli["e11"], moduli["e22"], moduli["g12"], moduli["nu12"], moduli["nu21"]
+        Yt, Sl = self.strength["sigma22t"], self.strength["tau"]
+        G2t, G2s = self.GIc, self.GIIc
+
+        telda22 = 2 * ((1 / E22) - (NU21**2 / E11))
+        scalarOrArrayMask = np.ones_like(plyThickness)  # make all results have the same size as plyThickness
+        if isOuterPly:
+            Yt_outer_thin, Ys_outer_thin = self._getInsituOuterPlyStrengths(G12, G2t, G2s, plyThickness, telda22, beta)
+            return np.max([Yt_outer_thin, Yt * scalarOrArrayMask], axis=0), np.max(
+                [Ys_outer_thin, Sl * scalarOrArrayMask], axis=0
+            )
+        else:
+            Yt_inner_thick, Yt_inner_thin, Ys_inner_thin, Ys_inner_thick = self._getInSituInnerPlyStrengths(
+                G12, G2t, G2s, Yt, Sl, plyThickness, telda22, beta
+            )
+            return np.max([Yt_inner_thick, Yt_inner_thin], axis=0), np.max([Ys_inner_thin, Ys_inner_thick], axis=0)
+
+    def _getInSituInnerPlyStrengths(self, G12, G2t, G2s, Yt, Sl, plyThickness, telda22, beta):
+        scalarOrArrayMask = np.ones_like(plyThickness)
+        Yt_inner_thick = 1.12 * np.sqrt(2) * Yt * scalarOrArrayMask  # For a thick embedded ply
+        Yt_inner_thin = np.sqrt(8 * G2t / (np.pi * plyThickness * telda22))  # For a thin embedded ply
+        phi = 48 * G2s / (np.pi * plyThickness)
+        Ys_inner_thin = np.sqrt(((1 + beta * phi * G12**2) ** 0.5 - 1) / (3 * beta * G12))
+        phi = 12 * Sl**2 / G12 + 18 * beta * Sl**4
+        Ys_inner_thick = np.sqrt(((1 + beta * phi * G12**2) ** 0.5 - 1) / (3 * beta * G12)) * scalarOrArrayMask
+        return Yt_inner_thick, Yt_inner_thin, Ys_inner_thin, Ys_inner_thick
+
+    def _getInsituOuterPlyStrengths(self, G12, G2t, G2s, plyThickness, telda22, beta):
+        Yt_outer_thin = 1.78 * np.sqrt(G2t / (np.pi * plyThickness * telda22))
+        phi = 24 * G2s / (np.pi * plyThickness)
+        Ys_outer_thin = np.sqrt(((1 + beta * phi * G12**2) ** 0.5 - 1) / (3 * beta * G12))
+        return Yt_outer_thin, Ys_outer_thin
+
+    def getInSituStrengthAllValues(self, plyThickness, beta=2.98e-8):
+        """Calculate in situ strength for sigma22t(R22), "sigma22c", "tau"
+
+        :param isOuterPly: flag if the ply is an outer ply
+        :param plyThickness: thickness of the ply
+        :param beta: nonlinear shear response parameter. Default value from IM7-8552
+        :return: 2-tuple: in situ transverse tension strength, in situ longitudinal shear strength
+        """
+        moduli = self.moduli
+        E11, E22, G12, NU12, NU21 = moduli["e11"], moduli["e22"], moduli["g12"], moduli["nu12"], moduli["nu21"]
+        Yt, Sl = self.strength["sigma22t"], self.strength["tau"]
+        G2t, G2s = self.GIc, self.GIIc
+        telda22 = 2 * ((1 / E22) - (NU21**2 / E11))
+
+        scalarOrArrayMask = np.ones_like(plyThickness)  # make all results have the same size as plyThickness
+
+        result = self._getInsituOuterPlyStrengths(G12, G2t, G2s, plyThickness, telda22, beta)
+        Yt_outer_thin, Ys_outer_thin = result
+        result = self._getInSituInnerPlyStrengths(G12, G2t, G2s, Yt, Sl, plyThickness, telda22, beta)
+        Yt_inner_thick, Yt_inner_thin, Ys_inner_thin, Ys_inner_thick = result
+
+        return (
+            Yt_outer_thin,
+            Yt * scalarOrArrayMask,
+            Ys_outer_thin,
+            Sl * scalarOrArrayMask,
+            Yt_inner_thin,
+            Yt_inner_thick,
+            Ys_inner_thin,
+            Ys_inner_thick,
+        )
 
 
 class Composite:

{patme-0.4.4 → patme-0.4.5}/src/patme/service/mathutils.py

@@ -54,7 +54,8 @@ def get2DSubArrayWithPregivenOrder(arr, columnValueOrder, columnNumber=0, return
 
     columnValueOrder = np.asarray(columnValueOrder)
     arr_is_sorted = (np.diff(arr[:, columnNumber]) == 1).all()
-    if arr_is_sorted:
+    query_ids_sorted = (np.diff(columnValueOrder) == 1).all()
+    if arr_is_sorted and query_ids_sorted:
         ii = (columnValueOrder - int(arr[:, columnNumber][0])).astype(int)
     else:
         ii = None

{patme-0.4.4 → patme-0.4.5}/src/patme/sshtools/cara.py

@@ -59,18 +59,26 @@ def _getClusterAuthentication():
     hostKeyString = "AAAAB3NzaC1yc2EAAAADAQABAAACAQDL9y9u3D+refVuZnJJNdVeMK53EG0hfGUwuA+JyT2zOs6xOnhXhbTB0hOpORv4sd9V3mHJDf1yyIlZ/bgJCT4Znazz3amqzD7SmqGeNR8r7Z4whQY0drMpL67fthFNsqoUdjsOn+FZfWsZhy2ntMLIi4KRZ9Kaoe8Kqo3j1gej0iwq6W2+LYB69zhP1SHtT+603Qw97kAgrQeA2R71BFwUXSRzgDbPlucX8he9S4WjWZ3OTpfXksQtIN/8jGAsTw6x/4iu1ia8bjW5jc4q5qrF4UPdsRlbuByn2/QBU4XHZUcq6rZqv6KGyNqja2sZHsT7weDHo5JtYMNUzVB75SfmMigIxy3hcD6xicc5gSLQuw7e1BZsC8ld9Ku5hkL9OdXl/jkble55dO9lEKgze+y0QscBAYJKgi0FpQSMxw9SNt1IdImosIWfTT3jY3halybgWKvx85LVM86q45bk0RSSjgh1Oup87UO3GqF72zA+PX36v32WqMKoQ6ssqKjXOwSsXC1Ytf4GU7utoUXsqqFZOM/6CZp/09yPTTkkZGGsy2iUOw/1bS3uQcZi+lIpWqtEbsHYjrEOIPxofz4gl2Fo8yfQoUhKmED4XwWMnw0jwxNHy2uwBQz0ysIT4tz1ekBUh4fgO+2xhX/g6O24sLsfAGzc/I1gIUpmMaGJOQiwuw=="
 
     """this is the key from the file "~/.ssh/known_hosts" used by openssh on a linux machine"""
-    privateKey = os.path.join(os.path.expanduser("~"), ".ssh", "id_rsa")
+    from patme.sshtools.sshcall import privateKeyFileConfig
+
+    privateKey = privateKeyFileConfig
+    if not os.path.exists(privateKey):
+        privateKey = os.path.join(os.path.expanduser("~"), ".ssh", "id_rsa")
 
     try:
         from sshconf import read_ssh_config
 
         cfgfile = os.path.join(os.path.expanduser("~"), ".ssh", "config")
         if os.path.exists(cfgfile):
+            # log.debug(f"SSH configuration file found: {cfgfile}")
             conf = read_ssh_config(cfgfile)
             for host in conf.hosts():
                 cara_host = conf.host(host)
                 if "cara.dlr.de" in cara_host["hostname"]:
+                    # log.debug(f"CARA ssh configuration found in {cfgfile}.")
                     privateKey = cara_host["identityfile"]
+                    # log.debug(f"{privateKey} is used as new private key file.")
+
                     break
 
     except ImportError:

{patme-0.4.4 → patme-0.4.5}/src/patme/sshtools/clustercaller.py

@@ -53,7 +53,6 @@ class ClusterCaller:
         """Directory where files will be copied remotely. Defaults to solverName in runRemote
         remoteRunDir = ~/remoteBaseDir/self.runDir[-1]"""
         self.remoteCmds = None
-        self.solverName = None
         self.preCommands = []
         """List of commands that are sent to the cluster prior to the remote command.
         It is intended to setup the environment for the call that will be done
@@ -68,6 +67,8 @@ class ClusterCaller:
         self._clusterName = kwargs.pop("clusterName", "cara")
         self.__checkClusterName(self._clusterName)
 
+        self.docker_container = kwargs.pop("docker_container", None)
+
         if "wsl" in self.clusterName:
             self.remoteCmds = [
                 "bash",
@@ -75,8 +76,8 @@ class ClusterCaller:
                 self.REMOTE_SCRIPT,
             ]
         elif "cara" in self.clusterName:
+            self.preCommands.append(f"chmod a+x {self.REMOTE_SCRIPT}")
             self.remoteCmds = [
-                f"chmod a+x {self.REMOTE_SCRIPT} ; ",
                 "sbatch",
                 self.REMOTE_SCRIPT,
             ]
@@ -95,12 +96,17 @@ class ClusterCaller:
         """doc"""
         log.info(f"call {self.solverName} remotely on '{self.clusterName}'")
 
-        self.addClusterSpecificBatchCmds()
-
         remoteRunDir = kwargs.get("remoteRunDir", None)
         if not remoteRunDir:
             ws_dir_name, remoteRunDir = self.getRemoteRunDir(**kwargs)
 
+        if self.docker_container is not None:
+            basedir = os.path.basename(remoteRunDir)
+            docker_mnt_dir = f"/mnt/{basedir}"
+            self.addClusterSpecificBatchCmds(jobName, docker_mnt_dir)
+        else:
+            self.addClusterSpecificBatchCmds(jobName, remoteRunDir)
+
         # copy rundir to network folder
         if copyFilesLocalToHost:
             log.info(f"Copy files to remote machine '{self.clusterName}'")
@@ -115,7 +121,17 @@ class ClusterCaller:
         if "wsl" not in self.clusterName:
             command = f"cd {remoteRunDir};{remoteCmdsJoin}"
         else:
-            command = remoteCmdsJoin
+            if self.docker_container is not None:
+                if ".sh" not in remoteCmds[-1]:
+                    raise Exception("Test")
+
+                remoteCmds[-1] = f"{docker_mnt_dir}/{remoteCmds[-1]}"
+                remoteCmds[0] = (
+                    f"docker run -w {docker_mnt_dir} -it -v {remoteRunDir}:{docker_mnt_dir} {self.docker_container} "
+                )
+                command = " ".join(remoteCmds)
+            else:
+                command = remoteCmdsJoin
 
         if self.preCommands:
             precmd = ";".join(self.preCommands)
@@ -137,7 +153,6 @@ class ClusterCaller:
         else:
 
             jobId = "WSL_NOJOBID"
-            command += " > cluster.r00.log"
             remoteRunDirAsWinPath = self.__getWSLRemoteDirAsWinPath(remoteRunDir)
             wsl_cmd = f"wsl --cd {remoteRunDirAsWinPath} {command}"
             p = subprocess.run(wsl_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@@ -255,10 +270,9 @@ class ClusterCaller:
         4.1 optionally extract tarfile remotely to reuse the calculation results
         5. remove the tarfile remote"""
 
-        def getFileAndExtract(tarFileName, tarFileNamePath, clusterLog, remoteRunDir, copyFunc, username=None):
+        def getFileAndExtract(tarFileName, tarFileNamePath, remoteRunDir, copyFunc, username=None):
             """doc"""
-            for ffile in [tarFileName, clusterLog]:
-                copyFunc([ffile], remoteRunDir, self.runDir, "get", username=username)
+            copyFunc([tarFileName], remoteRunDir, self.runDir, "get", username=username)
 
             with tarfile.open(tarFileNamePath) as f:
                 f.extractall(self.runDir, filter="data")
@@ -291,15 +305,11 @@ class ClusterCaller:
 
             try:
                 log.info("copy result from cluster")
-                prefix = f"cluster.r{jobId}"
-                tarFileName = f"{prefix}.tar.gz"
-                clusterLog = f"{prefix}.log"
+                tarFileName = f"cluster.r{jobId}.tar.gz"
                 tarFileNamePath = os.path.join(self.runDir, tarFileName)
 
                 try:
-                    getFileAndExtract(
-                        tarFileName, tarFileNamePath, clusterLog, remoteRunDir, copyFunc, username=username
-                    )
+                    getFileAndExtract(tarFileName, tarFileNamePath, remoteRunDir, copyFunc, username=username)
 
                 except tarfile.ReadError:
                     msg = "Could not open the result tar file. "
@@ -312,7 +322,7 @@ class ClusterCaller:
                     msg += "Try again to copy and extract"
                     log.error(msg)
                     try:
-                        getFileAndExtract(tarFileName, tarFileNamePath, clusterLog, remoteRunDir)
+                        getFileAndExtract(tarFileName, tarFileNamePath, remoteRunDir)
                     except tarfile.ReadError:
                         msg = "Could not open the result tar file. "
                         msg += "Probably the calculation was cancelled."
@@ -339,7 +349,7 @@ class ClusterCaller:
                 log.warning(msg)
                 log.debug("error message to the above warning: " + str(exception))
 
-    def addClusterSpecificBatchCmds(self, *args, **kwargs):
+    def addClusterSpecificBatchCmds(self, jobName, remoteRunDir, **kwargs):
         """Create bash cmds which for remote sbatch call"""
         runScriptCmds = ["#!/bin/bash"]
         if self.clusterName == "cara":
@@ -350,7 +360,11 @@ class ClusterCaller:
             if cara_partion == "ppp":
                 slurm_args["ntasks"] = "1"
 
+            slurm_args["output"] = f"{jobName}.log"
+
             for sarg, sval in slurm_args.items():
+                if f"--{sarg}" in self.remoteCmds:
+                    continue
                 cmd = f"#SBATCH --{sarg}"
                 cmd += "" if not sval else f"={sval}"
                 runScriptCmds.append(cmd)
@@ -359,18 +373,19 @@ class ClusterCaller:
                 ". /usr/share/lmod/lmod/init/sh",
                 ". /etc/profile.d/10-dlr-modulepath.sh",
                 "module --force purge",
+                'curtime=$(date +"%Y-%m-%d %H:%M:%S")',
+                # find can only distinguish between timestamps which have seconds as highest precision
+                "sleep 1s",
             ]
 
-        runScriptCmds += [
-            'curtime=$(date +"%Y-%m-%d %H:%M:%S")',
-            # find can only distinguish between timestamps which have seconds as highest precision
-            "sleep 1s",
-            'tarFile="cluster.r$SLURM_JOB_ID.tar.gz"',
-        ]
-        runScriptCmds += self.generateSolverSpecificRemoteCmds()
-        runScriptCmds += [
-            'tar -czf $tarFile -C . $(find . -newermt "$curtime" -type f)',
-        ]
+        runScriptCmds += [f"cd {remoteRunDir}"]
+        runScriptCmds += self.generateSolverSpecificRemoteCmds(jobName)
+        runScriptCmds += [f"touch {jobName}.log"]
+        if self.clusterName == "cara":
+            runScriptCmds += [
+                'tarFile="cluster.r$SLURM_JOB_ID.tar.gz"',
+                'tar -czf $tarFile -C . $(find . -newermt "$curtime" -type f)',
+            ]
 
         runScriptFile = os.path.join(self.runDir, self.REMOTE_SCRIPT)
         with open(runScriptFile, "w") as f:

{patme-0.4.4 → patme-0.4.5}/src/patme/sshtools/sshcall.py

@@ -56,15 +56,21 @@ def callSSH(
         _expandKnownHostsFile(hostname, hostKeyString, port, keytype)
 
     callArgs = [shutil.which("ssh")]
-    if (privateKeyFile is not None) and os.path.exists(privateKeyFile):
-        callArgs += ["-i", privateKeyFile]
 
-    callArgs += ["-o", "BatchMode=true"]
-    if port:
-        callArgs += ["-p", str(port)]
-    if not username:
-        username = getpass.getuser()
-    callArgs += [f"{username}@{hostname}", remoteCommand]
+    ssh_alias = os.environ.get("PATME_SSH_ALIAS", None)
+    if ssh_alias is None:
+        if (privateKeyFile is not None) and os.path.exists(privateKeyFile):
+            callArgs += ["-i", privateKeyFile]
+
+        callArgs += ["-o", "BatchMode=true"]
+        if port:
+            callArgs += ["-p", str(port)]
+        if not username:
+            username = getpass.getuser()
+        callArgs += [f"{username}@{hostname}", remoteCommand]
+
+    else:
+        callArgs += [ssh_alias, remoteCommand]
 
     log.info("Call ssh: " + " ".join(callArgs))
     result = run(callArgs, stdout=PIPE, stderr=PIPE, universal_newlines=True, encoding="latin-1", errors="ignore")
@@ -114,15 +120,21 @@ def copyFilesSCP(
     sendList = [f if os.path.isabs(f) else os.path.join(srcBaseDir, f) for f in files]
 
     callArgs = [shutil.which("scp"), "-T"]
-    if (privateKeyFile is not None) and os.path.exists(privateKeyFile):
-        callArgs += ["-i", privateKeyFile]
-
-    callArgs += ["-o", "BatchMode=true"]
-    if port:
-        callArgs += ["-p", str(port)]
-    if not username:
-        username = getpass.getuser()
-    userAndHost = f"{username}@{hostname}:"
+    ssh_alias = os.environ.get("PATME_SSH_ALIAS", None)
+    if ssh_alias is None:
+
+        if (privateKeyFile is not None) and os.path.exists(privateKeyFile):
+            callArgs += ["-i", privateKeyFile]
+
+        callArgs += ["-o", "BatchMode=true"]
+        if port:
+            callArgs += ["-p", str(port)]
+        if not username:
+            username = getpass.getuser()
+        userAndHost = f"{username}@{hostname}:"
+    else:
+        userAndHost = f"{ssh_alias}:"
+
     if mode == "put":
         source = sendList
         dest = userAndHost + destBaseDir