Upload 43 files

app.py

@@ -157,22 +157,22 @@ class AbMeltPipeline:
                 
             # Step 1: Generate structure (10% progress)
             if progress_callback:
-                progress_callback(10, "Generating antibody structure with ImmuneBuilder...")
+                progress_callback(10, "Generating antibody structure...")
                 
             structure_path = self.structure_gen.generate_structure(
                 heavy_chain, light_chain
             )
             
+            if not structure_path or not os.path.exists(structure_path):
+                raise FileNotFoundError("Structure generation failed. PDB file not created.")
+            
             # Copy structure file to persistent location before cleanup
-            if structure_path and os.path.exists(structure_path):
-                persistent_dir = os.path.join(os.getcwd(), "outputs")
-                os.makedirs(persistent_dir, exist_ok=True)
-                persistent_structure = os.path.join(persistent_dir, f"structure_{job_id}.pdb")
-                shutil.copy2(structure_path, persistent_structure)
-                results['intermediate_files']['structure'] = persistent_structure
-                logger.info(f"Structure copied to persistent location: {persistent_structure}")
-            else:
-                results['intermediate_files']['structure'] = structure_path
+            persistent_dir = os.path.join(os.getcwd(), "outputs")
+            os.makedirs(persistent_dir, exist_ok=True)
+            persistent_structure = os.path.join(persistent_dir, f"structure_{job_id}.pdb")
+            shutil.copy2(structure_path, persistent_structure)
+            results['intermediate_files']['structure'] = persistent_structure
+            logger.info(f"Structure copied to persistent location: {persistent_structure}")
                 
             results['logs'].append("✓ Structure generation completed")
             
@@ -262,6 +262,10 @@ class AbMeltPipeline:
                 results['error'] = error_msg
                 results['logs'].append(f"✗ {error_msg}")
                 logger.error(error_msg)
+                # Add specific check for NaN coordinate error
+                if "NaN" in str(e) or "invalid coordinates" in str(e):
+                    results['logs'].append("  Hint: This error is often caused by problems in the fallback "
+                                         "structure generator. Check sequence validity.")
                 
             finally:
                 # Cleanup MD pipeline
@@ -270,7 +274,7 @@ class AbMeltPipeline:
                 except:
                     pass
                     
-        except Exception as e:
+        except (Exception, GromacsError) as e:
             error_msg = f"Pipeline error: {str(e)}"
             results['error'] = error_msg
             results['logs'].append(f"✗ {error_msg}")

requirements.txt

@@ -30,7 +30,6 @@ optuna
 
 # System utilities (auto-update - rarely break compatibility)
 psutil
-
 tqdm
 
 # File handling (auto-update - stable API)

src/gromacs_pipeline.py

@@ -143,7 +143,7 @@ class GromacsPipeline:
     def _pdb2gmx(self, pdb_file, force_field, water):
         """Convert PDB to GROMACS topology"""
         try:
-            # First, let's check the PDB file content for debugging
+            # First, let's validate the PDB file for NaN coordinates
             logger.info(f"Processing PDB file: {pdb_file}")
             if os.path.exists(pdb_file):
                 file_size = os.path.getsize(pdb_file)
@@ -153,6 +153,9 @@ class GromacsPipeline:
                 if not os.access(pdb_file, os.R_OK):
                     raise PermissionError(f"Cannot read PDB file: {pdb_file}")
                 
+                # Validate PDB coordinates before processing
+                self._validate_pdb_coordinates(pdb_file)
+                
                 # Check for histidine residues that might cause issues
                 with open(pdb_file, 'r') as f:
                     content = f.read()
@@ -268,6 +271,9 @@ class GromacsPipeline:
                 raise ValueError(f"Invalid atom count in line 2: {lines[1].strip()}")
                 
             # Check coordinate lines
+            nan_detected = False
+            invalid_coords = []
+            
             for i, line in enumerate(lines[2:2+num_atoms], 3):
                 if len(line.strip()) == 0:
                     continue
@@ -280,26 +286,134 @@ class GromacsPipeline:
                         raise ValueError(f"Line {i}: insufficient columns: {line.strip()}")
                         
                     # Check coordinates (columns 4, 5, 6 in 0-indexed)
