Rowan

Rowan is a community skill for computational chemistry using the Rowan platform, covering molecular simulation setup, quantum chemistry calculations, geometry optimization, property prediction, and workflow automation for molecular modeling research.

What Is This?

Overview

Rowan provides tools for running computational chemistry calculations through a cloud-based molecular modeling platform. It covers molecular simulation setup that configures calculation parameters for different levels of theory and basis sets, quantum chemistry calculations that run density functional theory and wavefunction methods on molecular structures, geometry optimization that finds minimum energy configurations through iterative gradient-based relaxation, property prediction that computes molecular energies, dipole moments, vibrational frequencies, and orbital properties, and workflow automation that chains multiple calculations into multi-step computational pipelines. The skill helps researchers run molecular calculations efficiently.

Who Should Use This

This skill serves computational chemists running quantum chemistry calculations, materials scientists exploring molecular properties for design applications, and pharmaceutical researchers computing binding energies and conformational landscapes.

Why Use It?

Problems It Solves

Setting up quantum chemistry calculations requires specifying methods, basis sets, and convergence parameters that vary by application. Running calculations on local hardware limits the size and number of molecules that can be studied simultaneously. Managing input and output files across many calculations creates organizational complexity. Chaining multiple calculation types into a coherent workflow requires manual coordination between steps.

Core Highlights

Calculation builder configures quantum chemistry jobs with method and basis set selection. Cloud executor runs calculations on remote infrastructure without local hardware requirements. Geometry optimizer finds stable molecular configurations through energy minimization. Workflow manager chains calculations into automated multi-step pipelines.

How to Use It?

Basic Usage

import rowan

client = rowan.Client(
  api_key='YOUR_KEY')

mol = rowan.Molecule(
  smiles='CCO',
  name='ethanol')

calc = client.calculate(
  molecule=mol,
  method='B3LYP',
  basis='6-31G*',
  task='energy')

result = calc.wait()
print(
  f'Energy: '
  f'{result.energy:.6f}'
  f' Hartree')

opt = client.calculate(
  molecule=mol,
  method='B3LYP',
  basis='6-31G*',
  task='optimize')

opt_result = opt.wait()
print(
  f'Optimized energy: '
  f'{opt_result.energy:.6f}')
print(
  f'Converged: '
  f'{opt_result.converged}')

Real-World Examples

import rowan

class MolecularScreen:
  def __init__(
    self,
    client: rowan.Client,
    method: str = 'B3LYP',
    basis: str = '6-31G*'
  ):
    self.client = client
    self.method = method
    self.basis = basis

  def screen(
    self,
    smiles_list:
      list[str]
  ) -> list[dict]:
    jobs = []
    for smi in (
      smiles_list
    ):
      mol = rowan\
        .Molecule(
          smiles=smi)
      job = self.client\
        .calculate(
          molecule=mol,
          method=
            self.method,
          basis=self.basis,
          task='optimize')
      jobs.append(
        (smi, job))

    results = []
    for smi, job in jobs:
      res = job.wait()
      results.append({
        'smiles': smi,
        'energy':
          res.energy,
        'converged':
          res.converged})
    return sorted(
      results,
      key=lambda x:
        x['energy'])

client = rowan.Client(
  api_key='YOUR_KEY')
screener = MolecularScreen(
  client)
results = screener.screen(
  ['CCO', 'CC=O',
   'CC(=O)O'])
for r in results:
  print(
    f'{r["smiles"]}: '
    f'{r["energy"]:.4f}')

Advanced Tips

Start with a lower level of theory for geometry optimization then refine with higher-accuracy methods on the optimized structure. Submit batch calculations in parallel to take advantage of cloud infrastructure for throughput. Check convergence criteria in optimization results to verify that the final structure is a true minimum.

When to Use It?

Use Cases

Optimize molecular geometries to find minimum energy configurations for drug candidates. Screen a library of molecules by computing energies and properties in parallel. Run frequency calculations to verify that optimized structures are true energy minima.

Related Topics

Rowan, computational chemistry, quantum chemistry, DFT, molecular modeling, geometry optimization, and molecular properties.

Important Notes

Requirements

Rowan platform account with API credentials for cloud calculations. Molecular structures as SMILES strings or coordinate files for input. Understanding of quantum chemistry methods and basis sets for appropriate calculation configuration.

Usage Recommendations

Do: validate calculation results against known experimental values or benchmark data when starting with a new method. Use appropriate basis sets for the properties being computed since small basis sets may give unreliable results. Monitor calculation costs when running large batch jobs on cloud infrastructure.

Don't: use high-level theory methods for initial screening when lower levels provide sufficient accuracy at reduced cost. Trust optimization results without checking convergence since unconverged calculations may produce incorrect geometries. Run frequency calculations without first optimizing the geometry since non-minimum structures produce imaginary frequencies.

Limitations

Calculation accuracy depends on the choice of method and basis set which requires domain expertise to select appropriately. Cloud-based calculations incur costs that scale with molecular size and the level of theory selected. Large molecules may require significant computation time even with cloud resources.