---
name: "sc_SimpleCo"
section: "3"
platform: "linux"
package: "libsc-doc"
version: "2.3.1-22"
release: "Debian 12 (Bookworm)"
platforms: ["linux"]
url: "https://new.carta.tech/sc_SimpleCo"
---

# sc\_SimpleCo(3)

The SimpleCo abstract class describes a simple internal coordinate of a molecule.

## NAME

sc::SimpleCo - The **SimpleCo** abstract class describes a simple internal coordinate of a molecule.

## SYNOPSIS

`#include <simple.h>`

Inherits **sc::IntCoor**.

Inherited by **sc::BendSimpleCo**, **sc::LinIPSimpleCo**, **sc::LinOPSimpleCo**, **sc::OutSimpleCo**, **sc::ScaledTorsSimpleCo**, **sc::StreSimpleCo**, and **sc::TorsSimpleCo**.

### Public Member Functions

**SimpleCo** (int, const char \*=0)\
 This constructor takes an integer argument which is the number of atoms needed to describe the coordinate.  **SimpleCo** (const **Ref**\< **KeyVal** \> &, int natom)\
 The **KeyVal** constructor requires the number of atoms.  int **natoms** () const\
 Returns the number of atoms in the coordinate.  int **operator\[\]** (int i) const\
 Returns the index of the i'th atom in the coordinate.  void **save\_data\_state** (**StateOut** &)\
 Save the base classes (with save\_data\_state) and the members in the same order that the **StateIn** CTOR initializes them.  **SimpleCo** (**StateIn** &)\
 virtual int **operator==** (**SimpleCo** &)\
 int **operator!=** (**SimpleCo** &u)\
 double **force\_constant** (**Ref**\< **Molecule** \> &)\
 Returns an approximate force constant (a la Almlof).  void **update\_value** (const **Ref**\< **Molecule** \> &)\
 Recalculates the value of the coordinate based on the geometry in the **Molecule**.  void **bmat** (const **Ref**\< **Molecule** \> &, **RefSCVector** &bmat, double coef=1.0)\
 Fill in a row of the B matrix.  virtual double **calc\_force\_con** (**Molecule** &)=0\
 Calculates an approximate force constant and returns it's value.  virtual double **calc\_intco** (**Molecule** &, double \*=0, double=1)=0\
 Calculate the value of the coordinate based on what's in **Molecule**.  void **print\_details** (const **Ref**\< **Molecule** \> &, std::ostream &=**ExEnv::out0**()) const\
 Print the coordinate.  int **equivalent** (**Ref**\< **IntCoor** \> &)\
 Tests to see if two coordinates are equivalent to each other.

### Protected Attributes

int **natoms\_**\
 int \* **atoms**\

### Additional Inherited Members

## Detailed Description

The **SimpleCo** abstract class describes a simple internal coordinate of a molecule.

The number atoms involved can be 2, 3 or 4 and is determined by the specialization of **SimpleCo**.

There are three ways to specify the atoms involved in the internal coordinate. The first way is a shorthand notation, just a vector of a label followed by the atom numbers (starting at 1) is given. For example, a stretch between two atoms, 1 and 2, is given, in the **ParsedKeyVal** format, as

```
  stretch<StreSimpleCo>: [ R12 1 2 ]
```

The other two ways to specify the atoms are more general. With them, it is possible to give parameters for the **IntCoor** base class (and thus give the value of the coordinate). In the first of these input formats, a vector associated with the keyword atoms gives the atom numbers. The following specification for stretch is equivalent to that above:

```
  stretch<StreSimpleCo>:( label = R12 atoms = [ 1 2 ] )
```

In the second, a vector, atom\_labels, is given along with a **Molecule** object. The atom labels are looked up in the **Molecule** object to find the atom numbers. The following specification for stretch is equivalent to those above:

```
  molecule<Molecule>: (
    { atom_labels atoms   geometry      } = {
          H1         H   [ 1.0 0.0 0.0 ]
          H2         H   [-1.0 0.0 0.0 ] } )
  stretch<StreSimpleCo>:( label = R12
                          atom_labels = [ H1 H2 ]
                          molecule = $:molecule )
```

## Constructor & Destructor Documentation

### sc::SimpleCo::SimpleCo (int, const char \* = `0`)

This constructor takes an integer argument which is the number of atoms needed to describe the coordinate. A second optional char\* argument is a label for the coordinate. This argument is passed on to the **IntCoor** constructor.

## Member Function Documentation

### void sc::SimpleCo::bmat (const Ref\< Molecule \> &, RefSCVector & bmat, double coef = `1.0`)` [virtual]`

Fill in a row of the B matrix.

Implements **sc::IntCoor**.

### virtual double sc::SimpleCo::calc\_intco (Molecule &, double \* = `0`, double = `1`)` [pure virtual]`

Calculate the value of the coordinate based on what's in **Molecule**. If given a double\*, fill in that part of the B matrix. If the bmatrix is to be calculated, the third argument gives the coefficient.

### int sc::SimpleCo::equivalent (Ref\< IntCoor \> &)` [virtual]`

Tests to see if two coordinates are equivalent to each other. This is false if the atoms don't match.

Implements **sc::IntCoor**.

### double sc::SimpleCo::force\_constant (Ref\< Molecule \> &)` [virtual]`

Returns an approximate force constant (a la Almlof).

Implements **sc::IntCoor**.

### void sc::SimpleCo::print\_details (const Ref\< Molecule \> &, std::ostream & = ExEnv::out0`()`) const` [virtual]`

Print the coordinate.

Reimplemented from **sc::IntCoor**.

### void sc::SimpleCo::save\_data\_state (StateOut &)` [virtual]`

Save the base classes (with save\_data\_state) and the members in the same order that the **StateIn** CTOR initializes them. This must be implemented by the derived class if the class has data.

Reimplemented from **sc::IntCoor**.

### void sc::SimpleCo::update\_value (const Ref\< Molecule \> &)` [virtual]`

Recalculates the value of the coordinate based on the geometry in the **Molecule**.

Implements **sc::IntCoor**.

## Author

Generated automatically by Doxygen for MPQC from the source code.