-                    x, y, z = float(parts[3]), float(parts[4]), float(parts[5])
+                    x_str, y_str, z_str = parts[3], parts[4], parts[5]
+                    
+                    # Check for NaN values in string form first
+                    if any('nan' in coord.lower() for coord in [x_str, y_str, z_str]):
+                        nan_detected = True
+                        invalid_coords.append(f"Line {i}: NaN coordinates detected: {x_str} {y_str} {z_str}")
+                        continue
+                        
+                    # Convert to float and check for NaN/inf values
+                    x, y, z = float(x_str), float(y_str), float(z_str)
+                    
+                    # Use math module to check for NaN and inf
+                    import math
+                    if math.isnan(x) or math.isnan(y) or math.isnan(z):
+                        nan_detected = True
+                        invalid_coords.append(f"Line {i}: NaN coordinates after float conversion: {x} {y} {z}")
+                        continue
+                        
+                    if math.isinf(x) or math.isinf(y) or math.isinf(z):
+                        invalid_coords.append(f"Line {i}: Infinite coordinates detected: {x} {y} {z}")
+                        continue
                     
                     # Check if coordinates contain decimal points in string representation
-                    if '.' not in parts[3] or '.' not in parts[4] or '.' not in parts[5]:
-                        logger.warning(f"Line {i}: coordinates may lack decimal points: {parts[3]} {parts[4]} {parts[5]}")
+                    if '.' not in x_str or '.' not in y_str or '.' not in z_str:
+                        logger.warning(f"Line {i}: coordinates may lack decimal points: {x_str} {y_str} {z_str}")
                         
                 except (ValueError, IndexError) as e:
-                    raise ValueError(f"Line {i}: invalid coordinate format: {line.strip()} - {e}")
+                    invalid_coords.append(f"Line {i}: invalid coordinate format: {line.strip()} - {e}")
+                    
+            # Report any coordinate issues
+            if nan_detected or invalid_coords:
+                error_msg = f"Coordinate validation failed for {gro_file}:\n"
+                for error in invalid_coords[:10]:  # Show first 10 errors
+                    error_msg += f"  {error}\n"
+                if len(invalid_coords) > 10:
+                    error_msg += f"  ... and {len(invalid_coords) - 10} more errors\n"
+                
+                logger.error(error_msg)
+                
+                # Show file content for debugging
+                with open(file_path, 'r') as f:
+                    content_lines = f.readlines()[:20]
+                logger.error(f"First 20 lines of {gro_file}:")
+                for i, line in enumerate(content_lines, 1):
+                    logger.error(f"  {i:2d}: {line.rstrip()}")
+                
+                if nan_detected:
+                    raise GromacsError(f"NaN coordinates detected in {gro_file}. This indicates a problem with structure generation. "
+                                     f"The fallback structure generator may have produced invalid coordinates.")
+                else:
+                    raise ValueError(f"Invalid coordinate format in {gro_file}")
                     
             logger.info(f"GRO file {gro_file} validation passed")
             
         except Exception as e:
             logger.error(f"GRO file validation failed for {gro_file}: {e}")
             # Show first few lines for debugging
-            with open(file_path, 'r') as f:
-                first_lines = f.readlines()[:10]
-            logger.error(f"First 10 lines of {gro_file}:")
-            for i, line in enumerate(first_lines, 1):
-                logger.error(f"  {i:2d}: {line.rstrip()}")
+            try:
+                with open(file_path, 'r') as f:
+                    first_lines = f.readlines()[:10]
+                logger.error(f"First 10 lines of {gro_file}:")
+                for i, line in enumerate(first_lines, 1):
+                    logger.error(f"  {i:2d}: {line.rstrip()}")
+            except Exception as debug_e:
+                logger.error(f"Could not read file for debugging: {debug_e}")
             raise
