void ExcitedStates::updateMoPlot(int const index)
{
   clearTransitionLines();
   QList<Data::Amplitude>  amplitudes(m_excitedStates.data().amplitudes(index));

   qDebug() << "Number of amplitudes" << amplitudes.size();

   QPen pen;
   QColor color;
   pen.setStyle(Qt::SolidLine);
   pen.setWidth(3);

   double dx(-0.2);
   QList<Data::Amplitude>::const_iterator iter;
   for (iter = amplitudes.begin(); iter != amplitudes.end(); ++iter) {

       color.setHsv(280, 255*std::abs((*iter).m_amplitude), 255);
       pen.setColor(color);

       QCPItemLine* line(new QCPItemLine(m_moPlot));
       line->setSelectable(true);
       m_transitionLines.append(line);

       double x( ((*iter).m_spin == Data::Alpha) ? 0.75 : 2.5 );
       line->position("start")->setCoords(x+dx, (*iter).m_ei);
       line->position("end")->setCoords(x+dx, (*iter).m_ea);
       dx += 0.1;

       line->setPen(pen);
       line->setSelectedPen(m_selectedPen);
       line->setHead(QCPLineEnding::esSpikeArrow);
   }

   m_moPlot->replot();
}
Example #2
0
    VCRDecoder()
    {
        FileStream inputStream = File("U:\\c2.raw", true).openRead();
        //FileStream inputStream = File("U:\\captured.bin", true).openRead();
        int nn = inputStream.size();

        FileStream h = File("U:\\vcr_decoded.bin", true).openWrite();

        int samplesPerFrame = 1824*253;
        Array<Byte> input(samplesPerFrame);
        _fftData.allocate(2048);
        _chromaData.allocate(2048);
        _burstData.allocate(91);
        _forward = fftwf_plan_dft_1d(2048, reinterpret_cast<fftwf_complex*>(&_fftData[0]), reinterpret_cast<fftwf_complex*>(&_fftData[0]), -1, FFTW_MEASURE);
        _backward = fftwf_plan_dft_1d(2048, reinterpret_cast<fftwf_complex*>(&_fftData[0]), reinterpret_cast<fftwf_complex*>(&_fftData[0]), 1, FFTW_MEASURE);
        _chromaForward = fftwf_plan_dft_1d(2048, reinterpret_cast<fftwf_complex*>(&_chromaData[0]), reinterpret_cast<fftwf_complex*>(&_chromaData[0]), -1, FFTW_MEASURE);
        _chromaBackward = fftwf_plan_dft_1d(2048, reinterpret_cast<fftwf_complex*>(&_chromaData[0]), reinterpret_cast<fftwf_complex*>(&_chromaData[0]), 1, FFTW_MEASURE);
        Complex<float> localOscillatorFrequency = unit(4.4f*11/315);
        Complex<float> chromaOscillatorFrequency = unit(2.0f/91);  // 0.629 == 315/11 / 2 / 4 * 16 / 91      0.629f*11/315 == 16/8/91

        //static const float cutoff = 3.0f*2048*11/315;  // 3.3f
        //static const int cutoff = 208;
        static const int cutoff = static_cast<int>(2.2f*2048*11/315);
        static const int chromaCutoff = static_cast<int>(2048.0*2.0/91)*0.75;  // *0.5;

        _outputb0.allocate(2048);
        _outputb1.allocate(2048);

        Array<Complex<float>> amplitudes(253);
        for (int y = 0; y < 253; ++y)
            amplitudes[y] = 0;

        Array<Vector3<float>> frameCache(3*2048*253);
        for (int i = 0; i < 3*2048*253; ++i)
            frameCache[i] = Vector3<float>(0, 0, 0);

        int frame = 0;
        Complex<float> burstAcc = 0;
        Complex<float> framePhase = unit((90 - 33)/360.0f);
    }
