Struct ConstantVolume 

pub struct ConstantVolume<TT, TR = TT> {
    pub delta_t: f64,
    pub translational_thermostat: TT,
    pub rotational_thermostat: TR,
}

Integrate bodies’ translational and rotational degrees of freedom in the microstate.

The ConstantVolume implementation follows the symplectic integration scheme by Tuckerman et al. 2006 for translational motion and Miller et al. 2002 for rotational motion.

Use NoThermostat to integrate trajectories that sample the microcanonical ensemble:

use hoomd_md::method::ConstantVolume;

let delta_t = 0.001;
let constant_volume = ConstantVolume::builder(delta_t).build();

Use Bussi (or one of the other thermostats) to integrate trajectories that sample the canonical ensemble:

use hoomd_md::{method::ConstantVolume, thermostat::Bussi};

let delta_t = 0.001;
let constant_volume = ConstantVolume::builder(delta_t)
    .thermostat(Bussi::default())
    .build();

Reference

• Tuckerman et al. 2006
• Miller et al. 2002

Fields

delta_t: f64

The time step size.

translational_thermostat: TT

Translational thermostat.

rotational_thermostat: TR

Rotational thermostat.

Implementations

impl ConstantVolume<NoThermostat, NoThermostat>

pub fn builder( delta_t: f64, ) -> ConstantVolumeBuilder<NoThermostat, NoThermostat>

Start building a new ConstantVolume.

The default builder uses the given value for delta_t and NoThermostat for both the translational and rotational thermostats. Call zero or more of the ConstantVolumeBuilder methods to set the thermostats.

Example

use hoomd_md::method::ConstantVolume;

let delta_t = 0.001;
let constant_volume = ConstantVolume::builder(delta_t).build();

impl<TT, TR> ConstantVolume<TT, TR>

pub fn translational_thermostat(&self) -> &TT

Access the translational thermostat.

pub fn translational_thermostat_mut(&mut self) -> &mut TT

Access the translational thermostat (mutable).

pub fn rotational_thermostat(&self) -> &TR

Access the rotational thermostat.

pub fn rotational_thermostat_mut(&mut self) -> &mut TR

Access the rotational thermostat (mutable).

Trait Implementations

impl<TT: Clone, TR: Clone> Clone for ConstantVolume<TT, TR>

fn clone(&self) -> ConstantVolume<TT, TR>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<TT: Debug, TR: Debug> Debug for ConstantVolume<TT, TR>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, TT, TR> Deserialize<'de> for ConstantVolume<TT, TR>

where TT: Deserialize<'de>, TR: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<TT: PartialEq, TR: PartialEq> PartialEq for ConstantVolume<TT, TR>

fn eq(&self, other: &ConstantVolume<TT, TR>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S, X, C, TT, TR, M> RotationalMotion<DynamicOrientedPoint<Cartesian<2>, Angle>, S, X, C, M> for ConstantVolume<TT, TR>

where DynamicOrientedPoint<Cartesian<2>, Angle>: Transform<S>, S: Position<Position = Cartesian<2>> + Default, X: PointUpdate<Cartesian<2>, SiteKey>, C: Wrap<DynamicOrientedPoint<Cartesian<2>, Angle>> + Wrap<S> + GenerateGhosts<S>, TR: Thermostat<M>,

Rotational motion in 2-dimensional cartesian space.

fn integrate_rotation_half_step_one_with_filter<F: Fn(&Tagged<Body<DynamicOrientedPoint<Cartesian<2>, Angle>, S>>) -> bool>( &mut self, microstate: &mut Microstate<DynamicOrientedPoint<Cartesian<2>, Angle>, S, X, C>, macrostate: &M, should_integrate_body: F, )

Integrate selected body orientations forward a full step and their angular momenta forward a half step.

The first half step of the symplectic integration procedure is given by the equations below, which are applied to each selected body i. In each step, the marker $'$ is used when a variable’s value changes during a step to distinguish the value before ( $'$ is present) from the value after ( $'$ is absent). Selected bodies which have moment_of_inertia = 0.0 are skipped.

1. The rotational thermostat is integrated forward a half-step and then angular momentum is rescaled accordingly:

   L_i(t) = L'_i(t) \cdot \mathrm{rotational\_thermostat.integrate\_half\_step\_one}\left(\sum_{j \in \mathrm{selection}} K'_{rot,j}(t) \right)

   where the summation represents the total rotational kinetic energy of the selected bodies at the start of the step, and rotational_thermostat.integrate_half_step_one() is the first half step method implemented by TR.