+            
+    def _validate_pdb_coordinates(self, pdb_file):
+        """Validate PDB file coordinates before processing with GROMACS"""
+        logger.info(f"Validating PDB coordinates: {pdb_file}")
+        
+        try:
+            with open(pdb_file, 'r') as f:
+                lines = f.readlines()
+                
+            invalid_coords = []
+            atom_count = 0
+            
+            for i, line in enumerate(lines, 1):
+                if line.startswith('ATOM') or line.startswith('HETATM'):
+                    atom_count += 1
+                    try:
+                        # PDB format: columns 31-38 (x), 39-46 (y), 47-54 (z)
+                        x_str = line[30:38].strip()
+                        y_str = line[38:46].strip()
+                        z_str = line[46:54].strip()
+                        
+                        # Check for NaN values in string form
+                        if any('nan' in coord.lower() for coord in [x_str, y_str, z_str]):
+                            invalid_coords.append(f"Line {i}: NaN coordinates detected in PDB: {x_str} {y_str} {z_str}")
+                            continue
+                            
+                        # Try to convert to float and check for NaN/inf
+                        x, y, z = float(x_str), float(y_str), float(z_str)
+                        
+                        import math
+                        if math.isnan(x) or math.isnan(y) or math.isnan(z):
+                            invalid_coords.append(f"Line {i}: NaN coordinates after conversion: {x} {y} {z}")
+                            continue
+                            
+                        if math.isinf(x) or math.isinf(y) or math.isinf(z):
+                            invalid_coords.append(f"Line {i}: Infinite coordinates: {x} {y} {z}")
+                            continue
+                            
+                    except (ValueError, IndexError) as e:
+                        invalid_coords.append(f"Line {i}: Could not parse coordinates: {e}")
+                        
+            logger.info(f"Validated {atom_count} atoms in PDB file")
+            
+            if invalid_coords:
+                error_msg = f"Invalid coordinates found in PDB file {pdb_file}:\n"
+                for error in invalid_coords[:10]:  # Show first 10 errors
+                    error_msg += f"  {error}\n"
+                if len(invalid_coords) > 10:
+                    error_msg += f"  ... and {len(invalid_coords) - 10} more errors\n"
+                    
+                logger.error(error_msg)
+                raise GromacsError(f"Invalid coordinates in PDB file {pdb_file}. "
+                                 f"The structure generator produced NaN or invalid coordinates. "
+                                 f"This will cause GROMACS to fail with 'coordinate does not contain a \".\"' error.")
+                                 
+            logger.info(f"PDB coordinate validation passed for {pdb_file}")
+            
+        except Exception as e:
+            if isinstance(e, GromacsError):
+                raise  # Re-raise our custom error
+            logger.error(f"PDB coordinate validation failed: {e}")
+            raise GromacsError(f"Could not validate PDB coordinates: {e}")
         
     def _solvate_system(self):
         """Add water molecules"""

src/structure_generator.py

@@ -35,26 +35,34 @@ class StructureGenerator:
                 logger.info(f"Using system temp directory: {self.temp_dir}")
         return self.temp_dir
         
-    def generate_structure(self, heavy_chain, light_chain, output_path=None):
+    def generate_structure(self, heavy_chain, light_chain, force_fallback=False):
         """
-        Generate antibody structure from sequences using ImmuneBuilder
+        Generate antibody structure using ImmuneBuilder or a basic fallback.
         
         Args:
-            heavy_chain (str): Heavy chain variable region sequence
-            light_chain (str): Light chain variable region sequence
-            output_path (str): Output PDB file path
-            
+            heavy_chain (str): Heavy chain sequence.
+            light_chain (str): Light chain sequence.
+            force_fallback (bool): If True, forces the use of the basic fallback generator for testing.
+        
         Returns:
-            str: Path to generated PDB file
+            str: Path to the generated PDB file.
         """
-        try:
-            from ImmuneBuilder import ABodyBuilder2
-            logger.info("ImmuneBuilder available - using for structure generation")
-            return self._generate_with_immunebuilder(heavy_chain, light_chain, output_path)
-        except ImportError as e:
-            logger.warning(f"ImmuneBuilder not available ({e})")
-            logger.info("Using fallback structure generation method")
-            return self._generate_fallback_structure(heavy_chain, light_chain, output_path)
+        if not self.immune_builder_available or force_fallback:
+            logger.warning(
+                "ImmuneBuilder not found or fallback forced. Using basic structure generator. "
+                "This is a simplified model and may not be accurate."
+            )
+            try:
+                pdb_file = self._create_basic_pdb_structure(heavy_chain, light_chain)
+                if not os.path.exists(pdb_file):
+                    raise FileNotFoundError("Fallback structure generator failed to create a PDB file.")
+                logger.info(f"Fallback PDB file created: {pdb_file}")
+                return pdb_file
+            except Exception as e:
+                logger.error(f"Fallback structure generator failed: {e}")
+                raise
+
+        logger.info("Attempting to generate structure with ImmuneBuilder...")
     
     def _generate_with_immunebuilder(self, heavy_chain, light_chain, output_path):
         """Generate structure using ImmuneBuilder (when available)"""
