enbid-ananke 0.3.0__cp310-cp310-manylinux_2_39_x86_64.whl

enbid_ananke/Enbid-2.0/src/ngb_search.h

@@ -0,0 +1,35 @@
+/***************************************************************************
+                          tree_search.cpp  -  description
+                             -------------------
+    begin                : Mon Jan 16 2006
+    copyright            : (C) 2006 by Sanjib Sharma
+    email                : ssharma@aip.de
+***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+void ngb_treesearch_sphere_metric(int no,struct NODE *nodes1, int NumBucket, int DesNumNgb,struct pqueue* pqxA,bool* imarkA);
+void ngb_treesearch_sphere_metric_periodic(int no,struct NODE *nodes1, int NumBucket, int DesNumNgb,struct pqueue* pqxA,bool* imarkA);
+void ngb_treesearch_sphere_gmatrix(int no,struct NODE *nodes1, int NumBucket, int DesNumNgb,struct pqueue* pqxA,bool * imarkA);
+void ngb_treesearch_sphere_nometric(int no, struct NODE* nodes1,int NumBucket, int DesNumNgb,struct pqueue* pqxA,bool * imarkA);
+void ngb_treesearch_box_metric(int no,struct NODE *nodes1, int NumBucket, int DesNumNgb,struct pqueue* pqxA, bool * imarkA);
+float  ngb_treedensity_sphere_metric(float xyz[ND],struct NODE *nodes1, int desngb, struct pqueue* pqxA, struct linklist* pqStartA, bool *idoneA,bool *imarkA);
+float  ngb_treedensity_sphere_metric_periodic(float xyz[ND],struct NODE *nodes1, int desngb, struct pqueue* pqxA, struct linklist* pqStartA, bool *idoneA,bool *imarkA);
+float  ngb_treedensity_sphere_nometric(float xyz[ND],struct NODE *nodes1, int desngb, struct pqueue* pqxA, struct linklist* pqStartA, bool *idoneA,bool *imarkA);
+float  ngb_treedensity_box_metric(float xyz[ND],struct NODE *nodes1, int desngb, struct pqueue* pqxA, struct linklist* pqStartA, bool *idoneA,bool *imarkA);
+float  ngb_treedensity_sphere_gmatrix(float xyz[ND],struct NODE *nodes1, int desngb, struct pqueue* pqxA, struct linklist* pqStartA, bool *idoneA,bool *imarkA);
+float anisokernel_density(float xyz[ND],struct NODE *nodes1, int desngbA, struct pqueue* pqxA, struct linklist* pqStartA, bool *idoneA,bool *imarkA, int desngbB, struct pqueue* pqxB, struct linklist* pqStartB, bool *idoneB,bool *imarkB);
+void create_linklist(struct pqueue* &pqx,struct linklist* &pqStart,bool* &imark,bool* &idone,int desngb,int numpart);
+void initialize_linklist(struct linklist* pqStart,bool* imark,int iStart,int desngb,int numpart);
+float density_general(float xyz[ND],struct NODE *nodes1, int desngbA, struct pqueue* pqxA, struct linklist* pqStartA, bool *idoneA,bool *imarkA, int desngbB, struct pqueue* pqxB, struct linklist* pqStartB, bool *idoneB,bool *imarkB);
+void print_list(struct linklist *pq1,int size1);
+float  ngb_treedensity_bruteforce(float xyz[ND], int parttype,int desngb, struct pqueue* pqxA, struct linklist* pqStartA);
+
+
+

enbid_ananke/Enbid-2.0/src/nr.cpp

@@ -0,0 +1,186 @@
+/* Numerical recipies Shapiro, Teukolsky */ 
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <math.h>
+#include "nr.h"
+
+#define NR_END 1
+#define FREE_ARG char*
+
+
+void nrerror(char error_text[])
+    /* Numerical Recipes standard error handler */
+{
+    fprintf(stderr,"Numerical Recipes run-time error...\n");
+    fprintf(stderr,"%s\n",error_text);
+    fprintf(stderr,"...now exiting to system...\n");
+    exit(1);
+}
+
+float *fvector(long nl, long nh)
+    /* allocate a float vector with subscript range v[nl..nh] */
+{
+    float *v;
+  
+    v=(float *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(float)));
+    if (!v) nrerror("allocation failure in vector()");
+    return v-nl+NR_END;
+}
+
+int *ivector(long nl, long nh)
+    /* allocate an int vector with subscript range v[nl..nh] */
+{
+    int *v;
+  
+    v=(int *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(int)));
+    if (!v) nrerror("allocation failure in ivector()");
+    return v-nl+NR_END;
+}
+
+
+float **matrix(long nrl, long nrh, long ncl, long nch)
+    /* allocate a float matrix with subscript range m[nrl..nrh][ncl..nch] */
+{
+    long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
+    float **m;
+  
+  
+    /* allocate pointers to rows */
+    m=(float **) malloc((size_t)((nrow+NR_END)*sizeof(float*)));
+    if (!m) nrerror("allocation failure 1 in matrix()");
+    m += NR_END;
+    m -= nrl;
+  
+    /* allocate rows and set pointers to them */
+    m[nrl]=(float *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(float)));
+    if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
+    m[nrl] += NR_END;
+    m[nrl] -= ncl;
+  
+    for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
+  
+    /* return pointer to array of pointers to rows */
+    return m;
+}
+
+
+void free_fvector(float *v, long nl, long nh)
+    /* free a float vector allocated with vector() */
+{
+  
+    free((FREE_ARG) (v+nl-NR_END));
+}
+
+void free_ivector(int *v, long nl, long nh)
+    /* free an int vector allocated with ivector() */
+{
+  
+    free((FREE_ARG) (v+nl-NR_END));
+}
+
+
+void free_matrix(float **m, long nrl, long nrh, long ncl, long nch)
+    /* free a float matrix allocated by matrix() */
+{
+  
+    free((FREE_ARG) (m[nrl]+ncl-NR_END));
+    free((FREE_ARG) (m+nrl-NR_END));
+}
+
+
+void free_imatrix(int **m, long nrl, long nrh, long ncl, long nch)
+    /* free an int matrix allocated by imatrix() */
+{
+  
+    free((FREE_ARG) (m[nrl]+ncl-NR_END));
+    free((FREE_ARG) (m+nrl-NR_END));
+}
+
+
+
+#define ROTATE(a,i,j,k,l) g=a[i][j];h=a[k][l];a[i][j]=g-s*(h+g*tau);\
+a[k][l]=h+s*(g-h*tau);
+
+void jacobi(float **a, int n, float d[], float **v, int *nrot)
+{
+    int j,iq,ip,i;
+    float tresh,theta,tau,t,sm,s,h,g,c,*b,*z;
+  
+    b=fvector(1,n);
+    z=fvector(1,n);
+    for (ip=1;ip<=n;ip++) {
+	for (iq=1;iq<=n;iq++) v[ip][iq]=0.0;
+	v[ip][ip]=1.0;
+    }
+    for (ip=1;ip<=n;ip++) {
+	b[ip]=d[ip]=a[ip][ip];
+	z[ip]=0.0;
+    }
+    *nrot=0;
+    for (i=1;i<=50;i++) {
+	sm=0.0;
+	for (ip=1;ip<=n-1;ip++) {
+	    for (iq=ip+1;iq<=n;iq++)
+		sm += fabs(a[ip][iq]);
+	}
+	if (sm == 0.0) {
+	    free_fvector(z,1,n);
+	    free_fvector(b,1,n);
+	    return;
+	}
+	if (i < 4)
+	    tresh=0.2*sm/(n*n);
+	else
+	    tresh=0.0;
+	for (ip=1;ip<=n-1;ip++) {
+	    for (iq=ip+1;iq<=n;iq++) {
+		g=100.0*fabs(a[ip][iq]);
+		if (i > 4 && (float)(fabs(d[ip])+g) == (float)fabs(d[ip])
+		    && (float)(fabs(d[iq])+g) == (float)fabs(d[iq]))
+		    a[ip][iq]=0.0;
+		else if (fabs(a[ip][iq]) > tresh) {
+		    h=d[iq]-d[ip];
+		    if ((float)(fabs(h)+g) == (float)fabs(h))
+			t=(a[ip][iq])/h;
+		    else {
+			theta=0.5*h/(a[ip][iq]);
+			t=1.0/(fabs(theta)+sqrt(1.0+theta*theta));
+			if (theta < 0.0) t = -t;
+		    }
+		    c=1.0/sqrt(1+t*t);
+		    s=t*c;
+		    tau=s/(1.0+c);
+		    h=t*a[ip][iq];
+		    z[ip] -= h;
+		    z[iq] += h;
+		    d[ip] -= h;
+		    d[iq] += h;
+		    a[ip][iq]=0.0;
+		    for (j=1;j<=ip-1;j++) {
+			ROTATE(a,j,ip,j,iq)
+			    }
+		    for (j=ip+1;j<=iq-1;j++) {
+			ROTATE(a,ip,j,j,iq)
+			    }
+		    for (j=iq+1;j<=n;j++) {
+			ROTATE(a,ip,j,iq,j)
+			    }
+		    for (j=1;j<=n;j++) {
+			ROTATE(v,j,ip,j,iq)
+			    }
+		    ++(*nrot);
+		}
+	    }
+	}
+	for (ip=1;ip<=n;ip++) {
+	    b[ip] += z[ip];
+	    d[ip]=b[ip];
+	    z[ip]=0.0;
+	}
+    }
+    nrerror("Too many iterations in routine jacobi");
+}
+#undef ROTATE
+

