enbid-ananke 0.3.0__cp310-cp310-manylinux_2_39_x86_64.whl

enbid_ananke/Enbid-2.0/src/functions.cpp

@@ -0,0 +1,256 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string>
+#include <math.h>
+#include "allvars.h"
+#include "proto.h"
+#include "functions.h"
+#include "nr.h"
+#include "tree.h"
+
+
+/*  this function wraps the distance x to the closest image
+ *  for the given box size
+ */
+
+/* matrix multiplication of two matrices C=AB*/
+void m_multiply(float **a, float **b,float **c,int n1, int n2,int transpose)
+{
+    int i,j,k;
+
+    for (i=n1;i<=n2;i++)
+	for (j=n1;j<=n2;j++)
+	    for (k=n1,c[i][j]=0.0;k<=n2;k++)
+	    {
+		switch(transpose)
+		{
+		    case 0: c[i][j]+=a[i][k]*b[k][j]; break;
+		    case 1: c[i][j]+=a[k][i]*b[k][j]; break;
+		    case 2: c[i][j]+=a[i][k]*b[j][k]; break;
+		    case 3: c[i][j]+=a[k][i]*b[j][k]; break;
+		    default: cout<<"give m_multiply options correctly"<<endl;endrun(10); break;
+		}
+	    }
+
+}
+
+/* matrix operation on a vector C=AB*/
+void m_multiply_a(float **a, float *b,float *c,int n1, int n2,int transpose)
+{
+    int i,k;
+
+    for (i=n1;i<=n2;i++)
+	for (k=n1,c[i]=0.0;k<=n2;k++)
+	{
+
+	    if(transpose)
+		c[i]+=a[k][i]*b[k];
+	    else
+		c[i]+=a[i][k]*b[k];
+//       switch(transpose)
+//       {
+//       case 0: c[i]+=a[i][k]*b[k]; break;
+//       case 1: c[i]+=a[k][i]*b[k]; break;
+//       default: cout<<"give m_multiply options correctly"<<endl;endrun(10); break;
+//       }
+	}
+
+}
+
+/* print matrix */
+void m_print(float **a,int n1 ,int n2)
+{
+    int i,j;
+    for (i=n1;i<=n2;i++)
+	for (j=n1;j<=n2;j++)
+	{
+	    printf("%12.6f ",a[i][j]);
+	    if(j==n2) cout<<endl;
+	}
+}
+
+/* copy matrix */
+void m_copy(float **a,float **b,int n1, int n2,int transpose)
+{
+    int i,j;
+    for (i=n1;i<=n2;i++)
+	for (j=n1;j<=n2;j++)
+	{
+	    if (transpose)      b[i][j]=a[j][i];
+	    else                    b[i][j]=a[i][j];
+	}
+}
+
+
+/* copy array */
+void a_copy(float *a,float *b,int n1, int n2)
+{
+    int i;
+    for (i=n1;i<=n2;i++)
+	b[i]=a[i];
+
+}
+
+
+
+/* print array */
+void a_print(float *a,int n1,int n2)
+{
+    int i;
+    for (i=n1;i<=n2;i++)
+    {
+	printf("%12.6e ",a[i]);
+	if(i==n2) cout<<endl;
+    }
+}
+
+/* max element array */
+float a_max(float *a,int n1 , int n2)
+{
+    int i;
+    float amax=a[n1];
+    for (i=n1;i<=n2;i++)
+    {
+	if(a[i] > amax ) amax=a[i];
+    }
+    return amax;
+}
+
+/* min element array */
+float a_min(float *a,int n1, int n2)
+{
+    int i;
+    float amin=a[n1];
+    for (i=n1;i<=n2;i++)
+    {
+	if(a[i] < amin ) amin=a[i];
+    }
+    return amin;
+}
+
+
+
+
+
+double second(void)
+{
+    return ((double)((unsigned int)clock()))/CLOCKS_PER_SEC;
+
+    /* note: on AIX and presumably many other 32bit systems,
+     * clock() has only a resolution of 10ms=0.01sec
+     */
+}
+
+
+/* returns the time difference between two measurements
+ * obtained with second(). The routine takes care of the
+ * possible overflow of the tick counter on 32bit systems.
+ */
+double timediff(double t0,double t1)
+{
+    double dt;
+
+    dt=t1-t0;
+
+    if(dt<0)  /* overflow has occured */
+    {
+	dt=t1 + pow(2.0,32.0)/CLOCKS_PER_SEC - t0;
+    }
+
+    return dt;
+}
+
+
+
+/* returns the maximum of two double
+ */
+double dmax(double x,double y)
+{
+    if(x>y)
+	return x;
+    else
+	return y;
+}
+
+/* returns the minimum of two double
+ */
+double dmin(double x,double y)
+{
+    if(x<y)
+	return x;
+    else
+	return y;
+}
+
+/* returns the maximum of two integers
+ */
+int imax(int x,int y)
+{
+    if(x>y)
+	return x;
+    else
+	return y;
+}
+
+
+/* returns the minimum of two integers
+ */
+int imin(int x,int y)
+{
+    if(x<y)
+	return x;
+    else
+	return y;
+}
+
+
+
+/* end the run */
+void endrun(int ierr)
+{
+    if(ierr)
+    {
+	fprintf(stdout,"endrun called with an error level of %d\n\n\n", ierr);
+	exit(1);
+    }
+    exit(0);
+}
+
+
+
+void checkrun(string s1 ,string s2, string s3)
+{
+    int temp;
+    cout<<s1<<endl;
+    cout<<"Type 0 to "<<s2<<" or 1 to "<<s3<<" :";
+    cin>>temp;
+    if(temp!=1)
+	exit(1);
+}
+
+
+void endrunm(string s )
+{
+    cout<<s<<endl;
+    exit(1);
+}
+
+
+
+/* calculate the gamma function */
+float gammln(float xx)
+{
+    double x,y,tmp,ser;
+    static double cof[6]={76.18009172947146,-86.50532032941677,
+			  24.01409824083091,-1.231739572450155,
+			  0.1208650973866179e-2,-0.5395239384953e-5};
+    int j;
+
+    y=x=xx;
+    tmp=x+5.5;
+    tmp -= (x+0.5)*log(tmp);
+    ser=1.000000000190015;
+    for (j=0;j<=5;j++) ser += cof[j]/++y;
+    return -tmp+log(2.5066282746310005*ser/x);
+}
+

