void parse_header(void** data_segment){ nef_head = (nef_data*)malloc(sizeof(nef_data)); switch((int)data_segment[0]){ case 64206: nef_head->topHeader = (int)data_segment[0]; nef_head->vmMode = NORMAL; break; case 0xcafe: nef_head->vmMode = UPDATE; case 0xcab: nef_head->vmMode = REAL; default: nef_head->vmMode = FAIL; break; } nef_head->DataIdentifer = 0x7E; nef_head->RODataIdentifer = 0x7F; nef_head->InstructionIdentifer = 0x80; switch((int)data_segment[1]) { case 0x302E3130: // 0.1 break; default: // I Dont Recoginze Any Other Version break ; } switch((int)data_segment[2]){ case 0x40000000: //64Bit nef_head->arch = 0x400000; break; case 0x20000000: //32Bit nef_head->arch = 0x200000; break; default: // What The F**k! 128? 225? break; } switch((unsigned long)data_segment[3]){ // 4 case 80305197: nef_head->top_signature_succeeded=1; break; case 0: nef_head->top_signature_succeeded=0; break; } switch((unsigned long)data_segment[3]){ case 80305197: nef_head->bottom_signature_succeeded =1; break; case 0: nef_head->bottom_signature_succeeded =0; break; } switch((unsigned long)data_segment[4]){ case 2: if(nef_head->top_signature_succeeded == 1 && nef_head->bottom_signature_succeeded == 1){ nef_head->vmMode = UPDATE; } break; case 1: nef_head->vmMode = NORMAL; break; } switch(nef_head->vmMode){ case NORMAL: // Normal break; case UPDATE: // Update break; case DEBUG_VM: // Unlock break; case UNLOCK: // Debug break; } switch((unsigned long)data_segment[5]){ // 7-8-9 case 0x7E: // Data Segment Identifer nef_head->i_offset = ((int)data_segment[6]); nef_head->d_offset = (((int)data_segment[nef_head->i_offset+7])); build_table(20000); // Ignore The 9th Number *Its Magical* if(nef_head->arch == 0x200000){ InitCPU(1, 1, 1); memoryptr = p_getPtrToMem(); } if(nef_head->arch == 0x400000){ InitCPU(1, 1, 1); memoryptr = p_getPtrToMem(); } for(int i=0 ; i < nef_head->i_offset; i++){ if(i==0){ setISSegmentPos(0, nef_head->i_offset); memoryptr[0] = (void**)0x7E; memoryptr[1] = (void**)nef_head->i_offset; } else{ register_type_manual(sizeof(data_segment[5+i]), 5+i); memoryptr[i] = data_segment[i+5]; } } break; } switch((unsigned long)data_segment[nef_head->i_offset+7]){ case 0x7f: for(int i=0 ; i < nef_head->d_offset; i++){ if(i==0){ setDSSegmentPos(nef_head->d_offset); memoryptr[nef_head->i_offset+1] = (void**)0x7f; memoryptr[nef_head->i_offset+2] = data_segment[nef_head->i_offset]; // Let Captian Noah Log A Entry In The Virtual MU Segment Table arghhhhh... } else{ register_type_manual(sizeof(data_segment[5+nef_head->i_offset+i]), nef_head->i_offset+i); memoryptr[nef_head->i_offset+i] = data_segment[5+nef_head->i_offset+i]; } } break; } switch((unsigned long)data_segment[nef_head->i_offset+6]){ //Lets Run Through The CheckList For Launch Houstin } LoadLib("libbasicIONative.dylib"); // This Is Hardcoded But Can Be Changed /* Lets Begin The Loading Cycle */ if(nef_head->vmMode == UPDATE){ printf("Update Mode Initated!"); // I Hear You Loud And Clear if(nef_head->vmMode == NORMAL){ // Shhhh... Be Quiet! } if(nef_head->vmMode == REAL){ } } }
static ALCboolean pulse_load(void) //{{{ { ALCboolean ret = ALC_FALSE; if(!pa_handle) { pa_threaded_mainloop *loop; #ifdef HAVE_DYNLOAD #ifdef _WIN32 #define PALIB "libpulse-0.dll" #elif defined(__APPLE__) && defined(__MACH__) #define PALIB "libpulse.0.dylib" #else #define PALIB "libpulse.so.0" #endif pa_handle = LoadLib(PALIB); if(!pa_handle) return ALC_FALSE; #define LOAD_FUNC(x) do { \ p##x = GetSymbol(pa_handle, #x); \ if(!(p##x)) { \ CloseLib(pa_handle); \ pa_handle = NULL; \ return ALC_FALSE; \ } \ } while(0) LOAD_FUNC(pa_context_unref); LOAD_FUNC(pa_sample_spec_valid); LOAD_FUNC(pa_stream_drop); LOAD_FUNC(pa_strerror); LOAD_FUNC(pa_context_get_state); LOAD_FUNC(pa_stream_get_state); LOAD_FUNC(pa_threaded_mainloop_signal); LOAD_FUNC(pa_stream_peek); LOAD_FUNC(pa_threaded_mainloop_wait); LOAD_FUNC(pa_threaded_mainloop_unlock); LOAD_FUNC(pa_threaded_mainloop_in_thread); LOAD_FUNC(pa_context_new); LOAD_FUNC(pa_threaded_mainloop_stop); LOAD_FUNC(pa_context_disconnect); LOAD_FUNC(pa_threaded_mainloop_start); LOAD_FUNC(pa_threaded_mainloop_get_api); LOAD_FUNC(pa_context_set_state_callback); LOAD_FUNC(pa_stream_write); LOAD_FUNC(pa_xfree); LOAD_FUNC(pa_stream_connect_record); LOAD_FUNC(pa_stream_connect_playback); LOAD_FUNC(pa_stream_readable_size); LOAD_FUNC(pa_stream_writable_size); LOAD_FUNC(pa_stream_cork); LOAD_FUNC(pa_stream_is_suspended); LOAD_FUNC(pa_stream_get_device_name); LOAD_FUNC(pa_path_get_filename); LOAD_FUNC(pa_get_binary_name); LOAD_FUNC(pa_threaded_mainloop_free); LOAD_FUNC(pa_context_errno); LOAD_FUNC(pa_xmalloc); LOAD_FUNC(pa_stream_unref); LOAD_FUNC(pa_threaded_mainloop_accept); LOAD_FUNC(pa_stream_set_write_callback); LOAD_FUNC(pa_threaded_mainloop_new); LOAD_FUNC(pa_context_connect); LOAD_FUNC(pa_stream_set_buffer_attr); LOAD_FUNC(pa_stream_get_buffer_attr); LOAD_FUNC(pa_stream_get_sample_spec); LOAD_FUNC(pa_stream_get_time); LOAD_FUNC(pa_stream_set_read_callback); LOAD_FUNC(pa_stream_set_state_callback); LOAD_FUNC(pa_stream_set_moved_callback); LOAD_FUNC(pa_stream_set_underflow_callback); LOAD_FUNC(pa_stream_new); LOAD_FUNC(pa_stream_disconnect); LOAD_FUNC(pa_threaded_mainloop_lock); LOAD_FUNC(pa_channel_map_init_auto); LOAD_FUNC(pa_channel_map_parse); LOAD_FUNC(pa_channel_map_snprint); LOAD_FUNC(pa_channel_map_equal); LOAD_FUNC(pa_context_get_server_info); LOAD_FUNC(pa_context_get_sink_info_by_name); LOAD_FUNC(pa_context_get_sink_info_list); LOAD_FUNC(pa_context_get_source_info_list); LOAD_FUNC(pa_operation_get_state); LOAD_FUNC(pa_operation_unref); #undef LOAD_FUNC #define LOAD_OPTIONAL_FUNC(x) do { \ p##x = GetSymbol(pa_handle, #x); \ } while(0) #if PA_CHECK_VERSION(0,9,15) LOAD_OPTIONAL_FUNC(pa_channel_map_superset); LOAD_OPTIONAL_FUNC(pa_stream_set_buffer_attr_callback); #endif #if PA_CHECK_VERSION(0,9,16) LOAD_OPTIONAL_FUNC(pa_stream_begin_write); #endif #undef LOAD_OPTIONAL_FUNC #else /* HAVE_DYNLOAD */ pa_handle = (void*)0xDEADBEEF; #endif if((loop=pa_threaded_mainloop_new()) && pa_threaded_mainloop_start(loop) >= 0) { pa_context *context; pa_threaded_mainloop_lock(loop); context = connect_context(loop, AL_TRUE); if(context) { ret = ALC_TRUE; pa_context_disconnect(context); pa_context_unref(context); } pa_threaded_mainloop_unlock(loop); pa_threaded_mainloop_stop(loop); } if(loop) pa_threaded_mainloop_free(loop); if(!ret) { #ifdef HAVE_DYNLOAD CloseLib(pa_handle); #endif pa_handle = NULL; } } return ret; } //}}}
static ALCboolean alsa_load(void) { #ifdef HAVE_DYNLOAD if(!alsa_handle) { alsa_handle = LoadLib("libasound.so.2"); if(!alsa_handle) return ALC_FALSE; #define LOAD_FUNC(f) do { \ p##f = GetSymbol(alsa_handle, #f); \ if(p##f == NULL) { \ CloseLib(alsa_handle); \ alsa_handle = NULL; \ return ALC_FALSE; \ } \ } while(0) LOAD_FUNC(snd_strerror); LOAD_FUNC(snd_pcm_open); LOAD_FUNC(snd_pcm_close); LOAD_FUNC(snd_pcm_nonblock); LOAD_FUNC(snd_pcm_frames_to_bytes); LOAD_FUNC(snd_pcm_bytes_to_frames); LOAD_FUNC(snd_pcm_hw_params_malloc); LOAD_FUNC(snd_pcm_hw_params_free); LOAD_FUNC(snd_pcm_hw_params_any); LOAD_FUNC(snd_pcm_hw_params_current); LOAD_FUNC(snd_pcm_hw_params_set_access); LOAD_FUNC(snd_pcm_hw_params_set_format); LOAD_FUNC(snd_pcm_hw_params_set_channels); LOAD_FUNC(snd_pcm_hw_params_set_periods_near); LOAD_FUNC(snd_pcm_hw_params_set_rate_near); LOAD_FUNC(snd_pcm_hw_params_set_rate); LOAD_FUNC(snd_pcm_hw_params_set_rate_resample); LOAD_FUNC(snd_pcm_hw_params_set_buffer_time_near); LOAD_FUNC(snd_pcm_hw_params_set_period_time_near); LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_near); LOAD_FUNC(snd_pcm_hw_params_set_buffer_size_min); LOAD_FUNC(snd_pcm_hw_params_set_period_size_near); LOAD_FUNC(snd_pcm_hw_params_get_buffer_size); LOAD_FUNC(snd_pcm_hw_params_get_period_size); LOAD_FUNC(snd_pcm_hw_params_get_access); LOAD_FUNC(snd_pcm_hw_params_get_periods); LOAD_FUNC(snd_pcm_hw_params_test_format); LOAD_FUNC(snd_pcm_hw_params_test_channels); LOAD_FUNC(snd_pcm_hw_params); LOAD_FUNC(snd_pcm_sw_params_malloc); LOAD_FUNC(snd_pcm_sw_params_current); LOAD_FUNC(snd_pcm_sw_params_set_avail_min); LOAD_FUNC(snd_pcm_sw_params_set_stop_threshold); LOAD_FUNC(snd_pcm_sw_params); LOAD_FUNC(snd_pcm_sw_params_free); LOAD_FUNC(snd_pcm_prepare); LOAD_FUNC(snd_pcm_start); LOAD_FUNC(snd_pcm_resume); LOAD_FUNC(snd_pcm_reset); LOAD_FUNC(snd_pcm_wait); LOAD_FUNC(snd_pcm_state); LOAD_FUNC(snd_pcm_avail_update); LOAD_FUNC(snd_pcm_areas_silence); LOAD_FUNC(snd_pcm_mmap_begin); LOAD_FUNC(snd_pcm_mmap_commit); LOAD_FUNC(snd_pcm_readi); LOAD_FUNC(snd_pcm_writei); LOAD_FUNC(snd_pcm_drain); LOAD_FUNC(snd_pcm_drop); LOAD_FUNC(snd_pcm_recover); LOAD_FUNC(snd_pcm_info_malloc); LOAD_FUNC(snd_pcm_info_free); LOAD_FUNC(snd_pcm_info_set_device); LOAD_FUNC(snd_pcm_info_set_subdevice); LOAD_FUNC(snd_pcm_info_set_stream); LOAD_FUNC(snd_pcm_info_get_name); LOAD_FUNC(snd_ctl_pcm_next_device); LOAD_FUNC(snd_ctl_pcm_info); LOAD_FUNC(snd_ctl_open); LOAD_FUNC(snd_ctl_close); LOAD_FUNC(snd_ctl_card_info_malloc); LOAD_FUNC(snd_ctl_card_info_free); LOAD_FUNC(snd_ctl_card_info); LOAD_FUNC(snd_ctl_card_info_get_name); LOAD_FUNC(snd_ctl_card_info_get_id); LOAD_FUNC(snd_card_next); #undef LOAD_FUNC } #endif return ALC_TRUE; }
void CDynPatcher::Error(const char *File, const char *Func, int Line, bool IsCritical, char *Fmt, ...) { static char Buff[0x1000]; int len=0; len+=_snprintf(&Buff[len],sizeof(Buff)-len-1,"[CDynPatcher] %serror",IsCritical?"critical":""); if(File&&Func&&Line&&strlen(File)<MAX_PATH&&strlen(Func)<300) { len+=_snprintf(&Buff[len],sizeof(Buff)-len-1," at %s(%s:%i)",CSectionData::GetFileName(File),Func,Line); } len+=_snprintf(&Buff[len],sizeof(Buff)-len-1,":"); va_list marker; if(!Fmt) { len+=_snprintf(&Buff[len],sizeof(Buff)-len-1,"(NO DESCRIPTION)\r\n"); } else { va_start( marker, Fmt ); len+=_vsnprintf(&Buff[len],sizeof(Buff)-len-1, Fmt, marker ); } len+=_snprintf(&Buff[len],sizeof(Buff)-len-1,"\r\n"); printf("%s",Buff); if(IsCritical) { #ifdef WIN32 __asm{int 3}; if(!IsDebuggerPresent()) { exit(0); } #else exit(0); #endif } } void CDynPatcher::Message(const char *File, const char *Func, int Line, char *Fmt, ...) { static char Buff[0x1000]; int len=0; len+=_snprintf(&Buff[len],sizeof(Buff)-len-1,"[CDynPatcher]"); if(File&&Func&&Line&&strlen(File)<MAX_PATH&&strlen(Func)<300) { len+=_snprintf(&Buff[len],sizeof(Buff)-len-1," at %s(%s:%i)",CSectionData::GetFileName(File),Func,Line); } len+=_snprintf(&Buff[len],sizeof(Buff)-len-1,":"); va_list marker; if(!Fmt) { len+=_snprintf(&Buff[len],sizeof(Buff)-len-1,"(NO DESCRIPTION)\r\n"); } else { va_start( marker, Fmt ); len+=_vsnprintf(&Buff[len],sizeof(Buff)-len-1, Fmt, marker ); } len+=_snprintf(&Buff[len],sizeof(Buff)-len-1,"\r\n"); printf("%s",Buff); } bool CDynPatcher::Init(const char *LibName,bool ForceLoad) { if (!LibName) { szLibName = "<<===NO LIBRARY NAME===>>"; return false; } if(!LoadLib(LibName,ForceLoad)) { DynErr(false,"Unable to load \"%s\"",LibName); return false; } #ifdef WIN32 if(!ParseGenericDllData_PE()) { DynErr(false,"Failed to parse \"%s\"",szLibName); return false; } DynMsg("\"%s\" parsed",szLibName); #else FILE *fl = fopen(szLibName, "rb"); int LibSize; void* LibBuf; if (fl == NULL) { DynErr(false,"Failed to open '%s' for read\n", szLibName); return false; } fseek(fl, 0, SEEK_END); LibSize = ftell(fl); fseek(fl, 0, SEEK_SET); if (LibSize < 0) LibSize = 0; LibBuf = malloc(LibSize + 4); fread(LibBuf, 1, LibSize, fl); fclose(fl); if(!ParseGenericDllData_ELF(LibBuf, LibSize)) { DynErr(false,"Failed to parse \"%s\"",szLibName); return false; } #endif return true; } bool CDynPatcher::Init(const wchar_t *LibName, bool ForceLoad /*= false*/) { return 0; static char UTF8LibName[MAX_PATH]; //Q_UnicodeToUTF8(LibName, UTF8LibName, MAX_PATH-1); return Init(UTF8LibName, ForceLoad); } bool CDynPatcher::Init(void *FuncAddr) { char szTmpName[400]; sprintf(szTmpName, "Unk_load_by_func_addr_%p", FuncAddr); szLibName = new char[strlen(szTmpName) + 1]; strcpy(szLibName, szTmpName); bSelfLoaded = false; #ifdef _WIN32 MEMORY_BASIC_INFORMATION mem; VirtualQuery(FuncAddr, &mem, sizeof(mem)); szTmpName[0] = 0; GetModuleFileNameA(reinterpret_cast<HMODULE>(mem.AllocationBase ), szTmpName, sizeof(szTmpName) - 1); if (szTmpName[0] != 0) { delete[]szLibName; szLibName = new char[strlen(CSectionData::GetFileName(szTmpName)) + 1]; strcpy(szLibName, CSectionData::GetFileName(szTmpName)); } IMAGE_DOS_HEADER *dos = (IMAGE_DOS_HEADER*)mem.AllocationBase; IMAGE_NT_HEADERS *pe = (IMAGE_NT_HEADERS*)((unsigned long)dos + (unsigned long)dos->e_lfanew); if (pe->Signature == IMAGE_NT_SIGNATURE) { this->DllHandler = mem.AllocationBase; if (!ParseGenericDllData_PE()) { DynErr(false, "Failed to parse \"%s\"", szLibName); return false; } DynMsg("\"%s\" parsed",szLibName); } #else Dl_info info; if (dladdr(FuncAddr, &info) && info.dli_fbase &&info.dli_fname) { delete [] szLibName; szLibName = new char[strlen(info.dli_fname) + 1]; strcpy(szLibName, info.dli_fname); bool ParseOK=false; size_t LoadLibSize=0; DllBase = info.dli_fbase; LoadLibSize = (size_t)GetBaseLen(DllBase); DllHandler = dlopen(info.dli_fname, RTLD_NOW); dlclose(DllHandler); DynMsg("Found library \"%s\" at addr %p. Base=%p, size=%x, handler=%p",szLibName,FuncAddr,DllBase,LoadLibSize,DllHandler); FILE *fl = fopen(szLibName, "rb"); int LibSize; void* LibBuf; if (fl) { fseek(fl, 0, SEEK_END); LibSize = ftell(fl); fseek(fl, 0, SEEK_SET); DynMsg("Reading \"%s\" as file. Size=%x",szLibName,LibSize); if (LibSize < 0) LibSize = 0; LibBuf = malloc(LibSize + 4); fread(LibBuf, 1, LibSize, fl); fclose(fl); ParseOK=ParseGenericDllData_ELF(LibBuf, LibSize); free(LibBuf); } else { DynMsg("Unable to read \"%s\" as file. Trying to use information from Dl_info.",szLibName); ParseOK=ParseGenericDllData_ELF(DllBase, LoadLibSize); } if (!ParseOK) { DynErr(false, "Failed to parse \"%s\"", szLibName); return false; } } #endif else { DynErr(false, "Failed find library at %p",FuncAddr); return false; } return true; }
TProfile *extractFlowVZEROsingle(Int_t icentr,Int_t spec,Int_t arm,Bool_t isMC,Float_t pTh,Int_t addbin,const char *nameSp,Float_t detMin,Float_t detMax,Int_t chMin,Int_t chMax){ LoadLib(); pTh += 0.00001; // NUA correction currently are missing char name[100]; char stringa[200]; snprintf(name,100,"AnalysisResults.root"); if(!fo) fo = new TFile(name); snprintf(name,100,"contVZEROv%i",arm); TList *cont = (TList *) fo->Get(name); cont->ls(); Float_t xMin[5] = {icentr/*centrality bin*/,chMin/*charge*/,pTh/*prob*/,-TMath::Pi()/arm/*Psi*/,detMin/*PID mask*/}; Float_t xMax[5] = {icentr+addbin,chMax,1.0,TMath::Pi()/arm,detMax}; cont->ls(); TProfile *p1 = cont->At(2); TProfile *p2 = cont->At(3); TProfile *p3 = cont->At(4); TH2F *hPsi2DA = cont->At(5); TH2F *hPsi2DC = cont->At(6); TH1D *hPsiA = hPsi2DA->ProjectionY("PsiA",icentr+1,icentr+addbin+1); TH1D *hPsiC = hPsi2DC->ProjectionY("PsiC",icentr+1,icentr+addbin+1); if(!fPsi) fPsi = new TF1("fPsi","pol0",-TMath::Pi()/arm,TMath::Pi()/arm); hPsiA->Fit(fPsi,"0"); Float_t offsetA = fPsi->GetParameter(0); hPsiC->Fit(fPsi,"0"); Float_t offsetC = fPsi->GetParameter(0); Int_t nbinPsi = hPsiA->GetNbinsX(); Float_t *NUAcorrA = new Float_t[nbinPsi]; Float_t *NUAcorrC = new Float_t[nbinPsi]; for(Int_t i=0;i < nbinPsi;i++){ NUAcorrA[i] = offsetA/(hPsiA->GetBinContent(i+1)); NUAcorrC[i] = offsetC/(hPsiC->GetBinContent(i+1)); } Float_t res1=0,res2=0,res3=0; Float_t eres1=0,eres2=0,eres3=0; for(Int_t i = icentr; i <= icentr+addbin;i++){ if(p1->GetBinError(i+1)){ eres1 += 1./p1->GetBinError(i+1)/p1->GetBinError(i+1); res1 += p1->GetBinContent(i+1)/p1->GetBinError(i+1)/p1->GetBinError(i+1); } if(p2->GetBinError(i+1)){ eres2 += 1./p2->GetBinError(i+1)/p2->GetBinError(i+1); res2 += p2->GetBinContent(i+1)/p2->GetBinError(i+1)/p2->GetBinError(i+1); } if(p3->GetBinError(i+1)){ eres3 += 1./p3->GetBinError(i+1)/p3->GetBinError(i+1); res3 += p3->GetBinContent(i+1)/p3->GetBinError(i+1)/p3->GetBinError(i+1); } } res1 /= eres1; res2 /= eres2; res3 /= eres3; eres1 = sqrt(1./eres1); eres2 = sqrt(1./eres2); eres3 = sqrt(1./eres3); AliFlowVZEROResults *a = (AliFlowVZEROResults *) cont->At(0); AliFlowVZEROResults *b = (AliFlowVZEROResults *) cont->At(1); TProfile *pp,*pp2; if(kNUAcorr){ // with NUA corrections pp = a->GetV2reweight(spec,xMin,xMax,3,NUAcorrA); pp2 = b->GetV2reweight(spec,xMin,xMax,3,NUAcorrC); } else{ pp = a->GetV2(spec,xMin,xMax); pp2 = b->GetV2(spec,xMin,xMax); } Float_t scaling = sqrt(res1*res3/res2); if(kVZEROrescorr){ pp->Scale(1./scaling); } Float_t err1_2 = eres1*eres1/res1/res1/4 + eres2*eres2/res2/res2/4 + eres3*eres3/res3/res3/4; Float_t err2_2 = err1_2; err1_2 /= scaling*scaling; printf("resolution V0A = %f +/- %f\n",scaling,err1_2); scaling = sqrt(res2*res3/res1); err2_2 /= scaling*scaling; if(kVZEROrescorr){ pp2->Scale(1./scaling); } printf("resolution V0C =%f +/- %f\n",scaling,err2_2); pp->SetName("V0A"); pp2->SetName("V0C"); if(! kCleanMemory){ new TCanvas(); pp->Draw(); pp2->Draw("SAME"); } TProfile *pData = new TProfile(*pp); pData->Add(pp2); snprintf(stringa,100,"%sData",nameSp); pData->SetName(stringa); TProfile *pMc = NULL; TProfile *ppMC; TProfile *ppMC2; if(isMC){ snprintf(name,100,"contVZEROmc"); cont = (TList *) fo->Get(name); cont->ls(); if(arm == 2){ AliFlowVZEROResults *c = (AliFlowVZEROResults *) cont->At(0); if(! kCleanMemory) c->GetV2(spec,xMin,xMax)->Draw("SAME"); } AliFlowVZEROResults *cA; if(fo->Get("contVZEROv2")) cA = (AliFlowVZEROResults *) cont->At(1+2*(arm==3)); else cA = (AliFlowVZEROResults *) cont->At(0); AliFlowVZEROResults *cC; if(fo->Get("contVZEROv2")) cC = (AliFlowVZEROResults *) cont->At(2+2*(arm==3)); else cC = (AliFlowVZEROResults *) cont->At(1); TProfile *p1mc = cont->At(5+3*(arm==3)); TProfile *p2mc = cont->At(6+3*(arm==3)); TProfile *p3mc = cont->At(7+3*(arm==3)); Float_t resMC1=0,resMC2=0,resMC3=0; Float_t eresMC1=0,eresMC2=0,eresMC3=0; for(Int_t i = icentr; i <= icentr+addbin;i++){ if(p1mc->GetBinError(i+1)){ eresMC1 += 1./p1mc->GetBinError(i+1)/p1mc->GetBinError(i+1); resMC1 += p1mc->GetBinContent(i+1)/p1mc->GetBinError(i+1)/p1mc->GetBinError(i+1); } if(p2mc->GetBinError(i+1)){ eresMC2 += 1./p2mc->GetBinError(i+1)/p2mc->GetBinError(i+1); resMC2 += p2mc->GetBinContent(i+1)/p2mc->GetBinError(i+1)/p2mc->GetBinError(i+1); } if(p3mc->GetBinError(i+1)){ eresMC3 += 1./p3mc->GetBinError(i+1)/p3mc->GetBinError(i+1); resMC3 += p3mc->GetBinContent(i+1)/p3mc->GetBinError(i+1)/p3mc->GetBinError(i+1); } } resMC1 /= eresMC1; resMC2 /= eresMC2; resMC3 /= eresMC3; eresMC1 = sqrt(1./eresMC1); eresMC2 = sqrt(1./eresMC2); eresMC3 = sqrt(1./eresMC3); ppMC = cA->GetV2(spec,xMin,xMax); ppMC2 = cC->GetV2(spec,xMin,xMax); scaling = sqrt(resMC1*resMC3/resMC2); ppMC->Scale(1./scaling); err1_2 = eresMC1*eresMC1/resMC1/resMC1/4 + eresMC2*eresMC2/resMC2/resMC2/4 + eresMC3*eresMC3/resMC3/resMC3/4; err2_2 = err1_2; err1_2 /= scaling*scaling; printf("resolution V0A (MC) = %f +/- %f\n",scaling,err1_2); scaling = sqrt(resMC2*resMC3/resMC1); err2_2 /= scaling*scaling; ppMC2->Scale(1./scaling); printf("resolution V0C (MC) =%f +/- %f\n",scaling,err2_2); ppMC->SetName("V0Amc"); ppMC2->SetName("V0Cmc"); if(! kCleanMemory){ ppMC->Draw("SAME"); ppMC2->Draw("SAME"); } pMc = new TProfile(*ppMC); pMc->Add(ppMC2); snprintf(stringa,100,"%sMC",nameSp); pMc->SetName(stringa); pMc->SetLineColor(2); } if(! kCleanMemory){ new TCanvas(); pData->Draw(); } if(pMc && !kCleanMemory){ pMc->Draw("SAME"); TH1D *hData = pData->ProjectionX(); TH1D *hMc = pMc->ProjectionX(); hData->Divide(hMc); new TCanvas(); hData->Draw(); } delete[] NUAcorrA; delete[] NUAcorrC; if(kCleanMemory){ if(pp) delete pp; if(pp2) delete pp2; if(ppMC) delete ppMC; if(ppMC2) delete ppMC2; } delete cont; if(isMC) return pMc; return pData; }
void extractFlowVZERO(Int_t icentr,const char *type,Int_t arm,Float_t pTh,Bool_t isMC,Int_t addbin){ LoadLib(); char name[100]; snprintf(name,100,"AnalysisResults%s.root",type); if(!fo) fo = new TFile(name); new TCanvas(); Int_t cMin[] = {0,5,10,20,30,40,50,60,70}; Int_t cMax[] = {5,10,20,30,40,50,60,70,80}; if(kNUOcorr){ // Compute correction for NUO in TOF compareTPCTOF(icentr,0,arm,pTh,addbin); // compareTPCTOF(icentr,1,arm,pTh,addbin); // compareTPCTOF(icentr,2,arm,pTh,addbin); // compareTPCTOF(icentr,3,arm,pTh,addbin); // compareTPCTOF(icentr,4,arm,pTh,addbin); } TProfile *pAll; pAll=extractFlowVZEROsingle(icentr,0,arm,0,pTh,addbin,"all",0,1); pAll->SetMarkerStyle(24); TProfile *pPiTOF,*pPiTPC,*pPiTPC2; pPiTOF=extractFlowVZEROsingle(icentr,1,arm,0,pTh,addbin,"piTOF",1,1); pPiTPC=extractFlowVZEROsingle(icentr,1,arm,0,pTh,addbin,"piTPC",0,0); pPiTPC2=extractFlowVZEROsingle(icentr,1,arm,0,pTh,addbin,"piTPC2",2,2); pPiTPC->Add(pPiTPC2); TH1D *hPi = pPiTOF->ProjectionX("hPi"); hPi->SetLineColor(4); hPi->SetMarkerColor(4); hPi->SetMarkerStyle(20); for(Int_t i=1;i <=hPi->GetNbinsX();i++){ Float_t x = hPi->GetBinCenter(i); if(x < 0.2){ hPi->SetBinContent(i,0); hPi->SetBinError(i,0); } else if(x < 0.5){ hPi->SetBinContent(i,pPiTPC->GetBinContent(i)); hPi->SetBinError(i,pPiTPC->GetBinError(i)); } else{ if(kNUOcorr){ hPi->SetBinContent(i,pPiTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i)); hPi->SetBinError(i,pPiTOF->GetBinError(i)); } else{ hPi->SetBinContent(i,pPiTOF->GetBinContent(i)); hPi->SetBinError(i,pPiTOF->GetBinError(i)); } } } TProfile *pElTOF,*pElTPC,*pElTPC2; pElTOF=extractFlowVZEROsingle(icentr,4,arm,0,pTh,addbin,"piTOF",1,1); pElTPC=extractFlowVZEROsingle(icentr,4,arm,0,pTh,addbin,"piTPC",0,0); pElTPC2=extractFlowVZEROsingle(icentr,4,arm,0,pTh,addbin,"piTPC2",2,2); pElTPC->Add(pElTPC2); TH1D *hEl = pElTOF->ProjectionX("hEl"); hEl->SetLineColor(6); hEl->SetMarkerColor(6); hEl->SetMarkerStyle(20); for(Int_t i=1;i <=hEl->GetNbinsX();i++){ Float_t x = hEl->GetBinCenter(i); if(x < 0.2){ hEl->SetBinContent(i,0); hEl->SetBinError(i,0); } else if(x < 0.3){ hEl->SetBinContent(i,pElTPC->GetBinContent(i)); hEl->SetBinError(i,pElTPC->GetBinError(i)); } else{ if(kNUOcorr){ hEl->SetBinContent(i,pElTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i)); hEl->SetBinError(i,pElTOF->GetBinError(i)); } else{ hEl->SetBinContent(i,pElTOF->GetBinContent(i)); hEl->SetBinError(i,pElTOF->GetBinError(i)); } } } TProfile *pKTOF,*pKTPC,*pKTPC2; pKTOF=extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kaTOF",1,1); pKTPC=extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kaTPC",0,0); pKTPC2=extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kaTPC2",2,2); pKTPC->Add(pKTPC2); TH1D *hK = pKTOF->ProjectionX("hKa"); hK->SetLineColor(1); hK->SetMarkerColor(1); hK->SetMarkerStyle(21); for(Int_t i=1;i <=hK->GetNbinsX();i++){ Float_t x = hK->GetBinCenter(i); if(x < 0.25){ hK->SetBinContent(i,0); hK->SetBinError(i,0); } else if(x < 0.45){ hK->SetBinContent(i,pKTPC->GetBinContent(i)); hK->SetBinError(i,pKTPC->GetBinError(i)); } else{ if(kNUOcorr){ hK->SetBinContent(i,pKTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i)); hK->SetBinError(i,pKTOF->GetBinError(i)); } else{ hK->SetBinContent(i,pKTOF->GetBinContent(i)); hK->SetBinError(i,pKTOF->GetBinError(i)); } } } TProfile *pPrTOF,*pPrTOF2,*pPrTPC,*pPrTPC2; pPrTOF=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTOF",1,1,-1,-1); pPrTOF2=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTOF2",1,1,-1,1); pPrTPC=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTPC",0,0,-1,-1); pPrTPC2=extractFlowVZEROsingle(icentr,3,arm,0,pTh,addbin,"prTPC2",2,2,-1,-1); pPrTPC->Add(pPrTPC2); TH1D *hPr = pPrTOF->ProjectionX("hPr"); hPr->SetLineColor(2); hPr->SetMarkerColor(2); hPr->SetMarkerStyle(22); for(Int_t i=1;i <=hPr->GetNbinsX();i++){ Float_t x = hPr->GetBinCenter(i); if(x < 0.3){ hPr->SetBinContent(i,0); hPr->SetBinError(i,0); } else if(x < 1.0){ hPr->SetBinContent(i,pPrTPC->GetBinContent(i)); hPr->SetBinError(i,pPrTPC->GetBinError(i)); } else{ if(x < 3){ if(kNUOcorr){ hPr->SetBinContent(i,pPrTOF->GetBinContent(i) + hNUO[0]->GetBinContent(i)); hPr->SetBinError(i,pPrTOF->GetBinError(i)); } else{ hPr->SetBinContent(i,pPrTOF->GetBinContent(i)); hPr->SetBinError(i,pPrTOF->GetBinError(i)); } } else{ if(kNUOcorr){ hPr->SetBinContent(i,pPrTOF2->GetBinContent(i) + hNUO[0]->GetBinContent(i)); hPr->SetBinError(i,pPrTOF2->GetBinError(i)); } else{ hPr->SetBinContent(i,pPrTOF2->GetBinContent(i)); hPr->SetBinError(i,pPrTOF2->GetBinError(i)); } } } } pAll->Draw(); hPi->Draw("SAME"); hK->Draw("SAME"); hPr->Draw("SAME"); char name[100]; // PID correction if(kPIDcorr){ TFile *fPidTOF = new TFile("$ALICE_ROOT/PWGCF/FLOW/other/BayesianPIDcontTPCTOF.root"); TFile *fPidTPC = new TFile("$ALICE_ROOT/PWGCF/FLOW/other/BayesianPIDcontTPC.root"); // pi histos sprintf(name,"Pi_IDas_Picentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPiPi=(TH1D *) fPidTOF->Get(name); sprintf(name,"Pi_IDas_Elcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPiEl=(TH1D *) fPidTOF->Get(name); sprintf(name,"Pi_IDas_Kacentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPiKa=(TH1D *) fPidTOF->Get(name); sprintf(name,"Pi_IDas_Prcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPiPr=(TH1D *) fPidTOF->Get(name); TH1D *hPidAll = new TH1D(*hPidPiPi); hPidAll->Add(hPidPiKa); hPidAll->Add(hPidPiPr); hPidAll->Add(hPidPiEl); hPidPiPi->Divide(hPidAll); hPidPiKa->Divide(hPidAll); hPidPiPr->Divide(hPidAll); hPidPiEl->Divide(hPidAll); sprintf(name,"Pi_IDas_Picentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPiPiTPC=(TH1D *) fPidTPC->Get(name); sprintf(name,"Pi_IDas_Elcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPiElTPC=(TH1D *) fPidTPC->Get(name); sprintf(name,"Pi_IDas_Kacentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPiKaTPC=(TH1D *) fPidTPC->Get(name); sprintf(name,"Pi_IDas_Prcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPiPrTPC=(TH1D *) fPidTPC->Get(name); hPidAll->Reset(); hPidAll->Add(hPidPiPiTPC); hPidAll->Add(hPidPiKaTPC); hPidAll->Add(hPidPiPrTPC); hPidAll->Add(hPidPiElTPC); hPidPiPiTPC->Divide(hPidAll); hPidPiKaTPC->Divide(hPidAll); hPidPiPrTPC->Divide(hPidAll); hPidPiElTPC->Divide(hPidAll); // K histos sprintf(name,"Ka_IDas_Picentr%i_pth%4.2f",icentr,pTh); TH1D *hPidKaPi=(TH1D *) fPidTOF->Get(name); sprintf(name,"Ka_IDas_Elcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidKaEl=(TH1D *) fPidTOF->Get(name); sprintf(name,"Ka_IDas_Kacentr%i_pth%4.2f",icentr,pTh); TH1D *hPidKaKa=(TH1D *) fPidTOF->Get(name); sprintf(name,"Ka_IDas_Prcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidKaPr=(TH1D *) fPidTOF->Get(name); hPidAll->Reset(); hPidAll->Add(hPidKaPi); hPidAll->Add(hPidKaKa); hPidAll->Add(hPidKaPr); hPidAll->Add(hPidKaEl); hPidKaPi->Divide(hPidAll); hPidKaKa->Divide(hPidAll); hPidKaPr->Divide(hPidAll); hPidKaEl->Divide(hPidAll); sprintf(name,"Ka_IDas_Picentr%i_pth%4.2f",icentr,pTh); TH1D *hPidKaPiTPC=(TH1D *) fPidTPC->Get(name); sprintf(name,"Ka_IDas_Elcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidKaElTPC=(TH1D *) fPidTPC->Get(name); sprintf(name,"Ka_IDas_Kacentr%i_pth%4.2f",icentr,pTh); TH1D *hPidKaKaTPC=(TH1D *) fPidTPC->Get(name); sprintf(name,"Ka_IDas_Prcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidKaPrTPC=(TH1D *) fPidTPC->Get(name); hPidAll->Reset(); hPidAll->Add(hPidKaPiTPC); hPidAll->Add(hPidKaKaTPC); hPidAll->Add(hPidKaPrTPC); hPidAll->Add(hPidKaElTPC); hPidKaPiTPC->Divide(hPidAll); hPidKaKaTPC->Divide(hPidAll); hPidKaPrTPC->Divide(hPidAll); hPidKaElTPC->Divide(hPidAll); // pr histos sprintf(name,"Pr_IDas_Picentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPrPi=(TH1D *) fPidTOF->Get(name); sprintf(name,"Pr_IDas_Elcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPrEl=(TH1D *) fPidTOF->Get(name); sprintf(name,"Pr_IDas_Kacentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPrKa=(TH1D *) fPidTOF->Get(name); sprintf(name,"Pr_IDas_Prcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPrPr=(TH1D *) fPidTOF->Get(name); hPidAll->Reset(); hPidAll->Add(hPidPrPi); hPidAll->Add(hPidPrKa); hPidAll->Add(hPidPrPr); hPidAll->Add(hPidPrEl); hPidPrPi->Divide(hPidAll); hPidPrKa->Divide(hPidAll); hPidPrPr->Divide(hPidAll); hPidPrEl->Divide(hPidAll); sprintf(name,"Pr_IDas_Picentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPrPiTPC=(TH1D *) fPidTPC->Get(name); sprintf(name,"Pr_IDas_Elcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPrElTPC=(TH1D *) fPidTPC->Get(name); sprintf(name,"Pr_IDas_Kacentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPrKaTPC=(TH1D *) fPidTPC->Get(name); sprintf(name,"Pr_IDas_Prcentr%i_pth%4.2f",icentr,pTh); TH1D *hPidPrPrTPC=(TH1D *) fPidTPC->Get(name); hPidAll->Reset(); hPidAll->Add(hPidPrPiTPC); hPidAll->Add(hPidPrKaTPC); hPidAll->Add(hPidPrPrTPC); hPidAll->Add(hPidPrElTPC); hPidPrPiTPC->Divide(hPidAll); hPidPrKaTPC->Divide(hPidAll); hPidPrPrTPC->Divide(hPidAll); hPidPrElTPC->Divide(hPidAll); for(Int_t k=1;k <=hPi->GetNbinsX();k++){ Float_t pt = hPi->GetBinCenter(k); Float_t xPi=hPi->GetBinContent(k)*hPidPiPi->Interpolate(pt) + hK->GetBinContent(k)*hPidPiKa->Interpolate(pt) + hPr->GetBinContent(k)*hPidPiPr->Interpolate(pt) + hEl->GetBinContent(k)*hPidPiEl->Interpolate(pt); if(pt < 0.5) xPi=hPi->GetBinContent(k)*hPidPiPiTPC->Interpolate(pt) + hK->GetBinContent(k)*hPidPiKaTPC->Interpolate(pt) + hPr->GetBinContent(k)*hPidPiPrTPC->Interpolate(pt) + hEl->GetBinContent(k)*hPidPiElTPC->Interpolate(pt); Float_t xKa=hPi->GetBinContent(k)*hPidKaPi->Interpolate(pt) + hK->GetBinContent(k)*hPidKaKa->Interpolate(pt) + hPr->GetBinContent(k)*hPidKaPr->Interpolate(pt) + hEl->GetBinContent(k)*hPidKaEl->Interpolate(pt); if(pt < 0.45) xKa=hPi->GetBinContent(k)*hPidKaPiTPC->Interpolate(pt) + hK->GetBinContent(k)*hPidKaKaTPC->Interpolate(pt) + hPr->GetBinContent(k)*hPidKaPrTPC->Interpolate(pt) + hEl->GetBinContent(k)*hPidKaElTPC->Interpolate(pt); Float_t xPr=hPi->GetBinContent(k)*hPidPrPi->Interpolate(pt) + hK->GetBinContent(k)*hPidPrKa->Interpolate(pt) + hPr->GetBinContent(k)*hPidPrPr->Interpolate(pt) + hEl->GetBinContent(k)*hPidPrEl->Interpolate(pt); if(pt < 1) xPr=hPi->GetBinContent(k)*hPidPrPiTPC->Interpolate(pt) + hK->GetBinContent(k)*hPidPrKaTPC->Interpolate(pt) + hPr->GetBinContent(k)*hPidPrPrTPC->Interpolate(pt) + hEl->GetBinContent(k)*hPidPrElTPC->Interpolate(pt); hPi->SetBinContent(k,hPi->GetBinContent(k)*2 - xPi); hK->SetBinContent(k,hK->GetBinContent(k)*2 - xKa); hPr->SetBinContent(k,hPr->GetBinContent(k)*2 - xPr); } } // antiproton Feed down TProfile *pFromLambda = extractFlowVZEROsingle(icentr,11,arm,0,pTh,addbin,"pFromLambda",1,1); TProfile *piFromK = extractFlowVZEROsingle(icentr,12,arm,0,pTh,addbin,"piFromK",1,1,1,1); TProfile *pFromLambda2 = extractFlowVZEROsingle(icentr,11,arm,0,0.6,addbin,"pFromLambdanoPID",0,1); TProfile *piFromK2 = extractFlowVZEROsingle(icentr,12,arm,0,0.6,addbin,"piFromKnoPID",0,1); TProfile *piFromK3 = extractFlowVZEROsingle(icentr,12,arm,0,0.6,addbin,"piFromKnoPIDtof",1,1); TH1D *hFeedSyst = NULL; if(kFEEDcorr){ hFeedSyst = new TH1D(*hPr); hFeedSyst->SetName("hFeedSyst"); hFeedSyst->Reset(); for(Int_t k=1;k <=hPr->GetNbinsX();k++){ Float_t contam = 3.23174e-01 * TMath::Exp(- 9.46743e-01 * hPr->GetBinCenter(k)); Float_t corr = contam * pFromLambda->GetBinContent(k)/(1-contam); Float_t corrErr = contam * pFromLambda->GetBinError(k)/(1-contam); Float_t value = hPr->GetBinContent(k)/(1-contam) - corr; Float_t valueErr = hPr->GetBinError(k)/(1-contam); hFeedSyst->SetBinContent(k,hPr->GetBinContent(k) - value); hFeedSyst->SetBinContent(k,sqrt(corrErr*corrErr + valueErr*valueErr - hPr->GetBinError(k)*hPr->GetBinError(k))); hPr->SetBinContent(k,value); hPr->SetBinError(k,sqrt(corrErr*corrErr + valueErr*valueErr)); } hFeedSyst->Divide(hPr); } // write output snprintf(name,100,"results%03i-%03iv%i_pTh%3.1f%s.root",cMin[icentr],cMax[icentr+addbin],arm,pTh,type); TFile *fout = new TFile(name,"RECREATE"); pAll->ProjectionX()->Write(); hPi->Write(); hK->Write(); hPr->Write(); if(isMC){ TH1D *pTmp = extractFlowVZEROsingle(icentr,0,arm,1,pTh,addbin,"allMC",1,1,-1,1)->ProjectionX(); pTmp->SetLineColor(6); pTmp->SetMarkerColor(6); pTmp->SetMarkerStyle(24); pTmp->Write(); pTmp = extractFlowVZEROsingle(icentr,1,arm,1,pTh,addbin,"piMC",1,1,-1,1)->ProjectionX(); pTmp->SetLineColor(4); pTmp->SetMarkerColor(4); pTmp->SetMarkerStyle(24); pTmp->Write(); pTmp = extractFlowVZEROsingle(icentr,2,arm,1,pTh,addbin,"kaMC",1,1,-1,1)->ProjectionX(); pTmp->SetLineColor(1); pTmp->SetMarkerColor(1); pTmp->SetMarkerStyle(25); pTmp->Write(); pTmp = extractFlowVZEROsingle(icentr,3,arm,1,pTh,addbin,"prMC",1,1,-1,-1)->ProjectionX(); pTmp->SetLineColor(2); pTmp->SetMarkerColor(2); pTmp->SetMarkerStyle(26); pTmp->Write(); } extractFlowVZEROsingle(icentr,2,arm,0,pTh,addbin,"kProf")->Write(); extractFlowVZEROsingle(icentr,9,arm,0,pTh,addbin,"ks",0,1,1,1)->Write(); extractFlowVZEROsingle(icentr,9,arm,0,pTh,addbin,"ksMy",0,1,-1,-1)->Write(); extractFlowVZEROsingle(icentr,10,arm,0,pTh,addbin,"lambda")->Write(); pFromLambda->Write(); piFromK->Write(); pFromLambda2->Write(); piFromK2->Write(); piFromK3->Write(); if(hFeedSyst) hFeedSyst->Write(); fout->Close(); }