2. Angular momentum is integrated forward a half step.

   L_i\left(t + \frac{\Delta t}{2} \right) = L_i(t) + \tau_i(t) \frac{\Delta t}{2}

3. Orientation is integrated forward a full step using the new angular momentum.

   \theta_i(t + \Delta t) = \theta_i(t) + \frac{L_i\left( t + \frac{\Delta t}{2} \right)}{I_i} \Delta t

fn integrate_rotation_half_step_two_with_filter<F: Fn(&Tagged<Body<DynamicOrientedPoint<Cartesian<2>, Angle>, S>>) -> bool>( &mut self, microstate: &mut Microstate<DynamicOrientedPoint<Cartesian<2>, Angle>, S, X, C>, macrostate: &M, should_integrate_body: F, )

Integrate selected body angular momenta forward a half step.

The second half step of the symplectic integration procedure is given by the equations below, which are applied to each selected body i. In each step, the marker $'$ is used when a variable’s value changes during a step to distinguish the value before ( $'$ is present) from the value after ( $'$ is absent). Selected bodies which have moment_of_inertia = 0.0 are skipped.

1. Angular momentum is integrated forward a half step.

   L_i(t + \Delta t) = L_i\left( t + \frac{\Delta t}{2} \right) + \tau_i \left(t + \frac{\Delta t}{2} \right) \frac{\Delta t}{2}

2. The rotational thermostat is integrated forward a half step and then angular momentum is rescaled accordingly.

   L_i(t + \Delta t) = L'_i(t + \Delta t) \cdot \mathrm{rotational\_thermostat.integrate\_half\_step\_two}\left(\sum_{j \in \mathrm{selection}}K'_{rot,j}(t + \Delta t) \right)

   where the summation represents the total rotational kinetic energy of the selected bodies at the start of the step, and rotational_thermostat.integrate_half_step_two() is the second half step method implemented by TR.

fn integrate_rotation_half_step_one( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, )

Integrate all body orientations forward a full step and their angular momenta forward a half step.

fn integrate_rotation_half_step_two( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, )

Integrate all body angular momenta forward a half step.

fn integrate_translation_and_rotation_with_filter<E, F>( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, interaction_model: &E, should_integrate_body: F, )

where F: Fn(&Tagged<Body<B, S>>) -> bool, Microstate<B, S, X, C>: UpdateNetForceVirialAndTorque<E>, Self: TranslationalMotion<B, S, X, C, M>,

Integrate selected body translational and rotational degrees of freedom forward one step.

fn integrate_translation_and_rotation<E>( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, interaction_model: &E, )

where Microstate<B, S, X, C>: UpdateNetForceVirialAndTorque<E>, Self: TranslationalMotion<B, S, X, C, M>,

Integrate all body translational and rotational degrees of freedom forward one step.

impl<S, X, C, TT, TR, M> RotationalMotion<DynamicOrientedPoint<Cartesian<3>, Versor>, S, X, C, M> for ConstantVolume<TT, TR>

where DynamicOrientedPoint<Cartesian<3>, Versor>: Transform<S>, S: Position<Position = Cartesian<3>> + Default, X: PointUpdate<Cartesian<3>, SiteKey>, C: Wrap<DynamicOrientedPoint<Cartesian<3>, Versor>> + Wrap<S> + GenerateGhosts<S>, TR: Thermostat<M>,

Rotational motion in 3-dimensional cartesian space.

