scipion-em-xmipp 24.6.0.0__py3-none-any.whl → 24.12.2__py3-none-any.whl

xmipp3/convert/convert.py

@@ -31,6 +31,7 @@ This module contains converter functions that will serve to:
 """
 
 import os
+from typing import Union
 from os.path import join, exists
 from collections import OrderedDict
 try:
@@ -46,7 +47,7 @@ from pwem.constants import (NO_INDEX, ALIGN_NONE, ALIGN_PROJ, ALIGN_2D,
                             ALIGN_3D)
 from pwem.objects import (Angles, Coordinate, Micrograph, Volume, Particle,
                           MovieParticle, CTFModel, Acquisition, SetOfParticles,
-                          Class3D, SetOfVolumes, Transform)
+                          Class3D, SetOfVolumes, Movie, SetOfMovies, Transform)
 from pwem.emlib.image import ImageHandler
 import pwem.emlib.metadata as md
 
@@ -1657,10 +1658,30 @@ def writeShiftsMovieAlignment(movie, xmdFn, s0, sN):
 
     globalShiftsMD.write(xmdFn)
 
+def makeEerFilename(eer: str, fractioning: int, supersampling: str, datatype: str) -> str:
+    ARG_PREAMLE = '#'
+    SEPARATOR = ','
+    return eer + ARG_PREAMLE + ('%d' % fractioning) + SEPARATOR + supersampling + SEPARATOR + datatype
 
-def writeMovieMd(movie, outXmd, f1, fN, useAlignment=False):
+def frameToRow(frame, row, firstFrame, eerFrames):
+    frameFilename = ImageHandler.locationToXmipp(frame)
+    
+    if os.path.splitext(frameFilename)[-1] == '.eer':
+        frameFilename = makeEerFilename(frameFilename, eerFrames, '4K', 'uint16')
+    row.setValue(md.MDL_IMAGE, frameFilename)
+
+def isEerMovie(movie: Union[Movie, SetOfMovies]):
+    if movie is not None:
+        files = movie.getFiles()
+        if len(files) > 0:
+            return next(iter(files)).endswith('.eer')
+    
+    return False
+    
+def writeMovieMd(movie, outXmd, f1, fN, useAlignment=False, eerFrames=40):
     movieMd = md.MetaData()
     frame = movie.clone()
+    isEer = isEerMovie(movie)
     # get some info about the movie
     # problem is, that it can come from a movie set, and some
     # values might refer to different movie, e.g. no of frames :(
@@ -1673,19 +1694,20 @@ def writeMovieMd(movie, outXmd, f1, fN, useAlignment=False):
         if frames is not None:
             lastFrame = frames
 
-    if f1 < firstFrame or fN > lastFrame:
-        raise Exception("Frame range could not be greater"
-                        " than the movie one.")
+    if isEer:
+        lastFrame = eerFrames
 
-    ih = ImageHandler()
+    if f1 < firstFrame or fN > lastFrame:
+        raise ValueError(f"Frame range [{f1}-{fN}] could not be greater"
+                         f" than the movie one [{firstFrame}-{lastFrame}].")
 
     if useAlignment:
         alignment = movie.getAlignment()
         if alignment is None:
-            raise Exception("Can not write alignment for movie. ")
+            raise ValueError("Can not write alignment for movie.")
         a0, aN = alignment.getRange()
         if a0 < firstFrame or aN > lastFrame:
-            raise Exception("Trying to write frames which have not been aligned.")
+            raise ValueError("Trying to write frames which have not been aligned.")
         shiftListX, shiftListY = alignment.getShifts()
 
     row = md.Row()
@@ -1693,8 +1715,7 @@ def writeMovieMd(movie, outXmd, f1, fN, useAlignment=False):
 
     for i in range(f1, fN+1):
         frame.setIndex(stackIndex)
-        row.setValue(md.MDL_IMAGE, ih.locationToXmipp(frame))
-
+        frameToRow(frame, row, firstFrame=firstFrame, eerFrames=eerFrames)
         if useAlignment:
             shiftIndex = i - firstFrame
             row.setValue(emlib.MDL_SHIFT_X, shiftListX[shiftIndex])

xmipp3/protocols/__init__.py

@@ -31,14 +31,15 @@ from .protocol_preprocess import *
 from .protocol_assignment_tilt_pair import XmippProtAssignmentTiltPair
 from .protocol_align_volume import XmippProtAlignVolume, XmippProtAlignVolumeForWeb
 from .protocol_angular_graph_consistency import XmippProtAngularGraphConsistency
-from .protocol_angular_resolution_alignment import XmippProtResolutionAlignment
 from .protocol_preprocess.protocol_add_noise import (XmippProtAddNoiseVolumes,
                                                      XmippProtAddNoiseParticles)
 from .protocol_apply_alignment import XmippProtApplyAlignment
+from .protocol_apply_tilt_to_ctf import XmippProtApplyTiltToCtf
 from .protocol_apply_transformation_matrix import XmippProtApplyTransformationMatrix
 from .protocol_break_symmetry import XmippProtAngBreakSymmetry
 from .protocol_cl2d_align import XmippProtCL2DAlign
 from .protocol_cl2d import XmippProtCL2D
+from .protocol_cl2d_clustering import XmippProtCL2DClustering
 from .protocol_classify_pca import XmippProtClassifyPca
 from .protocol_classify_pca_streaming import XmippProtClassifyPcaStreaming
 #from .protocol_classify_kmeans2d import XmippProtKmeansClassif2D
@@ -63,11 +64,11 @@ from .protocol_extract_particles_pairs import XmippProtExtractParticlesPairs
 from .protocol_extract_asymmetric_unit import XmippProtExtractUnit
 from .protocol_helical_parameters import XmippProtHelicalParameters
 from .protocol_kerdensom import XmippProtKerdensom
+from .protocol_mics_defocus_balancer import XmippProtMicDefocusSampler
 from .protocol_ml2d import XmippProtML2D
 from .protocol_movie_gain import XmippProtMovieGain
 from .protocol_movie_alignment_consensus import XmippProtConsensusMovieAlignment
 from .protocol_flexalign import XmippProtFlexAlign
-from .protocol_movie_opticalflow import XmippProtOFAlignment, ProtMovieAlignment
 from .protocol_movie_max_shift import XmippProtMovieMaxShift
 from .protocol_movie_dose_analysis import XmippProtMovieDoseAnalysis
 from .protocol_movie_split_frames import XmippProtSplitFrames
@@ -135,3 +136,4 @@ from .protocol_volume_local_adjust import XmippProtLocalVolAdj
 from .protocol_classes_2d_mapping import XmippProtCL2DMap
 from .protocol_deep_hand import XmippProtDeepHand
 from .protocol_deep_center import XmippProtDeepCenter
+from .protocol_deep_center_predict import XmippProtDeepCenterPredict

xmipp3/protocols/protocol_apply_tilt_to_ctf.py

@@ -0,0 +1,114 @@
+# **************************************************************************
+# *
+# * Authors:     Oier Lauzirika Zarrabeitia (oierlauzi@bizkaia.eu)
+# *
+# * 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'
+# *
+# **************************************************************************
+
+from typing import Optional
+
+import pyworkflow.protocol.params as params
+from pyworkflow.utils.properties import Message
+
+from pwem.objects import (Particle, Coordinate, Micrograph, CTFModel,
+                          SetOfParticles, SetOfMicrographs)
+from pwem.protocols import EMProtocol
+from pyworkflow import BETA, UPDATED, NEW, PROD
+
+import math
+
+class XmippProtApplyTiltToCtf(EMProtocol):
+    """ Apply a local deviation to the CTF based on the micrograph's tilt
+    angle"""
+    _devStatus = NEW
+
+    _label = 'apply tilt to ctf'
+    _tilt_axes = ['X', 'Y']
+    _tilt_signs = ['Increasing', 'Decreasing']
+
+    #--------------------------- DEFINE param functions --------------------------------------------
+    def _defineParams(self, form):
+        form.addSection(label='Input')
+        form.addParam('inputParticles', params.PointerParam, label=Message.LABEL_INPUT_PART,
+                      pointerClass=SetOfParticles, pointerCondition='hasCTF and hasCoordinates',
+                      important=True,
+                      help='Select the particles that you want to apply the'
+                           'local CTF correction.')
+        form.addParam('inputMicrographs', params.PointerParam, label=Message.LABEL_INPUT_MIC,
+                      pointerClass=SetOfMicrographs,
+                      important=True,
+                      help='The micrographs from which particles were extracted.')
+        form.addParam('tiltAxis', params.EnumParam, label='Tilt axis', 
+                      choices=self._tilt_axes, default=1,
+                      help='The tilt axis. In tomography this is Y by convention.')
+        form.addParam('tiltAngle', params.FloatParam, label='Tilt angle',
+                      default=0, validators=[params.Range(0, 90)],
+                      help='The angle at which the acquisition is tilted. '
+                      'In degrees.')
+        form.addParam('tiltSign', params.EnumParam, label='Tilt sign',
+                      choices=self._tilt_signs, default=0,
+                      help='Wether defocus increases or decreases in terms '
+                      'of the selected tilt axis.')
+        
+    #--------------------------- INSERT steps functions --------------------------------------------
+    
+    def _insertAllSteps(self):
+        self._insertFunctionStep('createOutputStep')        
+
+    #--------------------------- STEPS functions --------------------------------------------        
+    def createOutputStep(self):
+        inputParticles: SetOfParticles = self.inputParticles.get()
+        outputParticles: SetOfParticles = self._createSetOfParticles()
+        
+        TILT_INDICES = [1, 0]
+        SIGNS = [+1, -1]
+        sign = SIGNS[self.tiltSign.get()]
+        self.tiltIndex = TILT_INDICES[self.tiltAxis.get()]
+        self.sineFactor = sign*math.sin(math.radians(self.tiltAngle.get()))
+        
+        outputParticles.copyInfo(inputParticles)
+        outputParticles.copyItems(inputParticles,
+                                  updateItemCallback=self._updateItem )
+     
+        self._defineOutputs(outputParticles=outputParticles)
+        self._defineSourceRelation(self.inputParticles, outputParticles)
+    
+    #--------------------------- UTILS functions --------------------------------------------
+    def _updateItem(self, particle: Particle, _):
+        # Obtain necessary objects
+        coordinate: Coordinate = particle.getCoordinate()
+        micrograph: Optional[Micrograph] = coordinate.getMicrograph()
+        if micrograph is None:
+            micrographId = coordinate.getMicId()
+            micrograph = self.inputMicrographs.get()[micrographId]
+        
+        # Compute the CTF offset
+        dimensions = micrograph.getXDim(), micrograph.getYDim()
+        position = coordinate.getPosition()
+        r = position[self.tiltIndex] - (dimensions[self.tiltIndex] / 2)
+        r *= micrograph.getSamplingRate() # Convert to angstroms.
+        dy = self.sineFactor*r
+        
+        # Write to output
+        ctf: CTFModel = particle.getCTF()
+        ctf.setDefocusU(ctf.getDefocusU() + dy)
+        ctf.setDefocusV(ctf.getDefocusV() + dy)

xmipp3/protocols/protocol_cl2d.py

@@ -67,7 +67,7 @@ class XmippProtCL2D(ProtClassify2D):
     the original dataset into a given number of classes. """
     
     _label = 'cl2d'
