/* ** The HAE to HEEQ transformation is given by the matrix ** ** S2 = <theta0,Z>*<i,X>*<Omega,Z> ** ** where the rotation angle theta0 is the the longitude of the Sun's ** central meridian, i is the the inclination of the Sun's equator and ** Omega is the the ecliptic longitude of the ascending node of the Sun's ** equator. This transformation comprises a rotation in the plane of the ** ecliptic from the First Point of Aries to the ascending node of the ** solar equator, then a rotation from the plane of the ecliptic to the ** plane of the equator and finally a rotation in the plane of the solar ** equator from the ascending node to the central meridian. ** ** Implemented by Kristi Keller on 2/2/2004 */ void mat_S2(const double et, Mat mat) { Mat mat_tmp; double Omega = 73.6667+0.013958*(MJD(et)+3242)/365.25; double theta0 = atand(cosd(7.25) * tand(lambda0(et)-Omega)); double angle_1 = lambda0(et)-Omega; angle_1=fmod(angle_1,360.0); if (angle_1 < 0.0) angle_1+=360.0; theta0=fmod(theta0,360.0); if (theta0 < 0.0) theta0+=360.0; if (angle_1 < 180.0) { if (theta0 < 180.0) theta0+=180.0; } if (angle_1 > 180.0) { if (theta0 > 180.0) theta0-=180.0; } hapgood_matrix(theta0, Z, mat); hapgood_matrix(7.25, X, mat_tmp); mat_times_mat(mat, mat_tmp, mat); hapgood_matrix(Omega, Z, mat_tmp); mat_times_mat(mat, mat_tmp, mat); }
/***********************************************************************//** * @brief Cartesian-to-spherical deprojection * * @param[in] nx X vector length. * @param[in] ny Y vector length (0=no replication). * @param[in] sxy Input vector step. * @param[in] spt Output vector step. * @param[in] x Vector of projected x coordinates. * @param[in] y Vector of projected y coordinates. * @param[out] phi Longitude of the projected point in native spherical * coordinates [deg]. * @param[out] theta Latitude of the projected point in native spherical * coordinates [deg]. * @param[out] stat Status return value for each vector element (always 0) * * Deproject Cartesian (x,y) coordinates in the plane of projection to native * spherical coordinates (phi,theta). * * This method has been adapted from the wcslib function prj.c::carx2s(). * The interface follows very closely that of wcslib. In contrast to the * wcslib routine, however, the method assumes that the projection has been * setup previsouly (as this will be done by the constructor). ***************************************************************************/ void GWcsSTG::prj_x2s(int nx, int ny, int sxy, int spt, const double* x, const double* y, double* phi, double* theta, int* stat) const { // Initialize projection if required if (!m_prjset) prj_set(); // Set value replication length mx,my int mx; int my; if (ny > 0) { mx = nx; my = ny; } else { mx = 1; my = 1; ny = nx; } // Do x dependence const double* xp = x; int rowoff = 0; int rowlen = nx * spt; for (int ix = 0; ix < nx; ++ix, rowoff += spt, xp += sxy) { double xj = *xp + m_x0; double* phip = phi + rowoff; for (int iy = 0; iy < my; ++iy, phip += rowlen) *phip = xj; } // Do y dependence const double* yp = y; double* phip = phi; double* thetap = theta; int* statp = stat; for (int iy = 0; iy < ny; ++iy, yp += sxy) { double yj = *yp + m_y0; double yj2 = yj*yj; for (int ix = 0; ix < mx; ++ix, phip += spt, thetap += spt) { double xj = *phip; double r = sqrt(xj*xj + yj2); if (r == 0.0) *phip = 0.0; else *phip = atan2d(xj, -yj); *thetap = 90.0 - 2.0*atand(r*m_w[1]); *(statp++) = 0; } } // Return return; }
void geodtgc(int iopt,double *gdlat,double *gdlon, double *grho,double *glat, double *glon,double *del) { double a=6378.16; double f=1.0/298.25; double b,e2; b=a*(1.0-f); e2=(a*a)/(b*b)-1; if (iopt>0) { *glat=atand( (b*b)/(a*a)*tand(*gdlat)); *glon=*gdlon; if (*glon > 180) *glon=*glon-360; } else { *gdlat=atand( (a*a)/(b*b)*tand(*glat)); *gdlon=*glon; } *grho=a/sqrt(1.0+e2*sind(*glat)*sind(*glat)); *del=*gdlat-*glat; }
void fldpnth_gs(double gdlat,double gdlon,double psi,double bore, double fh,double r,double *frho,double *flat, double *flon) { double rrad,rlat,rlon,del; double tan_azi,azi,rel,xel,fhx,xal,rrho,ral,xh; double dum,dum1,dum2,dum3; double frad; if (fh<=150) xh=fh; else { if (r<=300) xh=115; else if ((r>300) && (r<500)) xh=(r-300)/200*(fh-115)+115; else xh=fh; } if (r<150) xh=(r/150.0)*115.0; geodtgc(1,&gdlat,&gdlon,&rrad,&rlat,&rlon,&del); rrho=rrad; frad=rrad; do { *frho=frad+xh; rel=asind( ((*frho**frho) - (rrad*rrad) - (r*r)) / (2*rrad*r)); xel=rel; if (((cosd(psi)*cosd(psi))-(sind(xel)*sind(xel)))<0) tan_azi=1e32; else tan_azi=sqrt( (sind(psi)*sind(psi))/ ((cosd(psi)*cosd(psi))-(sind(xel)*sind(xel)))); if (psi>0) azi=atand(tan_azi)*1.0; else azi=atand(tan_azi)*-1.0; xal=azi+bore; geocnvrt(gdlat,gdlon,xal,xel,&ral,&dum); fldpnt(rrho,rlat,rlon,ral,rel,r,frho,flat,flon); geodtgc(-1,&dum1,&dum2,&frad,flat,flon,&dum3); fhx=*frho-frad; } while(fabs(fhx-xh) > 0.5); }
/***********************************************************************//** * @brief Cartesian-to-spherical deprojection * * @param[in] nx X vector length. * @param[in] ny Y vector length (0=no replication). * @param[in] sxy Input vector step. * @param[in] spt Output vector step. * @param[in] x Vector of projected x coordinates. * @param[in] y Vector of projected y coordinates. * @param[out] phi Longitude of the projected point in native spherical * coordinates [deg]. * @param[out] theta Latitude of the projected point in native spherical * coordinates [deg]. * @param[out] stat Status return value for each vector element (always 0) * * Deproject Cartesian (x,y) coordinates in the plane of projection to native * spherical coordinates (phi,theta). * * This method has been adapted from the wcslib function prj.c::merx2s(). * The interface follows very closely that of wcslib. In contrast to the * wcslib routine, however, the method assumes that the projection has been * setup previsouly (as this will be done by the constructor). ***************************************************************************/ void GWcsMER::prj_x2s(int nx, int ny, int sxy, int spt, const double* x, const double* y, double* phi, double* theta, int* stat) const { // Initialize projection if required if (!m_prjset) { prj_set(); } // Set value replication length mx,my int mx; int my; if (ny > 0) { mx = nx; my = ny; } else { mx = 1; my = 1; ny = nx; } // Do x dependence const double* xp = x; int rowoff = 0; int rowlen = nx * spt; for (int ix = 0; ix < nx; ++ix, rowoff += spt, xp += sxy) { double s = m_w[1] * (*xp + m_x0); double* phip = phi + rowoff; for (int iy = 0; iy < my; ++iy, phip += rowlen) { *phip = s; } } // Do y dependence const double* yp = y; double* thetap = theta; int* statp = stat; for (int iy = 0; iy < ny; ++iy, yp += sxy) { double t = 2.0 * atand(std::exp((*yp + m_y0)/m_r0)) - 90.0; for (int ix = 0; ix < mx; ++ix, thetap += spt) { *thetap = t; *(statp++) = 0; } } // Return return; }
void geocnvrt(double gdlat,double gdlon, double xal,double xel,double *ral,double *rel) { double kxg,kyg,kzg,kxr,kyr,kzr; double rrad,rlat,rlon,del; kxg=cosd(xel)*sind(xal); kyg=cosd(xel)*cosd(xal); kzg=sind(xel); geodtgc(1,&gdlat,&gdlon,&rrad,&rlat,&rlon,&del); kxr=kxg; kyr=kyg*cosd(del)+kzg*sind(del); kzr=-kyg*sind(del)+kzg*cosd(del); *ral=atan2d(kxr,kyr); *rel=atand(kzr/sqrt((kxr*kxr)+(kyr*kyr))); }
void scan_to_latlon(meta_parameters *meta, double x, double y, double z, double *lat_d, double *lon, double *height) { double qlat, qlon; double lat,radius; vector pos; meta_projection *proj = meta->projection; if (z != 0.0) { // height correction applies directly to y (range direction) double line, samp; line = (y-proj->startY)/proj->perY - meta->general->start_line; samp = (x-proj->startX)/proj->perX - meta->general->start_sample; double sr = meta_get_slant(meta,line,samp); double er = proj->param.atct.rlocal; double ht = meta_get_sat_height(meta,line,samp); double cos_ang = (sr*sr + er*er - ht*ht)/(2.0*sr*er); if (cos_ang > 1) cos_ang = 1; if (cos_ang < -1) cos_ang = -1; double incid = PI-acos(cos_ang); x += z*tan(PI/2-incid); } if (meta->sar->look_direction=='R') qlat = -x/proj->param.atct.rlocal; /* Right looking sar */ else qlat = x/proj->param.atct.rlocal; /* Left looking sar */ qlon = y/(proj->param.atct.rlocal*cos(qlat)); sph2cart(proj->param.atct.rlocal, qlat, qlon, &pos); rotate_z(&pos,-proj->param.atct.alpha3); rotate_y(&pos,-proj->param.atct.alpha2); rotate_z(&pos,-proj->param.atct.alpha1); cart2sph(pos,&radius,&lat,lon); *lon *= R2D; lat *= R2D; *lat_d = atand(tand(lat) / (1-ecc2(proj->re_minor,proj->re_major))); *height = z; // FIXME: Do we need to correct the height at all? }
int main (int argc, char *argv[]){ if (argc != 2){ printf("Give a parameter file.\n"); exit(1); } int SpaceGrp; double LatC[6], wl, Lsd, MaxRingRad; char *ParamFN; FILE *fileParam; ParamFN = argv[1]; char aline[1000]; fileParam = fopen(ParamFN,"r"); char *str, dummy[1000]; int LowNr; while (fgets(aline,1000,fileParam)!=NULL){ str = "SpaceGroup "; LowNr = strncmp(aline,str,strlen(str)); if (LowNr==0){ sscanf(aline,"%s %d", dummy, &SpaceGrp); continue; } str = "LatticeConstant "; LowNr = strncmp(aline,str,strlen(str)); if (LowNr==0){ sscanf(aline,"%s %lf %lf %lf %lf %lf %lf", dummy, &LatC[0], &LatC[1], &LatC[2], &LatC[3], &LatC[4], &LatC[5]); continue; } str = "LatticeParameter "; LowNr = strncmp(aline,str,strlen(str)); if (LowNr==0){ sscanf(aline,"%s %lf %lf %lf %lf %lf %lf", dummy, &LatC[0], &LatC[1], &LatC[2], &LatC[3], &LatC[4], &LatC[5]); continue; } str = "Wavelength "; LowNr = strncmp(aline,str,strlen(str)); if (LowNr==0){ sscanf(aline,"%s %lf", dummy, &wl); continue; } str = "Lsd "; LowNr = strncmp(aline,str,strlen(str)); if (LowNr==0){ sscanf(aline,"%s %lf", dummy, &Lsd); continue; } str = "MaxRingRad "; LowNr = strncmp(aline,str,strlen(str)); if (LowNr==0){ sscanf(aline,"%s %lf", dummy, &MaxRingRad); continue; } } printf("%f %f %f %d %f %f %f %f %f %f\n",wl,Lsd,MaxRingRad,SpaceGrp,LatC[0],LatC[1],LatC[2],LatC[3],LatC[4],LatC[5]); int h, k, l, iList, restriction, M, i, j; int Minh, Mink, Minl; int CCMx_PL[9], deterCCMx_LP = 0; double Epsilon = 0.0001; int Families[50000][3]; T_SgInfo *SgInfo; char SgName[200]; int F_Convention='A'; const T_TabSgName *tsgn; printf("Generating hkl's\n"); if((SgInfo = (T_SgInfo *)malloc(sizeof(T_SgInfo)))==NULL){ printf("Unable to allocate SgInfo\n"); printf("Aborting\n"); exit(1); } SgInfo->GenOption = 0; SgInfo->MaxList = 192; if((SgInfo->ListSeitzMx = (T_RTMx*)malloc(SgInfo->MaxList * sizeof(T_RTMx)))==NULL){ printf("Unable to allocate (SgInfo.ListSeitzMx\n"); printf("Aborting\n"); exit(1); } SgInfo->ListRotMxInfo = NULL; InitSgInfo(SgInfo); sprintf(SgName,"%d",SpaceGrp); tsgn = FindTabSgNameEntry(SgName, F_Convention); if (tsgn == NULL){ printf("Error: Unknown Space Group Symbol\n"); printf("Aborting\n"); exit(1); } sprintf(SgName,"%s",tsgn->HallSymbol); SgInfo->TabSgName = tsgn; if (tsgn) SgInfo->GenOption = 1; { int pos_hsym; pos_hsym = ParseHallSymbol(SgName, SgInfo); if (SgError != NULL) { printf("Error: Unknown Space Group Symbol\n"); printf("Aborting\n"); exit(1); } } if(CompleteSgInfo(SgInfo)!=0) { printf("Error in Complete\n"); printf("Aborting\n"); exit(1); } if (SgInfo->LatticeInfo->Code != 'P') { deterCCMx_LP = deterRotMx(SgInfo->CCMx_LP); InverseRotMx(SgInfo->CCMx_LP, CCMx_PL); if (deterCCMx_LP < 1) { printf("deterCMM failed.\n"); return 0; } } int Maxh, Maxk, Maxl; int nrFilled=0; Maxh = 10; Maxk = 10; Maxl = 10; SetListMin_hkl(SgInfo, Maxk, Maxl, &Minh, &Mink, &Minl); printf("Will go from %d to %d in h; %d to %d in k; %d to %d in l.\n",Minh, Maxh, Mink, Maxk, Minl, Maxl); for (h = Minh; h <= Maxh; h++){ for (k = Mink; k <= Maxk; k++){ for (l = Minl; l <= Maxl; l++){ if (h==0 && k==0 && l==0){ continue; } iList = IsSysAbsent_hkl(SgInfo, h, k, l, &restriction); if (SgError != NULL) { printf("IsSysAbsent_hkl failed.\n"); return 0; } if (iList == 0){ if ((iList = IsSuppressed_hkl(SgInfo, Minh, Mink, Minl, Maxk, Maxl, h, k, l)) != 0) {/* Suppressed reflections */ } else { //printf("New plane.\n"); T_Eq_hkl Eq_hkl; M = BuildEq_hkl(SgInfo, &Eq_hkl, h, k, l); if (SgError != NULL){ return 0; } for (i=0;i<Eq_hkl.N;i++){ for (j=-1;j<=1;j+=2){ //printf("%d %d %d\n",Eq_hkl.h[i]*j,Eq_hkl.k[i]*j,Eq_hkl.l[i]*j); Families[nrFilled][0] = Eq_hkl.h[i]*j; Families[nrFilled][1] = Eq_hkl.k[i]*j; Families[nrFilled][2] = Eq_hkl.l[i]*j; nrFilled++; } } } } } } } int AreDuplicates[50000]; double **UniquePlanes; UniquePlanes = allocMatrix(50000,3); for (i=0;i<50000;i++) AreDuplicates[i] = 0; int nrPlanes=0; for (i=0;i<nrFilled-1;i++){ if (AreDuplicates[i] == 1){ continue; } for (j=i+1;j<nrFilled;j++){ if (Families[i][0] == Families[j][0] && Families[i][1] == Families[j][1] && Families[i][2] == Families[j][2] && AreDuplicates[j] == 0){ AreDuplicates[j] = 1; } } UniquePlanes[nrPlanes][0] = (double)Families[i][0]; UniquePlanes[nrPlanes][1] = (double)Families[i][1]; UniquePlanes[nrPlanes][2] = (double)Families[i][2]; nrPlanes++; } double **hkls; hkls = allocMatrix(nrPlanes,12); CorrectHKLsLatC(LatC,UniquePlanes,nrPlanes,hkls); SortFunc(nrPlanes,11,hkls,3,-1); double DsMin = wl/(2*sind((atand(MaxRingRad/Lsd))/2)); for (i=0;i<nrPlanes;i++){ if (hkls[i][3] < DsMin){ nrPlanes = i; break; } } int RingNr = 1; double DsTemp = hkls[0][3]; hkls[0][4] = 1; hkls[0][8] = asind(wl/(2*(hkls[0][3]))); hkls[0][9] = hkls[0][8]*2; hkls[0][10] = Lsd*tand(hkls[0][9]); for (i=1;i<nrPlanes;i++){ if (fabs(hkls[i][3] - DsTemp) < Epsilon){ hkls[i][4] = RingNr; }else{ DsTemp = hkls[i][3]; RingNr++; hkls[i][4] = RingNr; } hkls[i][8] = asind(wl/(2*(hkls[i][3]))); hkls[i][9] = hkls[i][8]*2; hkls[i][10] = Lsd*tand(hkls[i][9]); } char *fn = "hkls.csv"; FILE *fp; fp = fopen(fn,"w"); fprintf(fp,"h k l D-spacing RingNr\n"); for (i=0;i<nrPlanes;i++){ fprintf(fp,"%.0f %.0f %.0f %f %.0f %f %f %f %f %f %f\n",hkls[i][0], hkls[i][1],hkls[i][2],hkls[i][3],hkls[i][4], hkls[i][5],hkls[i][6],hkls[i][7],hkls[i][8], hkls[i][9],hkls[i][10]); } }
int spcx2s( struct spcprm *spc, int nx, int sx, int sspec, const double x[], double spec[], int stat[]) { static const char *function = "spcx2s"; int statP2S, status = 0, statX2P; double beta; register int ix; register int *statp; register const double *xp; register double *specp; struct wcserr **err; /* Initialize. */ if (spc == 0x0) return SPCERR_NULL_POINTER; err = &(spc->err); if (spc->flag == 0) { if ((status = spcset(spc))) return status; } /* Convert intermediate world coordinate x to X. */ xp = x; specp = spec; statp = stat; for (ix = 0; ix < nx; ix++, xp += sx, specp += sspec) { *specp = spc->w[1] + (*xp)*spc->w[2]; *(statp++) = 0; } /* If X is the grism parameter then convert it to wavelength. */ if (spc->isGrism) { specp = spec; for (ix = 0; ix < nx; ix++, specp += sspec) { beta = atand(*specp) + spc->w[3]; *specp = (sind(beta) + spc->w[4]) * spc->w[5]; } } /* Apply the non-linear step of the algorithm chain to convert the */ /* X-type spectral variable to P-type intermediate spectral variable. */ if (spc->spxX2P) { if ((statX2P = spc->spxX2P(spc->w[0], nx, sspec, sspec, spec, spec, stat))) { if (statX2P == SPXERR_BAD_INSPEC_COORD) { status = SPCERR_BAD_X; } else if (statX2P == SPXERR_BAD_SPEC_PARAMS) { return wcserr_set(WCSERR_SET(SPCERR_BAD_SPEC_PARAMS), "Invalid spectral parameters: Frequency or wavelength is 0"); } else { return wcserr_set(SPC_ERRMSG(spc_spxerr[statX2P])); } } } /* Apply the linear step of the algorithm chain to convert P-type */ /* intermediate spectral variable to the required S-type variable. */ if (spc->spxP2S) { if ((statP2S = spc->spxP2S(spc->w[0], nx, sspec, sspec, spec, spec, stat))) { if (statP2S == SPXERR_BAD_INSPEC_COORD) { status = SPCERR_BAD_X; } else if (statP2S == SPXERR_BAD_SPEC_PARAMS) { return wcserr_set(WCSERR_SET(SPCERR_BAD_SPEC_PARAMS), "Invalid spectral parameters: Frequency or wavelength is 0"); } else { return wcserr_set(SPC_ERRMSG(spc_spxerr[statP2S])); } } } if (status) { wcserr_set(SPC_ERRMSG(status)); } return status; }
int spcx2s( struct spcprm *spc, int nx, int sx, int sspec, const double x[], double spec[], int stat[]) { int statP2S, status = 0, statX2P; double beta; register int ix; register int *statp; register const double *xp; register double *specp; /* Initialize. */ if (spc == 0) return 1; if (spc->flag == 0) { if (spcset(spc)) return 2; } /* Convert intermediate world coordinate x to X. */ xp = x; specp = spec; statp = stat; for (ix = 0; ix < nx; ix++, xp += sx, specp += sspec) { *specp = spc->w[1] + (*xp)*spc->w[2]; *(statp++) = 0; } /* If X is the grism parameter then convert it to wavelength. */ if (spc->isGrism) { specp = spec; for (ix = 0; ix < nx; ix++, specp += sspec) { beta = atand(*specp) + spc->w[3]; *specp = (sind(beta) + spc->w[4]) * spc->w[5]; } } /* Apply the non-linear step of the algorithm chain to convert the */ /* X-type spectral variable to P-type intermediate spectral variable. */ if (spc->spxX2P != 0) { if (statX2P = spc->spxX2P(spc->w[0], nx, sspec, sspec, spec, spec, stat)) { if (statX2P == 4) { status = 3; } else { return statX2P; } } } /* Apply the linear step of the algorithm chain to convert P-type */ /* intermediate spectral variable to the required S-type variable. */ if (spc->spxP2S != 0) { if (statP2S = spc->spxP2S(spc->w[0], nx, sspec, sspec, spec, spec, stat)) { if (statP2S == 4) { status = 3; } else { return statP2S; } } } return status; }
void Fit2DPeaks(unsigned nPeaks, int NrPixelsThisRegion, double *z, int **UsefulPixels, double *MaximaValues, int **MaximaPositions, double *IntegratedIntensity, double *IMAX, double *YCEN, double *ZCEN, double *RCens, double *EtaCens,double Ycen, double Zcen, double Thresh, int *NrPx,double *OtherInfo) { unsigned n = 1 + (8*nPeaks); double x[n],xl[n],xu[n]; x[0] = Thresh/2; xl[0] = 0; xu[0] = Thresh; int i; double *Rs, *Etas; Rs = malloc(NrPixelsThisRegion*2*sizeof(*Rs)); Etas = malloc(NrPixelsThisRegion*2*sizeof(*Etas)); for (i=0;i<NrPixelsThisRegion;i++){ Rs[i] = CalcNorm2(UsefulPixels[i][0]-Ycen,UsefulPixels[i][1]-Zcen); Etas[i] = CalcEtaAngle(UsefulPixels[i][0]-Ycen,UsefulPixels[i][1]-Zcen); } double Width = sqrt(NrPixelsThisRegion/nPeaks); for (i=0;i<nPeaks;i++){ x[(8*i)+1] = MaximaValues[i]; // Imax x[(8*i)+2] = CalcNorm2(MaximaPositions[i][0]-Ycen,MaximaPositions[i][1]-Zcen); //Radius x[(8*i)+3] = CalcEtaAngle(MaximaPositions[i][0]-Ycen,MaximaPositions[i][1]-Zcen); // Eta x[(8*i)+4] = 0.5; // Mu x[(8*i)+5] = Width; //SigmaGR x[(8*i)+6] = Width; //SigmaLR x[(8*i)+7] = atand(Width/x[(8*i)+2]); //SigmaGEta //0.5; x[(8*i)+8] = atand(Width/x[(8*i)+2]); //SigmaLEta //0.5; double dEta = rad2deg*atan(1/x[(8*i)+2]); xl[(8*i)+1] = MaximaValues[i]/2; xl[(8*i)+2] = x[(8*i)+2] - 1; xl[(8*i)+3] = x[(8*i)+3] - dEta; xl[(8*i)+4] = 0; xl[(8*i)+5] = 0.01; xl[(8*i)+6] = 0.01; xl[(8*i)+7] = 0.005; xl[(8*i)+8] = 0.005; xu[(8*i)+1] = MaximaValues[i]*2; xu[(8*i)+2] = x[(8*i)+2] + 1; xu[(8*i)+3] = x[(8*i)+3] + dEta; xu[(8*i)+4] = 1; xu[(8*i)+5] = 30; xu[(8*i)+6] = 30; xu[(8*i)+7] = 2; xu[(8*i)+8] = 2; } struct func_data f_data; f_data.NrPixels = NrPixelsThisRegion; f_data.Rs = &Rs[0]; f_data.Etas = &Etas[0]; f_data.z = &z[0]; struct func_data *f_datat; f_datat = &f_data; void *trp = (struct func_data *) f_datat; nlopt_opt opt; opt = nlopt_create(NLOPT_LN_NELDERMEAD, n); nlopt_set_lower_bounds(opt, xl); nlopt_set_upper_bounds(opt, xu); nlopt_set_maxtime(opt, 300); nlopt_set_min_objective(opt, problem_function, trp); double minf; nlopt_optimize(opt, x, &minf); nlopt_destroy(opt); for (i=0;i<nPeaks;i++){ IMAX[i] = x[(8*i)+1]; RCens[i] = x[(8*i)+2]; EtaCens[i] = x[(8*i)+3]; if (x[(8*i)+5] > x[(8*i)+6]){ OtherInfo[2*i] = x[(8*i)+5]; }else{ OtherInfo[2*i] = x[(8*i)+6]; } if (x[(8*i)+7] > x[(8*i)+8]){ OtherInfo[2*i+1] = x[(8*i)+7]; }else{ OtherInfo[2*i+1] = x[(8*i)+8]; } } YZ4mREta(nPeaks,RCens,EtaCens,YCEN,ZCEN); CalcIntegratedIntensity(nPeaks,x,Rs,Etas,NrPixelsThisRegion,IntegratedIntensity,NrPx); free(Rs); free(Etas); }