enbid_ananke/Enbid-2.0/src/nr.h

@@ -0,0 +1,13 @@
+/* Numerical recipies Shapiro, Teukolsky */
+void nrerror(char error_text[]);
+float *fvector(long nl, long nh);
+void free_fvector(float *v, long nl, long nh);
+float **matrix(long nrl, long nrh, long ncl, long nch);
+void jacobi(float **a, int n, float d[], float **v, int *nrot);
+void free_matrix(float **m, long nrl, long nrh, long ncl, long nch);
+int *ivector(long nl, long nh);
+void free_ivector(int *v, long nl, long nh);
+
+
+
+

enbid_ananke/Enbid-2.0/src/proto.h

@@ -0,0 +1,22 @@
+void   allocate_memory(void);
+void   begrun(void);
+void   free_memory(void);
+void   init(void);
+void   read_ic0(char *fname);
+void   read_ic1(char *fname);
+void   read_ic2(char *fname);
+void   read_parameter_file(char *fname);
+void   savepositions(void );
+void   savepositions_ioformat2(void);
+void   savepositions_ioformat1(void);
+void   savepositions_ioformat0(void);
+void   set_sph_kernel(int TypeOfKernel, int dim);
+void density_par(void);
+size_t my_fwrite1(void *ptr,int* pattern,size_t nmemb,int flag_swap,FILE *stream);
+size_t my_fread1(void *ptr, int *pattern, size_t nmemb,int flag_swap,FILE *stream);
+void SwapEndian(void* addr, int* pattern);
+template <class type> void order_particles(type* P,int *Id,int Nmax, int reverse);
+void read_typelist(char *fname,vector<int> &npart, struct particle_data P[]);
+void read_periodic_lengths(char *fname,double boxh[ND]);
+
+

