scipion-em-xmipp 25.6.0__py3-none-any.whl → 26.0.0__py3-none-any.whl

xmipp3/protocols/protocol_align_volume_and_particles.py

@@ -38,6 +38,7 @@ from pyworkflow.utils import weakImport
 from pyworkflow.utils.path import cleanPath
 
 from xmipp3.constants import SYM_URL
+from pyworkflow import BETA, UPDATED, NEW, PROD
 
 ALIGN_MASK_CIRCULAR = 0
 ALIGN_MASK_BINARY_FILE = 1
@@ -63,13 +64,14 @@ class XmippProtAlignVolumeParticles(ProtAlignVolume):
      """
     _label = 'align volume and particles'
     _possibleOutputs = AlignVolPartOutputs
+    _devStatus = UPDATED
     nVols = 0
+
     
     def __init__(self, **args):
         ProtAlignVolume.__init__(self, **args)
 
         # These 2 must match the output enum above.
-        self._alignmentMatrix = None
         self.Volume = None
         self.Particles = None
 
@@ -89,6 +91,8 @@ class XmippProtAlignVolumeParticles(ProtAlignVolume):
                            'calculated with the reference and input volumes.')
         form.addParam('alignmentMode', params.EnumParam, default=ALIGN_GLOBAL, choices=["Global","Local"],
                       label="Alignment mode")
+        form.addParam('considerMirrors', params.BooleanParam, default=False,
+                      label='Consider mirrors')
         form.addParam('symmetryGroup', params.StringParam, default='c1',
                       label="Symmetry group",
                       help='See %s page for a description of the symmetries '
@@ -160,6 +164,8 @@ class XmippProtAlignVolumeParticles(ProtAlignVolume):
             args += " --frm"
         else:
             args += " --local"
+        if self.considerMirrors:
+            args += " --consider_mirror"
         args += " --copyGeo %s" % fhInputTranMat
         if not self.wrap:
             args += ' --dontWrap'
@@ -168,13 +174,16 @@ class XmippProtAlignVolumeParticles(ProtAlignVolume):
         cleanPath(self.fnInputVol)
 
     def getAlignmentMatrix(self):
-
-        if self._alignmentMatrix is None:
+        if not (hasattr(self, '_lhsAlignmentMatrix') and hasattr(self, '_rhsAlignmentMatrix')):
             fhInputTranMat = self.getTransformationFile()
             transMatFromFile = np.loadtxt(fhInputTranMat)
-            self._alignmentMatrix = np.reshape(transMatFromFile, (4, 4))
+            self._lhsAlignmentMatrix = np.reshape(transMatFromFile, (4, 4))
+            self._rhsAlignmentMatrix = np.eye(4)
+            
+            if np.linalg.det(self._lhsAlignmentMatrix[:3,:3]) < 0:
+                self._rhsAlignmentMatrix[2,2] = -1
 
-        return self._alignmentMatrix
+        return self._lhsAlignmentMatrix, self._rhsAlignmentMatrix
 
     def getTransformationFile(self):
         return self._getExtraPath('transformation-matrix.txt')
@@ -217,12 +226,11 @@ class XmippProtAlignVolumeParticles(ProtAlignVolume):
         self._defineSourceRelation(self.inputParticles, outputParticles)
 
     def _updateParticleTransform(self, particle, row):
+        lhs, rhs = self.getAlignmentMatrix()
+        alignment = np.array(particle.getTransform().getMatrix())
+        alignment2 = lhs @ alignment @ rhs
 
-        aliMatrix = self.getAlignmentMatrix()
-        partTransformMat = particle.getTransform().getMatrix()
-        partTransformMatrix = np.matrix(partTransformMat)
-        newTransformMatrix = np.matmul(aliMatrix, partTransformMatrix)
-        particle.getTransform().setMatrix(newTransformMatrix)
+        particle.getTransform().setMatrix(alignment2)
 
     def getOutputAlignedVolumePath(self):
         outVolFn = self._getExtraPath("inputVolumeAligned.mrc")

xmipp3/protocols/protocol_break_symmetry.py

@@ -40,7 +40,7 @@ class XmippProtAngBreakSymmetry(ProtProcessParticles):
     equivalent angular assignment for a given symmetry.
 
     Be aware that input symmetry values follows Xmipp conventions as described in:
-    http://xmipp.cnb.csic.es/twiki/bin/view/Xmipp/Symmetry
+    https://i2pc.github.io/docs/Utils/Conventions/index.html#symmetry
     """
     _label = 'break symmetry'
 
