Add single-point calculation support to VASP processing

Enhanced VASP output processing to support single-point calculations and improved user prompts.

Author: adamlaho

amlpt.py

@@ -3269,17 +3269,31 @@ def _handle_output_processing(self):
             self._handle_output_processing()
 
     def _handle_vasp_output_processing_enhanced(self):
-        """Enhanced VASP output processing with batch capabilities."""
+        """Enhanced VASP output processing with batch capabilities and single-point support."""
         print("\n==== Enhanced VASP Output Processing ====\n")
 
         # Import the enhanced processor
         from pathlib import Path
         import json
 
         # Import the VASPOutputProcessor from the enhanced module
-        # In practice, this would be imported at the top of your main file
         processor = VASPOutputProcessor()
 
+        # NEW: Ask about calculation type
+        print("What type of VASP calculation are you processing?")
+        print("1. Single-point calculation (single energy evaluation)")
+        print("2. Cell/geometry optimization (multiple ionic steps)")
+        
+        calc_type_choice = input("\nSelect calculation type (1/2) [2]: ").strip() or "2"
+        is_single_point = (calc_type_choice == "1")
+        
+        if is_single_point:
+            print("\n[Processing as SINGLE-POINT calculations]")
+            print("Note: This mode expects OUTCAR with one energy and force evaluation.\n")
+        else:
+            print("\n[Processing as OPTIMIZATION calculations]")
+            print("Note: This mode expects OUTCAR with multiple ionic steps.\n")
+        
         # Ask for processing mode
         print("Processing modes:")
         print("1. Single directory (process one VASP calculation)")
@@ -3300,20 +3314,33 @@ def _handle_vasp_output_processing_enhanced(self):
                 return
 
             try:
-                # Process the calculation
-                result = processor.process_single_vasp_calculation(calc_path)
+                # Process the calculation with the specified calculation type
+                result = processor.process_single_vasp_calculation(calc_path, is_single_point=is_single_point)
 
                 # Save JSON file
                 output_json = calc_path / f"{calc_path.name}_vasp_output.json"
                 with open(output_json, 'w') as f:
                     json.dump(result["optimization_steps"], f, indent=2)
 
                 print(f"\nProcessing complete:")
-                print(f"  - Optimization steps: {result['num_steps']}")
+                print(f"  - Calculation type: {result['calculation_type']}")
+                print(f"  - Number of steps: {result['num_steps']}")
                 print(f"  - Output saved to: {output_json}")
 
+                # Show a preview of the data
+                if result["optimization_steps"]:
+                    first_step = result["optimization_steps"][0]
+                    print(f"\n  Preview of extracted data:")
+                    print(f"    - Energy: {first_step.get('energy', 'N/A')} eV")
+                    print(f"    - Number of atoms: {len(first_step.get('coordinates', []))}")
+                    print(f"    - Cell volume: {first_step.get('cell_volume', 'N/A'):.2f} ų")
+                
             except Exception as e:
                 print(f"\nError processing VASP output: {e}")
+                print("\nTroubleshooting tips:")
+                print("  - Check that POSCAR and OUTCAR files exist in the directory")
+                print("  - Verify that you selected the correct calculation type")
+                print("  - Ensure the OUTCAR file is complete (not from a crashed run)")
 
         else:
             # Batch mode processing
@@ -3331,18 +3358,28 @@ def _handle_vasp_output_processing_enhanced(self):
             recursive = input("Search recursively for VASP calculations? (y/n) [y]: ").strip().lower() != "n"
 
             try:
-                # Process all calculations
-                summary = processor.process_directory_batch(parent_path, recursive=recursive)
+                # Process all calculations with the specified calculation type
+                summary = processor.process_directory_batch(
+                    parent_path, 
+                    recursive=recursive,
+                    is_single_point=is_single_point
+                )
+                
+                print(f"\nBatch processing summary:")
+                print(f"  - Calculation type: {summary['calculation_type']}")
+                print(f"  - Total directories found: {summary['total_directories']}")
+                print(f"  - Successfully processed: {summary['processed_successfully']}")
+                print(f"  - Errors: {summary['errors']}")
 
             except Exception as e:
                 print(f"\nError during batch processing: {e}")
 
         # Ask if the user wants to process another output
-        another = input("\nProcess another output? (y/n): ").strip().lower()
+        another = input("\nProcess another VASP output? (y/n): ").strip().lower()
         if another == "y":
             self._handle_output_processing()
 
-
+            
 #### ML DATASET CREATION METHODS ######
 
     def _handle_ml_dataset_creation(self):