@@ -147,9 +155,15 @@ class StructureGenerator:
         
         # Add heavy chain atoms with complete side chains
         for i, aa in enumerate(heavy_chain, 1):
-            x = float(i * 3.8)  # Simple linear chain
-            y = 0.0
-            z = 0.0
+            # Ensure coordinates are proper floats to prevent NaN
+            x = self._safe_float(i * 3.8)  # Simple linear chain
+            y = self._safe_float(0.0)
+            z = self._safe_float(0.0)
+            
+            # Validate coordinates before proceeding
+            if not self._validate_coordinates(x, y, z):
+                logger.error(f"Invalid coordinates generated for heavy chain residue {i}: {x}, {y}, {z}")
+                raise ValueError(f"NaN coordinates detected for heavy chain residue {i}")
             
             three_letter = self._aa_three_letter(aa)
             
@@ -160,9 +174,15 @@ class StructureGenerator:
             
         # Add light chain atoms with complete side chains
         for i, aa in enumerate(light_chain, 1):
-            x = float(i * 3.8)
-            y = 15.0  # Offset from heavy chain
-            z = 0.0
+            # Ensure coordinates are proper floats to prevent NaN
+            x = self._safe_float(i * 3.8)
+            y = self._safe_float(15.0)  # Offset from heavy chain
+            z = self._safe_float(0.0)
+            
+            # Validate coordinates before proceeding
+            if not self._validate_coordinates(x, y, z):
+                logger.error(f"Invalid coordinates generated for light chain residue {i}: {x}, {y}, {z}")
+                raise ValueError(f"NaN coordinates detected for light chain residue {i}")
             
             three_letter = self._aa_three_letter(aa)
             
@@ -178,20 +198,31 @@ class StructureGenerator:
     def _add_complete_residue(self, pdb_lines, atom_counter, three_letter, res_id, x, y, z):
         """Add a complete amino acid residue with all required atoms"""
         
-        # Backbone atoms (required for all residues)
+        # Validate input coordinates
+        if not self._validate_coordinates(x, y, z):
+            logger.error(f"Invalid coordinates passed to _add_complete_residue: {x}, {y}, {z}")
+            raise ValueError(f"NaN coordinates detected for residue {res_id}")
+        
+        # Backbone atoms (required for all residues) - ensure all are valid floats
         backbone_atoms = [
-            ("N", x-1.0, y, z, "N"),
-            ("CA", x, y, z, "C"), 
-            ("C", x+1.0, y, z, "C"),
-            ("O", x+1.0, y+1.0, z, "O")
+            ("N", self._safe_float(x-1.0), self._safe_float(y), self._safe_float(z), "N"),
+            ("CA", self._safe_float(x), self._safe_float(y), self._safe_float(z), "C"), 
+            ("C", self._safe_float(x+1.0), self._safe_float(y), self._safe_float(z), "C"),
+            ("O", self._safe_float(x+1.0), self._safe_float(y+1.0), self._safe_float(z), "O")
         ]
         
         # Add side chain atoms based on residue type
         side_chain_atoms = self._get_side_chain_atoms(three_letter, x, y, z)
         
-        # Combine all atoms
+        # Combine all atoms and validate each coordinate
         all_atoms = backbone_atoms + side_chain_atoms
         
+        # Validate all atom coordinates before writing
+        for atom_name, ax, ay, az, element in all_atoms:
+            if not self._validate_coordinates(ax, ay, az):
+                logger.error(f"Invalid atom coordinates for {atom_name} in {res_id}: {ax}, {ay}, {az}")
+                raise ValueError(f"NaN coordinates detected for atom {atom_name} in residue {res_id}")
+        
         # Write atoms to PDB
         for atom_name, ax, ay, az, element in all_atoms:
             pdb_line = f"ATOM  {atom_counter:5d}  {atom_name:<3} {three_letter} {res_id}    {ax:8.3f}{ay:8.3f}{az:8.3f}  1.00 20.00           {element}"
