void
getVelosplines_lin(inputPars *par, struct grid *g){
int i,k,j;
double v[2];
for(i=0;i<par->pIntensity;i++){
g[i].a0=malloc(g[i].numNeigh*sizeof(double));
g[i].a1=malloc(g[i].numNeigh*sizeof(double));
for(k=0;k<g[i].numNeigh;k++){
v[0]=veloproject(g[i].dir[k].xn,g[i].vel);
v[1]=veloproject(g[i].dir[k].xn,g[i].neigh[k]->vel);
g[i].a1[k]=(v[0]-v[1])/(0-g[i].ds[k]);
g[i].a0[k]=v[0];
}
}
for(i=par->pIntensity;i<par->ncell;i++){
g[i].a0=malloc(g[i].numNeigh*sizeof(double));
g[i].a1=malloc(g[i].numNeigh*sizeof(double));
for(j=0;j<3;j++) g[i].vel[j]=0.;
for(j=0;j<g[i].numNeigh;j++){
g[i].a0[j]=0.;
g[i].a1[j]=0.;
}
}
}
void
velocityspline2(double x[3], double dx[3], double ds, double binv, double deltav, double *vfac){
int i,steps=10;
double v,d,val,vel[3];
*vfac=0.;
for(i=0;i<steps;i++){
d=i*ds/steps;
velocity(x[0]+(dx[0]*d),x[1]+(dx[1]*d),x[2]+(dx[2]*d),vel);
v=deltav+veloproject(dx,vel);
val=fabs(v)*binv;
if(val <= 2500.){
#ifdef FASTEXP
*vfac+= FastExp(val*val);
#else
*vfac+= exp(-(val*val));
#endif
}
}
*vfac=*vfac/steps;
return;
}
void
getVelosplines(inputPars *par, struct grid *g){
int i,k,j,l,s;
double v[5], vel[3], x[3], d;
gsl_matrix *matrix = gsl_matrix_alloc(5,5);
gsl_vector *a = gsl_vector_alloc(5);
gsl_vector *y = gsl_vector_alloc(5);
gsl_permutation *p = gsl_permutation_alloc(5);
for(i=0;i<par->pIntensity;i++){
g[i].a0=malloc(g[i].numNeigh*sizeof(double));
g[i].a1=malloc(g[i].numNeigh*sizeof(double));
g[i].a2=malloc(g[i].numNeigh*sizeof(double));
g[i].a3=malloc(g[i].numNeigh*sizeof(double));
g[i].a4=malloc(g[i].numNeigh*sizeof(double));
velocity(g[i].x[0],g[i].x[1],g[i].x[2],g[i].vel);
for(k=0;k<g[i].numNeigh;k++){
for(j=0;j<3;j++) x[j]=g[i].x[j];
for(l=0;l<5;l++){
velocity(x[0],x[1],x[2],vel);
v[l]=veloproject(g[i].dir[k].xn,vel);
for(j=0;j<3;j++) x[j]=x[j]+(g[i].dir[k].xn[j]*g[i].ds[k])/4.;
}
for(j=0;j<5;j++){
d=g[i].ds[k]/4*j;
gsl_matrix_set(matrix,j,0,d*d*d*d);
gsl_matrix_set(matrix,j,1,d*d*d);
gsl_matrix_set(matrix,j,2,d*d);
gsl_matrix_set(matrix,j,3,d);
gsl_matrix_set(matrix,j,4,1.);
}
for(j=0;j<5;j++) gsl_vector_set(y,j,v[j]);
gsl_linalg_LU_decomp (matrix, p, &s);
gsl_linalg_LU_solve (matrix, p, y, a);
g[i].a0[k]=gsl_vector_get(a,4);
g[i].a1[k]=gsl_vector_get(a,3);
g[i].a2[k]=gsl_vector_get(a,2);
g[i].a3[k]=gsl_vector_get(a,1);
g[i].a4[k]=gsl_vector_get(a,0);
}
}
for(i=par->pIntensity;i<par->ncell;i++){
g[i].a0=malloc(g[i].numNeigh*sizeof(double));
g[i].a1=malloc(g[i].numNeigh*sizeof(double));
g[i].a2=malloc(g[i].numNeigh*sizeof(double));
g[i].a3=malloc(g[i].numNeigh*sizeof(double));
g[i].a4=malloc(g[i].numNeigh*sizeof(double));
for(j=0;j<3;j++) g[i].vel[j]=0.;
for(j=0;j<g[i].numNeigh;j++){
g[i].a0[j]=0.;
g[i].a1[j]=0.;
g[i].a2[j]=0.;
g[i].a3[j]=0.;
g[i].a4[j]=0.;
}
}
gsl_permutation_free (p);
gsl_vector_free (a);
gsl_vector_free (y);
gsl_matrix_free (matrix);
}
void
traceray(rayData ray, int tmptrans, int im, inputPars *par, struct grid *g, molData *m, image *img, int nlinetot, int *counta, int *countb, double cutoff){
int ichan,posn,nposn,i,iline;
double vfac=0.,x[3],dx[3],vThisChan;
double deltav,ds,dist2,ndist2,xp,yp,zp,col,shift,jnu,alpha,remnantSnu,dtau,expDTau,snu_pol[3];
for(ichan=0;ichan<img[im].nchan;ichan++){
ray.tau[ichan]=0.0;
ray.intensity[ichan]=0.0;
}
xp=ray.x;
yp=ray.y;
if((xp*xp+yp*yp)/par->radiusSqu <= 1 ) {
zp=sqrt(par->radiusSqu-(xp*xp+yp*yp));
for(i=0;i<3;i++){
x[i]=xp*img[im].rotMat[i][0] + yp*img[im].rotMat[i][1] + zp*img[im].rotMat[i][2];
dx[i]= -img[im].rotMat[i][2];
}
i=0;
dist2=(x[0]-g[i].x[0])*(x[0]-g[i].x[0]) + (x[1]-g[i].x[1])*(x[1]-g[i].x[1]) + (x[2]-g[i].x[2])*(x[2]-g[i].x[2]);
posn=i;
for(i=1;i<par->ncell;i++){
ndist2=(x[0]-g[i].x[0])*(x[0]-g[i].x[0]) + (x[1]-g[i].x[1])*(x[1]-g[i].x[1]) + (x[2]-g[i].x[2])*(x[2]-g[i].x[2]);
if(ndist2<dist2){
posn=i;
dist2=ndist2;
}
}
col=0;
do{
ds=2.*zp-col;
nposn=-1;
line_plane_intersect(g,&ds,posn,&nposn,dx,x,cutoff);
if(par->polarization){
for(ichan=0;ichan<img[im].nchan;ichan++){
sourceFunc_pol(snu_pol,&dtau,ds,m,vfac,g,posn,0,0,img[im].theta);
#ifdef FASTEXP
ray.intensity[ichan]+=FastExp(ray.tau[ichan])*(1.-exp(-dtau))*snu_pol[ichan];
#else
ray.intensity[ichan]+= exp(-ray.tau[ichan])*(1.-exp(-dtau))*snu_pol[ichan];
#endif
ray.tau[ichan]+=dtau;
}
} else {
for(ichan=0;ichan<img[im].nchan;ichan++){
jnu=.0;
alpha=0.;
for(iline=0;iline<nlinetot;iline++){
if(img[im].doline && m[counta[iline]].freq[countb[iline]] > img[im].freq-img[im].bandwidth/2.
&& m[counta[iline]].freq[countb[iline]] < img[im].freq+img[im].bandwidth/2.){
if(img[im].trans > -1){
shift=(m[counta[iline]].freq[countb[iline]]-m[counta[iline]].freq[img[im].trans])/m[counta[iline]].freq[img[im].trans]*CLIGHT;
} else {
shift=(m[counta[iline]].freq[countb[iline]]-img[im].freq)/img[im].freq*CLIGHT;
}
vThisChan=(ichan-(img[im].nchan-1)/2.)*img[im].velres; // Consistent with the WCS definition in writefits().
deltav = vThisChan - img[im].source_vel + shift;
if(!par->pregrid) velocityspline2(x,dx,ds,g[posn].mol[counta[iline]].binv,deltav,&vfac);
else vfac=gaussline(deltav+veloproject(dx,g[posn].vel),g[posn].mol[counta[iline]].binv);
sourceFunc_line(&jnu,&alpha,m,vfac,g,posn,counta[iline],countb[iline]);
}
}
if(img[im].doline && img[im].trans > -1) sourceFunc_cont(&jnu,&alpha,g,posn,0,img[im].trans);
else if(img[im].doline && img[im].trans == -1) sourceFunc_cont(&jnu,&alpha,g,posn,0,tmptrans);
else sourceFunc_cont(&jnu,&alpha,g,posn,0,0);
dtau=alpha*ds;
//??? if(dtau < -30) dtau = -30; // as in photon()?
calcSourceFn(dtau, par, &remnantSnu, &expDTau);
remnantSnu *= jnu*m[0].norminv*ds;
#ifdef FASTEXP
ray.intensity[ichan]+=FastExp(ray.tau[ichan])*remnantSnu;
#else
ray.intensity[ichan]+= exp(-ray.tau[ichan])*remnantSnu;
#endif
ray.tau[ichan]+=dtau;
}
}
/* new coordinates */
for(i=0;i<3;i++) x[i]+=ds*dx[i];
col+=ds;
posn=nposn;
} while(col < 2*zp);
/* add or subtract cmb */
#ifdef FASTEXP
for(ichan=0;ichan<img[im].nchan;ichan++){
ray.intensity[ichan]+=(FastExp(ray.tau[ichan])-1.)*m[0].local_cmb[tmptrans];
}
#else
for(ichan=0;ichan<img[im].nchan;ichan++){
ray.intensity[ichan]+=(exp(-ray.tau[ichan])-1.)*m[0].local_cmb[tmptrans];
}
#endif
}
}