fn integrate_rotation_half_step_one_with_filter<F: Fn(&Tagged<Body<DynamicOrientedPoint<Cartesian<3>, Versor>, S>>) -> bool>( &mut self, microstate: &mut Microstate<DynamicOrientedPoint<Cartesian<3>, Versor>, S, X, C>, macrostate: &M, should_integrate_body: F, )

Integrate selected body orientations forward a full step and their angular momenta forward a half step.

The first half step of the symplectic integration procedure is given by the equations below, which are applied to each selected body i. In each step, the marker $'$ is used when a variable’s value changes during a step to distinguish the value before ( $'$ is present) from the value after ( $'$ is absent). Rotational degrees of freedom with a moment of inertia component of zero are skipped.

1. The rotational thermostat is integrated forward a half-step and then angular momentum is rescaled accordingly:

   \vec{L}_i(t) = \vec{L}'_i(t) \cdot \mathrm{rotational\_thermostat.integrate\_half\_step\_one}\left(\sum_{j \in \mathrm{selection}} K'_{rot,j}(t) \right)

   where the summation represents the total rotational kinetic energy of the selected bodies at the start of the step, and rotational_thermostat.integrate_half_step_one() is the first half step method implemented by TR.

2. Angular momentum $\vec{L}$ and orientation $\mathbf{q}$ are integrated forward. These integrations follow a complex, multi-step process, so a fuller explanation is provided below. In each step, the body index i and time t are implicit on every variable unless otherwise specified.

   1. Angular momentum and net torque are converted to quaternions $\mathbf{p}$ and $\mathbf{f}$, respectively:

      \begin{align*}
      
      \mathbf{p} &= 2\mathbf{S}(\mathbf{q}) \mathbf{L} \\
      \mathbf{f} &= 2\mathbf{S}(\mathbf{q}) \boldsymbol{\tau} \\
      
      \end{align*}

      where

      \begin{align*}
      
      \mathbf{L} &= (0, L_x, L_y, L_z) \\
      \boldsymbol{\tau} &= (0, \tau_x, \tau_y, \tau_z) \\
      
      \mathbf{S}(\mathbf{q}) &=
      \begin{pmatrix}
      q_0 & -q_1 & -q_2 & -q_3\\
      q_1 & q_0 & -q_3 & q_2\\
      q_2 & q_3 & q_0 & -q_1\\
      q_3 & -q_2 & q_1 & q_0
      \end{pmatrix}
      
      \end{align*}

   2. $\mathbf{p}$ and $\mathbf{q}$ are integrated forward using the novel symplectic quaternion scheme (NO_SQUISH) algorithm, which ensures the integration is both symplectic and preserves orientation quaternion unity. There are several steps to this algorithm, whose equations are given below.

      1. $\mathbf{p}$ is partially integrated forward a half step.

         \mathbf{p} = \mathbf{p}' + \frac{\Delta t}{2} \mathbf{f}

      2. $\mathbf{p}$ is integrated forward the remainder of the half step and $\mathbf{q}$ is integrated forward a full step. Properties of quaternion algebra are used to decompose the Liouvillian into a sum over permutation matrices applied to $\mathbf{q}$ and $\mathbf{p}$. There are five steps to this decomposition:

         \begin{align*}
         
         \phi_3 &= \frac{1}{4 I_{33}} \mathrm{dot} \left( \mathbf{p}, P_3 \mathbf{q} \right) \\
         \mathbf{q} &= \cos{(\phi_3 \frac{\Delta t}{2})} \mathbf{q}^{'} +  \sin{(\phi_3 \frac{\Delta t}{2})} P_3 \mathbf{q}^{'} \nonumber \\
         \mathbf{p} &= \cos{(\phi_3 \frac{\Delta t}{2})} \mathbf{p}' +  \sin{(\phi_3 \frac{\Delta t}{2})} P_3 \mathbf{p}' \nonumber \\ \nonumber \\
         
         \phi_2 &= \frac{1}{4 I_{22}} \mathrm{dot} \left( \mathbf{p}, P_2 \mathbf{q} \right) \\
         \mathbf{q} &= \cos{(\phi_2 \frac{\Delta t}{2})} \mathbf{q}^{'} +  \sin{(\phi_2 \frac{\Delta t}{2})} P_2 \mathbf{q}^{'} \nonumber \\
         \mathbf{p} &= \cos{(\phi_2 \frac{\Delta t}{2})} \mathbf{p}' +  \sin{(\phi_2 \frac{\Delta t}{2})} P_2 \mathbf{p}' \nonumber \\ \nonumber \\
         
         \phi_1 &= \frac{1}{4 I_{11}} \mathrm{dot} \left( \mathbf{p}, P_1 \mathbf{q} \right) \\
         \mathbf{q} &= \cos{(\phi_1 \Delta t)} \mathbf{q}^{'} +  \sin{(\phi_1 \Delta t)} P_1 \mathbf{q}^{'} \nonumber \\
         \mathbf{p} &= \cos{(\phi_1 \Delta t)} \mathbf{p}' +  \sin{(\phi_1 \Delta t)} P_1 \mathbf{p}' \nonumber  \nonumber \\ \nonumber \\
         
         \phi_2 &= \frac{1}{4 I_{22}} \mathrm{dot} \left( \mathbf{p}, P_2 \mathbf{q} \right) \\
         \mathbf{q} &= \cos{(\phi_2 \frac{\Delta t}{2})} \mathbf{q}^{'} +  \sin{(\phi_2 \frac{\Delta t}{2})} P_2 \mathbf{q}^{'} \nonumber \\
         \mathbf{p} &= \cos{(\phi_2 \frac{\Delta t}{2})} \mathbf{p}' +  \sin{(\phi_2 \frac{\Delta t}{2})} P_2 \mathbf{p}' \nonumber  \nonumber \\ \nonumber \\
         
         \phi_3 &= \frac{1}{4 I_{33}} \mathrm{dot} \left( \mathbf{p}, P_3 \mathbf{q} \right) \\
         \mathbf{q} \left( t + \Delta t \right) &= \cos{(\phi_3 \frac{\Delta t}{2})} \mathbf{q}^{'} +  \sin{(\phi_3 \frac{\Delta t}{2})} P_3 \mathbf{q}^{'} \nonumber \\
         \mathbf{p} \left( t + \frac{\Delta t}{2} \right) &= \cos{(\phi_3 \frac{\Delta t}{2})} \mathbf{p}' +  \sin{(\phi_3 \frac{\Delta t}{2})} P_3 \mathbf{p}' \nonumber    \nonumber \\ \nonumber \\
         
         \end{align*}

         where $I_{kk}$ is the component of the moment of inertia for $k = 1, 2, 3$ and $P_k$ is the corresponding permutation matrix such that

         \begin{align*}
         
         P_0\mathbf{q} &= (q_0, q_1, q_2, q_3) \\
         P_1\mathbf{q} &= (-q_1, q_0, q_3, -q_2) \\
         P_2\mathbf{q} &= (-q_2, -q_3, q_0, q_1) \\
         P_3\mathbf{q} &= (-q_3, q_2, -q_1, q_0) \\
         (PP^T)_{\alpha \beta} &= \delta_{\alpha \beta} \\
         
         \end{align*}

   3. $\mathbf{p}$ is converted back into vector-form angular momentum:

      \mathbf{L} \left( t + \frac{\Delta t}{2} \right) = \frac{1}{2} \mathbf{S}(\mathbf{q})^T \mathbf{p} \left( t + \frac{\Delta t}{2} \right)

      where

      \begin{align*}
      \mathbf{L} &= (0, L_x, L_y, L_z) \\
      \vec{L} &= (L_x, L_y, L_z)
      \end{align*}