Example #3
0
int main(int argc, char *argv[])
{
    try {
        StandardException exc;
        if(argc < 3)
        {
            std::string exceptionString = "Need to specify the spline type (linear or cubic) and the number of (internal) knots.";
            exc.set(exceptionString);
            throw exc;
        }

        bool isLinear = true;
        if(argv[1][0] == 'c')
            isLinear = false;

        const int nKnots = std::atoi(argv[2]);

        if(nKnots < 0 || nKnots > 100)
        {
            std::stringstream exceptionStr;
            exceptionStr << "The number of knots " << nKnots << " is invalid. Needs to be positive and not larger than 100.";
            exc.set(exceptionStr.str());
            throw exc;
        }

        bool varyNEff = false;
        bool varySumMNu = false;

        for(int i = 3; i < argc; ++i)
        {
            if(std::string(argv[i]) == "neff")
                varyNEff = true;
            if(std::string(argv[i]) == "sum_mnu")
                varySumMNu = true;
        }

        int nPar = 4 + 2 * (nKnots + 2) - 2;

        if(varyNEff)
        {
            ++nPar;
            output_screen("Varying N_eff!" << std::endl);
        }
        else
        {
            output_screen("N_eff not being varied. To vary it give \"neff\" as an extra argument." << std::endl);
        }
        
        if(varySumMNu)
        {
            ++nPar;
            output_screen("Varying sum_mnu!" << std::endl);
        }
        else
        {
            output_screen("sum_mnu not being varied. To vary it give \"sum_mnu\" as an extra argument." << std::endl);
        }

        // for A_planck
        ++nPar;

        const double kMin = 0.8e-6;
        const double kMax = 1.2;
        const double aMin = -2;
        const double aMax = 4;

        std::vector<double> kVals(nKnots + 2);
        std::vector<double> amplitudes(nKnots + 2, 2e-9);

        kVals[0] = kMin;
        kVals.back() = kMax;

        const double deltaLogK = (std::log(kMax) - std::log(kMin)) / (nKnots + 1);

        for(int i = 1; i < kVals.size() - 1; ++i)
            kVals[i] = std::exp(std::log(kMin) + i * deltaLogK);

        SplineWithDegenerateNeutrinosParams params(isLinear, 0.022, 0.12, 0.7, 0.1, kVals, amplitudes, 3.046, 0, 0, varyNEff, varySumMNu);

#ifdef COSMO_PLANCK_15
        PlanckLikelihood planckLike(true, true, true, false, true, false, false, false, 100);
#else
        ERROR NOT IMPLEMENTED;
#endif
        planckLike.setModelCosmoParams(&params);

        std::stringstream root;
        root << "knotted_";
        if(isLinear)
            root << "linear_";
        else
            root << "cubic_";
        root << nKnots;
        if(varyNEff)
            root << "_neff";
        if(varySumMNu)
            root << "_summnu";
        PolyChord pc(nPar, planckLike, 300, root.str(), 3 * (4 + (varyNEff ? 1 : 0) + (varySumMNu ? 1 : 0)));

        int paramIndex = 0;

        pc.setParam(paramIndex++, "ombh2", 0.02, 0.025, 1);
        pc.setParam(paramIndex++, "omch2", 0.1, 0.2, 1);
        pc.setParam(paramIndex++, "h", 0.55, 0.85, 1);
        pc.setParam(paramIndex++, "tau", 0.02, 0.20, 1);
        if(varyNEff)
            pc.setParam(paramIndex++, "n_eff", 2.0, 5.0, 1);
        if(varySumMNu)
            pc.setParam(paramIndex++, "sum_mnu", 0.001, 3.0, 1);

        for(int i = 1; i < kVals.size() - 1; ++i)
        {
            std::stringstream paramName;
            paramName << "k_" << i;
            pc.setParamSortedUniform(paramIndex++, paramName.str(), std::log(kMin), std::log(kMax), 0, 2);
        }

        for(int i = 0; i < amplitudes.size(); ++i)
        {
            std::stringstream paramName;
            paramName << "a_" << i;
            pc.setParam(paramIndex++, paramName.str(), aMin, aMax, 2);
        }
#ifdef COSMO_PLANCK_15
        pc.setParamGauss(paramIndex++, "A_planck", 1, 0.0025, 3);
#else
        ERROR NOT IMPLEMENTED;
#endif
        check(paramIndex == nPar, "");

        const std::vector<double> fracs{0.7, 0.25, 0.05};
        pc.setParameterHierarchy(fracs);

        pc.run(true);
    } catch (std::exception& e)
    {
        output_screen("EXCEPTION CAUGHT!!! " << std::endl << e.what() << std::endl);
        output_screen("Terminating!" << std::endl);
        return 1;
    }
    return 0;
}
Example #4
0
int main(int argc, char *argv[])
{
    std::string file_name = argv[1];
    
    bool isLinear = true;
    if(argv[2][0] == 'c')
        isLinear = false;

    const int nKnots = std::atoi(argv[3]);

    bool varyNEff = false;
    bool varySumMNu = false;

    for(int i = 4; i < argc; ++i)
    {
        if(std::string(argv[i]) == "neff")
            varyNEff = true;
        if(std::string(argv[i]) == "sum_mnu")
            varySumMNu = true;
    }

    int nPar = 4 + 2 * (nKnots + 2) - 2;

    if(varyNEff)
        ++nPar;

    if(varySumMNu)
        ++nPar;

    // Starting values for cosmological parameters
    // From Planck 2015 (http://arxiv.org/abs/1502.01589), Table 3, Column 4
    const double h = 0.6727;
    const double omBH2 = 0.02225;
    const double omCH2 = 0.1198;
    const double tau = 0.079;
    const double ns = 0.9645;
    const double as = 3.094; // ln(10^10*as)
    const double pivot = 0.05;

    const double kMin = 0.8e-6;
    const double kMax = 1.2;
    const double aMin = -2;
    const double aMax = 4;

    std::vector<double> kVals(nKnots + 2);
    std::vector<double> amplitudes(nKnots + 2);

    kVals[0] = kMin;
    kVals.back() = kMax;

    const double deltaLogK = (std::log(kMax) - std::log(kMin)) / (nKnots + 1);

    for(int i = 1; i < kVals.size() - 1; ++i)
        kVals[i] = std::exp(std::log(kMin) + i * deltaLogK);

    for(int i = 0; i < amplitudes.size(); ++i)
        amplitudes[i] = (std::exp(as)/1e10) * pow(kVals[i]/pivot, ns - 1.0);

    int nMassive = (varySumMNu ? 1 : 0);
    double nEff = 3.046; 
    double sumMNu = 0.0;

    SplineWithDegenerateNeutrinosParams params(isLinear, omBH2, omCH2, h, tau, kVals, amplitudes, nEff, nMassive, sumMNu, varyNEff, varySumMNu);

    Cosmo cosmo;
    cosmo.preInitialize(3500, false, true, false);

    std::ifstream datafile(file_name);
    std::ofstream outfile(file_name.substr(0, file_name.size()-4) + "sigma8.txt");
    std::string line;
    while(getline(datafile, line))
    {
        std::istringstream iss(line);
        std::vector<double> vec;
        double dummy;
        while(iss >> dummy)
            vec.push_back(dummy);
        std::vector<double> v(&vec[2], &vec[vec.size()-1]);
        params.setAllParameters(v);
        cosmo.initialize(params, true, true, true, true, 1.0);
        for(int i = 0; i < vec.size(); ++i)
            outfile << vec[i] << ' ';
        outfile << cosmo.sigma8() << std::endl;
    }
    outfile.close();
    datafile.close();

    return 0;
}
Example #5
0
int main(int argc, char* argv[])
{
    int nang, N;
    float dx, dz;
    int nx, nz;
    float ox, oz;
    int gnx, gnz;
    float gdx, gdz, gox, goz;
    struct point length;
    int inter;
    float TETAMAX, alpha2;
    FILE *outfile;
    int ii;
    int rays, wfront, gap;
    int lomx, first;
    int nr, nrmax, nt;
    int prcube, pr, ste;
    int ns, nou;
    float DSmax, dt, T, freq;
    float *vel;
    float ds, os, goox;
    float xmin, xmax, zmin, zmax;
    float depth;
    struct point *pos;
    struct heptagon *cube;
    struct grid *out;
    sf_file inp, ampl, time;

    sf_init(argc,argv);
    inp = sf_input("in");

/* GET MODEL PARAMETERS	*/
    if (!sf_histint(inp,"n1",&nz)) sf_error("No n1= in input");
    if (!sf_histint(inp,"n2",&nx)) sf_error("No n2= in input");
    if (!sf_histfloat(inp,"d1",&dz)) sf_error("No d1= in input");
    if (!sf_histfloat(inp,"d2",&dx)) sf_error("No d2= in input");
    if (!sf_histfloat(inp,"o1",&oz)) sf_error("No o1= in input");
    if (!sf_histfloat(inp,"o2",&ox)) sf_error("No o2= in input");

/* GET TRACING PARAMETERS */
    if(!sf_getint("nang",&nang))        nang = 10;    /* Number of take-off angles */
    if(!sf_getint("rays",&rays))        rays = 0;     /* If draw rays */
    if(!sf_getint("wfront",&wfront))    wfront = 0;   /* If draw wavefronts */ 
    if(!sf_getint("gap",&gap))        	gap = 1;      /* Draw wavefronts every gap intervals */
    if(!sf_getint("inter",&inter))      inter = 1;    /* If use linear interpolation */
    if(!sf_getfloat("DSmax",&DSmax))    DSmax = 5;    /* Maximum distance between contiguos points of a wavefront */
    if(!sf_getfloat("dt",&dt))          dt = 0.0005;  /* time step */
    if(!sf_getint("nt",&nt))            nt = 5;       /* Number of time steps between wavefronts */
    if(!sf_getint("nrmax",&nrmax))      nrmax = 2000; /* Maximum number of points that define a wavefront */
    if(!sf_getint("lomx",&lomx))        lomx = 1;     /* Use Lomax's waveray method */
    if(!sf_getint("first",&first))      first = 1;    /* Obtain first arrivals only */
    if(!sf_getint("nou",&nou))      	nou = 6;      

/* GET GRIDDING PARAMETERS */
    if(!sf_getint("gnx",&gnx))		gnx = nx;    /* Coordinates of output grid */
    if(!sf_getint("gnz",&gnz))		gnz = nz;
    if(!sf_getfloat("gdx",&gdx))	gdx = dx;
    if(!sf_getfloat("gdz",&gdz))	gdz = dz;
    if(!sf_getfloat("gox",&goox))	goox = ox;
    if(!sf_getfloat("goz",&goz))	goz = oz;

/* GET LOMAX SPECIFIC PARAMETERS */
    if(!sf_getint("N",&N))                N = 3;         /* Number of control points */
    if(!sf_getfloat("TETAMAX",&TETAMAX))  TETAMAX = 1.5; /* Truncation parameter */
    if(!sf_getfloat("alpha2",&alpha2))    alpha2 = 4.0;  /* Width of gaussian weighting function */
    if(!sf_getfloat("freq",&freq))	  freq = 100.;   /* Pseudo-frequency of waverays */

/* GET DEBUGGING INFO */
    if(!sf_getint("prcube",&prcube)) 	prcube=0;        /* For debugging porpouses */
    if(!sf_getint("pr",&pr)) 		pr=0;            /* For debugging porpouses */

/* GET SOURCE LOCATIONS */
    if(!sf_getint("ns",&ns) || ns==0)	  ns=1;          /* Number of source locations */
    if(!sf_getfloat("ds",&ds))		  ds=1.;         /* interval between sources */
    if(!sf_getfloat("os",&os))		  os=0.;         /* first source location */
    if(!sf_getfloat("depth",&depth))	  depth=dz;      /* Depth location of sources */

    pos = (struct point *) sf_alloc (ns,sizeof(struct point));
    for(ii=0;ii<ns;ii++) {
	pos[ii] = makepoint(ii*ds + os, depth);
    }

/* PREPARE OUTPUT */
    ampl = sf_output("ampl");
    sf_putint(ampl,"n1",gnz);
    sf_putint(ampl,"n2",gnx);
    sf_putint(ampl,"n3",ns);
    sf_putfloat(ampl,"d1",gdz);
    sf_putfloat(ampl,"d2",gdx);
    sf_putfloat(ampl,"d3",ds);
    sf_putfloat(ampl,"o1",goz);
    sf_putfloat(ampl,"o2",goox);
    sf_putfloat(ampl,"o3",os);

    time = sf_output("time");
    sf_putint(time,"n1",gnz);
    sf_putint(time,"n2",gnx);
    sf_putint(time,"n3",ns);
    sf_putfloat(time,"d1",gdz);
    sf_putfloat(time,"d2",gdx);
    sf_putfloat(time,"d3",ds);
    sf_putfloat(time,"o1",goz);
    sf_putfloat(time,"o2",goox);
    sf_putfloat(time,"o3",os);

/* READ VELOCITY MODEL */
    vel = sf_floatalloc(nx*nz+2);
    sf_floatread(vel,nx*nz,inp); 

/* ALLOCATE MEMORY FOR OUTPUT */
    out = (struct grid *) sf_alloc (1,sizeof(struct grid));

    out->time = sf_floatalloc (gnx*gnz);
    out->ampl = sf_floatalloc (gnx*gnz);
    out->flag = sf_intalloc (gnx*gnz);

    T = 1. / freq;

    length = makepoint((nx-1)*dx,(nz-1)*dz);

    cube = (struct heptagon *) sf_alloc (nrmax,sizeof(struct heptagon));

/* FOR DEBUGGING PORPOUSES, PRINT TO FILE */
    if(pr||prcube) {
	outfile = fopen("junk","w");
    } else {
	outfile = NULL;
    }

/*  SET DISPLAY IN ORDER TO SHOW RAYS ON SCREEN */
/*  NOTE: THIS PROGRAM USES DIRECT CALLS TO LIB_VPLOT
 *  TO DRAW THE RAYS AND THE WAVEFRONTS */
    if(rays || wfront) {
	setgraphics(ox, oz, length.x, length.z);
/*
	vp_color(BLUE);
	for(ii=0;ii<gnx;ii++)  {
	    vp_umove(ii*gdx+gox, goz); vp_udraw(ii*gdx+gox, (gnz-1)*gdz+goz); }
	for(ii=0;ii<gnz;ii++) {
	    vp_umove(gox, ii*gdz+goz); vp_udraw((gnx-1)*gdx+gox, ii*gdz+goz); } 
*/
    }

    norsar_init(gnx,gnz,
		TETAMAX,N,alpha2,inter,
		nx,nz,ox,oz,dx,dz,length);

/*  ALGORITHM: 
 *    For every source: */
    for(ii=0;ii<ns;ii++) {
	ste = 0;
	gox = goox + pos[ii].x;
	sf_warning("\nSource #%d\n", ii);

/*	1.- Construct the inital wavefront 			*/
	nr = nang;
    	initial (pos[ii], cube, vel, dt, nt, T, lomx, nr, out);

	gridding_init(gnx,gnz,
		      gdx,gdz,gox,goz,
		      outfile);

/*	run while the wavefront is not too small 		*/
	while (nr > 4) {
	    ste++;

/*	    2.- Propagate wavefront 				*/
	    wavefront (cube, nr, vel, dt, nt, T, lomx);
	    if(prcube || pr) {
		fprintf(outfile,"\n\nwavefront");
		printcube(cube, nr, outfile);
	    }

/*	    3.- Get rid of caustics				*/
            if(first) {
		if(ste%2==1) {			
		    caustics_up (cube, 0, nr);
		} else {
		    caustics_down (cube, nr-1, nr);
		}					
		if(prcube || pr) {	
		    fprintf(outfile,"\n\ncaustics");
		    printcube(cube, nr, outfile);
		}
	    }

/*          4.- Eliminate rays that cross boundaries, defined
		by xmin, xmax, zmin, zmax.
		Note that the computational grid is a little bigger 
		than the ouput grid. 				*/

	    xmin = gox-nou*gdx;	xmax = 2*pos[ii].x-gox+nou*gdx;
	    zmin = oz-nou*gdz;	zmax = length.z+oz+nou*gdz;
            mark_pts_outofbounds (cube, nr, xmin, xmax, zmin, zmax);
	    if(prcube) {
                fprintf(outfile, "\n\nboundaries");
                printcube(cube, nr, outfile);
            }

/*          5.- Rearrange cube                                  */
            makeup(cube, &nr);
	    if(nr<4) break;
	    if(prcube || pr) {	
                fprintf(outfile, "\n\nmakeup");
                printcube(cube, nr, outfile);
            }

/*          6.- Calculate amplitudes for new wavefront 		*/
	    amplitudes (cube, nr); 
	    if(prcube) {
                fprintf(outfile, "\n\namplitudes");
                printcube(cube, nr, outfile);
            }

/*	    7.- Draw rays 					*/
	    if(rays)
		draw_rays (cube, nr); 

/*          8.- Draw wavefront 					*/
	    if(wfront && (ste%gap==0)) 
		draw_wavefronts (cube, nr, DSmax); 

/*          9.- Parameter estimation at receivers 		*/
	    gridding (cube, nr, out, DSmax, (ste-1)*nt*dt, vel, first); /* pos[ii]); */

/*          10.- Interpolate new points of wavefront 		*/
            interpolation (cube, &nr, nrmax, DSmax); /* 0); */
	    if(prcube) {
                fprintf(outfile,"\n\ninterpolation");
                printcube(cube, nr, outfile);
            }

/*	    11.- Prepare to trace new wavefront 		*/
	    movwavf (cube, nr);
	    if(prcube) {
                fprintf(outfile,"\n\nmovwavf");
                printcube(cube, nr, outfile);
            }

	    if((wfront || rays) && (ste%gap==0)) vp_erase();
	}

/*	Finally interpolate amplitude and traveltime values to
        receivers that has not being covered.			*/
	TwoD_interp (out, gnx, gnz);

	sf_floatwrite(out->time, gnx * gnz, time); 
	sf_floatwrite(out->ampl, gnx * gnz, ampl);  
    }

   if(pr||prcube)
	fclose(outfile);

   exit(0);
}