#ifndef __MB_H__ #define __MB_H__ #include #include #ifdef USECONFIG_H # include "config.h" #else /* some defaults that would otherwise be guessed by configure */ # define PACKAGE_NAME "mrbayes" # define PACKAGE_VERSION "3.2" # undef HAVE_LIBREADLINE # define UNIX_VERSION 1 # undef FAST_LOG #if !defined(XCODE_VERSION) # undef _64BIT #endif #endif #if !defined(UNIX_VERSION) && !defined(WIN_VERSION) && !defined(MAC_VERSION) #ifdef __MWERKS__ #define MAC_VERSION #elif defined __APPLE__ #define MAC_VERSION #else #define WIN_VERSION #endif #endif /* found out that mrbayes crashes on 64 bit platform especially in sumt function. If every long is substituted with an int, it works. I'm going to define a SafeLong and an unsigned SafeLong for 64 bit platforms... Davide Cittaro - daweonline(at)gmail.com */ //#define SSE_ENABLED /* This is a configuration option from the configure script. */ #ifdef _64BIT typedef int SafeLong; #else typedef long SafeLong; #endif typedef double MrBFlt; /* double used for parameter values and generally for floating point values, if set to float MPI would not work becouse of use MPI_DOUBLE*/ #define MRBFLT_MAX DBL_MAX; /* maximum possible value that can be stored in MrBFlt */ #define MRBFLT_MIN DBL_MIN; /* maximum possible value that can be stored in MrBFlt */ #define MRBFLT_NEG_MAX (-DBL_MAX); /* maximum possible negative value that can be stored in MrBFlt */ typedef float CLFlt; /* single-precision float used for cond likes (CLFlt) to increase speed and reduce memory requirement */ /* set CLFlt to double if you want increased precision */ /* NOTE: CLFlt = double not compatible with SSE_ENABLED */ /* Define a compiler and vector size for the SSE code */ #if defined (SSE_ENABLED) #define FLOATS_PER_VEC 4 #if defined (WIN_VERSION) #define MS_VCPP_SSE #else #define GCC_SSE #undef ICC_SSE #endif #endif /*#define PRINT_RATEMULTIPLIERS_CPP*/ #if defined GCC_SSE /* gcc compiler */ #define ALIGNED_MALLOC(X,Y,Z) {int tmp;tmp=posix_memalign(X,Y,Z);} /*To remove warnings*/ #define ALIGNED_FREE free #include #elif defined ICC_SSE /* icc compiler */ #define ALIGNED_MALLOC _mm_malloc #define ALIGNED_FREE _mm_free #elif defined MS_VCPP_SSE /* Visual .Net */ #define ALIGNED_MALLOC _aligned_malloc #define ALIGNED_FREE _aligned_free #include #else #define ALIGNED_MALLOC malloc #endif /* For comparing floating points: two values are the same if the absolute difference is less then this value. */ #ifndef ETA #define ETA (1E-30) #endif #if defined (DEBUGOUTPUT) #define DEBUG(fmt, arg) printf("%s:%d ",__FILE__,__LINE__);printf(fmt,arg); #else #define DEBUG(a,b) #endif #if defined (MPI_ENABLED) #include "mpi.h" #endif #if defined (BEAGLE_ENABLED) #include "libhmsbeagle/beagle.h" #endif #define RELEASE #ifdef RELEASE #define VERSION_NUMBER "3.2.1" #else #define VERSION_NUMBER "3.2.1-svn" #endif /* TEMPSTRSIZE determines size of temporary sprintf buffer (for SafeSprintf) */ /* A patch was sent in by Allen Smith for SafeSprintf, but I could not get it compiled on SGI IRIX 6.5 (too old?) with _xpg5_vsnprintf undefined. The code below is a hack so SafeSprintf never has to reallocate memory. \todo fix */ #ifdef __sgi #define TEMPSTRSIZE 1000 #else #define TEMPSTRSIZE 200 #endif #undef NO_ERROR #undef ERROR #define NO_ERROR 0 #define ERROR 1 #define NO_ERROR_QUIT 2 #define ABORT 3 #define SKIP_COMMAND 4 #undef FALSE #undef TRUE #define FALSE 0 #define TRUE 1 #define NO 0 #define YES 1 #define UP 0 #define DOWN 1 #define UPPER 0 #define MIDDLE 1 #define LOWER 2 #define NONINTERACTIVE 0 #define INTERACTIVE 1 #define STANDARD_USER 1 #define DEVELOPER 3 #define DIFFERENT 0 #define SAME 1 #define CONSISTENT_WITH 2 #define LINETERM_UNIX 0 #define LINETERM_MAC 1 #define LINETERM_DOS 2 #define SCREENWIDTH 60 #define SCREENWIDTH2 61 #define AVGSTDDEV 0 #define MAXSTDDEV 1 #define NONE 0 #define DNA 1 #define RNA 2 #define PROTEIN 3 #define RESTRICTION 4 #define STANDARD 5 #define MIXED 6 #define CONTINUOUS 7 #define AAMODEL_POISSON 0 #define AAMODEL_JONES 1 #define AAMODEL_DAY 2 #define AAMODEL_MTREV 3 #define AAMODEL_MTMAM 4 #define AAMODEL_WAG 5 #define AAMODEL_RTREV 6 #define AAMODEL_CPREV 7 #define AAMODEL_VT 8 #define AAMODEL_BLOSUM 9 #define AAMODEL_EQ 10 #define AAMODEL_GTR 11 /* aa models with free parameters must be listed last */ #define NUCMODEL_4BY4 0 #define NUCMODEL_DOUBLET 1 #define NUCMODEL_CODON 2 #define NUCMODEL_AA 3 #define NST_MIXED -1 /* anything other than 1, 2, or 6 */ #define MISSING 10000000 #define GAP 10000001 #define UNORD 0 #define ORD 1 #define DOLLO 2 #define IRREV 3 #define IN_CMD 0 #define IN_FILE 1 #define NOTHING 0 #define COMMAND 1 #define PARAMETER 2 #define EQUALSIGN 3 #define COLON 4 #define SEMICOLON 5 #define COMMA 6 #define POUNDSIGN 7 #define QUESTIONMARK 8 #define DASH 9 #define LEFTPAR 10 #define RIGHTPAR 11 #define LEFTCOMMENT 12 #define RIGHTCOMMENT 13 #define ALPHA 14 #define NUMBER 15 #define RETURNSYMBOL 16 #define ASTERISK 17 #define BACKSLASH 18 #define FORWARDSLASH 19 #define EXCLAMATIONMARK 20 #define PERCENT 21 #define QUOTATIONMARK 22 #define WEIRD 23 #define UNKNOWN_TOKEN_TYPE 24 #define LEFTCURL 25 #define RIGHTCURL 26 #define DOLLAR 27 #define AMPERSAND 28 #define MAX_Q_RATE 100.0f #define MIN_SHAPE_PARAM 0.0001f #define MAX_SHAPE_PARAM 200.0f #define MAX_SITE_RATE 10.0f #define MAX_GAMMA_CATS 20 #define MAX_GAMMA_CATS_SQUARED 400 #define BRLENS_MIN 0.00000001f #define BRLENS_MAX 100.0f #define RELBRLENS_MIN 0.00000001f #define RELBRLENS_MAX 100.0f #define KAPPA_MIN 0.01f #define KAPPA_MAX 1000.0f #define GROWTH_MIN -1000000.0f #define GROWTH_MAX 1000000.0f #define RATE_MIN 0.000001f #define RATE_MAX 100.0f #define CPPRATEMULTIPLIER_MIN 0.001f #define CPPRATEMULTIPLIER_MAX 1000.0f #define SYMPI_MIN 0.000001f #define SYMPI_MAX 100.0f #define ALPHA_MIN 0.0001f #define ALPHA_MAX 10000.0f #define DIR_MIN 0.000001f #define PI_MIN 0.000001f #define OFFSETEXPLAMBDA_MIN 0.000001f #define OFFSETEXPLAMBDA_MAX 100000.0f #define TREEHEIGHT_MIN 0.00000001f #define TREEHEIGHT_MAX 1000.0f #define TREEAGE_MIN 0.00000001f #define TREEAGE_MAX 1000000.0f #define CPPLAMBDA_MIN 0.00001f #define CPPLAMBDA_MAX 100.0f #define TK02VAR_MIN 0.00001f #define TK02VAR_MAX 100000.0f #define IGRVAR_MIN 0.00001f #define IGRVAR_MAX 100000.0f #define OMEGA_MAX 1000000.0f #define POS_MIN 1E-25f #define POS_MAX 1E25f #define POS_INFINITY 1E25f #define NEG_INFINITY -1000000.0f #define POSREAL_MIN 1E-25f #define POSREAL_MAX 1E25f #define CMD_STRING_LENGTH 100000 #define pos(i,j,n) ((i)*(n)+(j)) #define NUM_ALLOCS 92 #define ALLOC_MATRIX 0 #define ALLOC_CHARINFO 2 #define ALLOC_CHARSETS 3 #define ALLOC_TAXA 4 #define ALLOC_TMPSET 5 #define ALLOC_PARTITIONS 6 #define ALLOC_PARTITIONVARS 7 #define ALLOC_TAXASETS 8 #define ALLOC_CONSTRAINTS 9 #define ALLOC_USERTREE 10 #define ALLOC_SUMTPARAMS 11 #define ALLOC_TERMSTATE 12 #define ALLOC_ISPARTAMBIG 13 #define ALLOC_AVAILNODES 25 #define ALLOC_AVAILINDICES 26 #define ALLOC_CURLNL 28 #define ALLOC_CURLNPR 29 #define ALLOC_CHAINID 30 #define ALLOC_PARAMS 31 #define ALLOC_TREE 32 #define ALLOC_NODES 33 #define ALLOC_LOCTAXANAMES 34 #define ALLOC_COMPMATRIX 39 #define ALLOC_NUMSITESOFPAT 40 #define ALLOC_COMPCOLPOS 41 #define ALLOC_COMPCHARPOS 42 #define ALLOC_ORIGCHAR 43 #define ALLOC_PARAMVALUES 46 #define ALLOC_MCMCTREES 47 #define ALLOC_MOVES 48 #define ALLOC_PRELIKES 52 #define ALLOC_SITEJUMP 54 #define ALLOC_MARKOVTIS 55 #define ALLOC_RATEPROBS 56 #define ALLOC_STDTYPE 57 #define ALLOC_PACKEDTREES 58 #define ALLOC_SUMPSTRING 62 #define ALLOC_SUMPINFO 63 #define ALLOC_SWAPINFO 64 #define ALLOC_SYMPIINDEX 65 #define ALLOC_POSSELPROBS 66 #define ALLOC_PBF 68 #define ALLOC_LOCALTAXONCALIBRATION 69 #define ALLOC_SPR_PARSSETS 72 #define ALLOC_PFCOUNTERS 74 #define ALLOC_FILEPOINTERS 75 #define ALLOC_STATS 76 #define ALLOC_DIAGNTREE 77 #define ALLOC_USEDMOVES 82 #define ALLOC_MODEL 83 #define ALLOC_STDSTATEFREQS 84 #define ALLOC_PRINTPARAM 85 #define ALLOC_TREELIST 86 #define ALLOC_TFILEPOS 87 #define ALLOC_BEST 88 #define ALLOC_SPECIESPARTITIONS 89 #define ALLOC_SS 90 #define LINKED 0 #define UNLINKED 1 /*paramType*/ #define NUM_LINKED 28 #define P_TRATIO 0 #define P_REVMAT 1 #define P_OMEGA 2 #define P_PI 3 #define P_SHAPE 4 #define P_PINVAR 5 #define P_CORREL 6 #define P_SWITCH 7 #define P_RATEMULT 8 #define P_TOPOLOGY 9 #define P_BRLENS 10 #define P_SPECRATE 11 #define P_EXTRATE 12 #define P_POPSIZE 13 #define P_AAMODEL 14 #define P_BRCORR 15 #define P_BRSIGMA 16 #define P_GROWTH 17 #define P_CPPMULTDEV 18 #define P_CPPRATE 19 #define P_TK02VAR 20 #define P_CPPEVENTS 21 #define P_TK02BRANCHRATES 22 #define P_IGRVAR 23 #define P_IGRBRANCHLENS 24 #define P_CLOCKRATE 25 #define P_SPECIESTREE 26 #define P_GENETREERATE 27 /* NOTE: If you add another parameter, change NUM_LINKED */ #define CPPm 0 /* CPP rate multipliers */ #define CPPi 1 /* CPP independent rates */ #define MAX_NUM_USERTREES 200 /* maximum number of user trees MrBayes will read */ #define MAX_CHAINS 256 /* maximum numbder of chains you can run actually only half of it becouse of m->lnLike[MAX_CHAINS] */ //#define PARAM_NAME_SIZE 400 typedef void * VoidPtr; typedef int (*CmdFxn)(void); typedef int (*ParmFxn)(char *, char *); typedef struct { MrBFlt sum; /* sum of standard deviations */ MrBFlt max; /* maximum standard deviation */ MrBFlt numPartitions; MrBFlt numSamples; MrBFlt avgStdDev; MrBFlt **pair; } STATS; /* enumeration for calibration prior */ enum CALPRIOR { unconstrained, fixed, offsetExponential, uniform }; enum ConstraintType { PARTIAL, NEGATIVE, HARD }; /* typedef for calibration */ typedef struct calibration { char name[100]; enum CALPRIOR prior; MrBFlt max; MrBFlt min; MrBFlt offset; MrBFlt lambda; MrBFlt age; } Calibration; /* typedef for tree (topology) list element */ typedef struct element { struct element *next; int *order; } TreeListElement; /* typedef for list of trees (topologies) */ typedef struct { TreeListElement *first; TreeListElement *last; } TreeList; /* typedef for packed tree */ typedef struct { int *order; MrBFlt *brlens; } PackedTree; /* typedef for binary tree node */ /* NOTE: Any variable added here must also be copied in CopyTrees */ typedef struct node { char *label; /*!< name of node if tip */ struct node *left, *right, *anc; /*!< pointers to adjacent nodes */ int memoryIndex; /*!< memory index (do not change) */ int index; /*!< index to node (0 to numLocalTaxa for tips) */ int upDateCl; /*!< cond likes need update? */ int upDateTi; /*!< transition probs need update? */ int marked, x, y; /*!< scratch variables */ int scalerNode; /*!< is node scaling cond likes? */ int isLocked; /*!< is node locked? */ int lockID; /*!< id of lock */ int isDated; /*!< is node dated (calibrated)? */ SafeLong *partition; /*!< pointer to bitfield describing splits */ MrBFlt length; /*!< length of pending branch */ MrBFlt nodeDepth; /*!< node depth (height) */ MrBFlt age; /*!< age of node */ MrBFlt d; /*!< scratch variable */ Calibration *calibration; /*!< pointer to calibration data */ } TreeNode; /* typedef for binary tree */ typedef struct { char name[100]; /*!< name of tree */ int memNodes; /*!< number of allocated nodes (do not exceed!) */ int nNodes; /*!< number of nodes in tree (including lower root in rooted trees) */ int nIntNodes; /*!< number of interior nodes in tree (excluding lower root in rooted trees) */ int isRooted; /*!< is tree rooted? */ int isClock; /*!< is tree clock? */ int isCalibrated; /*!< is tree calibrated? */ int nRelParts; /*!< number of relevant partitions */ int *relParts; /*!< pointer to relevant partitions */ int checkConstraints; /*!< does tree have constraints? */ int nConstraints; /*!< number of constraints */ int *constraints; /*!< pointer to constraints */ int nLocks; /*!< number of constrained (locked) nodes */ TreeNode **allDownPass; /*!< downpass array of all nodes */ TreeNode **intDownPass; /*!< downpass array of interior nodes (including upper but excluding lower root in rooted trees) */ TreeNode *root; /*!< pointer to root (lower root in rooted trees) */ TreeNode *nodes; /*!< array containing the nodes */ SafeLong *bitsets; /*!< pointer to bitsets describing splits */ SafeLong *flags; /*!< pointer to cond like flags */ int fromUserTree; /*!< YES is set for the trees whoes branch lengthes are set from user tree(as start tree or fix branch length prior ), NO otherwise */ } Tree; /* typedef for node in polytomous tree */ typedef struct pNode { char label[100]; /*!< name of node if terminal */ struct pNode *left, *sib, *anc; /*!< pointers to adjacent nodes */ int x, y, mark; /*!< scratch variables */ int partitionIndex; /*!< partition index in sumt (scratch) */ int index; /*!< index of node (if < numLocalTaxa = local taxon index) */ int memoryIndex; /*!< immutable index of memory position */ int isLocked; /*!< is the node locked? */ int lockID; /*!< id of lock */ int isDated; /*!< is node dated? */ MrBFlt length; /*!< age of node */ MrBFlt depth; /*!< depth (height) of node */ MrBFlt age; /*!< age of node */ MrBFlt support, f; /*!< scratch variables */ SafeLong *partition; /*!< pointer to partition (split) bitset */ Calibration *calibration; /*!< pointer to dating of node */ } PolyNode; /* typedef for polytomous tree */ typedef struct { char name[100]; /*!< name of tree */ int memNodes; /*!< number of allocated nodes; do not exceed! */ int nNodes; /*!< number of nodes in tree */ int nIntNodes; /*!< number of interior nodes in tree */ PolyNode **allDownPass; /*!< downpass array over all nodes */ PolyNode **intDownPass; /*!< downpass array over interior nodes */ PolyNode *root; /*!< pointer to root (lower for rooted trees */ PolyNode *nodes; /*!< array holding the tree nodes */ SafeLong *bitsets; /*!< bits describing partitions (splits) */ int nBSets; /*!< number of effective branch length sets */ int nESets; /*!< number of breakpoint rate sets */ char **bSetName; /*!< names of effective branch length sets */ char **eSetName; /*!< names of breakpoint rate sets */ int **nEvents; /*!< number of branch events of bp rate set */ MrBFlt ***position; /*!< position of branch events */ MrBFlt ***rateMult; /*!< parameter of branch events */ MrBFlt **effectiveBrLen; /*!< effective branch lengths of ebl set */ int brlensDef; /*!< are brlens defined ? */ int isRooted; /*!< is tree rooted? */ int isClock; /*!< is tree clock? */ int isCalibrated; /*!< is tree calibrated? */ int isRelaxed; /*!< is tree relaxed? */ MrBFlt clockRate; /*!< clock rate */ int popSizeSet; /*!< does tree have a population size set? */ MrBFlt *popSize; /*!< the population size */ char *popSizeSetName; /*!< name of the population size set */ } PolyTree; /* typedef for a ln prior prob fxn */ typedef MrBFlt (*LnPriorProbFxn)(MrBFlt val, MrBFlt *priorParams); /* typedef for a ln prior prob ratio fxn */ typedef MrBFlt (*LnPriorRatioFxn)(MrBFlt newVal, MrBFlt oldVal, MrBFlt *priorParams); /* struct for holding model parameter info for the mcmc run */ typedef struct param { int index; /* index to the parameter (0, 1, 2, ...) */ int paramType; /* the type of the parameter */ int paramId; /* unique ID for parameter x prior combination */ MrBFlt *values; /* main values of parameter */ MrBFlt *subValues; /* subvalues of parameter */ int *intValues; /* integer values (model index/growth fxn) */ int nValues; /* number of values */ int nSubValues; /* number of subvalues */ int nIntValues; /* number of intvalues */ MrBFlt min; /* minimum value of parameter */ MrBFlt max; /* maximum value of parameter */ int *relParts; /* pointer to relevant divisions */ int nRelParts; /* number of relevant divisions */ int upDate; /* update flag (for copying) */ struct param **subParams; /* pointers to subparams (for topology) */ int nSubParams; /* number of subparams */ Tree **tree; /* pointer to tree ptrs (for brlens & topology) */ int treeIndex; /* index to first tree in mcmcTree */ int hasBinaryStd; /* has binary standard chars */ int *sympiBsIndex; /* pointer to sympi bsIndex (std chars) */ int *sympinStates; /* pointer to sympi nStates (std chars) */ int *sympiCType; /* pointer to sympi cType (std chars) */ int nSympi; /* number of sympis */ int printParam; /* whether parameter should be printed */ int nPrintSubParams; /* number of subparams that should be printed */ char *paramHeader; /* a string holding header for param values */ char *name; /* string holding name of parameter */ char *paramTypeName; /* pointer to description of parameter type */ int checkConstraints; /* is tree parameter constrained? */ int fill; /* flags whether the parameter should be filled */ int nStdStateFreqs; /* number of std state frequencies */ MrBFlt *stdStateFreqs; /* pointer to std state frequencies */ int **nEvents; /* number of branch events for Cpp model */ /* nEvents[0..2*numCains][0..numNodes=2*numTaxa]*/ MrBFlt ***position; /* event positions for Cpp relaxed clock model */ MrBFlt ***rateMult; /* rate multipliers for Cpp relaxed clock model */ int affectsLikelihood; /* does parameter directly influence likelihood? */ MrBFlt* priorParams; /* pointer to the prior parameters */ LnPriorProbFxn LnPriorProb; /* ln prior prob function */ LnPriorRatioFxn LnPriorRatio; /* ln prior prob ratio function */ } Param; #if defined(THREADS_ENABLED) #include typedef struct s_launch_struct { int chain; int division; MrBFlt* lnL; } LaunchStruct; #endif /* parameter ID values */ /* identifies unique model parameter x prior combinations */ #define TRATIO_DIR 1 #define TRATIO_FIX 2 #define REVMAT_DIR 3 #define REVMAT_FIX 4 #define OMEGA_DIR 5 #define OMEGA_FIX 6 #define SYMPI_UNI 7 #define SYMPI_UNI_MS 8 #define SYMPI_EXP 9 #define SYMPI_EXP_MS 10 #define SYMPI_FIX 11 #define SYMPI_FIX_MS 12 #define SYMPI_EQUAL 13 #define PI_DIR 14 #define PI_USER 15 #define PI_EMPIRICAL 16 #define PI_EQUAL 17 #define PI_FIXED 18 #define SHAPE_UNI 19 #define SHAPE_EXP 20 #define SHAPE_FIX 21 #define PINVAR_UNI 22 #define PINVAR_FIX 23 #define CORREL_UNI 24 #define CORREL_FIX 25 #define SWITCH_UNI 26 #define SWITCH_EXP 27 #define SWITCH_FIX 28 #define RATEMULT_DIR 29 #define RATEMULT_FIX 30 #define TOPOLOGY_NCL_UNIFORM 31 #define TOPOLOGY_NCL_CONSTRAINED 32 #define TOPOLOGY_NCL_FIXED 33 #define TOPOLOGY_NCL_UNIFORM_HOMO 34 #define TOPOLOGY_NCL_UNIFORM_HETERO 35 #define TOPOLOGY_NCL_CONSTRAINED_HOMO 36 #define TOPOLOGY_NCL_CONSTRAINED_HETERO 37 #define TOPOLOGY_NCL_FIXED_HOMO 38 #define TOPOLOGY_NCL_FIXED_HETERO 39 #define TOPOLOGY_CL_UNIFORM 40 #define TOPOLOGY_CL_CONSTRAINED 41 #define TOPOLOGY_CL_FIXED 42 #define TOPOLOGY_CCL_UNIFORM 43 #define TOPOLOGY_CCL_CONSTRAINED 44 #define TOPOLOGY_CCL_FIXED 45 #define TOPOLOGY_PARSIMONY_UNIFORM 46 #define TOPOLOGY_PARSIMONY_CONSTRAINED 47 #define TOPOLOGY_PARSIMONY_FIXED 48 #define BRLENS_UNI 49 #define BRLENS_EXP 50 #define BRLENS_FIXED 51 #define BRLENS_CLOCK_UNI 52 #define BRLENS_CLOCK_COAL 53 #define BRLENS_CLOCK_BD 54 #define BRLENS_CLOCK_FIXED 55 #define BRLENS_CLOCK_SPCOAL 56 #define BRLENS_PARSIMONY 57 #define SPECRATE_UNI 60 #define SPECRATE_EXP 61 #define SPECRATE_FIX 62 #define EXTRATE_BETA 63 #define EXTRATE_FIX 65 #define POPSIZE_UNI 66 #define POPSIZE_GAMMA 67 #define POPSIZE_FIX 68 #define POPSIZE_NORMAL 69 #define POPSIZE_LOGNORMAL 70 #define AAMODEL_FIX 71 #define AAMODEL_MIX 72 #define GROWTH_UNI 73 #define GROWTH_EXP 74 #define GROWTH_FIX 75 #define GROWTH_NORMAL 76 #define OMEGA_BUD 77 #define OMEGA_BUF 78 #define OMEGA_BED 79 #define OMEGA_BEF 80 #define OMEGA_BFD 81 #define OMEGA_BFF 82 #define OMEGA_FUD 83 #define OMEGA_FUF 84 #define OMEGA_FED 85 #define OMEGA_FEF 86 #define OMEGA_FFD 87 #define OMEGA_FFF 88 #define OMEGA_ED 89 #define OMEGA_EF 90 #define OMEGA_FD 91 #define OMEGA_FF 92 #define OMEGA_10UUB 93 #define OMEGA_10UUF 94 #define OMEGA_10UEB 95 #define OMEGA_10UEF 96 #define OMEGA_10UFB 97 #define OMEGA_10UFF 98 #define OMEGA_10EUB 99 #define OMEGA_10EUF 100 #define OMEGA_10EEB 101 #define OMEGA_10EEF 102 #define OMEGA_10EFB 103 #define OMEGA_10EFF 104 #define OMEGA_10FUB 105 #define OMEGA_10FUF 106 #define OMEGA_10FEB 107 #define OMEGA_10FEF 108 #define OMEGA_10FFB 109 #define OMEGA_10FFF 110 #define CPPRATE_FIX 111 #define CPPRATE_EXP 112 #define CPPMULTDEV_FIX 113 #define TK02VAR_FIX 114 #define TK02VAR_EXP 115 #define TK02VAR_UNI 116 #define TOPOLOGY_RCL_UNIFORM 117 #define TOPOLOGY_RCL_CONSTRAINED 118 #define TOPOLOGY_RCL_FIXED 119 #define TOPOLOGY_RCCL_UNIFORM 121 #define TOPOLOGY_RCCL_CONSTRAINED 122 #define TOPOLOGY_RCCL_FIXED 123 #define TOPOLOGY_SPECIESTREE 124 #define CPPEVENTS 125 #define TK02BRANCHRATES 126 #define TOPOLOGY_FIXED 127 #define IGRVAR_FIX 129 #define IGRVAR_EXP 130 #define IGRVAR_UNI 131 #define IGRBRANCHLENS 132 #define CLOCKRATE_FIX 133 #define CLOCKRATE_NORMAL 134 #define CLOCKRATE_LOGNORMAL 135 #define CLOCKRATE_GAMMA 136 #define CLOCKRATE_EXP 137 #define SPECIESTREE_UNIFORM 138 #define GENETREERATEMULT_DIR 139 #define REVMAT_MIX 140 #if defined (BEAGLE_ENABLED) #define MB_BEAGLE_SCALE_ALWAYS 0 #define MB_BEAGLE_SCALE_DYNAMIC 1 #if defined (_DEBUG) #define MB_PRINT_DYNAMIC_RESCALE_FAIL_STAT #endif #endif /* typedef for a MoveFxn */ typedef int (MoveFxn)(Param *param, int chain, SafeLong *seed, MrBFlt *lnPriorRatio, MrBFlt *lnProposalRatio, MrBFlt *mvp); /* typedef for an ApplicFxn */ typedef int (ApplicFxn)(Param *param); /* typedef for an AutotuneFxn */ typedef void (AutotuneFxn)(MrBFlt acceptanceRate, MrBFlt targetRate, int batch, MrBFlt *tuningParameter, MrBFlt minTuning, MrBFlt maxTuning); /* struct holding info on each move type that the program handles */ typedef struct { MoveFxn *moveFxn; /* pointer to the move function */ ApplicFxn *isApplicable; /* pointer to function determining whether move is applicable to a parameter */ int nApplicable; /* number of relevant params */ int applicableTo[40]; /* pointer to ID of relevant params */ char *name; /* name of the move type */ char *shortName; /* abbreviated name of the move type */ char *paramName; /* name of subparameter if complex parameter */ int subParams; /* are we changing subparams (brlens of topol.) */ char *tuningName[3]; /* name of tuning params */ char *shortTuningName[3];/* short name of tuning params */ MrBFlt relProposalProb; /* default relative proposal probability */ int numTuningParams; /* number of tuning parameters */ MrBFlt tuningParam[3]; /* default tuning parameters for the proposal */ MrBFlt minimum[3]; /* minimum values for tuning params */ MrBFlt maximum[3]; /* maximum values for tuning params */ int parsimonyBased; /* this move is based on parsimony (YES/NO) */ int level; /* user level of this move */ AutotuneFxn *Autotune; /* pointer to the autotuning function */ MrBFlt targetRate; /* default target acceptance rate for autotuning */ } MoveType; /* max number of move types */ #define NUM_MOVE_TYPES 100 /* struct holding info on each move */ /* Note: This allows several different moves to affect the same parameter */ /* It also allows the same move to affect different parameters as before */ /* This is also a good place to keep the proposal probs */ typedef struct { char *name; /* name of the move */ MoveType *moveType; /* pointer to the move type */ MoveFxn *moveFxn; /* pointer to the move function */ Param *parm; /* ptr to parameter the move applies to */ MrBFlt *relProposalProb; /* the relative proposal probability */ MrBFlt *cumProposalProb; /* the cumulative proposal probability */ int *nAccepted; /* number of accepted moves */ int *nTried; /* number of tried moves */ int *nBatches; /* counter for autotuning rounds */ int *nTotAccepted; /* total number of accepted moves */ int *nTotTried; /* total number of tried moves */ MrBFlt *targetRate; /* target acceptance rate for autotuning */ MrBFlt *lastAcceptanceRate;/* acceptance rate in last complete batch */ MrBFlt **tuningParam; /* tuning parameters for the move */ } MCMCMove; typedef int (*LikeDownFxn)(TreeNode *, int, int); typedef int (*LikeRootFxn)(TreeNode *, int, int); typedef int (*LikeScalerFxn)(TreeNode *, int, int); typedef int (*LikeFxn)(TreeNode *, int, int, MrBFlt *, int); typedef int (*TiProbFxn)(TreeNode *, int, int); typedef int (*LikeUpFxn)(TreeNode *, int, int); typedef int (*PrintAncStFxn)(TreeNode *, int, int); typedef int (*StateCodeFxn) (int); typedef int (*PrintSiteRateFxn) (TreeNode *, int, int); typedef struct cmdtyp { int cmdNumber; char *string; int specialCmd; CmdFxn cmdFxnPtr; short numParms; short parmList[50]; int expect; char *cmdDescription; int cmdUse; int hiding; } CmdType; typedef struct parm { char *string; /* parameter name */ char *valueList; /* list of values that could be input */ ParmFxn fp; /* function pointer */ } ParmInfo, *ParmInfoPtr; typedef struct model { int dataType; /* data type for partition */ int nStates; /* number of states for this type of data */ int codon[64]; /* gives protein ID for each codon */ int codonNucs[64][3]; /* gives triplet for each codon */ int codonAAs[64]; /* gives protein ID for implemented code */ char nucModel[100]; /* nucleotide model used */ char nst[100]; /* number of substitution types */ char parsModel[100]; /* use the (so-called) parsimony model */ char geneticCode[100]; /* genetic code used */ char coding[100]; /* type of patterns encoded */ char ploidy[100]; /* ploidy level */ char omegaVar[100]; /* type of omega variation model */ char ratesModel[100]; /* rates across sites model */ int numGammaCats; /* number of categories for gamma approximation */ char useGibbs[100]; /* flags whether Gibbs sampling of discrete gamma is used */ int gibbsFreq; /* frequency of Gibbs resampling of discrete gamma */ int numBetaCats; /* number of categories for beta approximation */ int numM10GammaCats; /* number of cats for gamma approx (M10 model) */ int numM10BetaCats; /* number of cats for beta approx (M10 model) */ char covarionModel[100];/* use covarion model? (yes/no) */ char augmentData[100]; /* should data be augmented */ char tRatioPr[100]; /* prior for ti/tv rate ratio */ MrBFlt tRatioFix; MrBFlt tRatioDir[2]; char revMatPr[100]; /* prior for GTR model */ MrBFlt revMatFix[6]; MrBFlt revMatDir[6]; MrBFlt revMatSymDir; /* prior for mixed GTR subspace model */ char aaModelPr[100]; /* prior for amino acid model */ char aaModel[100]; MrBFlt aaModelPrProbs[10]; char aaRevMatPr[100]; /* prior for aa GTR model */ MrBFlt aaRevMatFix[190]; MrBFlt aaRevMatDir[190]; char omegaPr[100]; /* prior for omega */ MrBFlt omegaFix; MrBFlt omegaDir[2]; char ny98omega1pr[100]; /* prior for class 1 omega (Ny98 model) */ MrBFlt ny98omega1Fixed; MrBFlt ny98omega1Beta[2]; char ny98omega3pr[100]; /* prior for class 3 omega (Ny98 model) */ MrBFlt ny98omega3Fixed; MrBFlt ny98omega3Uni[2]; MrBFlt ny98omega3Exp; char m3omegapr[100]; /* prior for all three omegas (M3 model) */ MrBFlt m3omegaFixed[3]; char m10betapr[100]; /* prior for omega variation (M10 model) */ char m10gammapr[100]; MrBFlt m10betaExp; MrBFlt m10betaUni[2]; MrBFlt m10betaFix[2]; MrBFlt m10gammaExp; MrBFlt m10gammaUni[2]; MrBFlt m10gammaFix[2]; char codonCatFreqPr[100];/* prior for selection cat frequencies */ MrBFlt codonCatFreqFix[3]; MrBFlt codonCatDir[3]; char stateFreqPr[100]; /* prior for character state frequencies */ MrBFlt stateFreqsFix[200]; MrBFlt stateFreqsDir[200]; char stateFreqsFixType[100]; int numDirParams; char shapePr[100]; /* prior for gamma shape parameter */ MrBFlt shapeFix; MrBFlt shapeUni[2]; MrBFlt shapeExp; char pInvarPr[100]; /* prior for proportion of invariable sites */ MrBFlt pInvarFix; MrBFlt pInvarUni[2]; char adGammaCorPr[100]; /* prior for correlation param of adGamma model */ MrBFlt corrFix; MrBFlt corrUni[2]; char covSwitchPr[100]; /* prior for switching rates of covarion model */ MrBFlt covswitchFix[2]; MrBFlt covswitchUni[2]; MrBFlt covswitchExp; char symPiPr[100]; /* prior for pi when unidentifiable states used */ MrBFlt symBetaFix; MrBFlt symBetaUni[2]; MrBFlt symBetaExp; char ratePr[100]; /* prior on rate for a partition */ MrBFlt ratePrDir; char brownCorPr[100]; /* prior for correlation of Brownian model */ MrBFlt brownCorrFix; MrBFlt brownCorrUni[2]; char brownScalesPr[100];/* prior for scales of Brownian model */ MrBFlt brownScalesFix; MrBFlt brownScalesUni[2]; MrBFlt brownScalesGamma[2]; MrBFlt brownScalesGammaMean; char topologyPr[100]; /* prior for tree topology */ int topologyFix; /* user tree index for fixed topology */ int *activeConstraints;/* which constraints are active? */ int numActiveConstraints; int numActiveLocks; char brlensPr[100]; /* prior on branch lengths */ int brlensFix; /* user tree index for fixed brlens */ MrBFlt brlensUni[2]; MrBFlt brlensExp; char speciesTreeBrlensPr[100]; /* prior on branch lengths of species tree */ char unconstrainedPr[100]; /* prior on branch lengths if unconstrained */ char clockPr[100]; /* prior on branch if clock enforced */ char clockVarPr[100]; /* prior on clock rate variation (strict, cpp, mb(rateautocorr)) */ char nodeAgePr[100]; /* prior on node depths (unconstrained, constraints) */ char speciationPr[100]; /* prior on speciation rate */ MrBFlt speciationFix; MrBFlt speciationUni[2]; MrBFlt speciationExp; char extinctionPr[100]; /* prior on extinction rate */ MrBFlt extinctionFix; MrBFlt extinctionBeta[2]; MrBFlt extinctionExp; char sampleStrat[30]; /* taxon sampling strategy (for b-d process) */ MrBFlt sampleProb; /* taxon sampling fraction (for b-d process) */ char treeAgePr[100]; /* prior on tree age for uniform clock prior */ MrBFlt treeAgeGamma[2]; MrBFlt treeAgeExp; MrBFlt treeAgeFix; char clockRatePr[100]; /* prior on base substitution rate of tree for clock trees */ MrBFlt clockRateNormal[2]; MrBFlt clockRateLognormal[2]; MrBFlt clockRateGamma[2]; MrBFlt clockRateExp; MrBFlt clockRateFix; char popSizePr[100]; /* prior on population size */ MrBFlt popSizeFix; MrBFlt popSizeUni[2]; MrBFlt popSizeLognormal[2]; MrBFlt popSizeGamma[2]; MrBFlt popSizeNormal[2]; char popVarPr[100]; /* prior on pop. size variation across tree */ char growthPr[100]; /* prior on coalescence growth rate */ MrBFlt growthFix; MrBFlt growthUni[2]; MrBFlt growthExp; MrBFlt growthNorm[2]; char cppRatePr[100]; /* prior on CPP rate */ MrBFlt cppRateFix; MrBFlt cppRateExp; char cppMultDevPr[100]; /* prior on CPP rate multiplier Lognormal variance */ MrBFlt cppMultDevFix; char tk02varPr[100]; /* prior on TK02 lognormal rate variance */ MrBFlt tk02varFix; MrBFlt tk02varUni[2]; MrBFlt tk02varExp; char igrvarPr[100]; /* prior on IGR gamma distribution variance */ MrBFlt igrvarFix; MrBFlt igrvarUni[2]; MrBFlt igrvarExp; char tratioFormat[30]; /* format used to report tratio */ char revmatFormat[30]; /* format used to report revmat */ char ratemultFormat[30]; /* format used to report ratemult */ char treeFormat[30]; /* format used to report trees/topologies */ char inferAncStates[5]; /* should ancestral states be inferred (Yes/No)?*/ char inferSiteOmegas[5]; /* should site omega vals be inferred (Yes/No)? */ char inferSiteRates[5]; /* should site rates be inferred (Yes/No)? */ char inferPosSel[5]; /* should site selection be inferred (Yes/No)? */ } Model, ModelParams; typedef struct chain { int numGen; /* number of MCMC cycles */ int sampleFreq; /* frequency to sample chain */ int printFreq; /* frequency to print chain */ int swapFreq; /* frequency to attempt swap of states */ int numRuns; /* number of runs */ int numChains; /* number of chains */ int isSS; /* do we do Steppingstone Sampling */ int startFromPriorSS; /* If Yes SS is moving from Prior to Posterior */ int numStepsSS; /* Number of steps in SS */ int burninSS; /* Fixed burnin for SS */ MrBFlt alphaSS; /* Beta values are distributed according to quantiles of Beta(alphaSS,1.0) distribution */ int backupCheckSS; /* Frequency of checkpoints backup */ MrBFlt chainTemp; /* chain temperature */ int userDefinedTemps; /* should we use the users temperatures? */ MrBFlt userTemps[MAX_CHAINS]; /* user-defined chain temperatures */ char chainFileName[100]; /* chain file name for output */ int chainBurnIn; /* chain burn in length */ int numStartPerts; /* number of perturbations to starting tree */ char startTree[100]; /* starting tree for chain (current/random) */ char startParams[100]; /* starting values for chain (current/reset) */ int saveBrlens; /* should branch lengths be saved */ MrBFlt weightScheme[3]; /* percent chars to increase/decrease in weight */ int calcPbf; /* should we calculate the pseudo Bayes factor */ int pbfInitBurnin; /* initial burnin when calculating pseudo BF */ int pbfSampleFreq; /* sample frequency for pseudo BF */ int pbfSampleTime; /* how many cycles to calcualate site prob. */ int pbfSampleBurnin; /* burnin period for each site for pseudo BF */ int swapAdjacentOnly; /* whether we only swap adjacent temperatures */ int redirect; /* should output go to stdout */ int allChains; /* should stats be output for all chains? */ int numSwaps; /* number of swaps to try each time */ int mcmcDiagn; /* should mcmc diagnostics be output? */ int diagnFreq; /* mcmc diagnostics frequency */ int diagnStat; /* statistic to use for mcmc diagnostics */ int relativeBurnin; /* should a relative burnin be used ? */ MrBFlt burninFraction; /* the sample fraction to discard as burnin */ int allComps; /* top conv diagnosis for all pairs? */ MrBFlt minPartFreq; /* minimum partition frequency for conv diagn */ MrBFlt stopVal; /* top conv diagn value to reach before stopping */ int stopRule; /* use stop rule? */ STATS *stat; /* ptr to structs with mcmc diagnostics info */ Tree *dtree; /* pointing to tree used for conv diagnostics */ TreeList *treeList; /* vector of tree lists for saving trees */ int saveTrees; /* save tree samples for later removal? */ int stopTreeGen; /* generation after which no trees need be saved */ fpos_t *tFilePos; /* position for reading trees for removal */ int printMax; /* maximum number of chains to print */ int printAll; /* whether to print all or only cold chains */ int checkPoint; /* should we use check-pointing? */ int checkFreq; /* check-pointing frequency */ int runWithData; /* should we run with or without data? */ int orderTaxa; /* order taxa before printing tree to file? */ int append; /* order taxa before printing tree to file? */ int autotune; /* autotune tuning parameters of proposals ? */ int tuneFreq; /* autotuning frequency */ } Chain; typedef struct modelinfo { /* General model information */ int dataType; /* data type for partition */ int nucModelId; /* structure of nucleotide model */ int nst; /* # substitution types */ int aaModelId; /* amino acid model type */ int parsModelId; /* is parsimony model used YES/NO */ /* Specific model information */ int numGammaCats; /* number of gamma cats (1 if inapplic.) */ int numBetaCats; /* number of beta cats (1 if inapplic.) */ int numOmegaCats; /* number of omega cats (1 if inapplic.) */ int numTiCats; /* number of cats needing different tis */ int numModelStates; /* number of states including hidden ones */ int numStates; /* number of observable discrete states */ /* Model parameter pointers */ Param *tRatio; /* ptr to tRatio used in model */ Param *revMat; /* ptr to revMat used in model */ Param *omega; /* ptr to omega used in model */ Param *stateFreq; /* ptr to statFreq used in model */ Param *shape; /* ptr to shape used in model */ Param *pInvar; /* ptr to pInvar used in model */ Param *correlation; /* ptr to correlation used in model */ Param *switchRates; /* ptr to switchRates (off<->on) */ Param *rateMult; /* ptr to parition rateMult used in model */ Param *geneTreeRateMult; /* ptr to gene tree rateMult used in model */ Param *speciationRates; /* ptr to speciationRates used in model */ Param *extinctionRates; /* ptr to extinctionRates used in model */ Param *popSize; /* ptr to population size used in model */ Param *growthRate; /* ptr to growth rate used in model */ Param *topology; /* ptr to topology used in model */ Param *brlens; /* ptr to brlens (and tree) used in model */ Param *speciesTree; /* ptr to species tree used in model */ Param *aaModel; /* ptr to amino acid matrix used */ Param *cppMultDev; /* ptr to cpp ratemult lognormal variance */ Param *cppRate; /* ptr to CPP rate used in model */ Param *cppEvents; /* ptr to CPP events */ Param *tk02var; /* ptr to variance for TK02 relaxed clock */ Param *tk02BranchRates; /* ptr to branch rates for TK02 relaxed clock */ Param *igrvar; /* ptr to gamma var for IGR relaxed clock */ Param *igrBranchRates; /* ptr to branch rates for IGR relaxed clock*/ Param *clockRate; /* ptr to clock rate parameter */ /* Information about characters and transformations */ int numChars; /* number of compressed characters */ int numUncompressedChars; /* number of uncompressed characters */ int numDummyChars; /* number of dummy characters */ int compMatrixStart; /* start column in compressed matrix */ int compMatrixStop; /* stop column in compressed matrix */ int compCharStart; /* start char among compressed chars */ int compCharStop; /* stop char among compressed chars */ int parsMatrixStart; /* start column in parsimony matrix */ int parsMatrixStop; /* stop collumn in parsimony matrix */ int nParsIntsPerSite; /* # parsimony ints per character */ int nCharsPerSite; /* number chars per site (eg 3 for codon) */ int rateProbStart; /* start of rate probs (for adgamma) */ /* Variables for eigen decompositions */ int cijkLength; /* stores length of cijk vector */ int nCijkParts; /* stores number of cijk partitions (1 except for omega/covarion models) */ int upDateCijk; /* whether cijk vector needs to be updated */ /* Variables for standard model */ int *tiIndex; /* index to trans probs for each compressed char*/ int *bsIndex; /* index to stat freqs for each compressed char */ int *nStates; /* # states of each compressed char */ int *cType; /* whether char is ord, unord or irrev */ int *weight; /* prior weight of each compressed char */ int isTiNeeded[20]; /* marks whether a trans prob matrix is needed */ /* Gibbs sampling of gamma site rate parameters */ CLFlt ***catLike; /* likelihood for Gibbs sampling of gamma */ CLFlt ***catLnScaler; /* scaler for Gibbs sampling of gamma */ int gibbsGamma; /* flags whether Gibbs sampling of discrete gamma is used */ int gibbsFreq; /* frequency of Gibbs resampling of discrete gamma */ /* Variables for parsimony sets and parsimony calculations */ MrBFlt parsTreeLength[MAX_CHAINS*2]; /* parsimony tree lengths for chains */ SafeLong **parsSets; /* parsimony sets */ int numParsSets; /* number of parsimony sets */ CLFlt *parsNodeLens; /* parsimony node lengths */ int numParsNodeLens; /* number of parsimony node lengths */ /* Miscellaneous parameters */ int mark; /* scratch parameter */ int parsimonyBasedMove; /* is parsimony-based move used (YES/NO) */ /* Variables for conditional likelihoods */ int upDateCl; /* flags whether update of cond likes needed */ int upDateAll; /* flags whether update of entire tree is needed*/ int *isPartAmbig; /* is tip partially ambiguous? */ int **termState; /* index arrays for terminal branch shortcuts */ CLFlt *invCondLikes; /* space for the invariable cond likes */ CLFlt **condLikes; /* space for the cond likes */ CLFlt **tiProbs; /* space for the ti probs */ CLFlt **scalers; /* space for the node and site scalers */ CLFlt **clP; /* handy pointers to cond likes for ti cats */ #if defined (SSE_ENABLED) __m128 **clP_SSE; /* handy pointers to cond likes, SSE version */ int numSSEChars; /* number of compact SSE character groups */ CLFlt *lnL_SSE; /* temp storage for log site likes */ CLFlt *lnLI_SSE; /* temp storage for log site invariable likes */ #endif MrBFlt **cijks; /* space for cijks */ int **condLikeIndex; /* index to cond like space for nodes & chains */ int *condLikeScratchIndex; /* index to scratch space for node cond likes */ int **nodeScalerIndex; /* index to scaler space for nodes & chains */ int *nodeScalerScratchIndex; /* index to scratch space for node scalers */ int **scalersSet; /* flags whether scalers are set */ int *scalersSetScratch; /* scratch flag for whether scalers are set */ int *siteScalerIndex; /* index to site scaler space for chains */ int siteScalerScratchIndex; /* index to scratch space for site scalers */ int **tiProbsIndex; /* index to ti probs for branches & chains */ int *tiProbsScratchIndex; /* index to scratch space for branch ti probs */ int *cijkIndex; /* index to cijks for chains */ int cijkScratchIndex; /* index to scratch space for cijks */ int numCondLikes; /* number of cond like arrays */ int numScalers; /* number of scaler arrays */ int numTiProbs; /* number of ti prob arrays */ int condLikeLength; /* length of cond like array (incl. ti cats) */ int tiProbLength; /* length of ti prob array */ MrBFlt lnLike[MAX_CHAINS]; /* log like for chain */ CLFlt *ancStateCondLikes; /* ancestral state cond like array */ /* Likelihood function pointers */ LikeDownFxn CondLikeDown; /* function for calculating partials */ LikeRootFxn CondLikeRoot; /* function for calculating partials at root */ LikeScalerFxn CondLikeScaler; /* function for scaling partials */ LikeFxn Likelihood; /* function for getting cond likes for tree */ TiProbFxn TiProbs; /* function for calculating transition probs */ LikeUpFxn CondLikeUp; /* final-pass calculation of cond likes */ PrintAncStFxn PrintAncStates; /* function for sampling ancestral states */ StateCodeFxn StateCode; /* function for getting states from codes */ PrintSiteRateFxn PrintSiteRates; /* function for samling site rates */ /* Report variables */ int printAncStates; /* should ancestral states be printed (YES/NO) */ int printSiteRates; /* should site rates be printed (YES/NO) */ int printPosSel; /* should selection be printed (YES/NO) */ int printSiteOmegas; /* should site omegas be printed (YES/NO) */ /* likelihood calculator flags */ int useBeagle; /* use Beagle for this partition? */ int useSSE; /* use SSE for this partition? */ #if defined (BEAGLE_ENABLED) /* Beagle variables */ int useBeagleResource; /* try to use this BEAGLE resource number */ MrBFlt* branchLengths; /* array of branch lengths for Beagle */ MrBFlt* inRates; /* array of category rates for Beagle */ int* tiProbIndices; /* array of trans prob indices for Beagle */ MrBFlt* logLikelihoods; /* array of log likelihoods from Beagle */ int beagleInstance; /* beagle instance for division */ MrBFlt* inWeights; /* array of weights for Beagle root likelihood */ int* bufferIndices; /* array of partial indices for root likelihood */ int* eigenIndices; /* array of eigen indices for root likelihood */ int* childBufferIndices; /* array of child partial indices (unrooted) */ int* childTiProbIndices; /* array of child ti prob indices (unrooted) */ int* cumulativeScaleIndices; /* array of cumulative scale indices */ int rescaleBeagleAll; /* set to rescale all nodes */ int* rescaleFreq; /* rescale frequency for each chain's tree */ int rescaleFreqOld; /* holds rescale frequency of current state */ int recalculateScalers; /* shoud we recalculate scalers for current state YES/NO */ int* succesCount; /* count number of succesful computation since last reset of scalers */ int** isScalerNode; /* for each node and chain set to YES if scaled node */ int* isScalerNodeScratch; /* scratch space to hold isScalerNode of proposed state*/ long* beagleComputeCount; /* count of number of calls to likelihood */ #endif } ModelInfo; /* TODO: Delete these old pointers to cond likes, ti probs and scalers */ typedef struct sumt { int *absentTaxa; /* information on absent taxa */ int brlensDef; /* branch lengths defined? */ char sumtFileName[100]; /* name of input file */ char sumtOutfile[120]; /* name of output file */ char curFileName[120]; /* name of file being processed */ int burnin; /* actual burnin when parsing tree files */ char sumtConType[100]; /* consensus tree type */ int calcTreeprobs; /* should the individual tree probs be calculated*/ int showSumtTrees; /* should the individual tree probs be shown */ int printBrlensToFile; /* should branch lengths be printed to file */ MrBFlt brlensFreqDisplay; /* threshold for printing branch lengths to file */ int numRuns; /* number of independent analyses to summarize */ int numTrees; /* number of tree params to summarize */ int orderTaxa; /* order taxa in trees? */ MrBFlt minPartFreq; /* minimum part. freq. for overall diagnostics */ int table; /* show table of partition frequencies? */ int summary; /* show summary diagnostics ? */ int showConsensus; /* show consensus trees ? */ int consensusFormat; /* format of consensus tree */ PolyTree *tree; /* for storing tree read from file */ int *order; /* for storing topology read from file */ int orderLen; /* length of order array */ int numTreesInLastBlock; /* number of trees in last block */ int numTreesEncountered; /* number of trees encounted in total */ int numTreesSampled; /* number of sampled trees in total */ int isRooted; /* is sumt tree rooted ? */ int isRelaxed; /* is sumt tree a relaxed clock tree ? */ int isClock; /* is sumt tree a clock tree ? */ int isCalibrated; /* is sumt tree calibrated ? */ int nESets; /* number of event sets */ int nBSets; /* number of branch rate sets */ char **bSetName; /* name of effective branch length sets */ char **eSetName; /* name of event sets */ int popSizeSet; /* do sumt trees have population size set? */ char *popSizeSetName; /* name of population size set */ int SafeLongsNeeded; /* number of safe longs needed for taxon bits */ int runId; /* id of run being processed */ int numTaxa; /* number of sumt taxa */ char **taxaNames; /* names of sumt taxa */ int *numFileTrees; /* number of trees per file */ int *numFileTreesSampled; /* number of trees sampled per file */ int HPD; /* use highest posterior density? */ } Sumt; /* formats for consensus trees */ #define SIMPLE 0 #define FIGTREE 1 typedef struct comptree { char comptFileName1[120]; /* name of first input file */ char comptFileName2[120]; /* name of second input file */ char comptOutfile[120]; /* name of output file */ int burnin; /* actual burnin used when parsing tree files */ MrBFlt minPartFreq; /* use partitions with frequency >= minPartFreq */ } Comptree; typedef struct sump { char sumpFileName[100]; /* name of input file */ char sumpOutfile[120]; /* name of output file */ //int plot; /* output plot (y/n)? */ int table; /* output table (y/n)? */ int margLike; /* output marginal likelihood (y/n)? */ int numRuns; /* number of independent analyses to summarize */ int allRuns; /* should data for all runs be printed (yes/no)? */ int HPD; /* use highest posterior density? */ MrBFlt minProb; /* cut-off for model probabilities to show */ } Sump; typedef struct sumss { //int plot; /* output plot (y/n)? */ int numRuns; /* number of independent analyses to summarize */ int allRuns; /* should data for all runs be printed (yes/no)? */ int stepToPlot; /* Which step to plot in the step plot */ int askForMorePlots; /* Should user be asked to plot for different discardfraction (y/n)? */ int smoothing; /* An integer indicating number of neighbors to average over when dooing smoothing of curvs on plots */ MrBFlt discardFraction; /* Proportion of samples discarded when ploting step plot.*/ } Sumss; typedef struct plot { char plotFileName[120]; /* name of input file */ char parameter[100]; /* parameter(s) to be plotted */ char match[100]; /* whether the match needs to be perfect */ } Plot; typedef struct { int numTrees; /* number of trees to reassemble */ int numRuns; /* number of runs to reassemble */ } ReassembleInfo; typedef struct doublet { SafeLong first, second; } Doublet; typedef struct matrix { SafeLong *origin; int rowSize; int nRows; int column; int row; } Matrix; typedef struct charinfo { int dType; int cType; int nStates; int constant[10]; int variable; int informative; } CharInfo; typedef struct { int isExcluded; /* is the character excluded */ int numStates; /* number of observed states for the character */ int charType; /* type of character */ int isMissAmbig; /* is the character missing or ambiguous */ int ctype; /* ordering of character */ int charId; /* char ID index for doublet and codon models */ int pairsId; /* char ID for doublets */ int bigBreakAfter; /* is there a large break after this character */ } CharInformation; typedef struct { int isDeleted; /* is the taxon deleted */ int charCount; /* count holder */ } TaxaInformation; typedef struct { MrBFlt curScore; MrBFlt minScore; MrBFlt totalScore; MrBFlt stopScore; MrBFlt warp; TreeNode **leaf; TreeNode **vertex; } TreeInfo; typedef struct { int allavailable; } ShowmovesParams; typedef struct { int numNames; char **names; } NameSet; #endif