@@ -203,127 +234,148 @@ class StructureGenerator:
     def _get_side_chain_atoms(self, three_letter, x, y, z):
         """Get side chain atoms for a specific amino acid"""
         
-        # Define side chain atoms for each amino acid type
+        # Ensure base coordinates are valid
+        if not self._validate_coordinates(x, y, z):
+            logger.error(f"Invalid base coordinates for side chain generation: {x}, {y}, {z}")
+            raise ValueError(f"NaN coordinates detected for side chain base coordinates")
+        
+        # Define side chain atoms for each amino acid type with safe coordinate calculation
         side_chains = {
-            'ALA': [("CB", x+0.5, y-0.5, z+0.5, "C")],
+            'ALA': [("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C")],
             'ARG': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("CD", x+1.5, y-1.5, z+1.5, "C"),
-                ("NE", x+2.0, y-2.0, z+2.0, "N"),
-                ("CZ", x+2.5, y-2.5, z+2.5, "C"),
-                ("NH1", x+3.0, y-3.0, z+3.0, "N"),
-                ("NH2", x+3.0, y-3.0, z+2.0, "N")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("CD", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "C"),
+                ("NE", self._safe_float(x+2.0), self._safe_float(y-2.0), self._safe_float(z+2.0), "N"),
+                ("CZ", self._safe_float(x+2.5), self._safe_float(y-2.5), self._safe_float(z+2.5), "C"),
+                ("NH1", self._safe_float(x+3.0), self._safe_float(y-3.0), self._safe_float(z+3.0), "N"),
+                ("NH2", self._safe_float(x+3.0), self._safe_float(y-3.0), self._safe_float(z+2.0), "N")
             ],
             'ASN': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("OD1", x+1.5, y-1.5, z+1.5, "O"),
-                ("ND2", x+1.5, y-1.0, z+0.5, "N")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("OD1", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "O"),
+                ("ND2", self._safe_float(x+1.5), self._safe_float(y-1.0), self._safe_float(z+0.5), "N")
             ],
             'ASP': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("OD1", x+1.5, y-1.5, z+1.5, "O"),
-                ("OD2", x+1.5, y-1.0, z+0.5, "O")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("OD1", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "O"),
+                ("OD2", self._safe_float(x+1.5), self._safe_float(y-1.0), self._safe_float(z+0.5), "O")
             ],
-            'CYS': [("CB", x+0.5, y-0.5, z+0.5, "C"), ("SG", x+1.0, y-1.0, z+1.0, "S")],
+            'CYS': [("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"), ("SG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "S")],
             'GLN': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("CD", x+1.5, y-1.5, z+1.5, "C"),
-                ("OE1", x+2.0, y-2.0, z+2.0, "O"),
-                ("NE2", x+2.0, y-1.5, z+1.0, "N")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("CD", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "C"),
+                ("OE1", self._safe_float(x+2.0), self._safe_float(y-2.0), self._safe_float(z+2.0), "O"),
+                ("NE2", self._safe_float(x+2.0), self._safe_float(y-1.5), self._safe_float(z+1.0), "N")
             ],
             'GLU': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("CD", x+1.5, y-1.5, z+1.5, "C"),
-                ("OE1", x+2.0, y-2.0, z+2.0, "O"),
-                ("OE2", x+2.0, y-1.5, z+1.0, "O")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("CD", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "C"),
+                ("OE1", self._safe_float(x+2.0), self._safe_float(y-2.0), self._safe_float(z+2.0), "O"),
+                ("OE2", self._safe_float(x+2.0), self._safe_float(y-1.5), self._safe_float(z+1.0), "O")
             ],
             'GLY': [],  # Glycine has no side chain
