void Correlator::Run() { complex <double> ycorr; Matrix < complex <double> > yvec(1,indim); /////////// fetch of sampled input yvec = vin1.GetDataObj(); ycorr = (Hermitian(yvec)*wvec)[0][0] ; // cout << ycorr << endl; // // Decision process // unsigned int Ns=(1 << Nb()); unsigned int symbol_id=Ns, outbit; double mindist=VERY_BIG_FLOAT; for (unsigned int sid=0; sid<Ns; sid++){ if (distance(sid,ycorr)<mindist) { symbol_id=sid; mindist=distance(sid,ycorr); } } for (int i=0; i<Nb(); i++) { outbit=( gray_decoding[symbol_id] >> (Nb()-i-1) ) & 0x1; out1.DeliverDataObj( outbit ); } }
void MainWindow::_update_scene_matrix(const QMatrix4x4& mat) { QMatrix4x4 moo; QVector3D eye(sqrt(2.0)*_axis_len/2.0, 0, sqrt(2.0)*_axis_len/2.0); QVector3D center(0,0,0); QVector3D up(0,1,0); //moo.lookAt(eye,center,up); QVector4D xvec(_axis_len,0,0,1); QVector4D yvec(0,_axis_len,0,1); QVector4D zvec(0,0,_axis_len,1); xvec = moo*_mat*xvec; yvec = moo*_mat*yvec; zvec = moo*_mat*zvec; _xitem->setLine(0,0,xvec.x(),-xvec.y()); _yitem->setLine(0,0,yvec.x(),-yvec.y()); _zitem->setLine(0,0,zvec.x(),-zvec.y()); }
CString CGenethonDoc::runTest3(PyObject *pModule, CString& function) { CString output = CString(); PyObject *pDict, *pFunc; PyObject *pArgTuple, *pValue, *pXVec, *pYVec; PyObject *ptype, *pvalue, *ptraceback; int i; // Set the path to include the current directory in case the module is located there. Found from // http://stackoverflow.com/questions/7624529/python-c-api-doesnt-load-module // and http://stackoverflow.com/questions/7283964/embedding-python-into-c-importing-modules if (pModule != NULL) { pFunc = PyObject_GetAttrString(pModule, function); //Get the function by its name // pFunc is a new reference if (pFunc && PyCallable_Check(pFunc)) { //Set up a tuple that will contain the function arguments. In this case, the //function requires two tuples, so we set up a tuple of size 2. pArgTuple = PyTuple_New(2); //Make some vectors containing the data static const double xarr[] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14 }; std::vector<double> xvec(xarr, xarr + sizeof(xarr) / sizeof(xarr[0])); static const double yarr[] = { 0,0,1,1,0,0,2,2,0,0,1,1,0,0 }; std::vector<double> yvec(yarr, yarr + sizeof(yarr) / sizeof(yarr[0])); //Transfer the C++ vector to a python tuple pXVec = PyTuple_New(xvec.size()); for (i = 0; i < xvec.size(); ++i) { pValue = PyFloat_FromDouble(xvec[i]); if (!pValue) { Py_DECREF(pXVec); Py_DECREF(pModule); return "Cannot convert array value\n"; } PyTuple_SetItem(pXVec, i, pValue); } //Transfer the other C++ vector to a python tuple pYVec = PyTuple_New(yvec.size()); for (i = 0; i < yvec.size(); ++i) { pValue = PyFloat_FromDouble(yvec[i]); if (!pValue) { Py_DECREF(pYVec); Py_DECREF(pModule); return "Cannot convert array value\n"; } PyTuple_SetItem(pYVec, i, pValue); // } //Set the argument tuple to contain the two input tuples PyTuple_SetItem(pArgTuple, 0, pXVec); PyTuple_SetItem(pArgTuple, 1, pYVec); //Call the python function pValue = PyObject_CallObject(pFunc, pArgTuple); Py_DECREF(pArgTuple); // Py_DECREF(pXVec); // Py_DECREF(pYVec); if (pValue != NULL) { PyObject* v = PyObject_GetAttrString(pModule, "richTextOutput"); output.Format("Result of call: %ld", PyLong_AsLong(pValue)); Py_DECREF(pValue); } //Some error catching else { Py_DECREF(pFunc); Py_DECREF(pModule); return handlePyError(); } } else { if (PyErr_Occurred()) { return handlePyError(); } } Py_XDECREF(pFunc); Py_DECREF(pModule); } else { return handlePyError(); } return output; }
FoMo::RenderCube CGAL2D(FoMo::GoftCube goftcube, const double l, const int x_pixel, const int y_pixel, const int lambda_pixel, const double lambda_width) { // // results is an array of at least dimension (x2-x1+1)*(y2-y1+1)*lambda_pixel and must be initialized to zero // // determine contributions per pixel typedef K::FT Coord_type; typedef K::Point_2 Point; std::map<Point, Coord_type, K::Less_xy_2> peakmap, fwhmmap, losvelmap; // typedef CGAL::Data_access< std::map<Point, Coord_type, K::Less_xyz_3 > > Value_access; int commrank; #ifdef HAVEMPI MPI_Comm_rank(MPI_COMM_WORLD,&commrank); #else commrank = 0; #endif //FoMo::DataCube goftcube=object.datacube; FoMo::tgrid grid = goftcube.readgrid(); int ng=goftcube.readngrid(); // We will calculate the maximum image coordinates by projecting the grid onto the image plane // Rotate the grid over an angle -l (around z-axis), and -b (around y-axis) // Take the min and max of the resulting coordinates, those are coordinates in the image plane if (commrank==0) std::cout << "Rotating coordinates to POS reference... " << std::flush; std::vector<double> xacc, yacc, zacc; xacc.resize(ng); yacc.resize(ng); zacc.resize(ng); std::vector<double> gridpoint; gridpoint.resize(3); Point temporarygridpoint; // Define the unit vector along the line-of-sight: the LOS is along y std::vector<double> unit = {cos(l), sin(l)}; // Read the physical variables FoMo::tphysvar peakvec=goftcube.readvar(0);//Peak intensity FoMo::tphysvar fwhmvec=goftcube.readvar(1);// line width, =1 for AIA imaging FoMo::tphysvar vx=goftcube.readvar(2); FoMo::tphysvar vy=goftcube.readvar(3); double losvelval; // No openmp possible here // Because of the insertions at the end of the loop, we get segfaults :( /*#ifdef _OPENMP #pragma omp parallel for #endif*/ for (int i=0; i<ng; i++) { for (int j=0; j<2; j++) gridpoint[j]=grid[j][i]; xacc[i]=gridpoint[0]*cos(l)-gridpoint[1]*sin(l);// rotated grid yacc[i]=gridpoint[0]*sin(l)+gridpoint[1]*cos(l); temporarygridpoint=Point(grid[0][i],grid[1][i]); //position vector // also create the map function_values here std::vector<double> velvec = {vx[i], vy[i]};// velocity vector losvelval = inner_product(unit.begin(),unit.end(),velvec.begin(),0.0);//velocity along line of sight for position [i]/[ng] losvelmap[temporarygridpoint]=Coord_type(losvelval); peakmap[temporarygridpoint]=Coord_type(peakvec[i]); fwhmmap[temporarygridpoint]=Coord_type(fwhmvec[i]); /* peakmap.insert(make_pair(temporarygridpoint,Coord_type(peakvec[i]))); fwhmmap.insert(make_pair(temporarygridpoint,Coord_type(fwhmvec[i]))); losvelmap.insert(make_pair(temporarygridpoint,Coord_type(losvelval)));*/ } double minx=*(min_element(xacc.begin(),xacc.end())); double maxx=*(max_element(xacc.begin(),xacc.end())); double miny=*(min_element(yacc.begin(),yacc.end())); double maxy=*(max_element(yacc.begin(),yacc.end())); /* Value_access peak=Value_access(peakmap); Value_access fwhm=Value_access(fwhmmap); Value_access losvel=Value_access(losvelmap);*/ xacc.clear(); // release the memory yacc.clear(); if (commrank==0) std::cout << "Done!" << std::endl; std::string chiantifile=goftcube.readchiantifile(); double lambda0=goftcube.readlambda0();// lambda0=AIA bandpass for AIA imaging double lambda_width_in_A=lambda_width*lambda0/speedoflight; Delaunay_triangulation_2 DT=triangulationfrom2Ddatacube(goftcube); Delaunay_triangulation_2 * DTpointer=&DT; if (commrank==0) std::cout << "Building frame: " << std::flush; double x,y,z,intpolpeak,intpolfwhm,intpollosvel,lambdaval,tempintens; int li,lj,ind; Point p,nearest; Delaunay_triangulation_2::Vertex_handle v; Delaunay_triangulation_2::Locate_type lt; Delaunay_triangulation_2::Face_handle c; boost::progress_display show_progress(x_pixel*y_pixel); //initialize grids FoMo::tgrid newgrid; FoMo::tcoord xvec(x_pixel*lambda_pixel),yvec(x_pixel*lambda_pixel),lambdavec(x_pixel*lambda_pixel); newgrid.push_back(xvec); if (lambda_pixel > 1) newgrid.push_back(lambdavec); FoMo::tphysvar intens(x_pixel*lambda_pixel,0); #ifdef _OPENMP #pragma omp parallel for schedule(dynamic) private (x,y,p,lt,li,v,nearest,intpolpeak,intpolfwhm,intpollosvel,lambdaval,tempintens,ind) #endif for (int j=0; j<x_pixel; j++) { #ifdef _OPENMP #pragma omp task #endif for (int i=0; i<y_pixel; i++) // scanning through ccd { x = double(j)/(x_pixel-1)*(maxx-minx)+minx; y = double(i)/(y_pixel-1)*(maxy-miny)+miny; // calculate the interpolation in the original frame of reference // i.e. derotate the point using angles -l and -b p= {x*cos(l)+y*sin(l),-x*sin(l)+y*cos(l)}; c=DTpointer->locate(p,lt,li); // Only look for the nearest point and interpolate, if the point p is inside the convex hull. if (lt!=Delaunay_triangulation_2::OUTSIDE_CONVEX_HULL) { // is this a critical operation? v=DTpointer->nearest_vertex(p,c); nearest=v->point(); /* This is how it is done in the CGAL examples pair<Coord_type,bool> tmppeak=peak(nearest); pair<Coord_type,bool> tmpfwhm=fwhm(nearest); pair<Coord_type,bool> tmplosvel=losvel(nearest); intpolpeak=tmppeak.first; intpolfwhm=tmpfwhm.first; intpollosvel=tmplosvel.first;*/ intpolpeak=peakmap[nearest]; intpolfwhm=fwhmmap[nearest]; intpollosvel=losvelmap[nearest]; } else { intpolpeak=0; } if (lambda_pixel>1)// spectroscopic study { for (int il=0; il<lambda_pixel; il++) // changed index from global variable l into il [D.Y. 17 Nov 2014] { // lambda is made around lambda0, with a width of lambda_width lambdaval=double(il)/(lambda_pixel-1)*lambda_width_in_A-lambda_width_in_A/2.; tempintens=intpolpeak*exp(-pow(lambdaval-intpollosvel/speedoflight*lambda0,2)/pow(intpolfwhm,2)*4.*log(2.)); ind=j*lambda_pixel+il;// newgrid[0][ind]=x; newgrid[2][ind]=lambdaval+lambda0; // this is critical, but with tasks, the ind is unique for each task, and no collision should occur intens[ind]+=tempintens;// loop over z and lambda [D.Y 17 Nov 2014] } } if (lambda_pixel==1) // AIA imaging study. Algorithm not verified [DY 14 Nov 2014] { tempintens=intpolpeak; ind=j; newgrid[0][ind]=x; intens[ind]+=tempintens; // loop over z [D.Y 17 Nov 2014] } // print progress ++show_progress; } } if (commrank==0) std::cout << " Done! " << std::endl << std::flush; FoMo::RenderCube rendercube(goftcube); FoMo::tvars newdata; double pathlength=(maxy-miny)/(y_pixel-1); intens=FoMo::operator*(pathlength*1e8,intens); // assume that the coordinates are given in Mm, and convert to cm newdata.push_back(intens); rendercube.setdata(newgrid,newdata); rendercube.setrendermethod("CGAL2D"); rendercube.setresolution(x_pixel,y_pixel,1,lambda_pixel,lambda_width); if (lambda_pixel == 1) { rendercube.setobservationtype(FoMo::Imaging); } else { rendercube.setobservationtype(FoMo::Spectroscopic); } return rendercube; }
std::vector<double> tb_lt_invert_Cpp_impl(double t, const std::vector<double>& lambda1, const std::vector<double>& lambda2, const std::vector<double>& lambda3, const int Ap1, const int Bp1, const int Cp1, const int direction, const int nblocks, const double tol, int& Lmax, ParallelizationScheme& scheme) { // auto start = std::chrono::steady_clock::now(); const double double_PI = 3.141592653589793238463, AA = 20.0; const int matsize = Ap1*Bp1*Cp1; std::vector<mytype::ComplexVector> ig; std::vector<double> res(matsize), yvec(matsize); for (int i=0; i<matsize; ++i) { yvec[i] = lambda1[i] + lambda2[i] + lambda3[i]; } ///////////////////////////////////////////////////////////// // The following code computes the inverse Laplace transform // Algorithm from Abate and Whitt using a Riemann sum // Levin tranform is used to accelerate the convergence ///////////////////////////////////////////////////////////// ig.resize(Lmax); scheme.for_each( boost::make_counting_iterator(0), boost::make_counting_iterator(Lmax), [&](int w) { mytype::ComplexNumber s(AA/(2*t),double_PI*(w+1)/t); ig[w].resize(matsize); tb_lt_Cpp(s,lambda1,lambda2,lambda3,Ap1,Bp1,Cp1,direction,yvec,ig[w]); }); mytype::ComplexNumber s(AA/(2*t),0.0); mytype::ComplexVector psum0(matsize); tb_lt_Cpp(s,lambda1,lambda2,lambda3,Ap1,Bp1,Cp1,direction,yvec,psum0); std::for_each(boost::make_counting_iterator(0), boost::make_counting_iterator(matsize), [&](int i) { Levin levin(tol); // A struct for Levin transform double term = 1e16, sdiff = 1e16; int k = 1; double psum = real(psum0[i])/(2*t); double sk,sk1; while ((std::abs(sdiff) > 1e-16)||(std::abs(term)>1e-3)) { double sgn = (k%2 == 0) ? 1.0 : -1.0; term = sgn*real(ig[k-1][i])/t; psum += term; double omega = k*term; sk = levin.next(psum,omega,1.0); if (k>1) sdiff = sk - sk1; k++; sk1 = sk; if (k > Lmax) { ig.resize(Lmax+nblocks); scheme.for_each( boost::make_counting_iterator(0), boost::make_counting_iterator(nblocks), [&](int w) { mytype::ComplexNumber s(AA/(2*t),double_PI*(w+Lmax+1)/t); ig[w+Lmax].resize(matsize); tb_lt_Cpp(s,lambda1,lambda2,lambda3,Ap1,Bp1,Cp1,direction,yvec,ig[w+Lmax]); }); Lmax += nblocks; } } res[i] = sk1*exp(AA/2); }); // Rcpp::Rcout << "Lmax: " << Lmax; // auto end = std::chrono::steady_clock::now(); // // using TimingUnits = std::chrono::microseconds; // Rcpp::Rcout << "Time: " << std::chrono::duration_cast<TimingUnits>(end - start).count() << std::endl; return(std::move(res)); }