@@ -49,7 +49,7 @@ class XmippProtAngBreakSymmetry(ProtProcessParticles):
         
         form.addParam('symmetryGroup', StringParam, default="c1",
                       label='Symmetry group',
-                      help="See http://xmipp.cnb.csic.es/twiki/bin/view/Xmipp/Symmetry"
+                      help="See https://i2pc.github.io/docs/Utils/Conventions/index.html#symmetry"
                            " for a description of the symmetry groups format in Xmipp.\n"
                            "If no symmetry is present, use _c1_.")
     
@@ -63,9 +63,9 @@ class XmippProtAngBreakSymmetry(ProtProcessParticles):
         # Create a metadata with the geometrical information
         # as expected by Xmipp
         imgsFn = self._getPath('input_particles.xmd')
-        self._insertFunctionStep('convertInputStep', imgsFn)
-        self._insertFunctionStep('breakSymmetryStep', imgsFn)
-        self._insertFunctionStep('createOutputStep')
+        self._insertFunctionStep(self.convertInputStep, imgsFn)
+        self._insertFunctionStep(self.breakSymmetryStep, imgsFn)
+        self._insertFunctionStep(self.createOutputStep)
 
     #--------------------------- STEPS functions --------------------------------------------
 

xmipp3/protocols/protocol_classify_pca.py

@@ -84,23 +84,14 @@ ALIGNMENT_DICT = {"shiftX": XMIPPCOLUMNS.shiftX.value,
                   "angleTilt": XMIPPCOLUMNS.angleTilt.value
                   }
 
-
-
-def updateEnviron(gpuNum):
-    """ Create the needed environment for pytorch programs. """
-    print("updating environ to select gpu %s" % (gpuNum))
-    if gpuNum == '':
-        os.environ['CUDA_VISIBLE_DEVICES'] = '0'
-    else:
-        os.environ['CUDA_VISIBLE_DEVICES'] = str(gpuNum)
-
 CONTRAST_AVERAGES_FILE = 'classes_contrast_classes.star'
 AVERAGES_IMAGES_FILE = 'classes_images.star'
         
 class XmippProtClassifyPca(ProtClassify2D, XmippProtocol):
-    """ Classifies a set of images. """
+    """ Classifies a set of images using Principal Component Analysis (PCA). This 2D classification groups (the number of groups can be set) are based on their similarities, assisting in the identification of different conformational states or particle populations. """
     
-    _label = 'Classifies a set of images using Principal Component Analysis (PCA). This 2D classification groups (the number of groups can be set) are based on their similarities, assisting in the identification of different conformational states or particle populations.'
+    _label= '2D classification pca'
+
     _lastUpdateVersion = VERSION_3_0
     _conda_env = 'xmipp_pyTorch'
     _devStatus = BETA
@@ -171,7 +162,6 @@ class XmippProtClassifyPca(ProtClassify2D, XmippProtocol):
     def _insertAllSteps(self):
 
         """ Mainly prepare the command line for call classification program"""
-        self.setGPU()
         self.imgsOrigXmd = self._getExtraPath('images_original.xmd')
         self.imgsXmd = self._getTmpPath('images.xmd')
         self.imgsFn = self._getTmpPath('images.mrc')
@@ -198,13 +188,21 @@ class XmippProtClassifyPca(ProtClassify2D, XmippProtocol):
     
         self._insertFunctionStep('createOutputStep')
 
-    def setGPU(self):
-        if self.useQueueForSteps() or self.useQueue():
-            myStr = os.environ["CUDA_VISIBLE_DEVICES"]
+
+    def getGpusList(self, separator):
+        strGpus = ""
+        for elem in self._stepsExecutor.getGpuList():
+            strGpus = strGpus + str(elem) + separator
+        return strGpus[:-1]
+
+    def setGPU(self, oneGPU=False):
+        if oneGPU:
+            gpus = self.getGpusList(",")[0]
         else:
-            myStr = self.gpuList.get()
-            os.environ["CUDA_VISIBLE_DEVICES"] = self.gpuList.get()
-        self.numGPU = myStr.split(',')[0]
+            gpus = self.getGpusList(",")
+        os.environ["CUDA_VISIBLE_DEVICES"] = gpus
+        self.info(f'Visible GPUS: {gpus}')
+        return gpus
 
 
     #--------------------------- STEPS functions -------------------------------
@@ -234,8 +232,9 @@ class XmippProtClassifyPca(ProtClassify2D, XmippProtocol):
         
         
     def pcaTraining(self, inputIm, resolutionTrain, numTrain):
+        gpuId = self.setGPU(oneGPU=True)
         args = ' -i %s  -s %s -hr %s -lr 530 -p %s -t %s -o %s/train_pca  --batchPCA -g %s'% \
-                (inputIm, self.sampling, resolutionTrain, self.coef.get(), numTrain, self._getExtraPath(), self.numGPU)
+                (inputIm, self.sampling, resolutionTrain, self.coef.get(), numTrain, self._getExtraPath(), gpuId)
 
         env = self.getCondaEnv()
         env['LD_LIBRARY_PATH'] = ''
@@ -243,9 +242,10 @@ class XmippProtClassifyPca(ProtClassify2D, XmippProtocol):
         
         
     def classification(self, inputIm, numClass, stfile, mask, sigma):
+        gpuId = self.setGPU(oneGPU=True)
         args = ' -i %s -c %s -b %s/train_pca_bands.pt -v %s/train_pca_vecs.pt -o %s/classes -stExp %s -g %s' % \
                 (inputIm, numClass, self._getExtraPath(), self._getExtraPath(),  self._getExtraPath(),
-                 stfile, self.numGPU)
+                 stfile, gpuId)
         if mask:
             args += ' --mask --sigma %s '%(sigma) 
             

xmipp3/protocols/protocol_classify_pca_streaming.py

@@ -162,8 +162,6 @@ class XmippProtClassifyPcaStreaming(ProtStreamingBase, XmippProtClassifyPca):
         self._initFnStep()
 
     def _initFnStep(self):
-        self.setGPU()
-        self.info(f'NUM GPUS: {self.numGPU}')
         self.inputFn = self.inputParticles.get().getFileName()
         self.imgsPcaXmd = self._getExtraPath('images_pca.xmd')
         self.imgsPcaXmdOut = self._getTmpPath('images_pca.xmd')  # Wiener
@@ -190,13 +188,21 @@ class XmippProtClassifyPcaStreaming(ProtStreamingBase, XmippProtClassifyPca):
         else:
             self.numberClasses = self.numberOfClasses.get()
 
-    def setGPU(self):
-        if self.useQueueForSteps() or self.useQueue():
-            myStr = os.environ["CUDA_VISIBLE_DEVICES"]
+    def getGpusList(self, separator):
+        strGpus = ""
+        for elem in self._stepsExecutor.getGpuList():
+            strGpus = strGpus + str(elem) + separator
+        return strGpus[:-1]
+
+    def setGPU(self, oneGPU=False):
+        if oneGPU:
+            gpus = self.getGpusList(",")[0]
         else:
-            myStr = self.gpuList.get()
-            os.environ["CUDA_VISIBLE_DEVICES"] = self.gpuList.get()
-        self.numGPU = myStr.split(',')[0]
+            gpus = self.getGpusList(",")
+        os.environ["CUDA_VISIBLE_DEVICES"] = gpus
+        self.info(f'Visible GPUS: {gpus}')
+        return gpus
+
 
     def runPCASteps(self, newParticlesSet):
         # Run PCA steps
@@ -267,17 +273,19 @@ class XmippProtClassifyPcaStreaming(ProtStreamingBase, XmippProtClassifyPca):
             self.firstTimeDone = True
 
     def pcaTraining(self, inputIm, resolutionTrain, numTrain):
+        gpuID = self.setGPU(oneGPU=True)
         args = ' -i %s  -s %s -hr %s -lr 530 -p %s -t %s -o %s/train_pca  --batchPCA -g %s' % \