enbid_ananke/Enbid-2.0/src/functions.h

@@ -0,0 +1,20 @@
+double dmax(double,double);
+double dmin(double,double);
+double drand48();
+void   endrun(int);
+int    imax(int,int);
+int    imin(int,int);
+double second(void);
+double timediff(double t0,double t1); 
+void m_multiply(float **a, float **b,float **c,int ,int , int);
+void m_print(float **a,int ,int);
+void m_copy(float **a,float **b,int , int, int);
+void a_copy(float *a,float *b,int , int);
+void a_print(float *a,int , int);
+float a_max(float *a,int n1 , int n2);
+float a_min(float *a,int n1 , int n2);
+void m_multiply_a(float **a, float *b,float *c,int , int ,int );
+double pow(double, double);
+float gammln(float xx);
+void   checkrun(string s1,string s2,string s3);
+void   endrunm(string s);

enbid_ananke/Enbid-2.0/src/init.cpp

@@ -0,0 +1,299 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "allvars.h"
+#include "proto.h"
+#include "tree.h"
+#include "functions.h"
+
+/*
+ *  init() reads in the initial conditions,
+ *  and allocates storage for the tree(s).
+ *  Then generates the tree  and finally calculates
+ *  the density.
+ */
+void init(void)
+{
+    int i,j;
+    float h2,m_min,m_max;
+    double t1,t2,xmean[ND];
+
+    t11=second();
+//     if(BatchFlag==1)
+// 	sprintf(All.InitCondFile,"%s%s_%03d",All.InputDir,All.InitFileBase,Var.FileNum);
+
+    if(All.AnisotropicKernel==1)
+    {
+	if((All.TypeOfSmoothing!=2)and(All.TypeOfSmoothing!=3))
+	{
+	    cout<<"For AnisotropicKernel=1, TypeOfSmoothing should be 2 or 3"<<endl; 
+	    endrun(10);
+	}
+    }
+
+
+    switch(All.ICFormat)
+    {
+	case 0:read_ic0(All.InitCondFile);break;
+	case 1:read_ic1(All.InitCondFile);break;
+	case 2:read_ic2(All.InitCondFile);break;
+	default:cout<<"Parameter ICFormat should be between 0 to 2"<<endl;endrun(10);
+    }
+
+
+    if(All.TypeListOn)
+    {
+	char buf[100];
+	char file_suf[10]="_typelist";
+	sprintf(buf,"%s%s",All.InitCondFile,file_suf);
+	read_typelist(buf,npart,P);	    
+    }
+
+#ifdef PERIODIC
+    if(All.PeriodicBoundaryOn==1)
+    {
+	char file_periodic[21]="periodic_lengths.txt";
+	read_periodic_lengths(file_periodic,All.boxh);	    
+
+	for(j=0,i=0;j<int(npart.size());j++)
+	    if(npart[j]>0) i++;
+	if(i>1)
+	{
+	    cout<<"WARNING:multiple species present,"<<endl; 
+#ifdef WARN
+	    checkrun("a constant global periodic boundary will be used for all of them","exit","continue");
+#else
+	    cout<<"a constant global periodic boundary will be used for all of them"<<endl;
+#endif
+	}
+
+    }
+    else
+    {
+	cout<<"Code compiled with PERIODIC option, Set parameter PeriodicBoundaryOn to 1"<<endl;
+	endrun(10);
+    }
+#else
+    if(All.PeriodicBoundaryOn!=0)
+    {
+	cout<<"Set parameter PeriodicBoundaryOn to 0"<<endl;
+	endrun(10);
+    }
+#endif
+
+// check multiple mass and issue warning
+    for(j=0;j<int(npart.size());j++)
+    {
+	i=npartc[j]+1;
+	m_min=P[i].Mass; m_max=P[i].Mass;
+	for(i=npartc[j]+1;i<=(npartc[j]+npart[j]);i++)
+	    {
+		if(m_min>P[i].Mass) m_min=P[i].Mass;
+		if(m_max<P[i].Mass) m_max=P[i].Mass;
+	    }
+	if(m_min!=m_max)
+	{
+	    if(All.TypeOfSmoothing==1)
+	    {
+		cout<<"For FiEstAS smoothing multiple mass support for same species of particle is not available"<<endl;
+		endrun(10);
+		}
+	    else
+	    {
+#ifdef WARN
+		checkrun("WARNING! particles with multiple mass results might not be accurate","exit","continue");
+#else
+		cout<<"WARNING! particles with multiple mass results might not be accurate"<<endl;
+#endif
+	    }
+	    
+	}
+    }
+    
+
+
+    header1.flag_density=1;
+    treeallocate( All.MaxPart);
+
+
+    /* scaling the velocity and spatial co-ordinates */
+    for(j=0;j<ND;j++)
+	All.hs[j]=1.0;
+
+    if(All.SpatialScale>0)
+    {
+	if(ND==6)
+	{
+	    for(j=0;j<3;j++)
+		All.hs[j]=All.SpatialScale;
+	}
+    }
+    else
+    {
+	for(j=0;j<ND;j++)
+	    xmean[j]=0.0;
+	for(i=1; i<=NumPart; i++) /*  start-up initialization */
+	{
+	    for(j=0;j<ND;j++)
+	    {
+		xmean[j]+=P[i].Pos[j];
+	    }
+	}
+	for(j=0;j<ND;j++)
+	    xmean[j]/=NumPart;
+
+	for(i=1; i<=NumPart; i++) /*  start-up initialization */
+	{
+	    for(j=0;j<ND;j++)
+	    {
+		All.hs[j]+=(P[i].Pos[j]-xmean[j])*(P[i].Pos[j]-xmean[j]);
+	    }
+	}
+
+	for(j=0;j<ND;j++)
+	    All.hs[j]=sqrt(All.hs[j]/NumPart);
+	cout<<"Scaling Co-ordinates based on variance"<<endl;
+	h2=a_max(All.hs,0,ND-1);
+	for(j=0;j<ND;j++)
+	{
+	    cout<<"i = "<<j<<" Sigma = "<<All.hs[j]<<" Scale = "<<All.hs[j]/h2<<endl;
+	    All.hs[j]=All.hs[j]/h2;
+	}
+
+    }
+
+    for(j=0,All.hsv=1.0;j<ND;j++)
+	All.hsv*=All.hs[j];
+    cout<<"Scaling Co-ordinates as x[i]=x[i]/h[i] with h[i]->"<<endl;
+    for(j=0;j<ND;j++)
+    {
+	cout<<All.hs[j]<<" ";
+    }
+    cout<<"\n"<<endl;
+
+
+
+    for(i=1; i<=NumPart; i++) /*  start-up initialization */
+    {
+	for(j=0;j<ND;j++)
+	{
+	    P[i].Pos[j]=P[i].Pos[j]/All.hs[j];
+	}
+    }
+
+#ifdef PERIODIC
+	for(j=0;j<ND;j++)
+	{
+	    if(All.boxh[j]>0)
+	    {
+		All.boxh[j]=All.boxh[j]/All.hs[j];
+	    }
+	}
+#endif
+
+
+
+    /* Build Tree */
+    if((All.NodeSplittingCriterion==1)&&(All.CubicCells==1))
+    {
+	if((ND!=6)&&(ND!=3))
+	{
+	    cout<<"Cubic Cells not allowed for dimensions other than 3 or 6 here Dim="<<ND<<endl;
+	    cout<<"Choose another option or modify routine"<<endl;
+	    endrun(10);
+	}
+    }
+
+    printf("Starting to Build Tree ......."); fflush(stdout);
+    for(i=1; i<=NumPart; i++)
+    {
+	P[i].Density=0.0;
+    }
+
+
+
+
+    t1=second();
+    treebuild_all();
+    t2=second();
+    cout<<"Treebuild time = "<<timediff(t1,t2)<<" s \n"<<endl;
+    t22=second();  t00+=timediff(t11,t22);
+
+
+    All.order_flag=1;
+    if(All.order_flag==1)
+    {
+	for(i=0; i<NumPart; i++)
+	    list_kdt[i]=list_kd[i];
+	order_particles(P+1,list_kd,NumPart,0);
+	for(i=0; i<NumPart; i++)
+	    list_kd[i]=i;
+    }
+
+
+
+
+	density_par();
+
+
+    if(All.order_flag==1)
+	order_particles(P+1,list_kdt,NumPart,1);
+
+//     for(int ii=0;ii<100;ii++)
+// 	cout<<"problem "<<Part[ii].Density<<endl;
+
+	savepositions();
+
+
+    /* correct for global scaling */
+    t22=second();  t00+=timediff(t11,t22);
+
+}
+
+
+
+template <class type> void order_particles(type* P,int *Id,int Nmax, int reverse)
+{
+    int i;
+    type Psave;
+    int idsource, idest,*Id1;
+
+    Id1= (int *) malloc(sizeof(int)*Nmax);
+
+    if(reverse==1)
+	for(i = 0; i < Nmax; i++)
+	    Id1[Id[i]]=i;
+    else
+	for(i = 0; i < Nmax; i++)
+	    Id1[i]=Id[i];
+
+    for(i = 0; i < Nmax; i++)
+    {
+	if(Id1[i] != i)
+        {
+            Psave=P[i];
+            idest = i;
+	    do
+            {
+		idsource=Id1[idest];
+		if(idsource == i)
+		{
+		    P[idest]=Psave;
+		    Id1[idest] =idest;
+		    break;
+		}
+		P[idest] = P[idsource];
+		Id1[idest] = idest;
+		idest = idsource;
+            }
+	    while(1);
+        }
+    }
+    free(Id1);
+}
+
+
+
+
+