Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

►Nboost
Citerator_range
►NCASM	Main CASM namespace
►Nadapter
CAdapter
CAdapter< Configuration, ConfigEnumData< EnumeratorType, InitialStateType > >
CAdapter< Supercell, ConfigEnumData< EnumeratorType, InitialStateType > >
CAdapter< DataObject, QueryData< DataObject > >
CAdapter< OccupantDoF< DiscreteType >, std::vector< DiscreteType > >
CAdapter< CASM::DoFSet, xtal::DoFSet >
CAdapter< CASM::DoFSet, xtal::SiteDoFSet >
CAdapter< xtal::SymOp, FromType >
CAdapter< xtal::SymOpVector, FromType >
CAdapter< SymOp, PermuteIterator >	Convert CASM::PermuteIterator -> CASM::SymOp
CAdapter< SymGroup, FromType >
CAdapter< SymOp, FromType >
CAdapter< SymOp, SymOp >
CAdapter< SupercellSymInfo, SupercellInfoData >
►NBasisSet_impl
CArgList
►Nbset_impl
COrbitPrinterAdapter
►NCASM_TMP
CIfIntegralTol
CIfIntegralTol< tol_type, true >
CIfIntegralTol< tol_type, false >
CIntegralLessThan
CFloatingPointLessThan
Cmake_void	Alias for void, to help SFINAE work
Cis_iterator	Base type inherits from std::false_type if T is not iterator
Cis_iterator< T, void_t< decltype(++std::declval< T & >()), decltype(*std::declval< T & >()), decltype(std::declval< T & >()==std::declval< T & >())> >	Specialized case inherits from std::true_type if T is an iterator
CUnaryIdentity	Unary transformation that behaves as Identity (i.e. transform(arg) == arg is true)
CConstantFunctor	N-nary function that behaves as a constant (i.e. transform(arg1,arg2,...) == constant is true)
CBracketAccess	Helper Functor for Counter container access using operator[]
CParenthesesAccess	Helper Functor for Counter container access using operator()
Cfor_each_type_impl
Cfor_each_type_impl< 1 >
Cfor_type_impl
Cfor_type_impl< 1 >
Cfor_type_short_impl
Cfor_type_short_impl< 1 >
Cfor_each_element_impl
Cfor_each_element_impl< I, true >
Chas_type
Chas_type< T, std::tuple<> >
Chas_type< T, std::tuple< U, Ts... > >
Chas_type< T, std::tuple< T, Ts... > >
►Nclex_SimpleStructureTools_impl
CTransformDirective
►NClexParamPack_impl
CBaseKey	BaseKey is base class from which all ClexParamKey implementation classes inherit. Hides implementation-specific access attributes through an abstract interface. A ClexParamKey object manages access for a particular type of data valuess. Additional specification of referenced data can be provided via linear or pair indices as necessary
►NClexulator_impl
CBase	Abstract base class for cluster expansion correlation calculations
►NClusterSpecs_impl
CDoFSitesFilter
CAllClusters
CMaxLengthClusterFilter
CEmptyNeighborhood
COriginNeighborhood
CMaxLengthNeighborhood
CCutoffRadiusNeighborhood
►NComparePTLeaf
CByMonomialOrder
CCustomOrder
►NCompleter
CSuboption
COption
CEngine
CArgHandler
COptionHandlerBase
CMonteOption
CRunOption
CBsetOption
CCompositionOption
CRefOption
CFilesOption
CFormatOption
CInitOption
CPerturbOption
CSettingsOption
CStatusOption
CSuperOption
CViewOption
CEnumOptionBase
CSymOption
CEnumOption
CInfoOption
CQueryOption
CImportOption
CSelectOption
CRmOption
CUpdateOption
►NConfigDoFIsEquivalent	Namespace containing DoF comparison functors
CBase	Base class for functors that compare ConfigDoF
COccupation
CAnisoOccupation
CFloat	Abstract base class specialization of Base for floating point DoF types
CLocal
CGlobal
►NConfigEnumSiteDoFsInterface_impl
CMakeEnumerator
►NConfigEnumStrainInterface_impl
CMakeEnumerator
►NConfigIO	Contains ConfigIO classes and functions
CComp	Calculate param composition of a Configuration
CCompN	Calculate number of each species per unit cell
CSiteFrac	Returns fraction of sites occupied by a species, including vacancies
CAtomFrac	Returns fraction of all species that are a particular species, excluding vacancies
CCorr	Returns correlation values
CCorrContribution	Returns correlation values
CPointCorr	Returns point correlation values
CGradCorr	Returns correlation values
CClex	Returns predicted formation energy
CBaseHull	Base class for hull info formatters
COnHull	Returns a boolean indicating if a Configuration is a convex hull vertex
CHullDist	Returns the distance, in eV, of a configuration's formation_energy_per_atom above the convex hull
COnClexHull	Returns a boolean indicating if a Configuration is a predicted convex hull vertex
CClexHullDist	Returns the distance, in eV, of a configuration's clex(formation_energy_per_atom) above the predicted convex hull
CNovelty	A DatumFormatter class to measure the 'novelty' of a configuration with respect to a population of configurations Larger numbers indicate a more novel configuration, and a very large number (>~100) indicates a configuration that is linearly independent from the population (in terms of its correlations)
CRelaxationStrain	The strain of the configuration due to relaxation, measured relative to ideal lattice vectors
CDoFStrain	The strain DoF value of the configuration
CStrucScore	Evaluates the mapping of a configuration onto an arbitrary primitive structure
►NConfigIO_impl
CMolDependent	Returns fraction of sites occupied by a species
►NConfigMapping
CSettings	Struct with optional parameters for Config Mapping Specifies default parameters for all values, in order to simplify parsing from JSON
►NDataStream_impl
CDataStreamPromoter
CDataStreamPromoter< std::string >
CDataStreamPromoter< double >
CDataStreamPromoter< long >
CDataStreamPromoter< bool >
CDataStreamPromoter< char >
►NDB
►NConfigIO
CImportData	Data structure for data import results
CResult	Data structure for mapping / import results
►CSelection
CCompare
CConstructImpl
CInterfaceData
CDatabase
CSelected	Returns true if configuration is specified in given selection (default: MASTER)
CValDatabase	Generic interface for database of a particular CASM type
CRemove< Supercell >
CDatabaseIterator	Wrapper class for specializations DatabaseIteratorBase
CCache	Store data in JSON
CTypeTag
CConfigData
CStructureMap
CDatabase< Configuration >
CStructureMap< Configuration >
CImport< Configuration >	Configuration-specialized Import
CUpdate< Configuration >	Configuration-specialized Import
CDatabaseBase	Fully generic database interface for use by DatabaseHandler
CDatabaseIteratorBase
►CDatabaseHandler	Provides access to all databases
CPropDBKey
CDatabaseNameIterator	DatabaseIterator for implementations using std::map<std::string, ObjIterator>
CDatabaseSetIterator	DatabaseIterator for implementations using std::set<ValueType>
CImportSettings	Struct with optional parameters for Config/Data Import Specifies default parameters for all values, in order to simplify parsing from JSON
CImportT	Generic ConfigType-dependent part of Import
CImport
CjsonDatabase
►CjsonDB
CDirectoryStructure
CjsonDatabase< Supercell >
CjsonDatabase< Configuration >
CjsonPropertiesDatabaseIterator
CjsonPropertiesDatabase	An implementation of PropertiesDatabase for reading/writing JSON
CNamed
CIndexed
CPropertiesDatabaseIteratorBase
CPropertiesDatabaseIterator	Wrapper class for specializations PropertiesDatabaseIteratorBase
►CPropertiesDatabase
CCompare	Compare type for std::set<std::string, Compare>, which sorts to determine the 'origin' configname for the best scoring MappedProperties to a particular config
CRemoveT	Generic ConfigType-dependent part of Remove
CRemove
CDatabase< Supercell >
CSelectionIterator
CUpdateT	Generic ConfigType-dependent part of Import
CUpdate
CEraseScelConfigsBase	Helper struct base class
CEraseScelConfigs
CEraseDataScelConfigs
CEraseAllScelConfigs
►NDoF
CRemoteHandle
CBase	A class that represents an individual Degree of Freedom
►NDoF_impl
►NOccupationDoFSpecs_impl
COccupationDoFSpecsValidator
CDisplacementDoFTraits
CMagSpinDoFSpecs
CMagSpinDoFTraits
CSublatComp
COccupationDoFSpecs
COccupationDoFTraits
CStrainDoFTraits
►NDoFSpaceIO
►COutputImpl
CError	Provide state_index, indentifier, and dof_key for any errors
CDirectoryOutput
CSymmetryDirectoryOutput	Implementation that outputs to <casm_project>/symmetry/analysis/<configname>
CSequentialDirectoryOutput	Implementation that outputs to <output_dir>/dof_space/state.<index>
CCombinedJsonOutput
CDoFSpaceAnalysisOptions
►NDoFType
CTraits	Collection of all the traits specific to a DoF type
CParamAllocation
►NLocal
CIrrepCompare
C_RealType
C_RealType< std::vector< T > >
C_RealType< Eigen::Matrix< Scalar, RowsAtCompileTime, ColsAtCompileTime > >
►NMonte
CCanonical
CCanonicalConditions
CCanonicalEvent	Data structure for storing information regarding a proposed grand canonical Monte Carlo event
CCanonicalSettings
CConversions
CSiteMod	Describes the modification of a variable on a basis site
CGrandCanonical
CGrandCanonicalConditions
CGrandCanonicalEvent	Data structure for storing information regarding a proposed grand canonical Monte Carlo event
CGrandCanonicalSettings
CMCData	MCData stores observations of properties
CMCDataEquilibration	Checks if a range of observations have equilibrated
CMCDataConvergence	Checks if a range of observations have converged
CSamplerNameCompare
CMonteCarlo	Interface base class for all types of Monte Carlo simulations (not meant to be used polymorphically)
CMonteCarloEnumMetric
CMonteCarloEnumCheck
CMonteCarloEnum
CMonteCounter	Track the number of passes, steps and samples taken in a Monte Carlo calculation
CMonteDriver
CMonteCarloDirectoryStructure
CCovEvaluator	Functor to help evaluate covariance
CMonteSampler	An abstract base class for sampling and storing data observations
CScalarMonteSampler	Sampler for a scalar property
CVectorMonteSampler	Sampler for individual elements of a vector property
►CQueryMonteSampler	Sampler for individual elements of a vector property
CFormatter	Data structure to make queries occur once each sample time
CCompMonteSampler	Sampler for parametric composition
CSiteFracMonteSampler	Sampler for site fraction
CAtomFracMonteSampler	Sampler for atom fraction
CMonteSettings	Settings for Monte Carlo calculations
CEquilibriumMonteSettings
COccCandidate
COccSwap	Store swap type, mutating sites, and info for keeping OccLocation up-to-date
COccCandidateList
CSpecies	Represents an indivisible molecule component
CMol	Represents the occupant on a site
COccTransform
CSpeciesLocation
CSpeciesTraj
COccEvent
COccLocation	Stores data to enable efficient proposal and update of occupation mutation
CSiteExchanger
►Nmultivector_impl
Cmultivector_tmp
Cmultivector_tmp< T, 0 >
►NOrbit_impl
CEqMapRow
CRelEqMap
►NParsingDictionary_impl
CDictionaryConverter	Conversion Functor for inserting BasicTraits into unique_cloneable_map
►NScelIO
CSupercellCheckBase
CIsSupercellOf
CIsUnitcellOf
CTransfMat
CConfigCountBase
CNconfig
CNcalc
CNdata
►Nsimpleformatter
CDataFormatter
CDatumFormatterOptions
CBaseDatumEvaluator
CDatumEvaluator
CVectorizedDatumEvaluator
CDatumEvaluatorEntry
CDatumEvaluatorDictionary
►NSubOrbits_impl
COpCompare
►NSymRepTools
CIrrepInfo
CIrrepWedge	An irreducible wedge in an irreducible vector space
CSubWedge	SubWedge is a vector of IrrepWedge, one from each irreducible subspace Together, the IrrepWedges that comprise the Subwedge span the entire space However, it is likely that the orbit of equivalent SubWedges does not fill the entire space
►NSymRepTools_v2
►NIrrepDecompositionImpl
CCommuterParamsCounter
CPossibleIrrep	Data structure used for storing and checking possible irreps
CIrrepInfo
CIrrepDecomposition	Performs irreducible subspace construction and symmetrization
CIrrepWedge	An irreducible wedge in an irreducible vector space
CSubWedge
C_RealType
C_RealType< std::vector< T > >
C_RealType< Eigen::Matrix< Scalar, RowsAtCompileTime, ColsAtCompileTime > >
CVectorSpaceSymReport	Summary of data associated with the action of a symmetry group on a vector space
CVectorInvariants	Used for generating SimpleOrbit of high symmetry direction vectors
CVectorSymCompare	Used for constructing SimpleOrbit of high symmetry direction vectors
►NVaspIO	Functions and classes related to VASP input/output
CPrintPOSCAR	Print POSCAR with formating options
►Nxtal
►NCoordinate_impl
CFracCoordinate	A class to enable vector assignment to the fractional vector of a Coordinate
CFracCoordinateComponent	A class to enable assignment to a component of the fractional vector of a Coordinate
CCartCoordinate	A class to enable vector assignment to the Cartesian vector of a Coordinate
CCartCoordinateComponent	A class to enable assignment to a component of the Cartesian vector of a Coordinate
►Nimpl
COrderedLatticePointGenerator
CBasicStructure	BasicStructure specifies the lattice and atomic basis of a crystal
CCoordinate	Represents cartesian and fractional coordinates
CCOORD_MODE	COORD_MODE specifies the current coordinate mode (Fractional or Cartesian)
CPERIODICITY_MODE
CDoFSet
CSiteDoFSet
CDoFSetIsEquivalent_f
CSiteDoFSetIsEquivalent_f
CHermiteCounter
CIntegralCoordinateWithin_f
CLattice
CLatticeIsEquivalent	Lattice comparisons
CIsPointGroupOp	Checks if operations are point group operations
CStrainCostCalculator
CLatticeMap
CUnitCellCoordIndexConverter
CUnitCellIndexConverter
C_LinearIndexConverter
C_LinearIndexConverter< UnitCell >
C_LinearIndexConverter< UnitCellCoord >
CAtomPosition	An atomic species associated with a position in space
CMolecule	Class representing a Molecule
CNiggliRep
CStandardOrientationCompare
CSimpleStrucMapCalculator
►CSimpleStructure	Representation of a crystal of molecular and/or atomic occupants, and any additional properties. It does not require a primitive Structure or BasicStructure object to act as a reference and can be thought of as the class that embodies all the information of a config.json or properties.calc.json file
CInfo	Struct to encode all information about the crystal basis Info may describe the basis in a atomic context or molecular context Within a particular context, species are considered indivisible points If both contexts are present within the SimpleStructure, they are assumed to be different representation of the same crystal basis. The only difference is that the 'atomic' context separates each molecule into its constituent atoms. SimpleStructure DOES NOT TRACK how the molecular and atomic representations are related
CSite
CSpeciesAttribute
CStrucMapCalculatorInterface
CLatticeNode	Class describing the lattice-mapping portion of a particular mapping A general map for child_struc onto parent_struc may require forming a supercell of parent_struc (most commonly) and/or of child_struc. As such, the LatticeNode is specified in terms of superlattices of both parent_struc and child_struc, as well as deformation and rotation information sufficient to fully define the lattice map
CAssignmentNode	Structure to encode the solution of a constrained atomic assignmnet problem This describes the permutation, translation, and time-reversal of the atoms of a child structure to bring them into registration with the atoms of a parent structure (assuming periodic boundary conditions). Also records the constrained and unconstrained assignment costs
CMappingNode
CStrucMapper
CSuperlattice
CScelEnumProps	Data structure for holding supercell enumeration properties
CSuperlatticeIterator	Iterators used with SuperlatticeEnumerator
CSuperlatticeEnumerator	A fake container of supercell matrices
CSymOp
CSymOpCompare_f
CSymOpPeriodicCompare_f
CSymOpMatrixCompare_f
CUnitCell	Unit Cell Indices
CTranslatable	CRTP class to implement '-=', '+', and '-' in terms of '+='
CUnitCellCoord	Unit Cell Coordinates
CAPICommandBase
CAPICommand
CBsetCommand	'casm enum' implementation
CCommandArgs	Data structure holding basic CASM command info
CInterfaceBase	Base class for generic use of algorithms through the API
CClexDescription	Specifies a particular cluster expansion
CCLIParse
CQueryTraits
CDirectoryStructure	Specification of CASM project directory structure
CConfigEnumData
CConfigEnumOptions	Options for the enumerate_configurations function
CEnumerateSupercellsOptions	Options for the enumerate_supercells function
CEnumInterfaceBase
CInputParser
CConfigEnumAllOccupationsInterface	Interface for ConfigEnumAllOccupations
CConfigEnumRandomLocalInterface	Interface for ConfigEnumRandomLocal
CConfigEnumRandomOccupationsInterface	Interface for ConfigEnumRandomOccupations
CConfigEnumSiteDoFsInterface	Interface for ConfigEnumSiteDoFs
CConfigEnumStrainInterface	Interface for ConfigEnumStrain
CScelEnumInterface	Interface for ScelEnum
CSuperConfigEnumInterface	Interface for SuperConfigEnum
CEnumCommand
CEnumeratorHandler
Cruntime_error
CFileEnumerator	Lists all files in a CASM project, for use with 'casm files' command
CParsingDictionary	Parsing dictionary for obtaining the correct MoleculeAttribute given a name
CHamiltonianModules
CImportCommandImpl
CImportCommand
CInfoInterfaceBase
CNeighborListInfoInterface	Interface for neighbor list info
CPrimInfoInterface	Interface for prim info
CSupercellInfoInterface	Interface for supercell info
CInfoCommand
CQueryHandler
CProjectSettings
CjsonConstructor	Helper struct for constructing objects that need additional data
CjsonConstructor< ProjectSettings >
CQueryData
CQueryCommandImpl
CQueryCommand
CRmCommandImpl
CRmCommand
CSelectCommandImpl
CSelectCommand
CSymCommand
CUpdateCommandImpl
CUpdateCommand
CSparseTensor
CFunction
CInnerProduct
CFunctionOperation
CDoFSpecs
CBasisFunctionSpecs	Specify how to construct basis functions
CBasisSet
COccupantDoF
CDiscreteDoF
CContinuousDoF
CDoFIsEquivalent	Class for checking equivalence of two DoFSet objects, with respect to symmetry transformations
COccupantDoFIsEquivalent	Class for checking equivalence of two OccupantDoF objects, with respect to symmetry transformations
CDoFSetInfo
CDoFSet
CArray	Basic std::vector like container (deprecated)
CFunctionVisitor
COccFuncLabeler
COccFuncBasisIndexer
COccFuncEvaluator	Evaluates
CVariableLabeler
CSubExpressionLabeler
COccupantFunction
COccOccOperation
CPolynomialFunction
CBasicPolyPolyScalarProd
CPolyPolyOperation
CPolyVarOperation
CPolyOccOperation
CVariable
CBasicVarVarScalarProd
CVarVarOperation
►CDataFormatter	Extract data from objects of 'DataObject' class
CFormattedIteratorPair	Implements generic formatting member functions for ranges of data objects
CFormattedObject	Implements generic formatting member functions for individual data objects
CBaseDatumFormatter	Abstract base class from which all other DatumFormatter<DataObject> classes inherit
CFormattedPrintable	Abstract base class to enable generic formatting
CDictionaryConverter
CDataFormatterDictionary	Parsing dictionary for constructing a DataFormatter<DataObject> object
CDataFormatterOperator	DataFormatters that operate on the results of other DataFormatters
CDatumFormatterAlias	Implements a DatumFormatter that is an alias for a combination of others
CConstantValueFormatter	Prints a string value specified at construction. A header string can also be passed
CBaseValueFormatter	Base class for creating scalar DatumFormatter
CGenericDatumFormatter	A DatumFormatter that returns a value of specified type, via functions that may be specified at runtime
CBase1DDatumFormatter	Abstract base class for creating 1D DatumFormatter
CGeneric1DDatumFormatter	A DatumFormatter that returns a 1D value of specified type, via functions that may be specified at runtime
CBase2DDatumFormatter	A DatumFormatter that returns a value of specified 2d container
CGeneric2DDatumFormatter	A DatumFormatter that returns a 2D value of specified type, via functions that may be specified at runtime
CDataFormatterFilter
CDataStream
CCountDataStream
CValueDataStream
CVectorDataStream
CDatumFormatterAdapter
CMatrixXdDataStream
CLabeledMatrixXdDataStream
CFormattedDataFileOptions
CFormattedDataFile
Ctraits
CFileData	Interface class to check and/or store path and last_write_time of file on disk. Used to determine if files have been updated or deleted
CFormatFlag
CKwargsParser
CParentInputParser
CjsonFile	Slightly more compact construction of jsonParser from file
CjsonParserIterator
►CjsonParser
Cas_array
Cas_flattest
CjsonMake	Helper struct for constructing objects that need additional data
CjsonConstructor< std::optional< T > >	Helper struct for constructing std::optional<T> objects
CLogText
CLogParagraph
CLogVerbatim
CLog
CFixedLog	A Log whose underlying ostream* cannot be reset
COStringStreamLog
CScopedLogging
CScopedNullLogging
CScopedStringStreamLogging
CSafeOfstream	Write to a temporary file to ensure a good write, then rename
CBasicClexParamKey
CBasicClexParamPack	Abstract base class for reading/writing clexulator parameters Parameters are assume be naturally representable as 1D or 2D arrays
CValAccess< double >
Ctraits< BasicClexParamPack::EvalMode >
CCalculable
CChemicalReferenceState	Stores the composition and energy in a single reference state
CChemicalReference
CChemicalReferencePrinter	BasicStructure to help print ChemicalReference
CClex	Pair of Clexulator and ECIContainer
CClexBasis
CClexBasisSpecs	Provides parameters for constructing a cluster expansion basis (ClexBasis)
CClexBasisWriter
CValAccess
CParamPackMixIn	ParamPackMixIn is interface class to control ClexParamPack portion of Clexulator printing Used primarily by ClexBasisWriter
CClexParamKey	Key for indexing clexulator parameters Contains pointer to implementation of the Key
CClexParamPack	Abstract base class for reading/writing clexulator parameters Parameters are assumed to be stored as, or at least sliceable into, 2D or 1D arrays in order to standardize read/write interface via Eigen types Arrays are layed out along two dimensions to form (m x N) or (m x 1) matrices where 'N' is the number of sites in the neighborhood of a unit cell, and 'm' is the intrinsic dimension of a particular parameter. Macroscopic or homogeneous properties of the crystal, such as evaluated crystal basis functions or homogeneous strain, which are not associated with individual sites, are represented as a (m x 1) array. The length of the 'm' dimension of a parameter array is referred do as 'dim' and the length of the N' dimension is referred to as 'size'
CClexulator	Evaluates correlations
CCompositionAxes
CCompositionConverter	Convert between number of species per unit cell and parametric composition
CGenericConfigCompare	Class for less than comparison of Configurations implemented via a ConfigTypeIsEqual class that also stores the less than result
CConfigDoF
CConfigDoFCompare	Wrapper class for generic less than comparison of ConfigDoF
CConfigDoFValues
CLocalDiscreteConfigDoFValues
CLocalContinuousConfigDoFValues
CGlobalContinuousConfigDoFValues
CConfigEnumAllOccupations
CConfigEnumByPermutation	Enumerate all equivalent Configurations obtained by permuations in a Supercell
CConfigEnumRandomLocalParams	Parameters controlling ConfigEnumRandomLocal
CConfigEnumRandomLocal	Enumerate random values for continuous degrees of freedom
CConfigEnumRandomOccupationsParams	Parameters controlling ConfigEnumRandomOccupations
CConfigEnumRandomOccupations	Enumerate n random occupations in a particular Supercell
CConfigEnumSiteDoFsParams
CConfigEnumSiteDoFs
CConfigEnumStrainParams
CConfigEnumStrain
CNorm
CConfigIsEquivalent	Class for comparison of Configurations (with the same Supercell)
CPrimStrucMapCalculator
►CConfigMapperResult	Data structure holding results of ConfigMapper algorithm
CIndividual
CConfigMapper
CConfiguration
CConfigInsertResult	Holds results of Configuration::insert
CRefToCanonicalPrim	Operations that transform a canonical primitive configuration to any equivalent
Ctraits< Configuration >
CDiffClexParamKey	Abstract base class for all keys that interact with DiffClexParamPack DiffClexParamPack values are assumed to be 1D, 2D, or to be naturally accessed via 2D slices Standalone values are assumed to be 1D or 2D (for example, a 3xN displacement field) Derived values typically have more dimensions (for example, the derivative of the Mx1 correlation vector with respect to the displacement field has 3 indices, whild the second derivative wrt the displacement field has 5 indices). Derivatives are always asociated with the first independent standalone value in the key name. The key "diff/corr/disp_var" would be associated with "disp_var", which is a 3xN Matrix, and thus the resulting derived value (which is the first derifative of correlations with respect to displacements) will be sliced into 3xN slices. Each slice corresponds to a particular entry in the Mx1 correlation vector (i.e., slice 'j' is the gradient of correlation value j with respect to the entire set of displacement variables). The 'j' index that specifies the particular slice is called a 'secondary identifier', and it can be specified via ClexParamKey::set_identifiers()
CDiffScalarContainer	Container struct for storing a standalone value as 2D arrays of both autodiff Scalars doubles
CDiffClexParamPack	Class for managing the set of all dependent and independent paramters used/generated by clexulator
CDiffClexParamValKey
CDiffClexParamGradKey
CDiffClexParamHessKey
Ctraits< DiffClexParamPack::EvalMode >
CValAccess< typename DiffClexParamPack::DiffScalar >
CECIContainer	A sparse container of ECI values and their corresponding orbit indices
CFillSupercell
CFilteredConfigIterator
CCanonicalForm	Implements canonical form finding when using SymCompare
CConfigCanonicalForm	Implements canonical form finding for Configuration and DiffTransConfiguration
CSupercellCanonicalForm
CHasPrimClex	Implements PrimClex dependent functions
CHasSupercell	Implements PrimClex dependent functions
CjsonConstructor< HyperPlaneReference >
CjsonConstructor< ChemicalReference >	Read chemical reference from JSON
CjsonMake< ConfigDoF >
CjsonConstructor< ConfigDoF >
CjsonConstructor< Configuration >
CjsonMake< Configuration >
CProtoFuncsPrinter	Print Orbit<SymCompareType> & ClexBasis, including prototypes and prototype basis functions
CClexBasisFunctionPrinter
CMappedProperties
►CScoreMappedProperties
COption
CPrimNeighborList	The PrimNeighborList gives the coordinates of UnitCell that are neighbors of the origin UnitCell
CSuperNeighborList
CNormPerUnitCell
CNormPerSpecies
CClexBasisBuilder
COrbitFunctionTraits	Virtual base class for printing orbit functions of type specified by implementation
CInvariantPolyBasisBuilder
CInvariantPolyOrbitFunctionTraits
CParamComposition
►CPrimClex	PrimClex is the top-level data structure for a CASM project
CPrimClexData
CConstantReference	Maps all Configurations to the same value
CHyperPlaneReferenceBase	Maps a Configuration to a scalar value via a hyperplane
CHyperPlaneReference	Maps a Configuration to a scalar value via a hyperplane
CScelEnumByProps
CScelEnumEquivalents	Enumerate equivalent Supercell
CScelCanonicalGenerator	Functor to find the canonical generating element for an orbit in a Supercell
CScelIsCanonical	Functor to find to check if element is in canonical form
CConfigIterator
CSupercell	Represents a supercell of the primitive parent crystal structure
Ctraits< Supercell >
CSuperConfigEnum	Given a selection of Configurations, enumerate all tilings into some supercell
CClusterInvariants	Stores cluster invariants: number of sites and site distances
CWithinScelClusterInvariants	Stores cluster invariants: number of sites and site distances (using robust_min_dist)
COrbitGenerators	Data structure that holds canonical generating elements and can then make sorted orbits
CIntegralClusterOrbitGenerator
COrbitBranchSpecs	Store data used to generate an orbit branch of IntegralCluster
CClusterSpecs
CPeriodicMaxLengthClusterSpecs
CLocalMaxLengthClusterSpecs	Parameters most commonly used for local orbit generation
CGenericPeriodicClusterSpecs
CGenericLocalClusterSpecs
CClusterSymCompare	CRTP Base class for common cluster symmetry and comparison implementations
CAperiodicSymCompare< Element >	Comparisons of clusters using aperiodic symmetry
CPrimPeriodicSymCompare< Element >	Comparisons of clusters using prim periodic symmetry
CScelPeriodicSymCompare< Element >	Comparisons of clusters using supercell periodic symmetry, but without periodic images
CAperiodicSymCompare	Template class to be specialized for comparisons with aperiodic symmetry
CPrimPeriodicSymCompare	Template class to be specialized for comparisons with periodic symmetry of the primitive lattice
CScelPeriodicSymCompare	Template class to be specialized for comparisons with periodic symmetry of the supercell lattice
CGenericCluster	A CRTP base class for a cluster of anything
Ctraits< IntegralCluster >	Traits, required for GenericCluster
CIntegralCluster
CIntegralClusterSymCompareTraits
Ctraits< AperiodicSymCompare< IntegralCluster > >
Ctraits< PrimPeriodicSymCompare< IntegralCluster > >
Ctraits< ScelPeriodicSymCompare< IntegralCluster > >
CjsonConstructor< IntegralCluster >
COrbitPrinterOptions
CjsonConstructor< OrbitPrinterOptions >
CPrinterBase
CPrinter
CPrinter< IntegralCluster >
COrbitPrinter
COrbitPrinter< _Element, ORBIT_PRINT_MODE::PROTO >	Print Orbit<SymCompareType>, including only prototypes
COrbitPrinter< _Element, ORBIT_PRINT_MODE::FULL >	Print Orbit<SymCompareType>, including all equivalents
CSubClusterGenerator	Generates subclusters of a cluster with an iterator-like interface
CClusterSiteIndicesCompare	Sort std::set<Index> by size, then value (lexicographical compare)
CReturnArray
CArraySizeLessThan
CCounterValueIterator
CBaseCounter	A Counter allows looping over many incrementing variables in one loop
CContainerTraits	Specialize container traits Expects:
CContainerTraits< std::vector< _value_type, Allocator > >
CContainerTraits< Eigen::Matrix< _value_type, a, b, c, d, e > >	Eigen::MatrixXd container traits
CCounter	A Counter allows looping over many incrementing variables in one loop
Ctraits< Counter< _Container, _value_type, _size_type, _Access, _Compare > >
CIsoCounter	A IsoCounter allows looping over many incrementing variables in one loop
Ctraits< IsoCounter< _Container, _value_type, _size_type, _Access, _Compare > >
CMultiCounter
CCounterValueIterator< MultiCounter< SubCounterType > >
Cmultivector	Shortcut for multidimensional vector (std::vector< std::vector< ...)
CPermutation
CPolyTrie
CPTNode
CPTLeaf
CPTIterator
CGramSchmidt
CDynamicMatrix
CReturnTensor
CTensor
CTensorBasis
CAnisoValTraits	Specifies traits of (possibly) anisotropic crystal properties
CjsonConstructor< xtal::AtomPosition >
CjsonConstructor< xtal::Molecule >
CjsonConstructor< xtal::Site >
CjsonConstructor< xtal::SiteDoFSet >
CjsonConstructor< xtal::DoFSet >
CSimpleJSonSiteStructure	Used to construct a BasicStructure from a 'properties.calc.json' object
CjsonConstructor< xtal::ScelEnumProps >	Make a ScelEnumProps object from JSON input
CLatticeEnumEquivalents	Enumerate equivalent Lattics, given a SymGroup
CStructure	Structure specifies the lattice and atomic basis of a crystal
CSymRepBuilderInterface	Abstract base class that provides interface for converting cartesian isometry to specialized transformation matrix Given a symmetry operation as a 3x3 orthogonal matrix acting on Cartesian space, a 3x1 Cartesian translation, and a time-reversal flag (true indicates +t goes to -t and false indicates +t goes to +t), returns a particular NxN matrix transformation whose dimension and value depends on the underlying implementation
CTemplateSymRepBuilderBase
CNullSymRepBuilder	Un-cloneable class for specifying absence of valid SymRepBuilder
CCartesianSymRepBuilder	Builds symmetry representation as the Cartesian matrix of povided SymOp
CKroneckerSymRepBuilder	Builds symmetry representation as the Kronecker product of two other representations
CIdentitySymRepBuilder	Builds symmetry representation as the 'dim' x 'dim' identity matrix, regardless of symop
CAngularMomentumSymRepBuilder	Builds symmetry representation that is the angular momentum symmetry representation of provided symop
CTimeReversalSymRepBuilder	Builds symmetry representation that is 'dim'x'dim' +Identity (-Identity) matrix if time_reversal is false (true)
CRank2TensorSymRepBuilder	Build 6x6 symmetry representation for a rank 2 Cartesian tensor represented in Kelvin notation
CTimeReversalSwapSymRepBuilder
CdOrbitalOccupationSymRepBuilder
CdOrbitalOccupationSpinPolarizedSymRepBuilder
CCopyApplyWithPrim_crtp
Ctraits< CASM::xtal::UnitCellCoord >
Ctraits< DB::jsonDB >
CConfigEnumInput
CDoFSpace
Cmake_symmetry_adapted_dof_space_error
CVectorSpaceMixingInfo	A struct which gives out the mixing information of given column_vector_space and a subspace
CEnumeratorBase	Abstract base class for enumerators
CValEnumerator
CEnumIteratorBase
CValEnumIterator
CInputEnumeratorBase	Base class for implementing specialized input enumerators
CInputEnumIterator
CInputEnumIteratorBase
CInputEnumerator	Generic input enumerator
CjsonConstructor< ConfigEnumInput >	Read ConfigEnumInput from JSON
CjsonConstructor< DoFSpace >
CjsonMake< DoFSpace >
CAxesCounterParams	Data structure used for continuous DoF enumeration IO
CRandomAccessEnumIterator	The iterator type for RandomAccessEnumerator
CRandomAccessEnumeratorBase	Base class for implementing specialized random access enumerators
CRandomAccessEnumerator	Generic random access enumerator
CRandomAccessEnumIteratorBase	RandomAccessEnumIterator implemenation
CUnaryCompare_f
Clibcasm_runtime_error
►CHull	Generate and inspect the convex hull generated from a selection of Configurations
CCompareVertex
CFloatCompare
CFilterIterator
►CHallOfFame	A container for storing best scoring objects
CCompare
CInsertResult	Results data structure for HallOfFame::insert
CHierarchyID
CDerivedID
CPCA	Principle component analysis
CValidator	Data structure to hold error and warning messages
CjsonConstructor< Monte::OccCandidate >
CjsonConstructor< Monte::OccSwap >
CStrainConverter
CEnumEquivalents	Enumerate over all equivalents
Ctraits< EnumEquivalents< ObjectType, SymOpIterator, SymOpType, SymOpCompare > >
CjsonConstructor< SymInfoOptions >
CSymInfoOptions	Options for printing SymInfo
COrbit	An Orbit of Element
CGetPrototype
CGetInvariants
CSymCompare	CRTP base class for implementing element and orbit comparison
COrbitGeneratorCompare	Compare concept functor for canonical generating elements
CCanonicalGenerator	Functor to find the canonical generating element for an orbit
CIsCanonical	Functor to find to check if element is in canonical form
CPermuteIterator
CjsonConstructor< PermuteIterator >
CSimpleOrbit
CMakeSubOrbitGenerators	Output the orbit generators necessary to construct the sub-orbits corresponding to group -> subgroup symmetry breaking
CSupercellSymInfo	A class that collects all symmetry information for for performing symmetry transformations on the site indices, site DoFs, and global DoFs of a Supercell or Configuration
CSymBasisPermute	SymBasisPermute describes how a symmetry operation permutes atoms in a basis
CSymGroup	SymGroup is a collection of symmetry operations that satisfy the group property The symmetry operations are stored as their coordinate representation, as described by the SymOp class i.e., if SymOps 'A' and 'B' are in SymGroup, C=A*B is also in SymGroup if 'A' is in SymGroup, then A.inverse() is in SymGroup SymGroup always contains an identity operation
CMasterSymGroup
CSymGroupRep	SymGroupRep is an alternative representation of a SymGroup for something other than real space. There is a one-to-one correspondence of SymOps in some SymGroup with the SymOpRepresentations in SymGroupRep SymGroupRep does not know or care about the specifics of what the SymOpRepresentations describe or how they are implemented
CSymGroupRepHandle
CSymGroupRepID	Type-safe ID object for communicating and accessing Symmetry representation info
CSymInfo	Simple struct to be used as return type for SymOp::info()
CSymMatrixXd	Generalized symmetry matrix representation for arbitrary dimension Can be used to describe application of symmetry to N-dimensional vector spaces Use for 3-dimensional transformations if they do not describe coordinate transformations
CSymOp	SymOp is the Coordinate representation of a symmetry operation it keeps fraction (FRAC) and Cartesian (CART) information about how a symetry operation transforms 3D spatial coordinates
CSymOpRepresentation	SymOpRepresentation is the base class for anything describes a symmetry operation
CSymRepIndexCompare
CSymPermutation	SymPermutation describes how a symmetry operation permutes a list of 'things' For example, Coordinates in a Cluster, basis atoms in a Structure, Clusters in an Orbit, etc
CVectorSpaceSymReport	Summary of data associated with the action of a symmetry group on a vector space
CVectorSymCompare
CVectorInvariants
CDirectionSymCompare
Ctraits< DirectionSymCompare< _Element, _SymApply > >	Traits class for DirectionSymCompare
CSubspaceSymCompare
Ctraits< SubspaceSymCompare< _Element, _SymApply > >	Traits class for SubspaceSymCompare
Ctraits< VectorSymCompare< Base > >	Traits class for VectorSymCompare
CEigenSymCompare	CRTP Base class for Vector comparisons
CEigenSymRepApply
CPopen	Remember how to use popen
Cruntime_lib_compile_error
Cruntime_lib_shared_error
CRuntimeLibrary	Write, compile, load and use code at runtime
CImportCommandImplBase	Defaults used if DataObject type doesn't matter or not given
CQueryCommandImplBase	Defaults used if DataObject type doesn't matter or not given
CRmCommandImplBase	Defaults used if DataObject type doesn't matter or not given
CSelectCommandImplBase	Defaults used if DataObject type doesn't matter or not given
CPrintDetails
CUpdateCommandImplBase	Defaults used if DataObject type doesn't matter or not given
CWriteBasisSetDataImpl	Write clust.json, basis.json, and clexulator source code, given orbits
CPolyWriter
►Nnotstd	Non-std smart pointer classes and functions
CCloneable	Base class for cloning
Ccloneable_ptr	A 'cloneable_ptr' can be used in place of 'unique_ptr'
Chas_clone	Base type inherits from std::false_type if T does not have clone method
Chas_clone< T, void_t< decltype(&T::clone)> >	Specialized case inherits from std::true_type if T does have clone method
Chas_move	Base type inherits from std::false_type if T does not have move method
Chas_move< T, void_t< decltype(&T::move)> >	Specialized case inherits from std::true_type if T does have move method
CComparisons	Implements other comparisons in terms of '<'
CCRTPBase	Base class for CRTP pattern
Cmake_void	Alias for void, to help SFINAE work
Cfunction_traits	Deduces return type and argument types for non-generic labmdas and functors
►Cfunction_traits< ReturnType(ClassType::*)(Args...) const >
Carg
CGetSecondDereferenced
CGetSecondDereferencedConst
CUniqueMapIterator	An iterator over a UniqueMap
CGetSecond
CGetSecondConst
Cunique_map	Std::map wrapper to enforce a 1-1 ValueType->KeyType relationship
►Nstd
Cis_floating_point< CASM::xtal::Coordinate_impl::FracCoordinateComponent >
Cis_floating_point< CASM::xtal::Coordinate_impl::CartCoordinateComponent >
Chash< CASM::xtal::UnitCell >
Chash< CASM::xtal::UnitCellCoord >