-               (inputIm, self.sampling, resolutionTrain, self.coef.get(), numTrain, self._getExtraPath(), self.numGPU)
+               (inputIm, self.sampling, resolutionTrain, self.coef.get(), numTrain, self._getExtraPath(), gpuID)
 
         env = self.getCondaEnv()
         env = self._setEnvVariables(env)
         self.runJob("xmipp_classify_pca_train", args, numberOfMpi=1, env=env)
 
     def classification(self, inputIm, numClass, stfile, mask, sigma):
+        gpuID = self.setGPU(oneGPU=True)
         args = ' -i %s -c %s -b %s/train_pca_bands.pt -v %s/train_pca_vecs.pt -o %s/classes -stExp %s -g %s' % \
                (inputIm, numClass, self._getExtraPath(), self._getExtraPath(), self._getExtraPath(),
-                stfile, self.numGPU)
+                stfile, gpuID)
         if mask:
             args += ' --mask --sigma %s ' % (sigma)
 

xmipp3/protocols/protocol_compare_reprojections.py

@@ -96,7 +96,7 @@ class XmippProtCompareReprojections(ProtAnalysis3D, ProjMatcher):
                       help='If this option is chosen, then the residual covariance matrix is calculated and '
                            'characterized. But this option takes time and disk space')
         form.addParam('symmetryGroup', StringParam, default="c1", label='Symmetry group',
-                      help='See http://xmipp.cnb.uam.es/twiki/bin/view/Xmipp/Symmetry for a description of the symmetry'
+                      help='See https://i2pc.github.io/docs/Utils/Conventions/index.html#symmetry for a description of the symmetry'
                            ' groups format. If no symmetry is present, give c1')
         form.addParam('angularSampling', FloatParam, default=5, expertLevel=LEVEL_ADVANCED,
                       label='Angular sampling rate',
@@ -634,4 +634,4 @@ def createSetOfParticles(classesSet, path):
     images = classesSet.getImages()
     particles = SetOfParticles.create(outputPath=path)
     particles.copyInfo(images)
-    return particles
+    return particles

xmipp3/protocols/protocol_compute_likelihood.py

@@ -57,7 +57,7 @@ class XmippProtComputeLikelihood(ProtAnalysis3D):
     _label = 'log likelihood'
     _lastUpdateVersion = VERSION_1_1
     _possibleOutputs = {"reprojections": SetOfParticles}
-    _devStatus = NEW
+    _devStatus = PROD
     stepsExecutionMode = STEPS_PARALLEL
 
     # Normalization enum constants

xmipp3/protocols/protocol_convert_pdb.py

@@ -45,7 +45,7 @@ from pyworkflow import UPDATED, PROD
 class XmippProtConvertPdb(ProtInitialVolume):
     """  Converts atomic structure files in PDB (Protein Data Bank) format into volumetric maps. Converting a PDB to a volume generates a simulated electron density map, useful for validating atomic models, fitting into experimental maps or performing docking."""
     _label = 'convert pdbs to volumes'
-    _devStatus = UPDATED
+    _devStatus = PROD
     OUTPUT_NAME1 = "outputVolume"
     OUTPUT_NAME2 = "outputVolumes"
     OUTPUT_NAME3 = "outputPdb"

xmipp3/protocols/protocol_ctf_correct_phase.py

@@ -0,0 +1,89 @@
+# **************************************************************************
+# *
+# * Authors:     Federico P. de Isidro Gomez
+# *
+# * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
+# *
+# * This program is free software; you can redistribute it and/or modify
+# * it under the terms of the GNU General Public License as published by
+# * the Free Software Foundation; either version 2 of the License, or
+# * (at your option) any later version.
+# *
+# * This program is distributed in the hope that it will be useful,
+# * but WITHOUT ANY WARRANTY; without even the implied warranty of
+# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# * GNU General Public License for more details.
+# *
+# * You should have received a copy of the GNU General Public License
+# * along with this program; if not, write to the Free Software
+# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+# * 02111-1307  USA
+# *
+# *  All comments concerning this program package may be sent to the
+# *  e-mail address 'scipion@cnb.csic.es'
+# *
+# **************************************************************************
+
+import pwem.emlib.metadata as md
+import pyworkflow.protocol.params as params
+from pwem.protocols import ProtProcessParticles
+
+from xmipp3.convert import writeSetOfParticles, xmippToLocation, readSetOfParticles
+
+
+class XmippProtCTFCorrectPhase2D(ProtProcessParticles):
+    """    
+    Perform CTF correction by phase flip.
+    """
+    _label = 'ctf_correct_phase'
+    
+    def __init__(self, *args, **kwargs):
+        ProtProcessParticles.__init__(self, *args, **kwargs)
+        #self.stepsExecutionMode = STEPS_PARALLEL
+        
+    #--------------------------- DEFINE param functions --------------------------------------------   
+    def _defineParams(self, form):
+        form.addSection(label='Input')
+
+        form.addParam('inputParticles', params.PointerParam, pointerClass='SetOfParticles', 
+                      label="Input particles",  
+                      help='Select the input projection images .')               
+        form.addParallelSection(threads=1, mpi=1)
+
+    #--------------------------- INSERT steps functions --------------------------------------------
+    def _insertAllSteps(self):
+        self._insertFunctionStep('convertInputStep',self.inputParticles.get().getObjId())        
+        self._insertFunctionStep('phaseStep')
+        self._insertFunctionStep('createOutputStep')
+        
+    def convertInputStep(self, particlesId):
+        """ Write the input images as a Xmipp metadata file. 
+        particlesId: is only need to detect changes in
+        input particles and cause restart from here.
+        """
+        writeSetOfParticles(self.inputParticles.get(), 
+                            self._getPath('input_particles.xmd'))
+    
+    def phaseStep(self):
+        params =  '  -i %s' % self._getPath('input_particles.xmd')
+        params +=  '  -o %s' % self._getPath('corrected_ctf_particles.stk')
+        params +=  '  --save_metadata_stack %s' % self._getPath('corrected_ctf_particles.xmd')
+        params +=  '  --sampling_rate %s' % self.inputParticles.get().getSamplingRate()
+
+        nproc = self.numberOfMpi.get()
+        nT=self.numberOfThreads.get() 
+
+        self.runJob('xmipp_ctf_correct_phase', 
+                    params, numberOfMpi=nproc,numberOfThreads=nT)
+    
+    def createOutputStep(self):
+        imgSet = self.inputParticles.get()
+        partSet = self._createSetOfParticles()
+        imgFn = self._getPath('corrected_ctf_particles.xmd')
+        
+        partSet.copyInfo(imgSet)
+        partSet.setIsPhaseFlipped(True)
+        readSetOfParticles(imgFn, partSet)
+        
+        self._defineOutputs(outputParticles=partSet)
+        self._defineSourceRelation(imgSet, partSet)

xmipp3/protocols/protocol_ctf_micrographs.py

@@ -261,10 +261,6 @@ class XmippProtCTFMicrographs(ProtCTFMicrographs):
                     if min(psd.shape) < self.windowSize.get():
                         localParams['pieceDim'] = self.windowSize.get()/2
                         localParams['ctfmodelSize'] = self.windowSize.get()/2
-                else:
-                    # This is needed to make sure that the micrograph has the correct sampling
-                    # Otherwise, it brings the last sampling tested
-                    copyFile(micFn, finalName)
 
                 # Update _params dictionary with mic and micDir
                 localParams['micFn'] = finalName

xmipp3/protocols/protocol_deep_center.py

@@ -104,17 +104,26 @@ class XmippProtDeepCenter(ProtAlign2D, xmipp3.XmippProtocol):
     def _insertAllSteps(self):
         self.fnImgs = self._getTmpPath('imgs.xmd')
         self.fnImgsTrain = self._getTmpPath('imgsTrain.xmd')
-        if self.useQueueForSteps() or self.useQueue():
-            myStr = os.environ["CUDA_VISIBLE_DEVICES"]
-        else:
-            myStr = self.gpuList.get()
-            os.environ["CUDA_VISIBLE_DEVICES"] = self.gpuList.get()
-        numGPU = myStr.split(',')
         self._insertFunctionStep("convertInputStep", self.inputParticles.get())
-        self._insertFunctionStep("train", numGPU[0])
-        self._insertFunctionStep("predict", numGPU[0])
+        self._insertFunctionStep("train")
+        self._insertFunctionStep("predict" )
         self._insertFunctionStep("createOutputStep")
 
+    def getGpusList(self, separator):
+        strGpus = ""
+        for elem in self._stepsExecutor.getGpuList():
+            strGpus = strGpus + str(elem) + separator
+        return strGpus[:-1]
+
+    def setGpu(self, oneGPU=False):
+        if oneGPU:
+            gpus = self.getGpusList(",")[0]
+        else:
+            gpus = self.getGpusList(",")
+        os.environ["CUDA_VISIBLE_DEVICES"] = gpus
+        self.info(f'Visible GPUS: {gpus}')
+        return gpus
+
     # --------------------------- STEPS functions ---------------------------------------------------
     def convertInputStep(self, inputSet):
         writeSetOfParticles(inputSet, self.fnImgs)
@@ -124,13 +133,15 @@ class XmippProtDeepCenter(ProtAlign2D, xmipp3.XmippProtocol):
         else:
             createLink(self.fnImgs, self.fnImgsTrain)
 
-    def train(self, gpuId):
+    def train(self):
+        gpuId = self.setGpu(oneGPU=True)
         args = "-i %s --omodel %s --sigma %f --maxEpochs %d --batchSize %d --gpu %s --learningRate %f --precision %f"%\
                 (self.fnImgsTrain, self._getExtraPath("model.h5"), self.sigma, self.numEpochs, self.batchSize, gpuId,
                  self.learningRate, self.precision)
         self.runJob(f"xmipp_deep_center", args, numberOfMpi=1, env=self.getCondaEnv())
 
-    def predict(self, gpuId):
+    def predict(self):
+        gpuId = self.setGpu(oneGPU=True)
         fnModel = self._getExtraPath("model.h5")
         args = "-i %s --gpu %s --model %s -o %s" % (self.fnImgs, gpuId, fnModel, self._getExtraPath('particles.xmd'))
         self.runJob("xmipp_deep_center_predict", args, numberOfMpi=1, env=self.getCondaEnv())

xmipp3/protocols/protocol_deep_center_predict.py

@@ -83,16 +83,25 @@ class XmippProtDeepCenterPredict(ProtAlign2D, xmipp3.XmippProtocol):
     # --------------------------- INSERT steps functions --------------------------------------------
     def _insertAllSteps(self):
         self.fnImgs = self._getExtraPath('imgs.xmd')
-        if self.useQueueForSteps() or self.useQueue():
-            myStr = os.environ["CUDA_VISIBLE_DEVICES"]
-        else:
-            myStr = self.gpuList.get()
-            os.environ["CUDA_VISIBLE_DEVICES"] = self.gpuList.get()
-        numGPU = myStr.split(',')
         self._insertFunctionStep("convertInputStep", self.inputParticles.get())
-        self._insertFunctionStep("predict", numGPU[0])
+        self._insertFunctionStep("predict")
         self._insertFunctionStep("createOutputStep")
 
+    def getGpusList(self, separator):
+        strGpus = ""
+        for elem in self._stepsExecutor.getGpuList():
+            strGpus = strGpus + str(elem) + separator
+        return strGpus[:-1]
+
+    def setGpu(self, oneGPU=False):
+        if oneGPU:
+            gpus = self.getGpusList(",")[0]
+        else:
+            gpus = self.getGpusList(",")
+        os.environ["CUDA_VISIBLE_DEVICES"] = gpus
+        self.info(f'Visible GPUS: {gpus}')
+        return gpus
+
     # --------------------------- STEPS functions ---------------------------------------------------
     def convertInputStep(self, inputSet):
         writeSetOfParticles(inputSet, self.fnImgs)
@@ -108,13 +117,14 @@ class XmippProtDeepCenterPredict(ProtAlign2D, xmipp3.XmippProtocol):
             self.runJob("xmipp_image_resize", "-i %s -o %s --fourier 64" % (self.fnImgs, fnTmp))
             self.fnImgs = self._getTmpPath("imgs.xmd")
 
-    def predict(self, gpuId):
+    def predict(self):
         if self.modelSource==self.PRETRAINED:
             fnModel = self.getModel('deepCenter', 'deepCenterModel.h5') 
         elif self.getRunMode()==self.PREVIOUS:
             fnModel = self.protocolPointer.get()._getExtraPath("model.h5")
         else:
             fnModel = self.modelFile.get()
+        gpuId = self.setGpu(oneGPU=True)
         args = "-i %s --gpu %s --model %s -o %s --scale %f" % (self.fnImgs, gpuId, fnModel,
                                                                self.fnImgs, self.scaleFactor)
         self.runJob("xmipp_deep_center_predict", args, numberOfMpi=1, env=self.getCondaEnv())

xmipp3/protocols/protocol_deep_hand.py

@@ -41,7 +41,7 @@ class XmippProtDeepHand(EMProtocol, XmippProtocol):
 
     _label ="deep hand"
     _conda_env = "xmipp_pyTorch"
-    _devStatus = UPDATED
+    _devStatus = PROD
 
     def __init__(self, *args, **kwargs):
         EMProtocol.__init__(self, *args, **kwargs)

xmipp3/protocols/protocol_deep_micrograph_screen.py

@@ -37,12 +37,14 @@ from xmipp3.base import XmippProtocol
 from xmipp_base import createMetaDataFromPattern
 from xmipp3.convert import (writeMicCoordinates, readSetOfCoordinates)
 from xmipp3.constants import SAME_AS_PICKING, OTHER
+from pyworkflow import BETA, UPDATED, NEW, PROD
 
 
 class XmippProtDeepMicrographScreen(ProtExtractParticles, XmippProtocol):
     """Removes coordinates located in carbon regions or large impurities in micrographs using a pre-trained deep learning model. This screening improves particle picking accuracy by filtering out false positives from contaminated areas."""
     _label = 'deep micrograph cleaner'
     _conda_env= "xmipp_MicCleaner"
+    _devStatus = UPDATED
 
     def __init__(self, **kwargs):
         ProtExtractParticles.__init__(self, **kwargs)
@@ -122,7 +124,24 @@ class XmippProtDeepMicrographScreen(ProtExtractParticles, XmippProtocol):
                        help="Add a list of GPU devices that can be used.")
 
         # form.addParallelSection(threads=4, mpi=1)