+            'HIS': [  # Fixed: Use proper histidine instead of mapping to ALA
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("ND1", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "N"),
+                ("CD2", self._safe_float(x+1.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CE1", self._safe_float(x+2.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("NE2", self._safe_float(x+2.0), self._safe_float(y-0.5), self._safe_float(z+0.5), "N")
+            ],
             'ILE': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG1", x+1.0, y-1.0, z+1.0, "C"),
-                ("CG2", x+1.0, y-0.5, z+0.0, "C"),
-                ("CD1", x+1.5, y-1.5, z+1.5, "C")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG1", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("CG2", self._safe_float(x+1.0), self._safe_float(y-0.5), self._safe_float(z+0.0), "C"),
+                ("CD1", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "C")
             ],
             'LEU': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("CD1", x+1.5, y-1.5, z+1.5, "C"),
-                ("CD2", x+1.5, y-0.5, z+0.5, "C")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("CD1", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "C"),
+                ("CD2", self._safe_float(x+1.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C")
             ],
             'LYS': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("CD", x+1.5, y-1.5, z+1.5, "C"),
-                ("CE", x+2.0, y-2.0, z+2.0, "C"),
-                ("NZ", x+2.5, y-2.5, z+2.5, "N")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("CD", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "C"),
+                ("CE", self._safe_float(x+2.0), self._safe_float(y-2.0), self._safe_float(z+2.0), "C"),
+                ("NZ", self._safe_float(x+2.5), self._safe_float(y-2.5), self._safe_float(z+2.5), "N")
             ],
             'MET': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("SD", x+1.5, y-1.5, z+1.5, "S"),
-                ("CE", x+2.0, y-2.0, z+2.0, "C")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("SD", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "S"),
+                ("CE", self._safe_float(x+2.0), self._safe_float(y-2.0), self._safe_float(z+2.0), "C")
             ],
             'PHE': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("CD1", x+1.5, y-1.5, z+1.5, "C"),
