cluster.h

#ifndef __CCEX_CLUSTER_H_
#define __CCEX_CLUSTER_H_
 
#include "general.h"
#include "bath.h"
#include "utilities.h"

typedef struct {

    int order;

    int  sK; 
    int  max_trial;  
    int  max_iter;   
 
    bool kmeans_pp;   
    bool iter_detail; 

    char method[MAX_CHARARRAY_LENGTH];

    int* nk; 

    bool addsubclus; 

    int*** clusinfo;
 
} Cluster;
 
/* High Level --------------------------------------------------------*/
 
 
 
// init
Cluster* Cluster_init();
void Cluster_clusterize(Cluster* cls, BathArray* ba, Config* config);
 
// free
void Cluster_freeAll(Cluster* cls);
 
// MPI
// int*** Clsuter_getLocalClusters_MPI(Cluster* cls);
 
// find clusters
// void Cluster_find_clusinfo_hash(Cluster* cls, BathArray* batharr, Config* config); // normal (hash) algorithm
// void Cluster_find_clusinfo_dsj(Cluster* cls, BathArray* batharr, Config* config); // disjoint algorithm
// void Cluster_find_clusinfo_itb(Cluster* cls, BathArray* batharr, Config* config); // inter-bathcluster algorithm
// void Cluster_find_clusinfo_dsjitb(Cluster* cls, BathArray* batharr, Config* config); // disjoint + inter-bathcluster algorithm
 
// report
void Cluster_report(Cluster* cls);
void Cluster_reportNk(Cluster* cls);
void Cluster_reportClusinfo(Cluster* cls);
void reportClusinfo(int*** clusinfo, int order);
 
/* Low Level --------------------------------------------------------*/
 
// clusinfo controller
 
void Cluster_allocClusinfo(Cluster* cls, int order); // alloc clusinfo[order+1] : 0 ~ order
void Cluster_freeClusinfo(Cluster* cls);
 
void Cluster_setClusinfo_0th(Cluster* cls); // Actually do nothing
void Cluster_setClusinfo_1th(Cluster* cls, BathArray* ba); // bathspins = clusinfo[1][j][k]
int Cluster_setClusinfo_addcluster(Cluster* cls, int order, int iter, int* cluster); // add new cluster, return the index of the cluster
void Cluster_setClusinfo_chgcluster(Cluster* cls, int order, int* cluster, int ic); // change cluster at ic-th cluster
void Cluster_setClusinfo_chgiter(Cluster* cls, int order, int iter, int ic); // change iter at ic-th cluster 
 
//void Cluster_setSk(Cluster* cls, int sk); //
//void Cluster_getSk(Cluster* cls); // output
 
 
 
// what's iter :     
// The number how many you will multiply/divide 
// in the coherence calculation for 0 th order
 
int Cluster_getClusinfo_ncluster(Cluster* cls, int order); // get the number of clusters at order
int* Cluster_getClusinfo_itercluster(Cluster* cls, int order, int ic); // get ic-th iter+cluster at order [0] = iter, [1~] = cluster
int Cluster_getClusinfo_iter(Cluster* cls, int order, int ic); // get ic-th iter+cluster at order [0] = iter, [1~] = cluster
int* Cluster_getClusinfo_cluster_copy(Cluster* cls, int order, int ic); // get ic-th cluster at order (copy)
int*** Cluster_getClusinfo(Cluster* cls);
 
// nk controller
void Cluster_allocNk(Cluster* cls);
void Cluster_freeNk(Cluster* qa);
int Cluster_getNk_order(Cluster* cls, int i); // get the number of clusters at ith-orderr at ith-order
int* Cluster_getNk(Cluster* cls);
 
// others controller
char* Cluster_getMethod(Cluster* cls);
int Cluster_getOrder(Cluster* cls);
bool Cluster_getAddsubclus(Cluster* cls);
int Cluster_getSk(Cluster* cls);
int Cluster_getMax_iter(Cluster* cls);
int Cluster_getMax_trial(Cluster* cls);
bool Cluster_getKmeans_pp(Cluster* cls);
bool Cluster_getIter_detail(Cluster* cls);
 
// set 
void Cluster_setOrder(Cluster* cls, int order);
void Cluster_setMethod(Cluster* cls, char* method);
void Cluster_setAddsubclus(Cluster* cls, bool addsubclus);
void Cluster_setNk(Cluster* cls, int* nk); // set the number of clusters at ith-order
void Cluster_setSk(Cluster* cls, int sK);
void Cluster_setMax_trial(Cluster* cls, int max_trial);
void Cluster_setMax_iter(Cluster* cls, int max_iter);
void Cluster_setKmeans_pp(Cluster* cls, bool kmeans_pp);
void Cluster_setIter_detail(Cluster* cls, bool iter_detail);
 
#endif // __CCEX_CLUSTER_H_