enbid_ananke/Enbid-2.0/src/read_ic.cpp

@@ -0,0 +1,434 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "allvars.h"
+#include "proto.h"
+#include<fstream>
+#include "functions.h"
+
+
+/* This function reads initial conditions that are in the default file format
+ * of Gadget or in ASCII format x[i] y[i] z[i].
+ */
+/* Read GADGET format file */
+void read_ic1(char *fname)
+{
+#define SKIP my_fread1(&blklen,patterns,1,All.flag_swap,fd);
+    FILE *fd;
+    int   i,k,massflag,count;
+    float dummy[3];
+    int   pc,type ;
+    int patternd[]={4,3,0},patterns[]={4,1,0},patternh[]={4,6,8,8,4,10,8,4,4,3,4,21,0};
+    int4byte  intdummy, blklen;
+    All.flag_swap=0;
+  
+  
+     if((ND!=3)&&(ND!=6))
+ 	endrunm("\nFor Gadget format file number of dimensions should be 3 or 6\n");
+
+  
+    if((fd=fopen(fname,"r")))
+    {
+	fprintf(stdout,"Reading GADGET format file: %s \n",fname); fflush(stdout);
+    
+	SKIP;
+	if(blklen!=256)
+	{
+	    All.flag_swap=1;
+	    SwapEndian(&blklen,patterns);
+	    if(blklen!=256)
+	    {
+		printf("incorrect header format (2)\n");
+		endrun(889);
+	    }
+	}
+
+	my_fread1(&header1,patternh,1,All.flag_swap,fd);
+
+
+	SKIP;
+	if(blklen!=256)
+	{
+	    printf("incorrect header format (2)\n");
+	    endrun(889);
+	}
+    
+//	All.BoxSize=header1.BoxSize;
+	for(i=0, massflag=0;i<6;i++)
+	{
+	    if(header1.mass[i]==0 && header1.npart[i]>0)
+		massflag=1;
+	}
+    
+    
+	for(i=0,NumPart=0;i<6;i++)
+	    NumPart+=header1.npart[i];
+
+	All.MaxPart = NumPart;    // sets the maximum number of particles 
+				    
+	allocate_memory();
+    
+	SKIP;
+	for(i=1;i<=NumPart;i++)
+	{
+	    my_fread1(&dummy[0],patternd,1,All.flag_swap,fd);
+		for(k=0;k<3;k++)
+		    P[i].Pos[k]=dummy[k];	
+	}
+	SKIP;
+    
+    
+	SKIP;
+	for(i=1;i<=NumPart;i++)
+	{
+	    my_fread1(&dummy[0],patternd,1,All.flag_swap,fd);
+#ifdef DIM3
+	    for(k=0;k<3;k++)
+		P[i].Vel[k]=dummy[k];
+#else
+	    if(ND>3)
+	    for(k=0;k<(ND-3);k++)
+		P[i].Pos[k+3]=dummy[k];
+#endif
+	}
+	SKIP;
+    
+    
+	SKIP;
+	for(i=1;i<=NumPart;i++)
+	{
+	    my_fread1(&intdummy, patterns, 1,All.flag_swap, fd);
+	    P[i].ID= intdummy;
+	}
+	SKIP;
+    
+    
+	if(massflag)
+	    SKIP;
+	for(type=0, count=1; type<6; type++)
+	{
+	    if(header1.mass[type]==0 && header1.npart[type]>0)
+	    {
+		k=count;
+		for(i=1;i<=header1.npart[type];i++)
+		{
+		    my_fread1(&dummy[0], patterns, 1,All.flag_swap, fd);
+		    P[count++].Mass=dummy[0];
+          
+		}
+        
+	    }
+	    else
+	    {
+		for(i=1;i<=header1.npart[type];i++)
+		{
+		    P[count++].Mass= header1.mass[type];
+		}
+	    }
+	}
+	if(massflag)
+	    SKIP;
+    
+	fclose(fd);
+	fprintf(stdout,"....done with reading.\n"); fflush(stdout);
+    
+
+	npart.clear();
+	npartc.clear();
+	for(i=0,k=0; i<6; i++)
+	{
+	    npart.push_back(header1.npart[i]);
+	    npartc.push_back(k);
+	    k+=npart[i];
+	}
+	/* set the particle types */
+	for(type=0, pc=1; type<6; type++)
+	    for(i=0; i<npart[type]; i++)
+		P[pc++].Type = type;
+
+    
+    }
+    else
+    {
+	fprintf(stdout,"File %s not found.\n", fname);
+	endrun(7);
+    }
+  
+    for(i=0; i<6; i++)
+	if(header1.npart[i]>0) cout<<"Type = "<<i<<" Particles = "<<header1.npart[i]<<endl;
+  
+    fprintf(stdout,"Total particles = %d\n", NumPart);
+  
+#undef SKIP    
+  
+}
+
+
+
+
+
+
+
+
+
+
+
+/* Read ASCII format file */
+void read_ic0(char *fname)
+{
+#define SKIP my_fread(&blklen,sizeof(int4byte),1,fd);
+    //  FILE *fd;
+    int   i,k,m=0;
+    float temp;
+    int   pc,type ;
+  
+    //  double u_init;
+    //  ofstream fd (fname);
+  
+  
+    ifstream fd;
+    fd.open(fname);
+    if (fd.is_open())
+    {
+	fprintf(stdout,"Reading ASCII format file: %s \n",fname); fflush(stdout);
+	m=0;
+	while(fd>>temp) m++;
+	if((m%ND)==0)
+	    cout<<"Read "<<m<<" records"<<endl;
+	else
+	{
+	    cout<<"File format incorrect expecting "<<m%ND<<" more records"<<endl;
+	    endrun(10);
+	}
+	fd.close();
+    }
+    else
+    {
+	fprintf(stdout,"File %s not found.\n", fname);
+	endrun(7);
+    }
+  
+    NumPart=m/ND;
+    All.MaxPart = NumPart;    // sets the maximum number of particles 
+				 
+    for(i=0;i<6;i++)
+    {
+	header1.npart[i]=0;
+	header1.npartTotal[i]=0;
+	header1.mass[i]=0;
+    }
+    header1.npart[1]=NumPart;
+    header1.mass[1]=1.0;
+    header1.npartTotal[1]=NumPart;
+  
+  
+    allocate_memory();
+  
+  
+    /* reading data */
+    ifstream fd1;
+    fd1.open(fname);
+    if (fd1.is_open())
+    {
+	for(i=1; i<=NumPart; i++) /*  start-up initialization */
+	{
+	    P[i].ID=i;
+	    for(k=0;k<ND;k++)
+		if(!(fd1>>P[i].Pos[k]))
+		{
+		    cout<<" file reading problem terminatiing"<<i<<" "<<k<<endl;
+		    //                endrun(10);
+		}
+	}
+	fd1.close();
+    }
+  
+    for(i=1; i<=NumPart; i++) /*  start-up initialization */
+	P[i].Mass=1.0;
+    /* set the particle types */
+	npart.clear();
+	npartc.clear();
+	for(i=0,k=0; i<6; i++)
+	{
+	    npart.push_back(header1.npart[i]);
+	    npartc.push_back(k);
+	    k+=npart[i];
+	}
+
+
+
+    for(type=0, pc=1; type<6; type++)
+	for(i=0; i<header1.npart[type]; i++)
+	    P[pc++].Type = type;
+  
+  
+    for(i=0; i<6; i++)
+	if(header1.npart[i]>0) cout<<"Type = "<<i<<" Particles = "<<header1.npart[i]<<endl;
+  
+    fprintf(stdout,"Total particles = %d\n", NumPart);
+  
+#undef SKIP  
+}
+
+/* write  a new reading routine */
+void read_ic2(char *fname)
+{
+  
+    int i,k,type,pc;
+    ifstream fd;
+    fd.open(fname);
+    if (fd.is_open())
+    {
+	fprintf(stdout,"Reading --- format file: %s \n",fname); fflush(stdout);
+	// read here
+
+	fd.close();
+    }
+    else
+	cout<<"Error opening file"<<endl;
+  
+    cout<<"Write your input routine here"<<endl;
+    endrun(10);
+  
+    //-------------------------------------
+    /* SPECIFY TOTAL NUMBER OF PARTICLES*/
+    NumPart=1;
+    //-------------------------------------
+  
+/* leave this unchanged */
+    All.MaxPart = NumPart;
+    for(i=0;i<6;i++)
+    {
+	header1.npart[i]=0;
+	header1.npartTotal[i]=0;
+	header1.mass[i]=0;
+    }
+    header1.npart[1]=NumPart;
+    header1.npartTotal[1]=NumPart;
+    allocate_memory();
+  
+    //-------------------------------------
+    /* READ THE DATA HERE AND ASSIGN IT TO P[i].Pos */
+    for(i=1; i<=NumPart; i++)
+	for(k=0;k<ND;k++)
+	    P[i].Pos[k]=1.0;
+    for(i=1; i<=NumPart; i++)
+    {
+	    P[i].ID=i;
+	P[i].Mass=1.0;
+    }
+    //-------------------------------------
+  
+  
+
+	npart.clear();
+	npartc.clear();
+	for(i=0,k=0; i<6; i++)
+	{
+	    npart.push_back(header1.npart[i]);
+	    npartc.push_back(k);
+	    k+=npart[i];
+	}
+
+
+
+    /* set the particle types */
+    for(type=0, pc=1; type<6; type++)
+	for(i=0; i<header1.npart[type]; i++)
+	    P[pc++].Type = type;
+  
+    for(i=0; i<6; i++)
+	if(header1.npart[i]>0) cout<<"Type = "<<i<<" Particles = "<<header1.npart[i]<<endl;
+    fprintf(stdout,"Total particles = %d\n", NumPart);
+  
+  
+  
+}
+
+
+
+
+
+
+
+/* Read typelist file */
+void read_typelist(char *fname,vector<int> &npart, struct particle_data P[])
+{
+    //  FILE *fd;
+    int   i,k=0;
+//    unsigned int j;
+    int temp;
+    int   pc,type ;
+  
+    ifstream fd;
+    fd.open(fname);
+    if (fd.is_open())
+    {
+	npart.clear();
+	npartc.clear();
+	fprintf(stdout,"Reading TypeList file: %s \n",fname); fflush(stdout);
+	while(fd>>temp) 
+	{
+	    npart.push_back(temp);
+	    npartc.push_back(k);
+	    k+=temp;
+	}
+	fd.close();
+	cout<<"Total No of particle types= "<<npart.size()<<" and Total Particles "<<k<<endl;
+    }
+    else
+    {
+	cout<<"Error opening typelist file"<<endl;
+	fprintf(stdout,"%s \n",fname); fflush(stdout);
+	endrun(1);
+    }
+
+//    if(k!=NumPart)  
+
+	for(type=0, pc=1; type<int(npart.size()); type++)
+	    for(i=0; i<npart[type]; i++)
+		P[pc++].Type = type;
+    
+}
+
+
+
+/* Read periodic lengths file */
+void read_periodic_lengths(char *fname,double boxh[ND])
+{
+    //  FILE *fd;
+    int   k=0;
+//    unsigned int j;
+    float temp;
+  
+    ifstream fd;
+    fd.open(fname);
+    if (fd.is_open())
+    {
+	fprintf(stdout,"Reading periodic lengths file: %s \n",fname); fflush(stdout);
+
+	for(k=0;k<ND;k++)
+	{
+	    if(fd>>temp) 
+	    {
+		boxh[k]=temp/2.0;
+	    }
+	    else
+	    {
+		cout<<"Error reading periodic lengths "<<endl;
+		cout<<"Read "<<k<<" out of "<<ND<<" records"<<endl;
+		endrun(1);
+	    }
+	    
+	}
+	fd.close();
+    }
+    else
+    {
+	cout<<"periodic_lengths.txt file not found"<<endl;
+	cout<<"should be in the curent directory"<<endl;
+	endrun(1);
+    }
+}
+