-                ("CD2", x+1.5, y-0.5, z+0.5, "C"),
-                ("CE1", x+2.0, y-2.0, z+2.0, "C"),
-                ("CE2", x+2.0, y+0.0, z+0.0, "C"),
-                ("CZ", x+2.5, y-1.0, z+1.0, "C")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("CD1", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "C"),
+                ("CD2", self._safe_float(x+1.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CE1", self._safe_float(x+2.0), self._safe_float(y-2.0), self._safe_float(z+2.0), "C"),
+                ("CE2", self._safe_float(x+2.0), self._safe_float(y+0.0), self._safe_float(z+0.0), "C"),
+                ("CZ", self._safe_float(x+2.5), self._safe_float(y-1.0), self._safe_float(z+1.0), "C")
             ],
             'PRO': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("CD", x+0.0, y-1.0, z+1.0, "C")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("CD", self._safe_float(x+0.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C")
             ],
-            'SER': [("CB", x+0.5, y-0.5, z+0.5, "C"), ("OG", x+1.0, y-1.0, z+1.0, "O")],
+            'SER': [("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"), ("OG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "O")],
             'THR': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("OG1", x+1.0, y-1.0, z+1.0, "O"),
-                ("CG2", x+1.0, y+0.0, z+0.0, "C")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("OG1", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "O"),
+                ("CG2", self._safe_float(x+1.0), self._safe_float(y+0.0), self._safe_float(z+0.0), "C")
             ],
             'TRP': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("CD1", x+1.5, y-1.5, z+1.5, "C"),
-                ("CD2", x+1.5, y-0.5, z+0.5, "C"),
-                ("NE1", x+2.0, y-1.0, z+1.0, "N"),
-                ("CE2", x+2.0, y-0.5, z+0.5, "C"),
-                ("CE3", x+2.0, y+0.5, z-0.5, "C"),
-                ("CZ2", x+2.5, y+0.0, z+0.0, "C"),
-                ("CZ3", x+2.5, y+1.0, z-1.0, "C"),
-                ("CH2", x+3.0, y+0.5, z-0.5, "C")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("CD1", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "C"),
+                ("CD2", self._safe_float(x+1.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("NE1", self._safe_float(x+2.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "N"),
+                ("CE2", self._safe_float(x+2.0), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CE3", self._safe_float(x+2.0), self._safe_float(y+0.5), self._safe_float(z-0.5), "C"),
+                ("CZ2", self._safe_float(x+2.5), self._safe_float(y+0.0), self._safe_float(z+0.0), "C"),
+                ("CZ3", self._safe_float(x+2.5), self._safe_float(y+1.0), self._safe_float(z-1.0), "C"),
+                ("CH2", self._safe_float(x+3.0), self._safe_float(y+0.5), self._safe_float(z-0.5), "C")
             ],
             'TYR': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG", x+1.0, y-1.0, z+1.0, "C"),
-                ("CD1", x+1.5, y-1.5, z+1.5, "C"),
-                ("CD2", x+1.5, y-0.5, z+0.5, "C"),
-                ("CE1", x+2.0, y-2.0, z+2.0, "C"),
-                ("CE2", x+2.0, y+0.0, z+0.0, "C"),
-                ("CZ", x+2.5, y-1.0, z+1.0, "C"),
-                ("OH", x+3.0, y-1.0, z+1.0, "O")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("CD1", self._safe_float(x+1.5), self._safe_float(y-1.5), self._safe_float(z+1.5), "C"),
+                ("CD2", self._safe_float(x+1.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CE1", self._safe_float(x+2.0), self._safe_float(y-2.0), self._safe_float(z+2.0), "C"),
+                ("CE2", self._safe_float(x+2.0), self._safe_float(y+0.0), self._safe_float(z+0.0), "C"),
+                ("CZ", self._safe_float(x+2.5), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("OH", self._safe_float(x+3.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "O")
             ],
             'VAL': [
-                ("CB", x+0.5, y-0.5, z+0.5, "C"),
-                ("CG1", x+1.0, y-1.0, z+1.0, "C"),
-                ("CG2", x+1.0, y+0.0, z+0.0, "C")
+                ("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C"),
+                ("CG1", self._safe_float(x+1.0), self._safe_float(y-1.0), self._safe_float(z+1.0), "C"),
+                ("CG2", self._safe_float(x+1.0), self._safe_float(y+0.0), self._safe_float(z+0.0), "C")
             ]
         }
         
-        return side_chains.get(three_letter, [("CB", x+0.5, y-0.5, z+0.5, "C")])  # Default CB for unknown
+        side_chain = side_chains.get(three_letter, [("CB", self._safe_float(x+0.5), self._safe_float(y-0.5), self._safe_float(z+0.5), "C")])  # Default CB for unknown
+        
+        # Validate all side chain atom coordinates
+        for atom_name, ax, ay, az, element in side_chain:
+            if not self._validate_coordinates(ax, ay, az):
+                logger.error(f"Invalid side chain coordinates for {atom_name} in {three_letter}: {ax}, {ay}, {az}")
+                raise ValueError(f"NaN coordinates detected for side chain atom {atom_name}")
+        
+        return side_chain
     
     def _aa_three_letter(self, one_letter):
         """Convert one-letter amino acid code to three-letter"""
         aa_map = {
             'A': 'ALA', 'R': 'ARG', 'N': 'ASN', 'D': 'ASP', 'C': 'CYS',
-            'Q': 'GLN', 'E': 'GLU', 'G': 'GLY', 'H': 'ALA', 'I': 'ILE',  # H->ALA to avoid HIS ring issues
+            'Q': 'GLN', 'E': 'GLU', 'G': 'GLY', 'H': 'HIS', 'I': 'ILE',  # Fixed: H->HIS instead of ALA
             'L': 'LEU', 'K': 'LYS', 'M': 'MET', 'F': 'PHE', 'P': 'PRO',
             'S': 'SER', 'T': 'THR', 'W': 'TRP', 'Y': 'TYR', 'V': 'VAL'
         }
@@ -341,6 +393,32 @@ class StructureGenerator:
         # Check if all characters are valid amino acids
         return all(aa in valid_aa for aa in sequence_clean)
         
+    def _safe_float(self, value):
+        """Safely convert value to float, ensuring no NaN or inf"""
+        try:
+            result = float(value)
+            if not self._is_valid_number(result):
+                logger.error(f"Invalid number detected: {value} -> {result}")
+                raise ValueError(f"Invalid coordinate value: {value}")
+            return result
+        except (TypeError, ValueError) as e:
+            logger.error(f"Could not convert to float: {value}, error: {e}")
+            raise ValueError(f"Could not convert coordinate to float: {value}")
+    
+    def _is_valid_number(self, value):
+        """Check if a number is valid (not NaN, not inf)"""
+        import math
+        return not (math.isnan(value) or math.isinf(value))
+        
+    def _validate_coordinates(self, x, y, z):
+        """Validate that coordinates are proper finite numbers"""
+        try:
+            return (self._is_valid_number(x) and 
+                   self._is_valid_number(y) and 
+                   self._is_valid_number(z))
+        except:
+            return False
+        
     def energy_minimize_structure(self, pdb_path):
         """
         Perform basic energy minimization on structure

test_pipeline.py

@@ -22,9 +22,17 @@ from mdp_manager import MDPManager
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-def test_structure_generation():
-    """Test antibody structure generation"""
-    logger.info("Testing structure generation...")
+def test_structure_generation(force_fallback=False):
+    """
+    Test antibody structure generation.
+    
+    Args:
+        force_fallback (bool): If True, forces the use of the basic fallback generator.
+    """
+    if force_fallback:
+        logger.info("Testing structure generation (FORCING FALLBACK)...")
+    else:
+        logger.info("Testing structure generation (ImmuneBuilder if available)...")
     
     # Test sequences (example antibody variable regions)
     heavy_chain = "QVQLVQSGAEVKKPGASVKVSCKASGYTFTSYYMHWVRQAPGQGLEWMGIINPSGGSTNYAQKFQGRVTMTRDTSASTAYMELSSLRSEDTAVYYCARSTYYGGDWYFDVWGQGTLVTVSS"
@@ -34,26 +42,37 @@ def test_structure_generation():
         generator = StructureGenerator()
         
         # Generate structure
-        structure_path = generator.generate_structure(heavy_chain, light_chain)
+        structure_path = generator.generate_structure(heavy_chain, light_chain, force_fallback=force_fallback)
         
         # Verify structure file exists
-        if os.path.exists(structure_path):
+        if structure_path and os.path.exists(structure_path):
             logger.info(f"✓ Structure generated successfully: {structure_path}")
             
             # Check file size
             file_size = os.path.getsize(structure_path)
             if file_size > 1000:  # Should be at least 1KB
                 logger.info(f"✓ Structure file size reasonable: {file_size} bytes")
+                
+                # Add validation for NaN coordinates
+                with open(structure_path, 'r') as f:
+                    for line in f:
+                        if "NaN" in line:
+                            logger.error(f"✗ NaN detected in generated structure file: {line.strip()}")
+                            return False, None
+                
+                logger.info("✓ No NaN coordinates found in structure file.")
                 return True, structure_path
             else:
                 logger.error(f"✗ Structure file too small: {file_size} bytes")
                 return False, None
         else:
-            logger.error("✗ Structure file not generated")
+            logger.error("✗ Structure file not generated or path is None")
             return False, None
             
     except Exception as e:
         logger.error(f"✗ Structure generation failed: {e}")
+        import traceback
+        traceback.print_exc()
         return False, None
     finally:
         try:
@@ -214,8 +233,11 @@ def run_all_tests():
     # Test 1: MDP templates
     results['mdp_templates'] = test_mdp_templates()
     
-    # Test 2: Structure generation
-    results['structure_generation'] = test_structure_generation()[0]
+    # Test 2: Structure generation with ImmuneBuilder (if available)
+    results['structure_generation_immune_builder'] = test_structure_generation(force_fallback=False)[0]
+
+    # Test 2.1: Structure generation with fallback generator
+    results['structure_generation_fallback'] = test_structure_generation(force_fallback=True)[0]
     
     # Test 3: GROMACS installation
     results['gromacs_installation'] = test_gromacs_installation()
@@ -224,7 +246,7 @@ def run_all_tests():
     results['ml_models'] = test_ml_models()
     
     # Test 5: Quick pipeline
-    if all([results['mdp_templates'], results['structure_generation'], results['gromacs_installation']]):
+    if all([results['mdp_templates'], results['structure_generation_fallback'], results['gromacs_installation']]):
         results['quick_pipeline'] = test_quick_pipeline()
     else:
         results['quick_pipeline'] = False