fn integrate_rotation_half_step_two_with_filter<F: Fn(&Tagged<Body<DynamicOrientedPoint<Cartesian<3>, Versor>, S>>) -> bool>( &mut self, microstate: &mut Microstate<DynamicOrientedPoint<Cartesian<3>, Versor>, S, X, C>, macrostate: &M, should_integrate_body: F, )

Integrate selected body angular momenta forward a half step.

The second half step of the symplectic integration procedure is given by the equations below, which are applied to each selected body i. In each step, the marker $'$ is used when a variable’s value changes during a step to distinguish the value before ( $'$ is present) from the value after ( $'$ is absent). The time $t + \frac{\Delta t}{2}$ is implicit on every variable unless otherwise specified. Rotational degrees of freedom with a moment of inertia component of zero are skipped.

1. Angular momentum and net torque are converted to quaternions $\mathbf{p}$ and $\mathbf{f}$, respectively:

   \begin{align*}
   
   \mathbf{p} &= 2\mathbf{S}(\mathbf{q}) \mathbf{L} \\
   \mathbf{f} &= 2\mathbf{S}(\mathbf{q}) \boldsymbol{\tau} \\
   
   \end{align*}

   where

   \begin{align*}
   
   \mathbf{L} &= (0, L_x, L_y, L_z) \\
   \boldsymbol{\tau} &= (0, \tau_x, \tau_y, \tau_z) \\
   
   \mathbf{S}(\mathbf{q}) &=
   \begin{pmatrix}
   q_0 & -q_1 & -q_2 & -q_3\\
   q_1 & q_0 & -q_3 & q_2\\
   q_2 & q_3 & q_0 & -q_1\\
   q_3 & -q_2 & q_1 & q_0
   \end{pmatrix}
   
   \end{align*}

2. $\mathbf{p}$ is integrated forward a half step.

   \mathbf{p}\left( t + \Delta t \right) = \mathbf{p}\left( t + \frac{\Delta t}{2} \right) + \frac{\Delta t}{2} \mathbf{f}

3. $\mathbf{p}$ is converted back into vector-form angular momentum:

   \mathbf{L} \left( t + \Delta t \right) = \frac{1}{2} \mathbf{S}(\mathbf{q})^T \mathbf{p} \left( t + \Delta t \right)

   where

   \begin{align*}
   \mathbf{L} &= (0, L_x, L_y, L_z) \\
   \vec{L} &= (L_x, L_y, L_z)
   \end{align*}

4. The rotational thermostat is integrated forward a half-step and then angular momentum is rescaled accordingly. (Note: rotational_thermostat.integrate_half_step_two() is the first half step method implemented by TR.)

   \vec{L}_i(t + \Delta t) = \vec{L}'_i(t + \Delta t) \cdot \mathrm{rotational\_thermostat.integrate\_half\_step\_two}\left(\sum_{i \in \mathrm{selection}} K'_{rot,j}(t + \Delta t) \right)

   where the summation represents the total rotational kinetic energy of the selected bodies at the start of the step, and rotational_thermostat.integrate_half_step_two() is the second half step method implemented by TR.

