double gauss4(double A1,double S1, /* S1-S4 are sigma^2 */ double A2,double S2, double A3,double S3, double A4,double S4, double r) { return gaus(A1,S1,r)+gaus(A2,S2,r)+gaus(A3,S3,r)+gaus(A4,S4,r); }
void MC_StepOld( VecCl &ph, double Phi0, int N, double MainHarm, int FurieDiscr, double FullTime, double StrongShort) { double gZero = 0, gSigma = 1; RndGaus gaus(gZero, gSigma); gaus.Init(-4 * gSigma, 4 * gSigma, 100, 1e-5); int NumJ = FurieDiscr; VecCl Phi_cos(NumJ), Phi_sin(NumJ); for(int k = 1; k <= NumJ; k++) { Phi_cos[k] = gaus.Rnd(); Phi_sin[k] = gaus.Rnd(); } double StrongCoef = StrongShort * sqr(2 * M_PI / FullTime); MainHarm *= 2 / FullTime; Phi_cos = Phi_cos * MainHarm; Phi_sin = Phi_sin * MainHarm; for(int k = 1; k <= N; k++) { ph[k] = Phi0; for(int j = 1; j <= NumJ; j++) ph[k] += (Phi_cos[j] * cos(M_PI * k * (j - 1) / N) + Phi_sin[j] * sin(M_PI * k * (j - 1) / N)) / (sqrt(max<double>(j - 1, 0.25)) * (1 + sqr(j) * StrongCoef)); } };
int main(){ /* We can use any function that implements the IntegrableFunction interface, here just use a gaussian */ Gaussian gaus(std::vector<double>(2, 0), std::vector<double>(2, 1)); AnalyticPdf gausPdf(&gaus); // takes ownership of a copy of gaussian // The dimensionality of the pdf now matches the underlying function std::cout << "Pdf is " << gausPdf.GetNDims() << std::endl; // now we can call it directly std::cout << " gausPdf(0, 0) = " << gausPdf(std::vector<double>(2, 0)) << std::endl; // or use a data representation to query an event // this pdf picks out the 0th and 2nd observables in an event std::vector<size_t> relevantIndices; relevantIndices.push_back(0); relevantIndices.push_back(2); gausPdf.SetDataRep(DataRepresentation(relevantIndices)); // fake event with ten observables in it, our pdf knows where to look EventData event(std::vector<double>(10, 0)); std::cout << "Probability = " << gausPdf.Probability(event) << std::endl; return 0; }
/** Restore a circular beam*/ void ModelRenderer::Restore(double* imageData, size_t imageWidth, size_t imageHeight, const Model& model, long double beamSize, long double startFrequency, long double endFrequency, PolarizationEnum polarization) { // Using the FWHM formula for a Gaussian: long double sigma = beamSize / (2.0L * sqrtl(2.0L * logl(2.0L))); int boundingBoxSize = ceil(sigma * 20.0 / std::min(_pixelScaleL, _pixelScaleM)); for(Model::const_iterator src=model.begin(); src!=model.end(); ++src) { for(ModelSource::const_iterator comp=src->begin(); comp!=src->end(); ++comp) { long double posRA = comp->PosRA(), posDec = comp->PosDec(), sourceL, sourceM; ImageCoordinates::RaDecToLM(posRA, posDec, _phaseCentreRA, _phaseCentreDec, sourceL, sourceM); const SpectralEnergyDistribution &sed = comp->SED(); const long double intFlux = sed.IntegratedFlux(startFrequency, endFrequency, polarization); //std::cout << "Source: " << comp->PosRA() << "," << comp->PosDec() << " Phase centre: " << _phaseCentreRA << "," << _phaseCentreDec << " beamsize: " << beamSize << "\n"; int sourceX, sourceY; ImageCoordinates::LMToXY<long double>(sourceL-_phaseCentreDL, sourceM-_phaseCentreDM, _pixelScaleL, _pixelScaleM, imageWidth, imageHeight, sourceX, sourceY); //std::cout << "Adding source " << comp->Name() << " at " << sourceX << "," << sourceY << " of " // << intFlux << " Jy (" // << startFrequency/1000000.0 << "-" << endFrequency/1000000.0 << " MHz).\n"; int xLeft = sourceX - boundingBoxSize, xRight = sourceX + boundingBoxSize, yTop = sourceY - boundingBoxSize, yBottom = sourceY + boundingBoxSize; if(xLeft < 0) xLeft = 0; if(xLeft > (int) imageWidth) xLeft = (int) imageWidth; if(xRight < xLeft) xRight = xLeft; if(xRight > (int) imageWidth) xRight = (int) imageWidth; if(yTop < 0) yTop = 0; if(yTop > (int) imageHeight) yTop = (int) imageHeight; if(yBottom < yTop) yBottom = yTop; if(yBottom > (int) imageHeight) yBottom = (int) imageHeight; for(int y=yTop; y!=yBottom; ++y) { double *imageDataPtr = imageData + y*imageWidth+xLeft; for(int x=xLeft; x!=xRight; ++x) { long double l, m; ImageCoordinates::XYToLM<long double>(x, y, _pixelScaleL, _pixelScaleM, imageWidth, imageHeight, l, m); l += _phaseCentreDL; m += _phaseCentreDM; long double dist = sqrt((l-sourceL)*(l-sourceL) + (m-sourceM)*(m-sourceM)); long double g = gaus(dist, sigma); (*imageDataPtr) += double(g * intFlux); ++imageDataPtr; } } } } }
/** * Restore a diffuse image (e.g. produced with multi-scale clean) */ void ModelRenderer::Restore(double* imageData, const double* modelData, size_t imageWidth, size_t imageHeight, long double beamMaj, long double beamMin, long double beamPA, long double pixelScaleL, long double pixelScaleM) { if(beamMaj == 0.0 && beamMin == 0.0) { for(size_t j=0; j!=imageWidth*imageHeight; ++j) imageData[j] += modelData[j]; } else { // Using the FWHM formula for a Gaussian: long double sigmaMaj = beamMaj / (2.0L * sqrtl(2.0L * logl(2.0L))); long double sigmaMin = beamMin / (2.0L * sqrtl(2.0L * logl(2.0L))); // Make rotation matrix long double transf[4]; // Position angle is angle from North: long double angle = beamPA+0.5*M_PI; transf[2] = sin(angle); transf[0] = cos(angle); transf[1] = -transf[2]; transf[3] = transf[0]; double sigmaMax = std::max(std::fabs(sigmaMaj * transf[0]), std::fabs(sigmaMaj * transf[1])); // Multiple with scaling matrix to make variance 1. transf[0] = transf[0] / sigmaMaj; transf[1] = transf[1] / sigmaMaj; transf[2] = transf[2] / sigmaMin; transf[3] = transf[3] / sigmaMin; size_t minDimension = std::min(imageWidth, imageHeight); size_t boundingBoxSize = std::min<size_t>(ceil(sigmaMax * 40.0 / std::min(pixelScaleL, pixelScaleM)), minDimension); if(boundingBoxSize%2!=0) ++boundingBoxSize; ao::uvector<double> kernel(boundingBoxSize*boundingBoxSize); typename ao::uvector<double>::iterator i=kernel.begin(); for(size_t y=0; y!=boundingBoxSize; ++y) { for(size_t x=0; x!=boundingBoxSize; ++x) { long double l, m; ImageCoordinates::XYToLM<long double>(x, y, pixelScaleL, pixelScaleM, boundingBoxSize, boundingBoxSize, l, m); long double lTransf = l*transf[0] + m*transf[1], mTransf = l*transf[2] + m*transf[3]; long double dist = sqrt(lTransf*lTransf + mTransf*mTransf); *i = gaus(dist, (long double) 1.0); ++i; } } ao::uvector<double> convolvedModel(imageWidth*imageHeight); memcpy(convolvedModel.data(), modelData, sizeof(double)*imageWidth*imageHeight); FFTWManager fftw; FFTConvolver::Convolve(fftw, convolvedModel.data(), imageWidth, imageHeight, kernel.data(), boundingBoxSize); for(size_t j=0; j!=imageWidth*imageHeight; ++j) imageData[j] += convolvedModel[j]; } }
void fix0Bins(TH1F* h){ //determine if this is a low stats shape float binUnc=0.; int nNon0bins=0; for(Int_t i=1;i<=h->GetNbinsX();i++){ if(h->GetBinContent(i)>0.){ nNon0bins++; binUnc+=h->GetBinError(i)/h->GetBinContent(i); } } binUnc=binUnc/nNon0bins; //if the average bin uncertainty is greater than 30% then smooth if(binUnc>0.5){ //TH1F* hs=new TH1F(TString(h->GetName())+"smeared",h->GetTitle(),h->GetXaxis()->GetNbins(),h->GetXaxis()->GetXmin(),h->GetXaxis()->GetXmax()); TH1F* hs=h->Clone("hs"); TF1 gaus("gauss","[0]*exp(-0.5*(x-[1])**2/[2]**2)",h->GetXaxis()->GetXmin(),h->GetXaxis()->GetXmax()); gaus.SetParameter(2,10); for(Int_t b=1;b<=h->GetXaxis()->GetNbins();b++){ gaus.SetParameter(0,h->GetBinContent(b)); gaus.SetParameter(1,h->GetBinCenter(b)); for(Int_t bs=1;bs<=h->GetXaxis()->GetNbins();bs++){ hs->AddBinContent(bs,hs->GetBinWidth(bs)*gaus.Eval(hs->GetBinCenter(bs))) ; } } for(Int_t bs=1;bs<=h->GetXaxis()->GetNbins();bs++){ hs->SetBinError(bs,0.);//not sure this is necessary } if(hs->Integral()>0.) hs->Scale(h->Integral()/hs->Integral());//make sure the output histo has the same integral else hs->Scale(0.); for(Int_t b=1;b<=h->GetXaxis()->GetNbins();b++){ h->SetBinContent(b,hs->GetBinContent(b)); h->SetBinError(b,hs->GetBinContent(b)*0.4); } delete hs; } //fix empty distributions for limit to run if(h->Integral()<=0.){ for(Int_t i=1;i<=h->GetNbinsX();i++){ h->SetBinContent(i,0.001); h->SetBinError(i,0.001); } } }
int proverca(double **a ,int n,int y) { int i,j,z; double min; do { t=2;//указатель ищет отрицательные правые части for( i=0; i<n ; i++ ) { if (a[i][y]<0) { t=t-1; if (t==1) { min=a[i][y]; } k=i; } if (a[i][y]<min) { min=a[i][y]; k=i; } } if (t==2) return 0; z=2; for (j=0 ; j<y ; j++) { if (a[k][j]<0) { z=z-1; if (t!=2) { printf("ggg11111 \n"); l=j; gaus(a,y,n); j=y; } } } if (z==2) { printf("нет решения"); return 0; } } while(t!=2); return 0; }
void MC_Step( VecCl &ph, double Phi0, int N, double MainHarm, int FurieDiscr, double FullTime, double StrongShort) { double gZero = 0, gSigma = 1; RndGaus gaus(gZero, gSigma); gaus.Init(-4 * gSigma, 4 * gSigma, 100, 1e-5); int NumJ = FurieDiscr, j, k; VecCl Phi_cos(NumJ), Phi_sin(NumJ); for(k = 1; k <= NumJ; k++) { Phi_cos[k] = gaus.Rnd(); Phi_sin[k] = gaus.Rnd(); } double StrongCoef = StrongShort * sqr(2 * M_PI / FullTime); MainHarm *= 2 / FullTime; Phi_cos = Phi_cos * MainHarm; Phi_sin = Phi_sin * MainHarm; VecCl CosIJ(N), SinIJ(N); double coef = M_PI / N; for(k = 1; k <= N; k++) { CosIJ[k] = cos(coef * (k - 1)); SinIJ[k] = sin(coef * (k - 1)); } for(k = 1; k <= N; k++) { ph[k] = Phi0; for(j = 1; j <= NumJ; j++) { int r = k * (j - 1) / N; double SCCoef = 1; if((r / 2) * 2 != r) SCCoef = -1; r = k * (j - 1) - r * N + 1; //if (r==0) r=N; ph[k] += (SCCoef * Phi_cos[j] * CosIJ[r] + SCCoef * Phi_sin[j] * SinIJ[r]) / sqrt(max<double>(j - 1, 0.25) * (1 + sqr(j) * StrongCoef)); } } };
void makePlots2() { gROOT->ProcessLine(".x lhcbStyle.C"); gStyle->SetOptStat(0); Double_t ignore, eff, massfit1, massfit2, bias1, bias2; Double_t value[6][19], stat[6][19], syst[6][19]; Int_t ng(4); TH1D pull("pull","",15,-3.0,3.0); std::ifstream fin("errs.dat"); fin.ignore(256,'\n'); for(Int_t q=0; q<19; ++q) { for(Int_t g=1; g<ng+1; ++g) { fin >> ignore >> ignore >> value[g+1][q] >> stat[g+1][q] >> eff >> massfit1 >> massfit2 >> bias1 >> bias2; syst[g+1][q] = TMath::Sqrt(stat[g+1][q]*stat[g+1][q] + eff*eff + massfit1*massfit1 + massfit2*massfit2 + bias1*bias1 + bias2*bias2); //plot syst errors on top of stats if(q<17) pull.Fill(value[g+1][q]/syst[g+1][q]); } value[0][q] = value[2][q]; stat[0][q] = stat[2][q]; syst[0][q] = syst[2][q]; value[1][q] = 2*value[3][q]+1; stat[1][q] = 2*stat[3][q]; syst[1][q] = 2*syst[3][q]; } fin.close(); Double_t xs[19] = { 0.54, 1.55, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 11.375, 12.125, 15.5, 16.5, 17.5, 18.5, 19.5, 20.5, 21.5, 3.55, 18.5}; Double_t exs[19] = { 0.44, 0.45, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.375, 0.375, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 2.45, 3.5}; TCanvas c; TF1 gaus("gaus","gaus(0)",-3.,3.); gaus.SetParameter(0,68); gaus.SetParameter(1,pull.GetBinCenter(pull.GetMaximumBin())); gaus.SetParameter(2,pull.GetStdDev()); gaus.SetParLimits(1,-2.0,2.0); gaus.SetParLimits(2,0.3,3.0); pull.Fit(&gaus,"S"); pull.Draw(); c.SaveAs("gPulls.pdf"); for(Int_t i=0; i<ng+2; ++i) { TString varName(""); TString varName2(""); switch(i) { case 0: varName="A_{FB}"; varName2="AFB"; break; case 1: varName="F_{H}"; varName2="FH"; break; default: varName="G^{("; varName+=(i-1); varName+=")}"; varName2="G"; varName2+=(i-1); } Double_t yMin = getMin(19,value[i])-getMax(19,syst[i]); Double_t yMax = getMax(19,value[i])+getMax(19,syst[i]); if(yMax-yMin == 0) continue; TH2D h("h","",1,0.0,22.,1,yMin,yMax); TLine l(0.0,0.0,22.0,0.0); l.SetLineStyle(kDashed); l.SetLineColor(kRed); h.GetYaxis()->SetTitle(varName); h.GetXaxis()->SetTitle("q^{2} [GeV^{2}/c^{4}]"); TGraphErrors g1(17,xs, value[i], exs, stat[i] ); TGraphErrors g2( 2,xs+17,value[i]+17,exs+17,stat[i]+17); TGraphErrors g3(17,xs, value[i], exs, syst[i] ); TGraphErrors g4( 2,xs+17,value[i]+17,exs+17,syst[i]+17); g2.SetLineColor(kBlue); g2.SetMarkerColor(kBlue); g3.SetLineColor(kRed); g4.SetLineColor(kRed); g2.SetFillColor(kBlue); g4.SetFillColor(kRed); g2.SetFillStyle(3001); g4.SetFillStyle(3002); h.Draw(); l.Draw(); g4.Draw("E2same"); g2.Draw("E2same"); g3.Draw("PEsame"); g1.Draw("PEsame"); c.SaveAs("plots/fromPatrickNew/"+varName2+".pdf"); c.SaveAs("plots/fromPatrickNew/"+varName2+".png"); } }
int main() { double **a,P1[5][7]= {{2.0,1,1,0,0,64,0},{1.0,3,0,1,0,72,0},{0,1,0,0,1,20,0},{-4,-6,0.0,0,0,0,0},{0,0,0,0,0,0,0,0}}, bb[]= {64.0,72.0,20.0} ; int i,j,n=3,y=5 ,v[4]= {0,0,0,0},m; // n-количество строк, y-количество столбцов double min; a=(double**)malloc(5*sizeof(double*)); for(i=0; i<5; i++) { a[i]=(double*)malloc(7*sizeof(double)); for(j=0; j<7; j++) a[i][j]=P1[i][j]; } for (i=0; i<=n ; i++) { for (j=0 ; j< y+1 ; j++) { printf("%.0f ",a[i][j]); } printf("\n"); } //proverca(a,n,y); t=2; do { ocenki(a,bb,n,y); t=2; for (j=0; j<y ; j++) { if (a[n][j]<0) { t=t-1; if (t==1) { l=j; min=a[n+1][j]; } if (a[n][j]<min) { min=a[n][j]; l=j; } } } printf("AAAAAA%dAAAAAA\n",l); j=0; if(t<2) { for ( i=0 ; i<n ; i++) { if (a[i][l]>0) { if (j==0) { min=a[i][y]/a[i][l]; j=2; k=i; } if ((a[i][y]/a[i][l])<min) { min=a[i][y]/a[i][l]; k=i; } } } gaus(a,y,n); } for (i=0; i<=n ; i++) { for (j=0 ; j<=y ; j++) { printf("%.1f ",a[i][j]); } printf("\n"); } } while (t!=2); return 0; }
void ModelRenderer::renderGaussianComponent(double* imageData, size_t imageWidth, size_t imageHeight, long double posRA, long double posDec, long double gausMaj, long double gausMin, long double gausPA, long double flux, bool normalizeIntegratedFlux) { // Using the FWHM formula for a Gaussian: long double sigmaMaj = gausMaj / (2.0L * sqrtl(2.0L * logl(2.0L))); long double sigmaMin = gausMin / (2.0L * sqrtl(2.0L * logl(2.0L))); // TODO this won't work for non-equally spaced dimensions long double minPixelScale = std::min(_pixelScaleL, _pixelScaleM); // ...And this is not accurate, as the correlation between beam and source PA has // to be taken into account if(normalizeIntegratedFlux) { double factor = 2.0L * M_PI * sigmaMaj * sigmaMin / (minPixelScale * minPixelScale); if(factor > 1.0) flux /= factor; } // Make rotation matrix long double transf[4]; // Position angle is angle from North: long double angle = gausPA+0.5*M_PI; transf[2] = sin(angle); transf[0] = cos(angle); transf[1] = -transf[2]; transf[3] = transf[0]; double sigmaMax = std::max(std::fabs(sigmaMaj * transf[0]), std::fabs(sigmaMaj * transf[1])); // Multiply with scaling matrix to make variance 1. transf[0] = transf[0] / sigmaMaj; transf[1] = transf[1] / sigmaMaj; transf[2] = transf[2] / sigmaMin; transf[3] = transf[3] / sigmaMin; int boundingBoxSize = ceil(sigmaMax * 20.0 / minPixelScale); long double sourceL, sourceM; ImageCoordinates::RaDecToLM(posRA, posDec, _phaseCentreRA, _phaseCentreDec, sourceL, sourceM); // Calculate the bounding box int sourceX, sourceY; ImageCoordinates::LMToXY<long double>(sourceL-_phaseCentreDL, sourceM-_phaseCentreDM, _pixelScaleL, _pixelScaleM, imageWidth, imageHeight, sourceX, sourceY); int xLeft = sourceX - boundingBoxSize, xRight = sourceX + boundingBoxSize, yTop = sourceY - boundingBoxSize, yBottom = sourceY + boundingBoxSize; if(xLeft < 0) xLeft = 0; if(xLeft > (int) imageWidth) xLeft = (int) imageWidth; if(xRight < xLeft) xRight = xLeft; if(xRight > (int) imageWidth) xRight = (int) imageWidth; if(yTop < 0) yTop = 0; if(yTop > (int) imageHeight) yTop = (int) imageHeight; if(yBottom < yTop) yBottom = yTop; if(yBottom > (int) imageHeight) yBottom = (int) imageHeight; for(int y=yTop; y!=yBottom; ++y) { double *imageDataPtr = imageData + y*imageWidth+xLeft; for(int x=xLeft; x!=xRight; ++x) { long double l, m; ImageCoordinates::XYToLM<long double>(x, y, _pixelScaleL, _pixelScaleM, imageWidth, imageHeight, l, m); l += _phaseCentreDL; m += _phaseCentreDM; long double lTransf = (l-sourceL)*transf[0] + (m-sourceM)*transf[1], mTransf = (l-sourceL)*transf[2] + (m-sourceM)*transf[3]; long double dist = sqrt(lTransf*lTransf + mTransf*mTransf); long double g = gaus(dist, 1.0L); (*imageDataPtr) += double(g * flux); ++imageDataPtr; } } }
void BfmWrapper::SpectralRange(bfm_qdp<Float> &bfm) { int Ls = bfm.Ls; multi1d<T4> gaus(Ls); for(int s=0;s<Ls;s++) gaussian(gaus[s]); Fermion_t tmp1,tmp2; Fermion_t b; Fermion_t Ab; double mu; tmp1 = bfm.allocFermion(); tmp2 = bfm.allocFermion(); b = bfm.allocFermion(); Ab = bfm.allocFermion(); bfm.importFermion(gaus,b,0); int dagyes= 1; int dagno = 0; int donrm = 1; double abnorm; double absq; double n; /////////////////////////////////////// // Get the highest evalue of MdagM /////////////////////////////////////// #pragma omp parallel for for(int i=0;i<bfm.nthread;i++) { int me = bfm.thread_barrier(); for(int k=0;k<100;k++){ n = bfm.norm(b); absq = bfm.Mprec(b,tmp2,tmp1,dagno,donrm); bfm.Mprec(tmp2,Ab,tmp1,dagyes); //MdagM mu = absq/n; if(bfm.isBoss() && (!me) ) { printf("PowerMethod %d mu=%le absq=%le n=%le \n",k,mu,absq,n); } abnorm = sqrt(absq); // b = Ab / |Ab| bfm.axpby(b,Ab,Ab,0.0,1.0/abnorm); } } ///////////////////////////////////////// // Get the lowest eigenvalue of mdagm // Apply power method to [lambda_max - MdagM] ///////////////////////////////////////// double lambda_max = mu; bfm.importFermion(gaus,b,0); #pragma omp parallel for for(int i=0;i<bfm.nthread;i++) { int me = bfm.thread_barrier(); for(int k=0;k<100;k++){ n = bfm.norm(b); absq = bfm.Mprec(b,tmp2,tmp1,dagno,donrm); bfm.Mprec(tmp2,Ab,tmp1,dagyes); bfm.axpby(Ab,Ab,b,-1,lambda_max); absq = lambda_max * n - absq; mu = absq/n; if(bfm.isBoss() && (!me) ) { printf("PowerMethod for low EV %d mu=%le absq=%le n=%le \n",k,mu,absq,n); printf("PowerMethod %d lambda_min =%le\n",k,lambda_max - mu); } abnorm = sqrt(absq); // b = Ab / |Ab| bfm.axpby(b,Ab,Ab,0.0,1.0/abnorm); } } bfm.freeFermion(tmp1); bfm.freeFermion(tmp2); bfm.freeFermion(b); bfm.freeFermion(Ab); }