-    
+
+    def getGpusList(self, separator):
+        strGpus = ""
+        for elem in self._stepsExecutor.getGpuList():
+            strGpus = strGpus + str(elem) + separator
+        return strGpus[:-1]
+
+    def setGPU(self, oneGPU=False):
+        if oneGPU:
+            gpus = self.getGpusList(",")[0]
+        else:
+            gpus = self.getGpusList(",")
+        os.environ["CUDA_VISIBLE_DEVICES"] = gpus
+        os.environ['TF_FORCE_GPU_ALLOW_GROWTH'] = 'true'
+        self.info(f'Visible GPUS: {gpus}')
+        return gpus
+
+
     #--------------------------- INSERT steps functions ------------------------
     def _insertInitialSteps(self):
         # Just overwrite this function to load some info
@@ -199,7 +218,7 @@ class XmippProtDeepMicrographScreen(ProtExtractParticles, XmippProtocol):
           args += ' -o %s' % self._getExtraPath('outputCoords')
           args += ' -b %d' % self.getBoxSize()
           args += ' -s 1' #Downsampling is automatically managed by scipion
-          args += ' -d %s' % self.getModel('deepMicrographCleaner', 'defaultModel.keras')
+          args += ' -d %s' % self.getModel('deepMicrographCleanerTF2', 'defaultModel.h5')
 
           if self.threshold.get() > 0:
               args += ' --deepThr %f ' % (1-self.threshold.get())