fn integrate_rotation_half_step_one( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, )

Integrate all body orientations forward a full step and their angular momenta forward a half step.

fn integrate_rotation_half_step_two( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, )

Integrate all body angular momenta forward a half step.

fn integrate_translation_and_rotation_with_filter<E, F>( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, interaction_model: &E, should_integrate_body: F, )

where F: Fn(&Tagged<Body<B, S>>) -> bool, Microstate<B, S, X, C>: UpdateNetForceVirialAndTorque<E>, Self: TranslationalMotion<B, S, X, C, M>,

Integrate selected body translational and rotational degrees of freedom forward one step.

fn integrate_translation_and_rotation<E>( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, interaction_model: &E, )

where Microstate<B, S, X, C>: UpdateNetForceVirialAndTorque<E>, Self: TranslationalMotion<B, S, X, C, M>,

Integrate all body translational and rotational degrees of freedom forward one step.

impl<TT, TR> Serialize for ConstantVolume<TT, TR>

where TT: Serialize, TR: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<V, B, S, X, C, TT, TR, M> TranslationalMotion<B, S, X, C, M> for ConstantVolume<TT, TR>

where V: Default + InnerProduct, B: Position<Position = V> + Momentum<Momentum = V> + NetForce<NetForce = V> + Mass + Transform<S> + Clone, S: Position<Position = V> + Default, X: PointUpdate<V, SiteKey>, C: Wrap<B> + Wrap<S> + GenerateGhosts<S>, TT: Thermostat<M>,