-    _devStatus = UPDATED
+    _devStatus = PROD
 
     _possibleOutputs = {OUTPUTCLASSES: SetOfClasses2D,
                         OUTPUTCLASSES+CLASSES_CORE: SetOfClasses2D,

xmipp3/protocols/protocol_cl2d_clustering.py

@@ -0,0 +1,303 @@
+# ******************************************************************************
+# *
+# * Authors:     Daniel Marchan Torres (da.marchan@cnb.csic.es)
+# *
+# * 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 os.path
+from pwem.objects.data import Class2D, Particle, SetOfClasses2D, SetOfAverages
+from pwem.protocols import ProtAnalysis2D
+from pyworkflow.protocol.params import (PointerParam, IntParam,
+                                        EnumParam, LEVEL_ADVANCED, LT, GT)
+from pyworkflow import NEW, BETA
+from xmipp3 import XmippProtocol
+
+FN = "class_representatives"
+RESULT_FILE = 'best_clusters_with_names.txt'
+OUTPUT_CLASSES = 'outputClasses'
+OUTPUT_AVERAGES = 'outputAverages'
+
+
+class XmippProtCL2DClustering(ProtAnalysis2D, XmippProtocol):
+    """2D clustering protocol to group similar images (2D Averages or 2D Classes) """
+
+    _label = 'clustering 2d classes'
+    _devStatus = BETA
+
+    _possibleOutputs = {OUTPUT_CLASSES: SetOfClasses2D,
+                        OUTPUT_AVERAGES: SetOfAverages}
+
+    CLASSES = 0
+    AVERAGES = 1
+    BOTH = 2
+
+    def __init__(self, **args):
+        ProtAnalysis2D.__init__(self, **args)
+
+    #--------------------------- DEFINE param functions ------------------------
+    def _defineParams(self, form):
+        form.addSection(label='Input')
+        form.addParam('inputSet2D', PointerParam,
+                      label="Input 2D images",
+                      important=True, pointerClass='SetOfClasses2D, SetOfAverages',
+                      help='Select the input classes or input averages to be clustered.')
+        form.addParam('min_cluster', IntParam, label='Minimum number of clusters',
+                      default=10, expertLevel=LEVEL_ADVANCED,
+                      validators=[GT(1, 'Error must be greater than 1')],
+                      help=' This number will limit the search for the optimum number of clusters. '
+                               'By default, the 2D averages will start searching for the optimum number of clusters'
+                               'with a minimum number of 10 classes.')
+        form.addParam('max_cluster', IntParam, label='Maximum number of clusters',
+                      default=-1, expertLevel=LEVEL_ADVANCED,
+                      validators=[LT(50, 'Error must be smaller than the number of classes - 2.')],
+                      help='This number will limit the search for the optimum number of clusters. '
+                              'If -1 then it will act as default. By default, the 2D averages will end searching'
+                              'for the optimum number of clusters until a maximum number of N_classes - 2.')
+        form.addParam('compute_threads', IntParam, label='Number of computational threads',
+                      default=8, expertLevel=LEVEL_ADVANCED,
+                      validators=[
+                          GT(0, 'Error must be greater than 0.')],
+                      help=' By default, the program will use 8 threads for computation.'
+                               'The higher the number the fastest the computation will be')
+
+        form.addSection(label='Output')
+        form.addParam('extractOption', EnumParam,
+                      choices=['Classes', 'Averages', 'Both'],
+                      default=self.CLASSES,
+                      label="Extraction option", display=EnumParam.DISPLAY_COMBO,
+                      help='Select an option to extract from the 2D Classes: \n '
+                           '_Classes_: Create a new set of 2D classes with the respective cluster distribution. \n '
+                           '_Averages_: Extract the representatives of each cluster. This are the most representative averages. \n'
+                           '_Both_: Create a new set of 2D classes and extract their representatives.')
+
+
+    # --------------------------- INSERT steps functions ------------------------
+    def _insertAllSteps(self):
+        convertStep = self._insertFunctionStep(self.convertStep)
+        clusterStep = self._insertFunctionStep(self.clusterClasses, prerequisites=convertStep)
+        self._insertFunctionStep(self.createOutputStep, prerequisites=clusterStep)
+
+
+    def convertStep(self):
+        self.info('Writting class representatives')
+        self.directoryPath = self._getExtraPath()
+        self.imgsFn = os.path.join(self.directoryPath, FN + ".mrcs")
+        self.refIdsFn = os.path.join(self.directoryPath, FN + ".txt")
+
+        inputSet2D = self.inputSet2D.get()
+        classes_refIds = []
+
+        if isinstance(inputSet2D, SetOfClasses2D):
+            self.samplingRate = inputSet2D.getFirstItem().getRepresentative().getSamplingRate()
+            for rep in inputSet2D.iterRepresentatives():
+                idClass, _ = rep.getLocation()
+                classes_refIds.append(idClass)
+        else: # In case the input is a SetOfAverages
+            self.samplingRate = inputSet2D.getSamplingRate()
+            for rep in inputSet2D.iterItems():
+                idClass, _ = rep.getLocation()
+                classes_refIds.append(idClass)
+
+        # Save the corresponding .mrcs file
+        inputSet2D.writeStack(self.imgsFn) # The same method for SetOfClasses and SetOfAverages
+        # Save the original ref ids
+        with open(self.refIdsFn, "w") as file:
+            for item in classes_refIds:
+                file.write(f"{item}\n")
+
+
+    def clusterClasses(self):
+        'xmipp_cl2d_clustering -i path/to/inputAverages.mrcs -o path/to/outputDir -m 10 -M 20 -j 8'
+
+        min_cluster = self.min_cluster.get()
+        max_cluster = self.max_cluster.get()
+        compute_threads = self.compute_threads.get()
+
+        args = (" -i %s -o %s -m %d -M %d -j %d"
+                %(self.imgsFn, self.directoryPath, min_cluster, max_cluster, compute_threads))
+
+        self.runJob("xmipp_cl2d_clustering", args)
+
+
+    def createOutputStep(self):
+        output_dict = {}
+        inputSet2D = self.inputSet2D.get()
+        inputSet2D.loadAllProperties()
+
+        result_dict_file = os.path.join(self.directoryPath, RESULT_FILE)
+        result_dict = self.read_clusters_from_txt(result_dict_file)
+
+        message = ("Classify original input set of %d images into %d groups of structural different images"
+                   % (self.inputSet2D.get().getSize(), len(result_dict)))
+
+        self.summaryVar.set(message)
+
+        if self.extractOption.get() == self.CLASSES or self.extractOption.get() == self.BOTH:
+            output_dict = self.createOutputSetOfClasses(inputSet2D, result_dict, output_dict)
+
+        if self.extractOption.get() == self.AVERAGES or self.extractOption.get() == self.BOTH:
+            output_dict = self.createOutputSetOfAverages(inputSet2D, result_dict, output_dict)
+
+        self._defineOutputs(**output_dict)
+
+        if self.extractOption.get() == self.CLASSES or self.extractOption.get() == self.BOTH:
+            self._defineSourceRelation(inputSet2D.getImagesPointer(), output_dict[OUTPUT_CLASSES])
+        if self.extractOption.get() == self.AVERAGES or self.extractOption.get() == self.BOTH:
+            self._defineSourceRelation(self.inputSet2D, output_dict[OUTPUT_AVERAGES])
+
+        self._store()
+
+
+    def createOutputSetOfAverages(self, inputSet2D, result_dict, output_dict):
+        outputRefs = self._createSetOfAverages()  # We need to create always an empty set since we need to rebuild it
+
+        for cluster, classesRef in result_dict.items():
+            self.info('For cluster %d' % cluster)
+            self.info('We have the following ref classes: %s' % classesRef)
+            firstTime = True
+            for classRef in classesRef:
+                if firstTime: # Just want to get the first ref
+                    if isinstance(inputSet2D, SetOfClasses2D):
+                        classTmp = inputSet2D.getItem("id", classRef).clone()
+                        rep = classTmp.getRepresentative().clone()
+                    else:
+                        rep = inputSet2D.getItem("id", classRef).clone()
+                        self.samplingRate = inputSet2D.getSamplingRate()
+                    self.info('Using centroid to create new Average %s' % classRef)
+                    newAvg = Particle()
+                    newAvg.copyInfo(rep)
+                    newAvg.setObjId(int(classRef))
+                    newAvg.setClassId(int(classRef))
+                    outputRefs.append(newAvg)
+                    firstTime = False
+
+        outputRefs.setSamplingRate(self.samplingRate)
+        output_dict[OUTPUT_AVERAGES] = outputRefs
+
+        return output_dict
+
+
+    def createOutputSetOfClasses(self, inputSet2D, result_dict, output_dict):
+        classes2DSet = self._createSetOfClasses2D(inputSet2D.getImagesPointer())
+        dictClasses = {}
+
+        for cluster, classesRef in result_dict.items():
+            self.info('For cluster %d' % cluster)
+            self.info('We have the following ref classes: %s' % classesRef)
+            firstTime = True
+            newParticles = []
+
+            for classRef in classesRef:
+                classTmp = inputSet2D.getItem("id", classRef)
+                if firstTime:
+                    self.info('First iter, using centroid to create new Class: %s' % classRef)
+                    newClass = Class2D()
+                    newClass.copyInfo(classTmp)
+                    newClass.setObjId(int(classRef))
+                    newClassId = newClass.getObjId()
+                    firstTime = False
+
+                for particle in classTmp.iterItems():
+                    particle.setClassId(newClassId)
+                    newParticles.append(particle.clone())
+
+            dictClasses[newClassId] = newParticles
+            self.info('Class particles size: %d' % len(newParticles))
+            classes2DSet.append(newClass)
+
+        for classId, particles in dictClasses.items():
+            self.info('Filling Class with ID %d with %d particles' % (classId, len(particles)))
+            class2D = classes2DSet[classId]
+            class2D.enableAppend()
+            for particle in particles:
+                class2D.append(particle)
+
+            classes2DSet.update(class2D)
+
+        classes2DSet.write()
+
+        output_dict[OUTPUT_CLASSES] = classes2DSet
+
+        return output_dict
+
+
+    # --------------------------- INFO functions --------------------------------------------
+    def _summary(self):
+        summary = []
+        if not hasattr(self, OUTPUT_CLASSES) and not hasattr(self, OUTPUT_AVERAGES):
+            summary.append("Output set not ready yet.")
+        else:
+            summary.append(self.summaryVar.get())
+
+        return summary
+
+
+    def _validate(self):
+        errors = []
+        if ((self.extractOption.get() == self.CLASSES or self.extractOption.get() == self.BOTH)
+                and not isinstance(self.inputSet2D.get(), SetOfClasses2D)):
+            errors.append("The input 2D must be a SetOfClasses2D to generate a SetOfClasses2D.")
+
+        return errors
+
+    # ------------------------------------ Utils ----------------------------------------------
+    def read_clusters_from_txt(self, file_path):
+        """
+        Reads a cluster dictionary from a .txt file formatted as:
+        Cluster 0:
+            6
+        Cluster 1:
+            36
+            34
+            44
+        ...
+
+        Args:
+            file_path (str): The path to the .txt file.
+
+        Returns:
+            dict: A dictionary where the key is the cluster number and the value is a list of associated numbers.
+        """
+        clusters = {}
+        current_cluster = None
+
+        with open(file_path, 'r') as file:
+            for line in file:
+                line = line.strip()
+                if line.startswith("Cluster"):
+                    # Extract the cluster number
+                    current_cluster = int(line.split()[1].replace(':', ''))
+                    clusters[current_cluster] = []
+                elif current_cluster is not None and line.isdigit():
+                    # Append numbers to the current cluster's list
+                    clusters[current_cluster].append(line)
+
+        return clusters
+
+    # --------------------------------- Viewer functions ---------------------------------
+    def getClusterPlot(self):
+        return self._getExtraPath('best_cluster_visualization_with_images.png')
+
+
+    def getClusterImagesPlot(self):
+        return self._getExtraPath('all_clusters_with_labels.png')

xmipp3/protocols/protocol_classify_pca.py

@@ -291,8 +291,10 @@ class XmippProtClassifyPca(ProtClassify2D, XmippProtocol):
             errors.append("You should resize the particles."
                           " Sizes smaller than 128 pixels are recommended.")
         er = self.validateDLtoolkit()
+        if not isinstance(er, list):
+            er = [er]
         if er:
-            errors.append(er)
+            errors+=er
         return errors
 
     def _warnings(self):

xmipp3/protocols/protocol_classify_pca_streaming.py

@@ -331,6 +331,7 @@ class XmippProtClassifyPcaStreaming(ProtStreamingBase, XmippProtClassifyPca):
         # Limit the number of threads
         env['OMP_NUM_THREADS'] = '12'
         env['MKL_NUM_THREADS'] = '12'
+        env['PYTORCH_CUDA_ALLOC_CONF'] = 'expandable_segments:True'
         return env
 
     def _updateFnClassification(self):

xmipp3/protocols/protocol_compare_reprojections.py

@@ -39,7 +39,7 @@ from pwem.emlib.image import ImageHandler
 from pwem import emlib
 
 from pyworkflow.protocol.constants import LEVEL_ADVANCED
-from pyworkflow import UPDATED
+from pyworkflow import UPDATED, PROD
 from pyworkflow import VERSION_3_0
 from pyworkflow.protocol.params import (PointerParam, StringParam, FloatParam, BooleanParam, EnumParam)
 from pyworkflow.utils.path import cleanPath, cleanPattern
@@ -63,7 +63,7 @@ class XmippProtCompareReprojections(ProtAnalysis3D, ProjMatcher):
 
     _label = 'compare reprojections'
     _lastUpdateVersion = VERSION_3_0
-    _devStatus = UPDATED
+    _devStatus = PROD
     _possibleOutputs = {}
 
     PARTICLES = 0

xmipp3/protocols/protocol_convert_pdb.py

@@ -39,13 +39,13 @@ from pwem.objects import Volume, Transform, SetOfVolumes, AtomStruct, SetOfAtomS
 from pwem.protocols import ProtInitialVolume
 import pyworkflow.protocol.params as params
 import pyworkflow.protocol.constants as const
-from pyworkflow.utils import replaceBaseExt, removeExt, getExt, createLink, replaceExt, removeBaseExt
+from pyworkflow.utils import replaceBaseExt, removeExt, getExt, createLink, replaceExt, removeBaseExt, red
 from pyworkflow import UPDATED, PROD
 
 class XmippProtConvertPdb(ProtInitialVolume):
     """ Convert atomic structure(s) into volume(s) """
     _label = 'convert pdbs to volumes'
-    _devStatus = PROD
+    _devStatus = UPDATED
     OUTPUT_NAME1 = "outputVolume"
     OUTPUT_NAME2 = "outputVolumes"
     OUTPUT_NAME3 = "outputPdb"
@@ -111,7 +111,7 @@ class XmippProtConvertPdb(ProtInitialVolume):
                       label="Store centered PDB",
                       help='Set to \'Yes\' if you want to save centered PDB. '
                            'It will be stored in the output directory of this protocol.')
-        form.addParam('convertCif', params.BooleanParam, default=True,
+        form.addParam('convertCif', params.BooleanParam, default=False,
                       expertLevel=const.LEVEL_ADVANCED, 
                       label="Convert CIF to PDB",
                       help='If set to true and input atom struct file is a CIF, it will get converted to PDB.')
@@ -278,7 +278,12 @@ class XmippProtConvertPdb(ProtInitialVolume):
 
         # If file extension is .cif and conversion is required, convert to .pdb, or else we link it as is
         if getExt(pdbRaw) == ".cif" and self.convertCif.get():
-            cifToPdb(pdbRaw, convertedPdb)
+            try:
+                cifToPdb(pdbRaw, convertedPdb)
+            except:
+                self.error(red("The conversion has failed. It might be for an excessive number of atoms. "\
+                          "Try not to convert the CIF into a PDB (hidden flag)."))
+                raise RuntimeError("PDB conversion")
         else:
             createLink(pdbRaw, convertedPdb)