@@ -208,14 +227,9 @@ class XmippProtDeepMicrographScreen(ProtExtractParticles, XmippProtocol):
               args += ' --predictedMaskDir %s ' % (self._getExtraPath("predictedMasks"))
 
           if self.useGpu.get():
-              if self.useQueueForSteps() or self.useQueue():
-                  args += ' -g all '
-              else:
-                  args += ' -g %s'%(",".join([str(elem) for elem in self.getGpuList()]))
-          else:
-              args += ' -g -1'
+              gpuId = self.setGPU(oneGPU=False)
+              args += f' -g {gpuId} '
 
-          os.environ['TF_FORCE_GPU_ALLOW_GROWTH'] = 'true'
           self.runJob('xmipp_deep_micrograph_cleaner', args)
 
 

xmipp3/protocols/protocol_extract_asymmetric_unit.py

@@ -31,7 +31,7 @@ from pwem.objects import Transform
 from pwem.convert import Ccp4Header
 from pwem.protocols import EMProtocol
 from pyworkflow.protocol.params import (PointerParam, FloatParam,
-                                        EnumParam, IntParam)
+                                        EnumParam, IntParam, GE)
 
 from xmipp3.constants import (XMIPP_SYM_NAME, XMIPP_TO_SCIPION, XMIPP_CYCLIC,
                               XMIPP_DIHEDRAL_X, XMIPP_TETRAHEDRAL, XMIPP_OCTAHEDRAL,
@@ -76,7 +76,7 @@ class XmippProtExtractUnit(EMProtocol):
                                " (" + SCIPION_SYM_NAME[XMIPP_TO_SCIPION[XMIPP_In25r]] + ")"],
                       default=XMIPP_I222,
                       label="Symmetry",
