227 lines
10 KiB
C++
227 lines
10 KiB
C++
#ifndef _RAFFINE_H_
|
|
#define _RAFFINE_H_
|
|
|
|
#include "clus_str.h"
|
|
#include "linalg.h"
|
|
#include "chull.h"
|
|
#include "lstsqr.h"
|
|
#include "plugin.h"
|
|
|
|
typedef LinkedList<Real> LinkedListReal;
|
|
|
|
class StructureInfo;
|
|
class ClusterExpansion;
|
|
|
|
class EnergyPredictor {
|
|
public:
|
|
EnergyPredictor(void) {}
|
|
virtual void static_init(const ClusterExpansion &ce) {}
|
|
virtual Real get_energy(const StructureInfo &str) {return 0.;}
|
|
};
|
|
|
|
class StructureInfo: public Structure {
|
|
public:
|
|
enum Status {unknown=1,calculated=2,busy=4,error=8,anystatus=15};
|
|
Real energy;
|
|
Status status;
|
|
Real cost;
|
|
AutoString label;
|
|
LinkedList<EnergyPredictor> predictor;
|
|
LinkedList<LinkedListReal> correlations;
|
|
StructureInfo(void): Structure(),
|
|
label(), correlations(), predictor()
|
|
{
|
|
energy=0;
|
|
status=unknown;
|
|
cost=0.;
|
|
}
|
|
StructureInfo(const Structure &str): Structure(str),
|
|
label(), correlations(), predictor()
|
|
{
|
|
energy=0;
|
|
status=unknown;
|
|
cost=0.;
|
|
}
|
|
};
|
|
|
|
Real calc_structure_cost(const Structure &str, const rMatrix3d &cell, const Array<rMatrix3d> &point_op, const Array<rVector3d> &trans, Real complexity_exp);
|
|
|
|
// Describes the status of a cluster expansion fit;
|
|
class CEFitInfo {
|
|
public:
|
|
enum Status {fit_ok=0, fit_impossible=1, gs_problem=2, new_gs=4};
|
|
// Respectively means:
|
|
// no problem;
|
|
// no enough data to fit;
|
|
// predicted ground states do not agree with currently known ground states;
|
|
// new ground states (whose exact energy is not known yet) have been predicted;
|
|
Status status;
|
|
Array<StructureInfo *> pstr; // Pointers to structures included in the fit;
|
|
Array<Real> pure_energy; // Energies of the end members (e.g. pure elements);
|
|
Array<Array<Real> > concentration; // Concentrations \;
|
|
Array<Real> fitted_energy; // Predicted energies | of the str used in the fit;
|
|
Array<Real> energy; // True energies /;
|
|
|
|
Array<Real> weight; // weights needed to get the right GS line;
|
|
Real cv; // crossvalidation score (when weights turned off);
|
|
Array<int> gs_list; // indices (into any of the 4 previous arrays) of the true ground states
|
|
LinkedList<PolytopeFace> hull;
|
|
Array2d<Real> corr_to_fullconc; // converts correlation to redundant concentration;
|
|
Array2d<Real> corr_to_conc; // converts correlation to non redundant concentration;
|
|
Array2d<Real> conc_to_fullconc; // converts nonredundant concentration to full redundant concentration;
|
|
Array<Real> conc_to_fullconc_c; // constant terms of previous matrix;
|
|
int max_volume; // largest volume considered when looking for new ground states;
|
|
Array<MultiCluster> cluster; // clusters used in the optimal fit;
|
|
Array<Real> multiplicity; // corresponding multiplicities;
|
|
Array<Real> eci; // corresponding ECI;
|
|
};
|
|
|
|
class ClusterExpansion {
|
|
protected:
|
|
SpaceGroup spacegroup; // see findsym.h;
|
|
StructureBank<StructureInfo> structures; // structure generation object \ see clus_str.h;
|
|
Array<MultiClusterBank *> pclusters; // cluster generation object /;
|
|
// *(pclusters(0)): points, *(pclusters(1)): pairs, etc.;
|
|
Array<LinkedList<Array<MultiCluster> > * > equiv_cluster; // image of each cluster by all elements of the factor group;
|
|
Array<Real> weight; // weights used in the optimal fit;
|
|
Array<Real> eci_mult; // fitted ECI (times multiplicity);
|
|
Structure parent_lattice; // the lattice;
|
|
Structure lattice_only; // the lattice, with fixed atoms removed;
|
|
Array<Arrayint> site_type_list; // as read by parse_lattice_file;
|
|
Array<AutoString> atom_label; // as read by parse_lattice_file;
|
|
int minimal_nc; // number of cluster in a minimal nearest neighbor cluster expansion;
|
|
int nb_calculated_str; // number of calculated structures;
|
|
int nb_clusters; // number of clusters used in the fit;
|
|
Real radius_1nn; // radius of the nearest neighbor shell;
|
|
|
|
CorrFuncTable *pcorrfunc;
|
|
Array2d<Real> corr_to_fullconc; // converts correlation to redundant concentration;
|
|
Array2d<Real> corr_to_conc; // converts correlation to non redundant concentration;
|
|
Array2d<Real> conc_to_fullconc; // converts nonredundant concentration to full redundant concentration;
|
|
Array<Real> conc_to_fullconc_c; // constant terms of previous matrix;
|
|
Array<Real> down_e;
|
|
LinkedList<LinearInequality> conc_range; // range of concentration sampled;
|
|
int ignore_gs;
|
|
int user_max_vol;
|
|
|
|
LinkedList<int> label_list;
|
|
LinkedListIterator<int> i_label_list;
|
|
int cur_label;
|
|
const char *predictor_labels;
|
|
Real high_energy;
|
|
public:
|
|
int max_multiplet; // maximum number of points in cluster (can be increased later on);
|
|
Real complexity_exp;
|
|
ClusterExpansion(const Structure &_parent_lattice,
|
|
const Array<Arrayint> &_site_type_list,
|
|
const Array<AutoString> &_atom_label,
|
|
const SpaceGroup &_spacegroup,
|
|
CorrFuncTable *_pcorrfunc);
|
|
~ClusterExpansion(void);
|
|
|
|
// Low-level functions;
|
|
// update corr. of one structure;
|
|
void update_correlations(StructureInfo *str);
|
|
// update corr. of all structures of a given status (multiple statuses can be or-ed together);
|
|
void update_correlations(StructureInfo::Status select);
|
|
// update list of equivalent clusters;
|
|
void update_equivalent_clusters(void);
|
|
// initialize the static members of the user-specified energy predictors;
|
|
void init_predictors(void);
|
|
// calculate the matrix that maps point correlation into concentrations;
|
|
void calc_point_to_concentration(Array<Real> *multiplicity, int nb_cols);
|
|
// calculate concentration from correlation vector;
|
|
void calc_concentration(Array<Real> *pconcentration, const Array<Real> &corr_matrix);
|
|
// calculate concentration from correlation matrix;
|
|
void calc_concentration(Array<Array<Real> > *pconcentration, const Array2d<Real> &corr_matrix);
|
|
// create a matrix of corr. and a vector of energies for structures maching a given status;
|
|
void calc_regression_matrices( Array2d<Real> *pcorr_matrix, Array<Real> *penergy, StructureInfo::Status select=StructureInfo::calculated);
|
|
// create a vector of predictor energies (using the user-specified predictor objects) for structures maching a given status;
|
|
void calc_predictor_energy( Array<Real> *penergy, StructureInfo::Status select=StructureInfo::calculated);
|
|
Real calc_predictor_energy(StructureInfo *str);
|
|
// restart from minimal cluster expansion (only 1nn pairs);
|
|
void reset_cluster_choice(void);
|
|
// iterate to the next choice of clusters;
|
|
int find_next_cluster_choice(int colinear=0);
|
|
// select a given choice of clusters: choice(1) gives the nunber of pairs, choice(2) gives the number of triplets, etc.;
|
|
void set_cluster_choice(const Array<int> &choice);
|
|
// opposite of the above;
|
|
void get_cluster_choice(Array<int> *pchoice);
|
|
// make an array of correlations from the list of corr. stored in a StructureInfo object;
|
|
void make_correlation_array(Array<Real> *array_corr, const LinkedList<LinkedListReal> &list_corr);
|
|
// restart from first structure;
|
|
void reset_structure(void);
|
|
// iterate to the next structure;
|
|
void find_next_structure(void);
|
|
|
|
// High-level functions;
|
|
// Set the concentration range where the ground states must be right;
|
|
void set_concentration_range(const LinkedList<LinearInequality> &_conc_range, int _ignore_gs);
|
|
// select predictors;
|
|
void set_predictor_labels(const char *labels);
|
|
// set max energy above GS hull allowed when generating new structures;
|
|
void set_highest_energy_allowed(Real _high_energy) {high_energy=_high_energy;};
|
|
void set_maximum_volume_allowed(int _user_max_vol) {user_max_vol=_user_max_vol;};
|
|
|
|
// the following 4 routines can be overridden in derived class to enable new fitting algorithms;
|
|
|
|
// Main routine calling the cluster enumeration and crossvalidation routines;
|
|
// Initialize *pfitinfo with results (see class CEFitInfo above);
|
|
virtual void find_best_cluster_choice(CEFitInfo *pfitinfo);
|
|
// Main routine calling the structure enumeration routines and the variance calculation codes.;
|
|
// Return pointer to structure found (or NULL upon failure);
|
|
virtual StructureInfo * find_best_structure(void);
|
|
// Finds the first few structures needed to initiate the refinement process.;
|
|
// Return pointer to structure found (or NULL upon failure);
|
|
virtual StructureInfo * find_initial_structures(void);
|
|
// Returns the least computationally intensive structure still marked as unknown.
|
|
// Return pointer to structure (never NULL);
|
|
virtual StructureInfo * find_first_unknown_structure(void);
|
|
|
|
// various functions to access private members;
|
|
const Structure & get_lattice(void) const {
|
|
return parent_lattice;
|
|
}
|
|
const Structure & get_lattice_only(void) const {
|
|
return lattice_only;
|
|
}
|
|
const Array<Arrayint> & get_site_type_list(void) const {
|
|
return site_type_list;
|
|
}
|
|
const Array<AutoString> & get_atom_label(void) const {
|
|
return atom_label;
|
|
}
|
|
const LinkedList<StructureInfo> & get_structure_list(void) {
|
|
return structures.get_structure_list();
|
|
}
|
|
LinkedList<StructureInfo> & access_structure_list(void) {
|
|
return structures.get_structure_list();
|
|
}
|
|
StructureBank<StructureInfo> & access_structure_bank(void) {
|
|
return structures;
|
|
}
|
|
const LinkedList<MultiCluster> & get_cluster_list(int ntuple) const {
|
|
return pclusters(ntuple)->get_cluster_list();
|
|
}
|
|
};
|
|
|
|
// Setup plugins to allow for alternate cluster expansion algorithms;
|
|
|
|
class ClusterExpansionCreator { // for the default algorithm;
|
|
public:
|
|
virtual ClusterExpansion* create(const Structure &_parent_lattice, const Array<Arrayint> &_site_type_list, const Array<AutoString> &_atom_label, const SpaceGroup &_spacegroup, CorrFuncTable *_pcorrfunc) {
|
|
return new ClusterExpansion(_parent_lattice,_site_type_list,_atom_label,_spacegroup,_pcorrfunc);
|
|
}
|
|
};
|
|
|
|
template<class T>
|
|
class CustomClusterExpansionCreator: public ClusterExpansionCreator { // for alternate algorithm;
|
|
virtual ClusterExpansion* create(const Structure &_parent_lattice, const Array<Arrayint> &_site_type_list, const Array<AutoString> &_atom_label, const SpaceGroup &_spacegroup, CorrFuncTable *_pcorrfunc) {
|
|
return new T(_parent_lattice,_site_type_list,_atom_label,_spacegroup,_pcorrfunc);
|
|
}
|
|
};
|
|
|
|
// end setting up plugins;
|
|
|
|
#endif
|