void Wf_return::setVals(Array2 <dcomplex> & vals , Array1 <doublevar> & p) { // here we extract amplitude and phase, and their gradients and laplacians, // from the complex value and its gradient and derivative is_complex=1; cvals=vals; int ntype=vals.GetDim(1); int nwf=vals.GetDim(0); for (int w=0; w< nwf; w++) { amp(w,0)=vals(w,0).real(); phase(w,0)=p(w); doublevar sum_ii=0; doublevar sum_ri=0; if (ntype>=4) { for (int i=1; i<4; i++) { amp(w,i)=vals(w,i).real(); phase(w,i)=vals(w,i).imag(); sum_ii+=phase(w,i)*phase(w,i); sum_ri+=amp(w,i)*phase(w,i); } } if (ntype>=5) { amp(w,4)=vals(w,4).real()+sum_ii; phase(w,4)=vals(w,4).imag()-2*sum_ri; } } }
void Wf_return::setVals(Array2 <log_value<doublevar> > & v ) { is_complex=0; int nfunc=v.GetDim(0); int nst=v.GetDim(1); Resize(nfunc,nst); for(int f=0; f< nfunc; f++) { amp(f,0)=v(f,0).logval; phase(f,0)=v(f,0).sign<0?pi:0.0; for(int s=1; s< nst; s++) { amp(f,s)=v(f,s).val(); phase(f,s)=0.0; } } }
void playWithHomeTheater() { // Create all the parts of the home theatre system Amplifier amp("Top-O-Line Amplifier"); CdPlayer cd("Top-O-Line CD Player", &); DvdPlayer dvd("Top-O-Line DVD Player", &); Screen screen("My Theater Screen"); PopcornPopper popper("My Popcorn Popper"); Tuner tuner("Top-O-Line AM/FM Tuner", &); TheaterLights lights("Theater Ceiling Lights"); Projector projector("Top-O-Line Projector"); popper.on(); // Turn on the popcorn popper... popper.pop(); // and start popping... lights.dim(10); // Dim the lights to 10%... screen.down(); // Put the screen down... projector.on(); // Turn on the projector... projector.setInput(&dvd); // set it to DVD... projector.wideScreenMode(); // and put it on wide screen mode for the movie... amp.on(); // Turn on the amp... amp.setInput(&dvd); // set it to DVD and... amp.setSurroundSound(); // put it into surround sound mode... amp.setVolume(11); // and set the volume to 11... dvd.on(); // Turn on the DVD player... dvd.play("Raiders of the lost ark"); // and FINALLY, play the movie! // What about shutting everything down again?! // How would you play a CD? etc... }
static A jttayamp(J jt,A w,B nf,A x,A h){A y;B ng=!nf;I j,n;V*v=VAV(h); ASSERT(AR(x)<=(nf?v->lr:v->rr),EVRANK); switch(v->id){ case CPLUS: R tpoly(over(x,one)); case CMINUS: R tpoly(nf?over(x,num[-1]):over(negate(x),one)); case CSTAR: R tpoly(over(zero,x)); case CDIV: ASSERT(ng,EVDOMAIN); R tpoly(over(zero,recip(x))); case CJDOT: R tpoly(nf?over(x,a0j1):over(jdot1(x),one)); case CPOLY: ASSERT(nf,EVDOMAIN); R tpoly(BOX&AT(x)?poly1(x):x); case CHGEOM: ASSERT(nf,EVDOMAIN); RE(j=i0(x)); ASSERT(0<=j,EVDOMAIN); y=IX(j); R tpoly(divide(hgcoeff(y,h),fact(y))); case CBANG: ASSERT(nf,EVDOMAIN); RE(j=i0(x)); ASSERT(0<=j,EVDOMAIN); R tpoly(divide(poly1(box(iota(x))),fact(x))); case CEXP: if(nf)R eva(x,"(^.x)&^ % !"); RE(n=i0(x)); R 0<=n?tpoly(over(reshape(x,zero),one)):atop(ds(CDIV),amp(h,sc(-n))); case CFIT: ASSERT(nf&&CPOLY==ID(v->f),EVDOMAIN); y=over(x,IX(IC(x))); R tpoly(mdiv(df2(x,y,h),atab(CEXP,y,IX(IC(x))))); case CCIRCLE: switch(i0(x)){ case 1: R eval("{&0 1 0 _1@(4&|) % !"); case -3: R eval("{&0 1 0 _1@(4&|) % ]"); case 2: R eval("{&1 0 _1 0@(4&|) % !"); case 5: R eval("2&| % !"); case -7: R eval("2&| % ]"); case 6: R eval("2&|@>: % !"); case -1: R eval("(2&| % ]) * ([: */ (1&+ % 2&+)@(i.@<.&.-:))\"0"); case -5: R eval("({&0 1 0 _1@(4&|) % ]) * ([: */ (1&+ % 2&+)@(i.@<.&.-:))\"0"); }} ASSERT(0,EVDOMAIN); }
EvtComplex EvtD0gammaDalitz::dalitzKsKK( const EvtDalitzPoint& point ) const { static const EvtDalitzPlot plot( _mKs, _mK, _mK, _mD0 ); // Defining resonances. static EvtDalitzReso a00_980 ( plot, _AC, _BC, _SCALAR, 0.999 , _RBW, .550173, .324, _EtaPic ); static EvtDalitzReso phi ( plot, _AC, _BC, _VECTOR, 1.01943, .00459319 , _RBW ); static EvtDalitzReso a0p_980 ( plot, _AC, _AB, _SCALAR, 0.999 , _RBW, .550173, .324, _EtaPic ); static EvtDalitzReso f0_1370 ( plot, _AC, _BC, _SCALAR, 1.350 , .265 , _RBW ); static EvtDalitzReso a0m_980 ( plot, _AB, _AC, _SCALAR, 0.999 , _RBW, .550173, .324, _EtaPic ); static EvtDalitzReso f0_980 ( plot, _AC, _BC, _SCALAR, 0.965 , _RBW, .695 , .165, _PicPicKK ); static EvtDalitzReso f2_1270 ( plot, _AC, _BC, _TENSOR, 1.2754 , .1851 , _RBW ); static EvtDalitzReso a00_1450( plot, _AC, _BC, _SCALAR, 1.474 , .265 , _RBW ); static EvtDalitzReso a0p_1450( plot, _AC, _AB, _SCALAR, 1.474 , .265 , _RBW ); static EvtDalitzReso a0m_1450( plot, _AB, _AC, _SCALAR, 1.474 , .265 , _RBW ); // Adding terms to the amplitude with their corresponding amplitude and phase terms. EvtComplex amp( 0., 0. ); // Phase space amplitude. amp += EvtComplex( 1.0 , 0.0 ) * a00_980 .evaluate( point ); amp += EvtComplex( -.126314 , .188701 ) * phi .evaluate( point ); amp += EvtComplex( -.561428 , .0135338 ) * a0p_980 .evaluate( point ); amp += EvtComplex( .035 , -.00110488 ) * f0_1370 .evaluate( point ); amp += EvtComplex( -.0872735 , .0791190 ) * a0m_980 .evaluate( point ); amp += EvtComplex( 0. , 0. ) * f0_980 .evaluate( point ); amp += EvtComplex( .257341 , -.0408343 ) * f2_1270 .evaluate( point ); amp += EvtComplex( -.0614342 , -.649930 ) * a00_1450.evaluate( point ); amp += EvtComplex( -.104629 , .830120 ) * a0p_1450.evaluate( point ); amp += EvtComplex( 0. , 0. ) * a0m_1450.evaluate( point ); return 2.8 * amp; // Multiply by 2.8 in order to reuse the same probmax as Ks pi pi. }
Cepstrum Spectrum_to_Cepstrum_hillenbrand (Spectrum me) { try { autoNUMfft_Table fftTable; // originalNumberOfSamplesProbablyOdd irrelevant if (my x1 != 0.0) { Melder_throw ("A Fourier-transformable Spectrum must have a first frequency of 0 Hz, not ", my x1, L" Hz."); } long numberOfSamples = my nx - 1; autoCepstrum thee = Cepstrum_create (0.5 / my dx, my nx); NUMfft_Table_init (&fftTable, my nx); autoNUMvector<double> amp (1, my nx); for (long i = 1; i <= my nx; i++) { amp [i] = my v_getValueAtSample (i, 0, 2); } NUMfft_forward (&fftTable, amp.peek()); for (long i = 1; i <= my nx; i++) { double val = amp[i] / numberOfSamples;// scaling 1/n because ifft(fft(1))= n; thy z[1][i] = val * val; // power cepstrum } return thee.transfer(); } catch (MelderError) { Melder_throw (me, ": not converted to Sound."); } }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTest::EresUnittest_RunAllNegativeTests // // @doc: // Run all negative tests for parsing DXL documents into DXL trees. // //--------------------------------------------------------------------------- GPOS_RESULT CParseHandlerTest::EresUnittest_RunAllNegativeTests() { CAutoMemoryPool amp(CAutoMemoryPool::ElcNone); IMemoryPool *pmp = amp.Pmp(); // loop over all test files for (ULONG ulFileNum = 0; ulFileNum < GPOS_ARRAY_SIZE(m_rgszNegativeTestsFileNames); ulFileNum++) { GPOS_TRY { // try running the test for the current file EresParseAndSerializePlan( pmp, m_rgszNegativeTestsFileNames[ulFileNum], true /* fValidate */ ); // if it does not throw an exception, then it failed return GPOS_FAILED; } GPOS_CATCH_EX(ex) { // these tests are supposed to throw exceptions, so if // the test throws an exception, then it is good GPOS_RESET_EX; } GPOS_CATCH_END; } return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CMiniDumperDXLTest::EresUnittest_Load // // @doc: // Load a minidump file // //--------------------------------------------------------------------------- GPOS_RESULT CMiniDumperDXLTest::EresUnittest_Load() { CAutoMemoryPool amp(CAutoMemoryPool::ElcExc); IMemoryPool *mp = amp.Pmp(); const CHAR *rgszMinidumps[] = { "../data/dxl/minidump/Minidump.xml", }; ULONG ulTestCounter = 0; GPOS_RESULT eres = CTestUtils::EresRunMinidumps ( mp, rgszMinidumps, 1, // ulTests &ulTestCounter, 1, // ulSessionId 1, // ulCmdId false, // fMatchPlans false // fTestSpacePruning ); return eres; }
void distortx_node_t::do_process( const render::context_t& context) { if( !expr_.get() || !expr_->isValid()) { image::make_color_bars( image_view()); return; } bool thread_safe = true; // while testing //bool thread_safe = expr_->isThreadSafe(); std::string warp_expr = get_value<std::string>( param( expr_param_name())); Imath::V2f amp( get_value<Imath::V2f>( param( "amplitude"))); amp /= context.subsample; se_expr_warp_fun f( this, warp_expr, amp, context); image_node_t *in = input_as<image_node_t>( 0); image_node_t *msk = input_as<image_node_t>( 1); if( msk) { mask_fun m( msk->const_image_view(), msk->defined()); masked_warp_fun<se_expr_warp_fun, mask_fun> mf( f, m); switch( get_value<int>( param( "borders"))) { case border_black: image::warp_bilinear( in->defined(), in->const_image_view(), defined(), image_view(), mf, false, thread_safe); break; case border_tile: image::warp_bilinear_tile( in->defined(), in->const_image_view(), defined(), image_view(), mf, false, thread_safe); break; case border_mirror: image::warp_bilinear_mirror( in->defined(), in->const_image_view(), defined(), image_view(), mf, false, thread_safe); break; } } else { switch( get_value<int>( param( "borders"))) { case border_black: image::warp_bilinear( in->defined(), in->const_image_view(), defined(), image_view(), f, false, thread_safe); break; case border_tile: image::warp_bilinear_tile( in->defined(), in->const_image_view(), defined(), image_view(), f, false, thread_safe); break; case border_mirror: image::warp_bilinear_mirror( in->defined(), in->const_image_view(), defined(), image_view(), f, false, thread_safe); break; } } }
static A jttcoamp(J jt,A w,B nf,A x,A h){I j;V*v=VAV(h); ASSERT(AR(x)<=v->mr,EVRANK); switch(v->id){ case CEXP: if(nf)R amp(logar1(x),ds(CEXP)); break; case CHGEOM: ASSERT(nf,EVDOMAIN); RE(j=i0(x)); ASSERT(0<=j,EVDOMAIN); R tpoly(hgcoeff(IX(j),h)); } R facit(tayamp(w,nf,x,h)); }
//---------------------------------------------------------------------- void Wf_return::setVals(Array2 <log_value<dcomplex> > & v ) { is_complex=1; int nfunc=v.GetDim(0); int nst=v.GetDim(1); Resize(nfunc,nst); for(int f=0; f< nfunc; f++) { amp(f,0)=v(f,0).logval.real(); phase(f,0)=v(f,0).logval.imag(); for(int s=1; s< nst; s++) { amp(f,s)=v(f,s).val().real(); phase(f,s)=v(f,s).val().imag(); } if(nst > 4) { doublevar sum_ii=0,sum_ri=0; for(int s=1; s< 4; s++) { sum_ii+=phase(f,s)*phase(f,s); sum_ri+=amp(f,s)*phase(f,s); } phase(f,4)-=2*sum_ri; amp(f,4)+=sum_ii; } } }
void playWithHomeTheaterFacade() { // Create all the parts of the home theatre system // Not encapsulated or owned by the facade. Amplifier amp("Top-O-Line Amplifier"); CdPlayer cd("Top-O-Line CD Player", &); DvdPlayer dvd("Top-O-Line DVD Player", &); Screen screen("My Theater Screen"); PopcornPopper popper("My Popcorn Popper"); Tuner tuner("Top-O-Line AM/FM Tuner", &); TheaterLights lights("Theater Ceiling Lights"); Projector projector("Top-O-Line Projector"); HomeTheaterFacade theater(&, &tuner, &dvd, &cd, &projector, &lights, &screen, &popper); theater.watchMovie("Raiders of the Lost Ark"); theater.endMovie(); }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTest::EresUnittest_ErrSAXParseException // // @doc: // Unittest for exception handling during parsing an ill-formed DXL document. // //--------------------------------------------------------------------------- GPOS_RESULT CParseHandlerTest::EresUnittest_ErrSAXParseException() { // create own memory pool CAutoMemoryPool amp(CAutoMemoryPool::ElcNone); IMemoryPool *mp = amp.Pmp(); // read DXL file CHAR *dxl_string = CDXLUtils::Read(mp, m_rgszXerceTestFileNames[0]); // function call should throw an exception ULLONG plan_id = gpos::ullong_max; ULLONG plan_space_size = gpos::ullong_max; (void) CDXLUtils::GetPlanDXLNode(mp, dxl_string, CTestUtils::m_szXSDPath, &plan_id, &plan_space_size); return GPOS_FAILED; }
//--------------------------------------------------------------------------- // @function: // CParseHandlerTest::EresUnittest_ErrSAXParseException // // @doc: // Unittest for exception handling during parsing an ill-formed DXL document. // //--------------------------------------------------------------------------- GPOS_RESULT CParseHandlerTest::EresUnittest_ErrSAXParseException() { // create own memory pool CAutoMemoryPool amp(CAutoMemoryPool::ElcNone); IMemoryPool *pmp = amp.Pmp(); // read DXL file CHAR *szDXL = CDXLUtils::SzRead(pmp, m_rgszXerceTestFileNames[0]); // function call should throw an exception ULLONG ullPlanId = ULLONG_MAX; ULLONG ullPlanSpaceSize = ULLONG_MAX; (void) CDXLUtils::PdxlnParsePlan(pmp, szDXL, CTestUtils::m_szXSDPath, &ullPlanId, &ullPlanSpaceSize); return GPOS_FAILED; }
//--------------------------------------------------------------------------- // @function: // CMDAccessorTest::EresUnittest_Negative // // @doc: // Test fetching non-existing metadata objects from the MD cache // //--------------------------------------------------------------------------- GPOS_RESULT CMDAccessorTest::EresUnittest_Negative() { CAutoMemoryPool amp(CAutoMemoryPool::ElcNone); IMemoryPool *mp = amp.Pmp(); // Setup an MD cache with a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(mp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp); // lookup a non-existing objects CMDIdGPDB *pmdidNonExistingObject = GPOS_NEW(mp) CMDIdGPDB(GPOPT_MDCACHE_TEST_OID /* OID */, 15 /* version */, 1 /* minor version */); // call should result in an exception (void) mda.RetrieveRel(pmdidNonExistingObject); pmdidNonExistingObject->Release(); return GPOS_OK; }
int main(int argc, char *argv[]) { float vol = 1.0f; int i; for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-vol") && i+1 < argc) vol = atof(argv[++i]); else if (!strcmp(argv[i], "-dB") && i+1 < argc) vol = pow(10.0f, atof(argv[++i]) / 20.0f); else if (!strcmp(argv[i], "-help")) { fprintf(stderr, "options: -vol multiplicand, -dB dB\n"); exit(0); } } SET_BINARY_MODE amp(vol); return 0; }
void EvtEtaDalitz::decay( EvtParticle *p){ p->initializePhaseSpace(getNDaug(),getDaugs()); EvtVector4R mompi0 = p->getDaug(2)->getP4(); double masspip = p->getDaug(0)->mass(); double masspim = p->getDaug(1)->mass(); double masspi0 = p->getDaug(2)->mass(); double m_eta = p->mass(); double y; //The decay amplitude coems from Layter et al PRD 7 2565 (1973). y=(mompi0.get(0)-masspi0)*(3.0/(m_eta-masspip-masspim-masspi0))-1.0; EvtComplex amp(sqrt(1.0-1.07*y),0.0); vertex(amp); return ; }
QVector<double> CrustalModel::calculate(const QVector<double> &freq) const { QVector<double> amp(freq.size()); // Slowness (inverse of the crustal velocity QVector<double> slowness(m_velocity.size()); for (int i = 0; i < slowness.size(); ++i) { slowness[i] = 1./m_velocity.at(i); } // average slowness over a depth range (1/velocity) QVector<double> avgSlow(freq.size(), slowness.first()); // Frequency dependent depth QVector<double> depth_f(freq.size(), 0.); for (int i = 0; i < freq.size(); ++i) { double error = 0; int count = 0; do { ++count; depth_f[i] = 1. / (4 * freq.at(i) * avgSlow.at(i)); const double oldValue = avgSlow.at(i); avgSlow[i] = averageValue(m_thickness, slowness, depth_f.at(i)); error = fabs((oldValue - avgSlow.at(i)) / avgSlow.at(i)); } while (error > 0.005 && count < 10); } for (int i = 0; i < freq.size(); ++i) { // Average density for the depth range const double avgDensity = averageValue(m_thickness, m_density, depth_f.at(i)); amp[i] = sqrt((m_velocity.at(i) * m_density.at(i)) / (avgDensity / avgSlow.at(i))); } return amp; }
void test_Granulator() { StaticVariable wave(1); //not implemented yet StaticVariable env(1); //not implemented yet StaticVariable amp(0.2); StaticVariable dur(0.07); StaticVariable pan(0); Envelope rate(11,0,30,11,70); rate.trigger(); RandomVariable freq_in1(kNormal, 500, 200, 0, 0); Clipper freq(freq_in1, kBoth, 100, 12000); Granulator gran(wave, env, rate, amp, freq, dur, pan); logMsg("playing granulator..."); gIO->set_root(gran); gIO->open(); //csl::sleep_usec(2000000); std::cout << "Starting" << endl; #ifdef RT_IO gIO->start(); csl::sleep_usec(10000000); #else //NOTE: REGULAR START FUNCTION DOESN"T SEEM TO WORK FOR FILEIO gIO->start(10); #endif std::cout << "Stopping" << endl; gIO->stop(); std::cout << "Closing" << endl; gIO->close(); std::cout << "Total grains produced 1: " << gran.num_grains << endl; logMsg("granulator done."); csl::sleep_usec(5000000); }
QString FFT::fftCurve() { int i, i2; int n2 = d_n/2; std::vector<double> amp(d_n); std::vector<double> result(2*d_n); if(amp.empty() || result.empty()){ QMessageBox::critical(dynamic_cast<ApplicationWindow *>(parent()), tr("MantidPlot") + " - " + tr("Error"), tr("Could not allocate memory, operation aborted!")); d_init_err = true; return ""; } double df = 1.0/(double)(d_n*d_sampling);//frequency sampling double aMax = 0.0;//max amplitude QString text; if(!d_inverse){ d_explanation = tr("Forward") + " " + tr("FFT") + " " + tr("of") + " " + d_curve->title().text(); text = tr("Frequency"); gsl_fft_real_workspace *work=gsl_fft_real_workspace_alloc(d_n); gsl_fft_real_wavetable *real=gsl_fft_real_wavetable_alloc(d_n); if(!work || !real){ QMessageBox::critical(dynamic_cast<ApplicationWindow *>(parent()), tr("MantidPlot") + " - " + tr("Error"), tr("Could not allocate memory, operation aborted!")); d_init_err = true; return ""; } gsl_fft_real_transform(d_y, 1, d_n, real,work); gsl_fft_halfcomplex_unpack (d_y, result.data(), 1, d_n); gsl_fft_real_wavetable_free(real); gsl_fft_real_workspace_free(work); } else { d_explanation = tr("Inverse") + " " + tr("FFT") + " " + tr("of") + " " + d_curve->title().text(); text = tr("Time"); gsl_fft_real_unpack (d_y, result.data(), 1, d_n); gsl_fft_complex_wavetable *wavetable = gsl_fft_complex_wavetable_alloc (d_n); gsl_fft_complex_workspace *workspace = gsl_fft_complex_workspace_alloc (d_n); if(!workspace || !wavetable){ QMessageBox::critical(dynamic_cast<ApplicationWindow *>(parent()), tr("MantidPlot") + " - " + tr("Error"), tr("Could not allocate memory, operation aborted!")); d_init_err = true; return ""; } gsl_fft_complex_inverse (result.data(), 1, d_n, wavetable, workspace); gsl_fft_complex_wavetable_free (wavetable); gsl_fft_complex_workspace_free (workspace); } if (d_shift_order){ for(i=0; i<d_n; i++){ d_x[i] = (i-n2)*df; int j = i + d_n; double aux = result[i]; result[i] = result[j]; result[j] = aux; } } else { for(i=0; i<d_n; i++) d_x[i] = i*df; } for(i=0;i<d_n;i++) { i2 = 2*i; double real_part = result[i2]; double im_part = result[i2+1]; double a = sqrt(real_part*real_part + im_part*im_part); amp[i]= a; if (a > aMax) aMax = a; } ApplicationWindow *app = dynamic_cast<ApplicationWindow *>(parent()); if (!app) { throw std::logic_error("Parent of FFTDialog is not ApplicationWindow as expected."); } QLocale locale = app->locale(); int prec = app->d_decimal_digits; text += "\t"+tr("Real")+"\t"+tr("Imaginary")+"\t"+ tr("Amplitude")+"\t"+tr("Angle")+"\n"; for (i=0; i<d_n; i++){ i2 = 2*i; text += locale.toString(d_x[i], 'g', prec)+"\t"; text += locale.toString(result[i2], 'g', prec)+"\t"; text += locale.toString(result[i2+1], 'g', prec)+"\t"; if (d_normalize) text += locale.toString(amp[i]/aMax, 'g', prec)+"\t"; else text += locale.toString(amp[i], 'g', prec)+"\t"; text += locale.toString(atan(result[i2+1]/result[i2]), 'g', prec)+"\n"; } return text; }
void EvtD0gammaDalitz::decay( EvtParticle* part ) { // Check if the D is from a B+- -> D0 K+- decay with the appropriate model. EvtParticle* parent = part->getParent(); // If there are no mistakes, should be B+ or B-. if (parent != 0 && EvtDecayTable::getInstance()->getDecayFunc( parent )->getName() == "BTODDALITZCPK" ) { EvtId parId = parent->getId(); if ( ( parId == _BP ) || ( parId == _BM ) || ( parId == _B0 ) || ( parId == _B0B) ) { _bFlavor = parId; } else { reportInvalidAndExit(); } } else { reportInvalidAndExit(); } // Read the D decay parameters from the B decay model. // Gamma angle in rad. double gamma = EvtDecayTable::getInstance()->getDecayFunc( parent )->getArg( 0 ); // Strong phase in rad. double delta = EvtDecayTable::getInstance()->getDecayFunc( parent )->getArg( 1 ); // Ratio between B->D0K and B->D0barK double rB = EvtDecayTable::getInstance()->getDecayFunc( parent )->getArg( 2 ); // Same structure for all of these decays. part->initializePhaseSpace( getNDaug(), getDaugs() ); EvtVector4R pA = part->getDaug( _d1 )->getP4(); EvtVector4R pB = part->getDaug( _d2 )->getP4(); EvtVector4R pC = part->getDaug( _d3 )->getP4(); // Squared invariant masses. double mSqAB = ( pA + pB ).mass2(); double mSqAC = ( pA + pC ).mass2(); double mSqBC = ( pB + pC ).mass2(); EvtComplex amp( 1.0, 0.0 ); // Direct and conjugated amplitudes. EvtComplex ampDir; EvtComplex ampCnj; if ( _isKsPiPi ) { // Direct and conjugated Dalitz points. EvtDalitzPoint pointDir( _mKs, _mPi, _mPi, mSqAB, mSqBC, mSqAC ); EvtDalitzPoint pointCnj( _mKs, _mPi, _mPi, mSqAC, mSqBC, mSqAB ); // Direct and conjugated amplitudes. ampDir = dalitzKsPiPi( pointDir ); ampCnj = dalitzKsPiPi( pointCnj ); } else { // Direct and conjugated Dalitz points. EvtDalitzPoint pointDir( _mKs, _mK, _mK, mSqAB, mSqBC, mSqAC ); EvtDalitzPoint pointCnj( _mKs, _mK, _mK, mSqAC, mSqBC, mSqAB ); // Direct and conjugated amplitudes. ampDir = dalitzKsKK( pointDir ); ampCnj = dalitzKsKK( pointCnj ); } if ( _bFlavor == _BP || _bFlavor == _B0 ) { amp = ampCnj + rB * exp( EvtComplex( 0., delta + gamma ) ) * ampDir; } else { amp = ampDir + rB * exp( EvtComplex( 0., delta - gamma ) ) * ampCnj; } vertex( amp ); return; }
static F1(jttpoly){A z; RZ(w); RZ(z=atop(amp(ds(CLBRACE),over(AT(w)&CMPX?w:xco1(w),zero)),amp(tally(w),ds(CMIN)))); VAV(z)->flag=VTAYFINITE; R z; }
//--------------------------------------------------------------------------- // @function: // CSubqueryHandlerTest::EresUnittest_SubqueryWithDisjunction // // @doc: // Test case of subqueries in a disjunctive tree // //--------------------------------------------------------------------------- GPOS_RESULT CSubqueryHandlerTest::EresUnittest_SubqueryWithDisjunction() { // use own memory pool CAutoMemoryPool amp(CAutoMemoryPool::ElcNone); IMemoryPool *mp = amp.Pmp(); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); CMDAccessor mda(mp, CMDCache::Pcache()); mda.RegisterProvider(CTestUtils::m_sysidDefault, pmdp); // install opt context in TLS CAutoOptCtxt aoc ( mp, &mda, NULL, /* pceeval */ CTestUtils::GetCostModel(mp) ); // create a subquery with const table get expression CExpression *pexprOuter = NULL; CExpression *pexprInner = NULL; CSubqueryTestUtils::GenerateGetExpressions(mp, &pexprOuter, &pexprInner); CExpression *pexpr = CSubqueryTestUtils::PexprSelectWithSubqueryBoolOp(mp, pexprOuter, pexprInner, true /*fCorrelated*/, CScalarBoolOp::EboolopOr); CXform *pxform = CXformFactory::Pxff()->Pxf(CXform::ExfSelect2Apply); CWStringDynamic str(mp); COstreamString oss(&str); oss << std::endl << "EXPRESSION:" << std::endl << *pexpr << std::endl; CExpression *pexprLogical = (*pexpr)[0]; CExpression *pexprScalar = (*pexpr)[1]; oss << std::endl << "LOGICAL:" << std::endl << *pexprLogical << std::endl; oss << std::endl << "SCALAR:" << std::endl << *pexprScalar << std::endl; GPOS_TRACE(str.GetBuffer()); str.Reset(); CXformContext *pxfctxt = GPOS_NEW(mp) CXformContext(mp); CXformResult *pxfres = GPOS_NEW(mp) CXformResult(mp); // calling the xform to perform subquery to Apply transformation pxform->Transform(pxfctxt, pxfres, pexpr); CExpression *pexprResult = pxfres->PexprNext(); oss << std::endl << "NEW LOGICAL:" << std::endl << *((*pexprResult)[0]) << std::endl; oss << std::endl << "RESIDUAL SCALAR:" << std::endl << *((*pexprResult)[1]) << std::endl; GPOS_TRACE(str.GetBuffer()); str.Reset(); pxfres->Release(); pxfctxt->Release(); pexpr->Release(); return GPOS_OK; }
//--------------------------------------------------------------------------- // @function: // CMiniDumperDXLTest::EresUnittest_Basic // // @doc: // Test minidumps in case of an exception // //--------------------------------------------------------------------------- GPOS_RESULT CMiniDumperDXLTest::EresUnittest_Basic() { CAutoMemoryPool amp(CAutoMemoryPool::ElcNone); IMemoryPool *mp = amp.Pmp(); CWStringDynamic minidumpstr(mp); COstreamString oss(&minidumpstr); CMiniDumperDXL mdrs(mp); mdrs.Init(&oss); CHAR file_name[GPOS_FILE_NAME_BUF_SIZE]; GPOS_TRY { CSerializableStackTrace serStackTrace; // read the dxl document CHAR *szQueryDXL = CDXLUtils::Read(mp, szQueryFile); // parse the DXL query tree from the given DXL document CQueryToDXLResult *ptroutput = CDXLUtils::ParseQueryToQueryDXLTree(mp, szQueryDXL, NULL); GPOS_CHECK_ABORT; CSerializableQuery serQuery(mp, ptroutput->CreateDXLNode(), ptroutput->GetOutputColumnsDXLArray(), ptroutput->GetCTEProducerDXLArray()); // setup a file-based provider CMDProviderMemory *pmdp = CTestUtils::m_pmdpf; pmdp->AddRef(); // we need to use an auto pointer for the cache here to ensure // deleting memory of cached objects when we throw CAutoP<CMDAccessor::MDCache> apcache; apcache = CCacheFactory::CreateCache<gpopt::IMDCacheObject*, gpopt::CMDKey*> ( true, // fUnique 0 /* unlimited cache quota */, CMDKey::UlHashMDKey, CMDKey::FEqualMDKey ); CMDAccessor::MDCache *pcache = apcache.Value(); CMDAccessor mda(mp, pcache, CTestUtils::m_sysidDefault, pmdp); CSerializableMDAccessor serMDA(&mda); CAutoTraceFlag atfPrintQuery(EopttracePrintQuery, true); CAutoTraceFlag atfPrintPlan(EopttracePrintPlan, true); CAutoTraceFlag atfTest(EtraceTest, true); COptimizerConfig *optimizer_config = GPOS_NEW(mp) COptimizerConfig ( CEnumeratorConfig::GetEnumeratorCfg(mp, 0 /*plan_id*/), CStatisticsConfig::PstatsconfDefault(mp), CCTEConfig::PcteconfDefault(mp), ICostModel::PcmDefault(mp), CHint::PhintDefault(mp), CWindowOids::GetWindowOids(mp) ); // setup opt ctx CAutoOptCtxt aoc ( mp, &mda, NULL, /* pceeval */ CTestUtils::GetCostModel(mp) ); // translate DXL Tree -> Expr Tree CTranslatorDXLToExpr *pdxltr = GPOS_NEW(mp) CTranslatorDXLToExpr(mp, &mda); CExpression *pexprTranslated = pdxltr->PexprTranslateQuery ( ptroutput->CreateDXLNode(), ptroutput->GetOutputColumnsDXLArray(), ptroutput->GetCTEProducerDXLArray() ); gpdxl::ULongPtrArray *pdrgul = pdxltr->PdrgpulOutputColRefs(); gpmd::CMDNameArray *pdrgpmdname = pdxltr->Pdrgpmdname(); ULONG ulSegments = GPOPT_TEST_SEGMENTS; CQueryContext *pqc = CQueryContext::PqcGenerate(mp, pexprTranslated, pdrgul, pdrgpmdname, true /*fDeriveStats*/); // optimize logical expression tree into physical expression tree. CEngine eng(mp); CSerializableOptimizerConfig serOptConfig(mp, optimizer_config); eng.Init(pqc, NULL /*search_stage_array*/); eng.Optimize(); CExpression *pexprPlan = eng.PexprExtractPlan(); (void) pexprPlan->PrppCompute(mp, pqc->Prpp()); // translate plan into DXL IntPtrArray *pdrgpiSegments = GPOS_NEW(mp) IntPtrArray(mp); GPOS_ASSERT(0 < ulSegments); for (ULONG ul = 0; ul < ulSegments; ul++) { pdrgpiSegments->Append(GPOS_NEW(mp) INT(ul)); } CTranslatorExprToDXL ptrexprtodxl(mp, &mda, pdrgpiSegments); CDXLNode *pdxlnPlan = ptrexprtodxl.PdxlnTranslate(pexprPlan, pqc->PdrgPcr(), pqc->Pdrgpmdname()); GPOS_ASSERT(NULL != pdxlnPlan); CSerializablePlan serPlan(mp, pdxlnPlan, optimizer_config->GetEnumeratorCfg()->GetPlanId(), optimizer_config->GetEnumeratorCfg()->GetPlanSpaceSize()); GPOS_CHECK_ABORT; // simulate an exception GPOS_OOM_CHECK(NULL); } GPOS_CATCH_EX(ex) { // unless we're simulating faults, the exception must be OOM GPOS_ASSERT_IMP ( !GPOS_FTRACE(EtraceSimulateAbort) && !GPOS_FTRACE(EtraceSimulateIOError) && !IWorker::m_enforce_time_slices, CException::ExmaSystem == ex.Major() && CException::ExmiOOM == ex.Minor() ); mdrs.Finalize(); GPOS_RESET_EX; CWStringDynamic str(mp); COstreamString oss(&str); oss << std::endl << "Minidump" << std::endl; oss << minidumpstr.GetBuffer(); oss << std::endl; // dump the same to a temp file ULONG ulSessionId = 1; ULONG ulCommandId = 1; CMinidumperUtils::GenerateMinidumpFileName(file_name, GPOS_FILE_NAME_BUF_SIZE, ulSessionId, ulCommandId, NULL /*szMinidumpFileName*/); std::wofstream osMinidump(file_name); osMinidump << minidumpstr.GetBuffer(); oss << "Minidump file: " << file_name << std::endl; GPOS_TRACE(str.GetBuffer()); } GPOS_CATCH_END; // TODO: - Feb 11, 2013; enable after fixing problems with serializing // XML special characters (OPT-2996) // // try to load minidump file // CDXLMinidump *pdxlmd = CMinidumperUtils::PdxlmdLoad(mp, file_name); // GPOS_ASSERT(NULL != pdxlmd); // delete pdxlmd; // delete temp file ioutils::Unlink(file_name); return GPOS_OK; }
void sleep_apnea::median_filter (QVector<QVector<double> > &h_freq, QVector<QVector<double> > &h_amp) { QVector<double> amp(window_median); QVector<double> freq(window_median); int i,j,k,l; double median_amp,median_freq; for (i=0;i<h_freq[0].size();i++) { if (i%window_median==0 && i>0) { k=(i/window_median)-1; //filling arrays l=0; for (j=0+window_median*k;j<window_median+window_median*k;j++) { freq[l]=h_freq[1][j]; amp[l]=h_amp[1][j]; l++; } //sorting arrays std::sort(freq.begin(),freq.end()); std::sort(amp.begin(),amp.end()); //finding median_elements if (freq.size()%2!=0) { median_freq=freq[int((freq.size()-1)/2)]; median_amp=amp[int((amp.size()-1)/2)]; } else { median_freq=(freq[int(floor((freq.size()-1)/2))]+ freq[int(floor((freq.size()-1)/2))+1] )*0.5; median_amp=(amp[int(floor((amp.size()-1)/2))]+ amp[int(floor((amp.size()-1)/2))+1] )*0.5; } //writing output arrays for (j=0+window_median*k;j<window_median+window_median*k;j++) { h_freq[1][j]=median_freq; h_amp[1][j]=median_amp; } } } //loop for last elements if (h_freq[0].size()%window_median!=0) { int start_id=int(floor(h_freq[0].size()/window_median)*window_median); int stop_id=h_freq[0].size()-1; QVector<double> amp1(stop_id-start_id+1); QVector<double> freq1(stop_id-start_id+1); //filling arrays j=start_id; for(i=0;i<freq1.size();i++) { freq1[i]=h_freq[1][j]; amp1[i]=h_amp[1][j]; j++; } //sorting arrays std::sort(freq1.begin(),freq1.end()); std::sort(amp1.begin(),amp1.end()); //finding median_elements if (freq1.size()%2!=0) { median_freq=freq1[int((freq1.size()-1)/2)]; median_amp=amp1[int((amp1.size()-1)/2)]; } else { median_freq=(freq1[int(floor((freq1.size()-1)/2))]+ freq1[int(floor((freq1.size()-1)/2))+1] )*0.5; median_amp=(amp1[int(floor((amp1.size()-1)/2))]+ amp1[int(floor((amp1.size()-1)/2))+1] )*0.5; } //writing output arrays for(i=start_id;i<=stop_id;i++) { h_freq[1][i]=median_freq; h_amp[1][i]=median_amp; } } }
double EvtPropSLPole::calBreitWigner(EvtParticle *pmeson, EvtPoint1D point){ EvtId mesnum = pmeson->getId(); double _mass = EvtPDL::getMeanMass(mesnum); double _width = EvtPDL::getWidth(mesnum); double _maxRange = EvtPDL::getMaxRange(mesnum); EvtSpinType::spintype mesontype=EvtPDL::getSpinType(mesnum); _includeDecayFact=true; _includeBirthFact=true; _spin = mesontype; _blatt = 3.0; double maxdelta = 15.0*_width; if ( _maxRange > 0.00001 ) { _massMax=_mass+maxdelta; _massMin=_mass-_maxRange; } else{ _massMax=_mass+maxdelta; _massMin=_mass-15.0*_width; } _massMax=_mass+maxdelta; if ( _massMin< 0. ) _massMin=0.; EvtParticle* par=pmeson->getParent(); double maxMass=-1.; if ( par != 0 ) { if ( par->hasValidP4() ) maxMass=par->mass(); for ( size_t i=0;i<par->getNDaug();i++) { EvtParticle *tDaug=par->getDaug(i); if ( pmeson != tDaug ) maxMass-=EvtPDL::getMinMass(tDaug->getId()); } } EvtId *dauId=0; double *dauMasses=0; size_t nDaug = pmeson->getNDaug(); if ( nDaug > 0) { dauId=new EvtId[nDaug]; dauMasses=new double[nDaug]; for (size_t j=0;j<nDaug;j++) { dauId[j]=pmeson->getDaug(j)->getId(); dauMasses[j]=pmeson->getDaug(j)->mass(); } } EvtId *parId=0; EvtId *othDaugId=0; EvtParticle *tempPar=pmeson->getParent(); if (tempPar) { parId=new EvtId(tempPar->getId()); if ( tempPar->getNDaug()==2 ) { if ( tempPar->getDaug(0) == pmeson ) othDaugId=new EvtId(tempPar->getDaug(1)->getId()); else othDaugId=new EvtId(tempPar->getDaug(0)->getId()); } } if ( nDaug!=2) return calBreitWignerBasic(maxMass); if ( _width< 0.00001) return 1.0; //first figure out L - take the lowest allowed. EvtSpinType::spintype spinD1=EvtPDL::getSpinType(dauId[0]); EvtSpinType::spintype spinD2=EvtPDL::getSpinType(dauId[1]); int t1=EvtSpinType::getSpin2(spinD1); int t2=EvtSpinType::getSpin2(spinD2); int t3=EvtSpinType::getSpin2(_spin); int Lmin=-10; // allow for special cases. if (Lmin<-1 ) { //There are some things I don't know how to deal with if ( t3>4) return calBreitWignerBasic(maxMass); if ( t1>4) return calBreitWignerBasic(maxMass); if ( t2>4) return calBreitWignerBasic(maxMass); //figure the min and max allowwed "spins" for the daughters state Lmin=std::max(t3-t2-t1,std::max(t2-t3-t1,t1-t3-t2)); if (Lmin<0) Lmin=0; assert(Lmin==0||Lmin==2||Lmin==4); } //double massD1=EvtPDL::getMeanMass(dauId[0]); //double massD2=EvtPDL::getMeanMass(dauId[1]); double massD1=dauMasses[0]; double massD2=dauMasses[1]; // I'm not sure how to define the vertex factor here - so retreat to nonRel code. if ( (massD1+massD2)> _mass ) return calBreitWignerBasic(maxMass); //parent vertex factor not yet implemented double massOthD=-10.; double massParent=-10.; int birthl=-10; if ( othDaugId) { EvtSpinType::spintype spinOth=EvtPDL::getSpinType(*othDaugId); EvtSpinType::spintype spinPar=EvtPDL::getSpinType(*parId); int tt1=EvtSpinType::getSpin2(spinOth); int tt2=EvtSpinType::getSpin2(spinPar); int tt3=EvtSpinType::getSpin2(_spin); //figure the min and max allowwed "spins" for the daughters state if ( (tt1<=4) && ( tt2<=4) ) { birthl=std::max(tt3-tt2-tt1,std::max(tt2-tt3-tt1,tt1-tt3-tt2)); if (birthl<0) birthl=0; massOthD=EvtPDL::getMeanMass(*othDaugId); massParent=EvtPDL::getMeanMass(*parId); } } double massM=_massMax; if ( (maxMass > -0.5) && (maxMass < massM) ) massM=maxMass; //special case... if the parent mass is _fixed_ we can do a little better //and only for a two body decay as that seems to be where we have problems // Define relativistic propagator amplitude EvtTwoBodyVertex vd(massD1,massD2,_mass,Lmin/2); vd.set_f(_blatt); EvtPropBreitWignerRel bw(_mass,_width); EvtMassAmp amp(bw,vd); // if ( _fixMassForMax) amp.fixUpMassForMax(); // else std::cout << "problem problem\n"; if ( _includeDecayFact) { amp.addDeathFact(); amp.addDeathFactFF(); } if ( massParent>-1.) { if ( _includeBirthFact ) { EvtTwoBodyVertex vb(_mass,massOthD,massParent,birthl/2); amp.setBirthVtx(vb); amp.addBirthFact(); amp.addBirthFactFF(); } } EvtAmpPdf<EvtPoint1D> pdf(amp); double ampVal = sqrt(pdf.evaluate(point)); if ( parId) delete parId; if ( othDaugId) delete othDaugId; if ( dauId) delete [] dauId; if ( dauMasses) delete [] dauMasses; return ampVal; }