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();
}