-                      help="See http://xmipp.cnb.csic.es/twiki/bin/view/Xmipp/"
+                      help="See https://i2pc.github.io/docs/Utils/Conventions/index.html#symmetry"
                            "Symmetry for a description of the symmetry groups "
                            "format in Xmipp.\n"
                            "If no symmetry is present, use _c1_."
@@ -89,9 +89,9 @@ class XmippProtExtractUnit(EMProtocol):
                       condition='symmetryGroup<=%d' % SYM_DIHEDRAL_X,
                       label="offset",
                       help="rotate unit cell around z-axis by offset degrees")
-        form.addParam('innerRadius', FloatParam, default=-1,
-                      label="Inner Radius (px)",
-                      help="inner Mask radius, if -1, the radius will be 0")
+        form.addParam('innerRadius', FloatParam, default=0.0,
+                      label="Inner Radius (px)", validators=[GE(0.0)],
+                      help="inner Mask radius")
         form.addParam('outerRadius', FloatParam, default=-1,
                       label="Outer Radius (px)",
                       help="outer Mask radius, if -1, the radius will be "
@@ -103,8 +103,8 @@ class XmippProtExtractUnit(EMProtocol):
     # --------------------------- INSERT steps functions ----------------------
 
     def _insertAllSteps(self):
-        self._insertFunctionStep('extractUnit')
-        self._insertFunctionStep('createOutputStep')
+        self._insertFunctionStep(self.extractUnit)
+        self._insertFunctionStep(self.createOutputStep)
 
     # --------------------------- STEPS functions -----------------------------
 
@@ -128,8 +128,8 @@ class XmippProtExtractUnit(EMProtocol):
         args = "-i %s -o %s" % \
                (inFileName, self._getOutputVol())
         args += " --unitcell %s " % sym
-        args += " %f " % self.innerRadius.get()
-        args += " %f " % self.outerRadius.get()
+        args += " %f " % self._getInnerRadius()
+        args += " %f " % self._getOuterRadius()
         args += " %f " % self.expandFactor.get()
         args += " %f " % self.offset.get()
         sampling = self.inputVolumes.get().getSamplingRate()
@@ -177,11 +177,21 @@ class XmippProtExtractUnit(EMProtocol):
         return []
 
     # --------------------------- UTILS functions -----------------------------
-
+    def _getInnerRadius(self):
+        return self.innerRadius.get()
+    
+    def _getOuterRadius(self):
+        outerRadius = self.outerRadius.get()
+        if outerRadius < 0:
+            volume: Volume = self.inputVolumes.get()
+            dim = volume.getDimensions()
+            outerRadius = dim[0] / 2
+        return outerRadius
+    
     def _getOutputVol(self):
         prefix = os.path.basename(self.inputVolumes.get().getFileName()).split(".")[0]
 
         return self._getExtraPath(prefix + "_output_volume.mrc")
 
     def replace_at_index(self, tup, ix, val):
-        return tup[:ix] + (val,) + tup[ix + 1:]
+        return tup[:ix] + (val,) + tup[ix + 1:]

xmipp3/protocols/protocol_extract_particles.py

@@ -50,7 +50,7 @@ FACTOR_BOXSIZE = 1.5
 class XmippProtExtractParticles(ProtExtractParticles, XmippProtocol):
     """Extracts particle images from micrographs based on provided coordinates. This essential step prepares particle stacks for further processing such as classification and reconstruction."""
     _label = 'extract particles'
-    _devStatus = UPDATED
+    _devStatus = PROD
     RESIZE_FACTOR = 0
     RESIZE_DIMENSIONS = 1
     RESIZE_SAMPLINGRATE = 2