fn integrate_translation_half_step_one_with_filter<F: Fn(&Tagged<Body<B, S>>) -> bool>( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, should_integrate_body: F, )

Integrate selected body positions forward a full step and their momenta forward a half step.

The first half step of the symplectic integration procedure is given by the equations below, which are applied to each selected body i. In each step, the marker $'$ is used when a variable’s value changes during a step to distinguish the value before ( $'$ is present) from the value after ( $'$ is absent).

1. The translational thermostat is integrated forward a half-step and then momentum is rescaled accordingly:

   \vec{p}_i\left( t \right) = \vec{p'}_i\left( t \right) \cdot \mathrm{translational\_thermostat.integrate\_half\_step\_one}\left( \sum_{j \in \mathrm{selection}} K'_{trans,j} \left( t \right) \right)

   where the summation represents the total translational kinetic energy of the selected bodies at the start of the step, and translational_thermostat.integrate_half_step_one() is the first half step method implemented by TT.

2. Momentum is integrated forward a half step.

   \vec{p}_i\left( t + \frac{\Delta t}{2} \right) = \vec{p}_i\left( t \right) + \vec{F}_i(t) \frac{\Delta t}{2}

3. Position is integrated forward a full step using the new momentum.

   \vec{r}_i\left( t + \Delta t \right) = \vec{r}_i\left( t \right) + \frac{\vec{p}_i\left( t + \frac{\Delta t}{2} \right)}{m_i} \Delta t

fn integrate_translation_half_step_two_with_filter<F: Fn(&Tagged<Body<B, S>>) -> bool>( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, should_integrate_body: F, )

Integrate selected body momenta forward a half step.

The second half step of the symplectic integration procedure is given by the equations below, which are applied to each selected body i. In each step, the marker $'$ is used when a variable’s value changes during a step to distinguish the value before ( $'$ is present) from the value after ( $'$ is absent).

1. Momentum is integrated forward a half step.

   \vec{p}_i\left( t + \Delta t \right) = \vec{p}_i\left( t + \frac{\Delta t}{2} \right) + \vec{F}_i\left( t + \frac{\Delta t}{2} \right) \frac{\Delta t}{2}

2. The translational thermostat is integrated forward a half step and then momentum is rescaled accordingly.

   \vec{p}_i\left( t + \Delta t \right) = \vec{p'}_i\left( t + \Delta t \right) \cdot \mathrm{translational\_thermostat.integrate\_half\_step\_two}\left( \sum_{j \in \mathrm{selection}} K'_{trans,j} \left( t + \Delta t \right) \right)

   where the summation represents the total translational kinetic energy of the selected bodies at the start of the step, and translational_thermostat.integrate_half_step_two() is the second half step method implemented by TT.

fn integrate_translation_half_step_one( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, )

Integrate all body positions forward a full step and the momenta forward a half step.

fn integrate_translation_half_step_two( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, )

Integrate all body momenta forward a half step.

fn integrate_translation_with_filter<E, F>( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, interaction_model: &E, should_integrate_body: F, )

where F: Fn(&Tagged<Body<B, S>>) -> bool, Microstate<B, S, X, C>: UpdateNetForceAndVirial<E>,

Integrate selected body translational degrees of freedom forward one step.

fn integrate_translation<E>( &mut self, microstate: &mut Microstate<B, S, X, C>, macrostate: &M, interaction_model: &E, )

where Microstate<B, S, X, C>: UpdateNetForceAndVirial<E>,

Integrate all body translational degrees of freedom forward one step.

impl<TT, TR> StructuralPartialEq for ConstantVolume<TT, TR>