SimSolid JavaScript Reference

• Integer
• This function returns an integer representing the exit code of the SimSolid.exe process. A value of 0 typically indicates successful execution.

// check if any disconnected groups of parts
if (!study.hasDisconnectedGroupsOfParts())
{
    // ... (rest of the analysis setup)
}
else
this.errorCode = 1; // error code if disconnected groups of parts

// Set default units for the project 
Project.setDefaultUnits
({ 
length: 'cm', 
force: 'N' 
});

// create a new design study
var study = Project.addDesignStudy({
		file: 'D:/Batch mode/Modal_Analysis/Pullup bar V1.step',
		reader: ‘ct’, //ct is the SimSolid legacy reader
		resolution: 'custom',
		angularDev: 12,
		chordalDev: 0.5,
		units: { length: 'cm', force: ‘N’ } });

Project.save ({ file: ‘<File_path>/<File_name>.ssp' });

Project.open ({ file: ‘<File_path>/<File_name>.ssp' });

Project.initializeSolutions();

Project.solveAllAnalyses();

Project.getDesignStudies())

// open project
Project.open({ file: D:/Batchmode/ fin2.ssp});
//Set number of logical cores for the solution
Project.setOptions({ numOfCoresToUse: 12 }); // Adjust to your desired number of cores
// run specific analysis
var analysisSpecific = null;
for (var study of Project.getDesignStudies()) {
if (study.getName() == 'Design study 1') { // Specify the exact name of your design study
              	for (var analysis of study.getAnalyses()) {
                     	if (analysis.getName() == 'Modal 1') { // Specify the exact name of your analysis
                           	analysisSpecific = analysis;
                          	break;
                     	}
              	}
              	break;
       	}
}
if (analysisSpecific) {
       	analysisSpecific.solve(); // Solve the identified specific analysis
} else { // Optional: Add logging or error handling if the specified analysis is not found 
Log.write ('Error: Specified design study or analysis not found.'); 
}
// save project
Project.save({ file: '%1%_solved.ssp'});

//Set number of logical cores for the solution
Project.setOptions({ numOfCoresToUse: 12 });

1. Applying common material to all parts in the assembly

   study.applyMaterial({
   		material: 'Aluminum',
   		partNameMask: '*' });

2. Applying different material to parts in the assembly

   // Apply 'Steel' to a part exactly named 'plate 1' 
   study.applyMaterial({ 
   material: 'Steel', 
   partNameMask: 'plate 1' 
   }); 
   
   // Apply 'Rubber' to parts named 'plate 2' and 'plate 4' 
   // The default delimiter (comma) is used here. 
   study.applyMaterial({ 
   material: 'Rubber', 
   partNameMask: 'plate 2, plate 4' 
   }); 
   
   // Apply 'Nickel' to parts named 'plate 3' and 'plate 5' 
   // Explicitly setting the delimiter, though not strictly necessary here as it's the default. study.applyMaterial({ 
   material: 'Nickel', 
   partNameMask: 'plate 3, plate 5', 
   partNameMaskDelimiter: ',' 
   });

• Gap and penetration: This defines the maximum allowable gap or overlap between faces for connection. SimSolid can auto-calculate this but adjust it if parts are not connecting as expected or if unwanted connections form.
• Resolution: This controls how sensitive the connection detection is. Higher settings (increased, high) find more subtle connections but increase processing time. Normal is good for most cases; High is for fine details or complex geometries.
• Units: This specifies the units for the gap and penetration parameters, primarily using the length property. If not specified, project-level length units are used. Refer to setDefaultUnits documentation for accepted unit properties.

// Automatically find all connections 
study.addConnections({ 
gap: 0.1 
penetration: 0.2
resolution: 'normal',
units: { length: 'mm' } });

study.hasDisconnectedGroupsOfParts()

// Check if there are any disconnected groups of parts 
if (!study.hasDisconnectedGroupsOfParts()) { 
// If no disconnected groups are found (i.e., returns false), proceed with analysis setup 
// Create a modal analysis object with 9 modes to find 
var analysis = study.addModalAnalysis({ numOfModes: 9 }); 
// Set global and local solution settings for the analysis 
analysis.setSolutionSettings({ 
adaptation: 'global+local', // Define the solution adaptation method 
}); 
// Add a specific solution settings group for parts matching 'PLATE*' 
analysis.addSolutionSettingsGroup({ 
partNameMask: 'PLATE*', // Apply these settings to parts whose names start with 
'PLATE'
adaptToFeatures: true, // Enable adaptation around geometric features 
adaptToThinSolids: true, // Enable adaptation for thin-solid geometries 
refinement: 'standard' // Set refinement level to standard 
}); 
// Attempt to solve the analysis 
if (analysis.solve()) { 
// If the analysis solves successfully 
// Import a set of datum points from a CSV file 
var datumPointSet = study.addDatumPointSet({ 
file: 'D:/Batch mode/Modal_Analysis/DatumPoints_Bar.csv', 
units: { length: 'mm' } // Specify units for the imported points 
}); 
// Export analysis results to a UNV file 
analysis.exportToUNV({ 
file: 'D:/Batch mode/Modal_Analysis/DatumPoints_Bar.unv', 
datumPointSet: datumPointSet // Include the imported datum points in the export }); 
// Save the current project state to an .ssp file 
Project.save({ 
file: 'D:/Batch mode/Modal_Analysis/Pullup bar.ssp' 
}); 
} else {
// If analysis fails to solve this.errorCode = 2; // Custom error code indicating analysis
 failure 
} 
}else { 
// If disconnected groups are found (i.e., returns true) 
this.errorCode = 1; // Custom error code indicating disconnected parts issue 
}

// create a modal analysis
	var analysis = study.addModalAnalysis({ numOfModes: 9 });

// import datum points
		var datumPointSet = study.addDatumPointSet({
file: ‘<File_path>/<File_name>.csv',
			units: {length: 'mm'} });

// create a multi-loadcase structural analysis
var analysis = study.addStructuralAnalysis({ type: 'multiload' });

// open project
Project.open({ file: D:/Batchmode/ fin2.ssp});
//Set number of logical cores for the solution
Project.setOptions({ numOfCoresToUse: 12 }); // Adjust to your desired number of cores
// run specific analysis
var analysisSpecific = null;
for (var study of Project.getDesignStudies()) {
if (study.getName() == 'Design study 1') { // Specify the exact name of your design study
              	for (var analysis of study.getAnalyses()) {
                     	if (analysis.getName() == 'Modal 1') { // Specify the exact name of your analysis
                           	analysisSpecific = analysis;
                          	break;
                     	}
              	}
              	break;
       	}
}
if (analysisSpecific) {
       	analysisSpecific.solve(); // Solve the identified specific analysis
} else { // Optional: Add logging or error handling if the specified analysis is not found 
Log.write ('Error: Specified design study or analysis not found.'); 
}
// save project
Project.save({ file: '%1%_solved.ssp'});

1. Add a gravity load to the load case directly.
2. Add a gravity load to the load case via analysis by load case name.
3. Find the load case by the name and add a gravity load to that load case.

// create a new design study
var study = Project.addDesignStudy({
	file: 'C:/Users/Batchmode/Pullup bar V1.x_t',
	reader: 'parasolid',
	resolution: 'standard'
	});
// apply material to all parts
study.applyMaterial({
	material: 'Steel',
	partNameMask: '*' });
	//partNameMask:


// find all connections automatically
study.addConnections({
	resolution: 'normal',
	//units: { length: 'mm' } 
	});
	
// take the first design study
//var study = Project.getDesignStudies()[0];

// create a new multi-load analysis
var analysis = study.addStructuralAnalysis({ type: 'multiload'});

// set global+local solution settings
	analysis.setSolutionSettings({
		adaptation: 'global+local',
	});

// create a new load case 1
var loadCase = analysis.addLoadCase();


// Option 1 - add a gravity load to the load case directly
loadCase.addGravityLoad({ direction: [0.2, 0.5, 0], factor: 10 });

// add constraint and loads
analysis.importSpotDisplacements({ file: 'C:/Users/Batchmode/spot_displacement.csv'});
analysis.importRemoteLoads({ file: 'C:/Users/Batchmode/import_loads.csv'});
 
// Option 2 - add a gravity load to the load case via analysis by load case name
analysis.addGravityLoad({ direction: [0.5, 0.5, 0], factor: 4, loadCaseName: 'Vertical' });
analysis.addGravityLoad({ direction: [0.5, 0.6, 0], factor: 8, loadCaseName: 'Horizontal' }); 


// Option 3 - find the load case by the name and add a gravity load to that load case
for (var loadCase of analysis.getLoadCases()) {
	if (loadCase.getName() == 'Vertical_right')
		loadCase.addGravityLoad({ direction: [0, 0, -1], factor: 2 });
}
for (var loadCase of analysis.getLoadCases()) {
	if (loadCase.getName() == 'Horizontal_Right')
		loadCase.addGravityLoad({ direction: [0, 0, 1], factor: 3 });
}

// solve
	if (analysis.solve())
	{
		//import datum points
		var datumPointSet = study.addDatumPointSet({
		file: 'C:/Users/Batchmode/DatumPoints_Bar.csv',
			units: {length: 'mm'}
			});
	
			
			analysis.exportToCSV({
               file: 'C:/Users/Batchmode/gravity_test_result_datum_points.csv' , datumPointSet: datumPointSet});
			   
		Project.exportToCSV({ file: 'C:/Users/Batchmode/gravity_export_results.csv', maxVonMises: true, maxDisplacement: true }); 

		Project.save({ file: 'C:/Users/Batchmode/Pullup_bar_gravity_results.ssp' });
	}
	else
		this.errorCode = 2; // error code if analysis fails

//import part in assembly 
study.addParts({
  file: D:/Batchmode/plate_1.x_b',
  reader:'parasolid',
  resolution:'fine',
  addConnections:true,
  connGap:2,
  connPenetration: 2});

// delete part from assembly 
study.deleteParts({partNameMask: 'plate 1'});
Project.save({ file: ' D:/Batchmode//3_plates_part_delete.ssp' })

//open project
Project.open({ file: '<File_Directory>/example.ssp'});
var counter = 1;
Project.getDesignStudies().forEach(study => {
	study.checkGeometryForDefects({ file: '<File_Directory>/geometry_defects_test' + counter + '.csv' });
	study.checkGeometryForOverlaps({ file: '<File_Directory>/geometry_overlaps_test' + counter + '.csv' });
	study.checkGeometryForSelfIntersections({ file: '<File_Directory>/geometry_selfintersects_test' + counter + '.csv' });
	counter++;
});
Project.save({ file: ‘<File_Directory>/example_saved.ssp' });

•Option 1 - export all analyses from all design studies to a single file
Project.exportToCSV({ file: <File_Directory> /All_analysis.csv', maxVonMises: true, maxDisplacement: true });

•Option 2 - export all analyses from all design studies into one file per design study
var counter = 1;
Project.getDesignStudies().forEach(study => {
study.exportToCSV({ file: ‘<File_Directory>/structural_output_per_ds' + (counter++) + '.csv', maxVonMises: true, maxDisplacement: true });
});

•Option 3 - export all analyses from all design studies into one file per analysis
var counter = 1;
Project.getDesignStudies().forEach(study => {
	study.getAnalyses().forEach(analysis => {
analysis.exportToCSV({ file: '<File_Directory>/sequential ' + (counter++) + '.csv', maxVonMises: true, maxDisplacement: true });
});
});

// Set default units for the project 
Project.setDefaultUnits
({ 
length: 'cm', 
force: 'N' 
});

// create a new design study
var study = Project.addDesignStudy({
		file: 'D:/Batch mode/Modal_Analysis/Pullup bar V1.step',
		reader: ‘ct’, //ct is the SimSolid legacy reader
		resolution: 'custom',
		angularDev: 12,
		chordalDev: 0.5,
		units: { length: 'cm', force: ‘N’ } });

Project.save ({ file: ‘<File_path>/<File_name>.ssp' });