bool Parser::statement() {
bool isReturn = false;
switch (lexer->token) {
case '{': isReturn = block(); break;
case TK_if: ifStat(); break;
case TK_while: whileStat(); break;
case TK_for: forStat(); break;
case TK_return: {
advance();
int top = syms->localsTop();
emit(top, RET, 0, expr(top), UNUSED);
isReturn = true;
break;
}
case TK_NAME: {
int lookahead = lexer->lookahead();
if (lookahead == '=' || lookahead == ':'+TK_EQUAL) {
Value name = lexer->info.name;
consume(TK_NAME);
if (lookahead == '=') {
int slot = lookupSlot(name);
consume('=');
int top = syms->localsTop();
patchOrEmitMove(top + 1, slot, expr(top));
proto->patchPos = -1;
} else {
consume(':'+TK_EQUAL);
if (syms->definedInThisBlock(name)) {
CERR(true, E_VAR_REDEFINITION, name);
// aSlot = slot; // reuse existing local with same name
} else {
const Value a = expr(syms->localsTop());
const int slot = syms->set(name);
patchOrEmitMove(slot+1, slot, a);
proto->patchPos = -1;
}
}
break;
}
}
default: {
int top = syms->localsTop();
Value lhs = expr(top);
if (TOKEN == '=') {
consume('=');
CERR(!IS_REG(lhs), E_ASSIGN_TO_CONST, lhs);
CERR(proto->patchPos < 0, E_ASSIGN_RHS, lhs);
unsigned code = proto->code.pop();
int op = OP(code);
CERR(op != GETI && op != GETF, E_ASSIGN_RHS, lhs);
assert((int)lhs == OC(code));
emit(top + 3, op + 1, OA(code), VAL_REG(OB(code)), expr(top + 2));
}
}
}
return isReturn;
}
bool Sphere::intersect(const Rayon &rayon, float& dist) const
{
Vector OC(sphereOrigin-rayon.getOrigin());
float k(dotProduct(OC,rayon.getDirect()));
float h(dotProduct(OC,OC) - k*k);
if (h <= radius*radius)
{
return true;
}
else
{
return false;
}
}
bool Sphere::intersect(const Rayon &rayon, Hit &hit, float& dist) const
{
const float m_Pi = 3.14159265358979323846;
Vector OC(sphereOrigin-rayon.getOrigin());
float k(dotProduct(OC,rayon.getDirect()));
float h(dotProduct(OC,OC) - k*k);
float radiusSquare = radius*radius ;
if (h <= radiusSquare)
{
float delta = sqrt(radiusSquare-h);
hit.setImpactPoint(rayon.getDistantPoint(k-delta));
dist = k-delta ;
if (dist <0)
{
return false ;
}
Vector normal(hit.getImpactPoint()-sphereOrigin);
normal.normalize();
hit.setNormal(normal);
hit.setV( (hit.getImpactPoint().z - (sphereOrigin.z - radius)) / (2*radius) );
Vector A (radius,0.0,0.0);
Vector B (hit.getImpactPoint().x-sphereOrigin.x,hit.getImpactPoint().y-sphereOrigin.y,0.0);
A.normalize();
B.normalize();
float cosAlpha = dotProduct(A,B) ;
float alphaAlpha = acos(cosAlpha) ;
float alpha ;
if (B.getY() >0)
{
alpha = alphaAlpha;
}
else
{
alpha = 2*m_Pi - alphaAlpha ;
}
hit.setU(alpha/(2*m_Pi));
return true;
}
else
{
return false;
}
}
void
pp_op_meta (const bytecode_data_header_t *bytecode_data_p,
vm_instr_counter_t oc,
op_meta opm,
bool rewrite)
{
bc_to_print_header_p = bytecode_data_p;
dump_asm (oc, opm.op);
printf (" // ");
switch (opm.op.op_idx)
{
PP_OP (VM_OP_ADDITION, "%s = %s + %s;");
PP_OP (VM_OP_SUBSTRACTION, "%s = %s - %s;");
PP_OP (VM_OP_DIVISION, "%s = %s / %s;");
PP_OP (VM_OP_MULTIPLICATION, "%s = %s * %s;");
PP_OP (VM_OP_REMAINDER, "%s = %s %% %s;");
PP_OP (VM_OP_UNARY_MINUS, "%s = -%s;");
PP_OP (VM_OP_UNARY_PLUS, "%s = +%s;");
PP_OP (VM_OP_B_SHIFT_LEFT, "%s = %s << %s;");
PP_OP (VM_OP_B_SHIFT_RIGHT, "%s = %s >> %s;");
PP_OP (VM_OP_B_SHIFT_URIGHT, "%s = %s >>> %s;");
PP_OP (VM_OP_B_AND, "%s = %s & %s;");
PP_OP (VM_OP_B_OR, "%s = %s | %s;");
PP_OP (VM_OP_B_XOR, "%s = %s ^ %s;");
PP_OP (VM_OP_B_NOT, "%s = ~ %s;");
PP_OP (VM_OP_LOGICAL_NOT, "%s = ! %s;");
PP_OP (VM_OP_EQUAL_VALUE, "%s = %s == %s;");
PP_OP (VM_OP_NOT_EQUAL_VALUE, "%s = %s != %s;");
PP_OP (VM_OP_EQUAL_VALUE_TYPE, "%s = %s === %s;");
PP_OP (VM_OP_NOT_EQUAL_VALUE_TYPE, "%s = %s !== %s;");
PP_OP (VM_OP_LESS_THAN, "%s = %s < %s;");
PP_OP (VM_OP_GREATER_THAN, "%s = %s > %s;");
PP_OP (VM_OP_LESS_OR_EQUAL_THAN, "%s = %s <= %s;");
PP_OP (VM_OP_GREATER_OR_EQUAL_THAN, "%s = %s >= %s;");
PP_OP (VM_OP_INSTANCEOF, "%s = %s instanceof %s;");
PP_OP (VM_OP_IN, "%s = %s in %s;");
PP_OP (VM_OP_POST_INCR, "%s = %s++;");
PP_OP (VM_OP_POST_DECR, "%s = %s--;");
PP_OP (VM_OP_PRE_INCR, "%s = ++%s;");
PP_OP (VM_OP_PRE_DECR, "%s = --%s;");
PP_OP (VM_OP_THROW_VALUE, "throw %s;");
PP_OP (VM_OP_REG_VAR_DECL, "%d tmp regs, %d local variable regs, %d argument variable regs");
PP_OP (VM_OP_VAR_DECL, "var %s;");
PP_OP (VM_OP_RETVAL, "return %s;");
PP_OP (VM_OP_RET, "ret;");
PP_OP (VM_OP_PROP_GETTER, "%s = %s[%s];");
PP_OP (VM_OP_PROP_SETTER, "%s[%s] = %s;");
PP_OP (VM_OP_DELETE_VAR, "%s = delete %s;");
PP_OP (VM_OP_DELETE_PROP, "%s = delete %s.%s;");
PP_OP (VM_OP_TYPEOF, "%s = typeof %s;");
PP_OP (VM_OP_WITH, "with (%s);");
PP_OP (VM_OP_FOR_IN, "for_in (%s);");
case VM_OP_IS_TRUE_JMP_UP: printf ("if (%s) goto %d;", VAR (1), oc - OC (2, 3)); break;
case VM_OP_IS_FALSE_JMP_UP: printf ("if (%s == false) goto %d;", VAR (1), oc - OC (2, 3)); break;
case VM_OP_IS_TRUE_JMP_DOWN: printf ("if (%s) goto %d;", VAR (1), oc + OC (2, 3)); break;
case VM_OP_IS_FALSE_JMP_DOWN: printf ("if (%s == false) goto %d;", VAR (1), oc + OC (2, 3)); break;
case VM_OP_JMP_UP: printf ("goto %d;", oc - OC (1, 2)); break;
case VM_OP_JMP_DOWN: printf ("goto %d;", oc + OC (1, 2)); break;
case VM_OP_JMP_BREAK_CONTINUE: printf ("goto_nested %d;", oc + OC (1, 2)); break;
case VM_OP_TRY_BLOCK: printf ("try (end: %d);", oc + OC (1, 2)); break;
case VM_OP_ASSIGNMENT:
{
printf ("%s = ", VAR (1));
switch (opm.op.data.assignment.type_value_right)
{
case OPCODE_ARG_TYPE_STRING: printf ("'%s': STRING;", VAR (3)); break;
case OPCODE_ARG_TYPE_NUMBER: printf ("%s: NUMBER;", VAR (3)); break;
case OPCODE_ARG_TYPE_NUMBER_NEGATE: printf ("-%s: NUMBER;", VAR (3)); break;
case OPCODE_ARG_TYPE_SMALLINT: printf ("%d: SMALLINT;", opm.op.data.assignment.value_right); break;
case OPCODE_ARG_TYPE_SMALLINT_NEGATE: printf ("-%d: SMALLINT;", opm.op.data.assignment.value_right); break;
case OPCODE_ARG_TYPE_VARIABLE: printf ("%s : TYPEOF(%s);", VAR (3), VAR (3)); break;
case OPCODE_ARG_TYPE_SIMPLE:
{
switch (opm.op.data.assignment.value_right)
{
case ECMA_SIMPLE_VALUE_NULL: printf ("null"); break;
case ECMA_SIMPLE_VALUE_FALSE: printf ("false"); break;
case ECMA_SIMPLE_VALUE_TRUE: printf ("true"); break;
case ECMA_SIMPLE_VALUE_UNDEFINED: printf ("undefined"); break;
case ECMA_SIMPLE_VALUE_ARRAY_HOLE: printf ("hole"); break;
default: JERRY_UNREACHABLE ();
}
printf (": SIMPLE;");
break;
}
}
break;
}
case VM_OP_CALL_N:
{
vargs_num = opm.op.data.call_n.arg_list;
seen_vargs = 0;
break;
}
case VM_OP_CONSTRUCT_N:
{
if (opm.op.data.construct_n.arg_list == 0)
{
pp_printf ("%s = new %s;", opm.op, opm.lit_id, oc, 1);
}
else
{
vargs_num = opm.op.data.construct_n.arg_list;
seen_vargs = 0;
}
break;
}
case VM_OP_FUNC_DECL_N:
{
if (opm.op.data.func_decl_n.arg_list == 0)
{
printf ("function %s ();", VAR (1));
}
else
{
vargs_num = opm.op.data.func_decl_n.arg_list;
seen_vargs = 0;
}
break;
}
case VM_OP_FUNC_EXPR_REF:
{
printf ("%s = function ();", VAR (1));
break;
}
case VM_OP_FUNC_EXPR_N:
{
if (opm.op.data.func_expr_n.arg_list == 0)
{
if (opm.op.data.func_expr_n.name_lit_idx == VM_IDX_EMPTY)
{
printf ("%s = function ();", VAR (1));
}
else
{
pp_printf ("%s = function %s ();", opm.op, opm.lit_id, oc, 1);
}
}
else
{
vargs_num = opm.op.data.func_expr_n.arg_list;
seen_vargs = 0;
}
break;
}
case VM_OP_ARRAY_DECL:
{
if (opm.op.data.array_decl.list_1 == 0
&& opm.op.data.array_decl.list_2 == 0)
{
printf ("%s = [];", VAR (1));
}
else
{
vargs_num = (((int) opm.op.data.array_decl.list_1 << JERRY_BITSINBYTE)
+ (int) opm.op.data.array_decl.list_2);
seen_vargs = 0;
}
break;
}
case VM_OP_OBJ_DECL:
{
if (opm.op.data.obj_decl.list_1 == 0
&& opm.op.data.obj_decl.list_2 == 0)
{
printf ("%s = {};", VAR (1));
}
else
{
vargs_num = (((int) opm.op.data.obj_decl.list_1 << JERRY_BITSINBYTE)
+ (int) opm.op.data.obj_decl.list_2);
seen_vargs = 0;
}
break;
}
case VM_OP_META:
{
switch (opm.op.data.meta.type)
{
case OPCODE_META_TYPE_UNDEFINED:
{
printf ("unknown meta;");
break;
}
case OPCODE_META_TYPE_CALL_SITE_INFO:
case OPCODE_META_TYPE_VARG:
case OPCODE_META_TYPE_VARG_PROP_DATA:
case OPCODE_META_TYPE_VARG_PROP_GETTER:
case OPCODE_META_TYPE_VARG_PROP_SETTER:
{
if (opm.op.data.meta.type != OPCODE_META_TYPE_CALL_SITE_INFO)
{
seen_vargs++;
}
if (seen_vargs == vargs_num)
{
bool found = false;
vm_instr_counter_t start = oc;
while ((int16_t) start >= 0 && !found)
{
start--;
switch (bc_get_instr (bytecode_data_p, start).op_idx)
{
case VM_OP_CALL_N:
case VM_OP_CONSTRUCT_N:
case VM_OP_FUNC_DECL_N:
case VM_OP_FUNC_EXPR_N:
case VM_OP_ARRAY_DECL:
case VM_OP_OBJ_DECL:
{
found = true;
break;
}
}
}
vm_instr_t start_op = bc_get_instr (bytecode_data_p, start);
switch (start_op.op_idx)
{
case VM_OP_CALL_N:
{
pp_printf ("%s = %s (", start_op, NULL, start, 1);
break;
}
case VM_OP_CONSTRUCT_N:
{
pp_printf ("%s = new %s (", start_op, NULL, start, 1);
break;
}
case VM_OP_FUNC_DECL_N:
{
pp_printf ("function %s (", start_op, NULL, start, 1);
break;
}
case VM_OP_FUNC_EXPR_N:
{
if (start_op.data.func_expr_n.name_lit_idx == VM_IDX_EMPTY)
{
pp_printf ("%s = function (", start_op, NULL, start, 1);
}
else
{
pp_printf ("%s = function %s (", start_op, NULL, start, 1);
}
break;
}
case VM_OP_ARRAY_DECL:
{
pp_printf ("%s = [", start_op, NULL, start, 1);
break;
}
case VM_OP_OBJ_DECL:
{
pp_printf ("%s = {", start_op, NULL, start, 1);
break;
}
default:
{
JERRY_UNREACHABLE ();
}
}
for (vm_instr_counter_t counter = start; counter <= oc; counter++)
{
vm_instr_t meta_op = bc_get_instr (bytecode_data_p, counter);
switch (meta_op.op_idx)
{
case VM_OP_META:
{
switch (meta_op.data.meta.type)
{
case OPCODE_META_TYPE_CALL_SITE_INFO:
{
opcode_call_flags_t call_flags = (opcode_call_flags_t) meta_op.data.meta.data_1;
if (call_flags & OPCODE_CALL_FLAGS_HAVE_THIS_ARG)
{
pp_printf ("this_arg = %s", meta_op, NULL, counter, 3);
}
if (call_flags & OPCODE_CALL_FLAGS_DIRECT_CALL_TO_EVAL_FORM)
{
printf ("['direct call to eval' form]");
}
break;
}
case OPCODE_META_TYPE_VARG:
{
pp_printf ("%s", meta_op, NULL, counter, 2);
break;
}
case OPCODE_META_TYPE_VARG_PROP_DATA:
{
pp_printf ("%s:%s", meta_op, NULL, counter, 2);
break;
}
case OPCODE_META_TYPE_VARG_PROP_GETTER:
{
pp_printf ("%s = get %s ();", meta_op, NULL, counter, 2);
break;
}
case OPCODE_META_TYPE_VARG_PROP_SETTER:
{
pp_printf ("%s = set (%s);", meta_op, NULL, counter, 2);
break;
}
default:
{
continue;
}
}
if (counter != oc)
{
printf (", ");
}
break;
}
}
}
switch (start_op.op_idx)
{
case VM_OP_ARRAY_DECL:
{
printf ("];");
break;
}
case VM_OP_OBJ_DECL:
{
printf ("};");
break;
}
default:
{
printf (");");
}
}
}
break;
}
case OPCODE_META_TYPE_END_WITH:
{
printf ("end with;");
break;
}
case OPCODE_META_TYPE_END_FOR_IN:
{
printf ("end for-in;");
break;
}
case OPCODE_META_TYPE_FUNCTION_END:
{
printf ("function end: %d;", oc + OC (2, 3));
break;
}
case OPCODE_META_TYPE_CATCH:
{
printf ("catch end: %d;", oc + OC (2, 3));
break;
}
case OPCODE_META_TYPE_CATCH_EXCEPTION_IDENTIFIER:
{
printf ("catch (%s);", VAR (2));
break;
}
case OPCODE_META_TYPE_FINALLY:
{
printf ("finally end: %d;", oc + OC (2, 3));
break;
}
case OPCODE_META_TYPE_END_TRY_CATCH_FINALLY:
{
printf ("end try");
break;
}
default:
{
JERRY_UNREACHABLE ();
}
}
break;
}
default:
{
JERRY_UNREACHABLE ();
}
}
if (rewrite)
{
printf (" // REWRITE");
}
printf ("\n");
}
//_____________________________________________________________________________
void FnormMacro(
const char* filename="../LHC15g.MuMu.1.root",
const char* associatedSimFileName="",
const char* associatedSimFileName2="",
const char* beamYear="PbPb2011",const int DebugLevel =0)
{
// //_____ FNorm
// analysis.ComputeIntFnormFromCounters("",kFALSE);
// //_____
AliAnalysisMuMu ana(filename,associatedSimFileName,associatedSimFileName2,beamYear);
AliLog::SetGlobalDebugLevel(DebugLevel);
if (!ana.OC() || !ana.CC())
{
AliError("No mergeable/counter collection. Consider Upgrade()");
return ;
}
else
{
cout << " ================================================================ " << endl;
cout << " Compute Mean Fnorm From Counters " << endl;
cout << " ================================================================ " << endl;
}
// Get configuration settings
TObjArray* eventTypeArray = ana.Config()->GetListElements(AliAnalysisMuMuConfig::kEventSelectionList,IsSimulation());
TObjArray* triggerMuonArray = ana.Config()->GetListElements(AliAnalysisMuMuConfig::kDimuonTriggerList,IsSimulation());
TObjArray* triggerMBArray = ana.Config()->GetListElements(AliAnalysisMuMuConfig::kMinbiasTriggerList,IsSimulation());
TObjArray* centralityArray = ana.Config()->GetListElements(AliAnalysisMuMuConfig::kCentralitySelectionList, IsSimulation());
// Iterator for loops
TIter nextTriggerMuon(triggerMuonArray);
TIter nextTriggerMB(triggerMBArray);
TIter nextEventType(eventTypeArray);
TIter nextCentrality(centralityArray);
// Strings
TObjString* striggerMuon;
TObjString* striggerMB;
TObjString* seventType;
TObjString* scentrality;
//Pointers on histo
TH1*h(0x0);
TH1*h1(0x0);
TH1*h2(0x0);
Double_t FNormOverStat(0.);
Double_t FNormTotError(0.);
Double_t FNormTotErrorInverse(0.);
Double_t FNormTotErrorSys(0.);
Double_t Norm(1.);
Int_t n =0; //counter
nextEventType.Reset();
// Loop on each envenType (see MuMuConfig)
//==============================================================================
while ( ( seventType = static_cast<TObjString*>(nextEventType())) )
{
AliDebug(1,Form("EVENTTYPE %s",seventType->String().Data()));
nextTriggerMuon.Reset();
// Loop on each Muon trigger (see MuMuConfig)
//==============================================================================
while ( ( striggerMuon = static_cast<TObjString*>(nextTriggerMuon())) )
{
AliDebug(1,Form("-MUON TRIGGER %s",striggerMuon->String().Data()));
nextTriggerMB.Reset();
// Loop on each MB trigger (not the ones in MuMuConfig but the ones set)
//==============================================================================
while ( ( striggerMB = static_cast<TObjString*>(nextTriggerMB())) )
{
AliDebug(1,Form("-- MB PAIRCUT %s",striggerMB->String().Data()));
nextCentrality.Reset();
// Loop on each centrality
//==============================================================================
while ( ( scentrality = static_cast<TObjString*>(nextCentrality()) ) )
{
TString id(Form("/FNORM-%s/%s/%s/PbPb",striggerMuon->String().Data(),seventType->String().Data(),scentrality->String().Data())); // Path where are saved histos in the mergeable collection
h = OC()->Histo(id.Data(),Form("hFNormIntVSrun_%s",striggerMB->String().Data()));
if (!h)
{
AliDebug(1,Form("Can't get histo %s/hFNormIntVSrun_%s",id.Data(),striggerMB->String().Data()));
continue;
}
h1 = OC()->Histo(id.Data(),Form("hFNormInt_%s",striggerMB->String().Data()));
if (!h1)
{
AliDebug(1,Form("Can't get histo %s/hFNormInt_%s",id.Data(),striggerMB->String().Data()));
continue;
}
h2 = OC()->Histo(id.Data(),Form("hFNormIntSys_%s",striggerMB->String().Data()));
if (!h2)
{
AliDebug(1,Form("Can't get histo %s/hFNormIntSys_%s",id.Data(),striggerMB->String().Data()));
continue;
}
cout << Form("Fnorm from %s/%s added",id.Data(),h1->GetName()) << endl;
cout << Form("Fnorm from %s/%s added",id.Data(),h2->GetName()) << endl;
// Normalise with respect to centrality
if (scentrality->String().Contains("V0M_00.00_90.00"))
{
Norm = 1.;
FNormOverStat = FNormOverStat + (Norm*h1->GetBinContent(1)) /(TMath::Power(Norm *h1->GetBinError(1),2.));
FNormTotError = FNormTotError + 1./(TMath::Power(Norm*h1->GetBinError(1),2.));
FNormTotErrorInverse = FNormTotErrorInverse + 1./(TMath::Power(Norm*h1->GetBinError(1),-2.));
FNormTotErrorSys = FNormTotErrorSys + 1./(TMath::Power(Norm*h2->GetBinContent(1),2.));
cout <<"--- Quantities from histogram : " << endl;
cout <<" - Norm = " << Norm << endl;
cout <<" - FNormHisto = " << h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << h2->GetBinContent(1) << endl;
cout <<"--- Quantities (normalized) from histogram: " << endl;
cout <<" - FNormHisto = " << Norm*h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << Norm*h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << Norm*h2->GetBinContent(1) << endl;
cout <<"--- After addition : " << endl;
cout <<" - FNormOverStat = " << FNormOverStat << endl;
cout <<" - FNormTotError = " << FNormTotError << endl;
cout <<" - FNormTotErrorInverse = " << FNormTotErrorInverse << endl;
cout <<" - FNormTotErrorSys = " << FNormTotErrorSys << endl;
}
else if (scentrality->String().Contains("V0M_10.00_50.00"))
{
Norm = (1./0.4)*0.445*0.9;
FNormOverStat = FNormOverStat + (Norm*h1->GetBinContent(1)) /(TMath::Power(Norm *h1->GetBinError(1),2.));
FNormTotError = FNormTotError + 1./(TMath::Power(Norm*h1->GetBinError(1),2.));
FNormTotErrorInverse = FNormTotErrorInverse + 1./(TMath::Power(Norm*h1->GetBinError(1),-2.));
FNormTotErrorSys = FNormTotErrorSys + 1./(TMath::Power(Norm*h2->GetBinContent(1),2.));
cout <<"--- Quantities from histogram : " << endl;
cout <<" - Norm = " << Norm << endl;
cout <<" - FNormHisto = " << h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << h2->GetBinContent(1) << endl;
cout <<"--- Quantities (normalized) from histogram: " << endl;
cout <<" - FNormHisto = " << Norm*h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << Norm*h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << Norm*h2->GetBinContent(1) << endl;
cout <<"--- After addition : " << endl;
cout <<" - FNormOverStat = " << FNormOverStat << endl;
cout <<" - FNormTotError = " << FNormTotError << endl;
cout <<" - FNormTotErrorInverse = " << FNormTotErrorInverse << endl;
cout <<" - FNormTotErrorSys = " << FNormTotErrorSys << endl;
}
else if (scentrality->String().Contains("V0M_00.00_07.50"))
{
Norm = (1./0.075)*0.443*0.9;
FNormOverStat = FNormOverStat + (Norm*h1->GetBinContent(1)) /(TMath::Power(Norm *h1->GetBinError(1),2.));
FNormTotError = FNormTotError + 1./(TMath::Power(Norm*h1->GetBinError(1),2.));
FNormTotErrorInverse = FNormTotErrorInverse + 1./(TMath::Power(Norm*h1->GetBinError(1),-2.));
FNormTotErrorSys = FNormTotErrorSys + 1./(TMath::Power(Norm*h2->GetBinContent(1),2.));
cout <<"--- Quantities from histogram : " << endl;
cout <<" - Norm = " << Norm << endl;
cout <<" - FNormHisto = " << h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << h2->GetBinContent(1) << endl;
cout <<"--- Quantities (normalized) from histogram: " << endl;
cout <<" - FNormHisto = " << Norm*h1->GetBinContent(1) << endl;
cout <<" - FNormHistoError = " << Norm*h1->GetBinError(1) << endl;
cout <<" - FNormHistoSys = " << Norm*h2->GetBinContent(1) << endl;
cout <<"--- After addition : " << endl;
cout <<" - FNormOverStat = " << FNormOverStat << endl;
cout <<" - FNormTotError = " << FNormTotError << endl;
cout <<" - FNormTotErrorInverse = " << FNormTotErrorInverse << endl;
cout <<" - FNormTotErrorSys = " << FNormTotErrorSys << endl;
}
else
{
AliError("Check this method for centrality selection !");
return;
}
n++;
}
}
}
}
cout << "Mean FNorm computed from " << n <<" results = " << FNormOverStat/FNormTotError << " +/- " <<
TMath::Sqrt(FNormTotErrorInverse) << " (stat) +/-" << TMath::Sqrt(FNormTotErrorSys) << " (sys) " <<endl;
delete triggerMuonArray ;
delete triggerMBArray ;
delete eventTypeArray ;
delete centralityArray ;
}
void Tier3StorageMain(Tier3StorageRef me){
do
{
if(me->doQuitGracefully)
{
OCObjectLock((OCObjectRef)me->newPLChunks);
if(OCListGetCount(me->newPLChunks) == 0 &&
OCListGetCount(me->toWritePLChunks) == 0)
{
OCObjectUnlock((OCObjectRef)me->newPLChunks);
break;
}
OCObjectUnlock((OCObjectRef)me->newPLChunks);
}
OCObjectLock((OCObjectRef)me->newPLChunks);
if(OCListGetCount(me->newPLChunks) == 0)
{
OCObjectUnlock((OCObjectRef)me->newPLChunks);
OCThreadSleep(me->thread, 1);
continue;
}
OCListRef _tmp = me->newPLChunks;
me->newPLChunks = me->toWritePLChunks;
me->toWritePLChunks = _tmp;
OCObjectUnlock((OCObjectRef)me->newPLChunks);
// do the writing here
// NOTE usually we would use a lock file here,
// however: we are the only process _writing_ to any file -
// the worker tool should only read or delete a file,
// since we can write to a deleted file (posix) we are fine
// in the case of concurrent access to the same file the worker
// may fail on this one, which is ok for us
ALPayloadChunkRef plc = NULL;
OCAutoreleasePoolCreate();
OCSerializerRef s = (OCSerializerRef)OCAutorelease(OCSerializerCreate());
while( (plc=(ALPayloadChunkRef)OCListFifoPop(me->toWritePLChunks)) != NULL)
{
OCAutorelease(plc);
OCByte* key;
size_t keyLength;
ALPayloadChunkGetKey(plc, &key, &keyLength);
OCByte* keyHexBytes = OCAllocate(ocDefaultAllocator, 2*keyLength+1);
if(keyHexBytes == NULL)
continue;
bzero(keyHexBytes, 2*keyLength+1);
OCBytes2Hex(keyHexBytes, key, keyLength);
OCStringRef keyStr = (OCStringRef)OC((char*)keyHexBytes);
if(keyStr == NULL)
{
OCDeallocate(ocDefaultAllocator, keyHexBytes);
continue;
}
OCStringRef pathStr = (OCStringRef)OCAutorelease(OCStringCreateAppended(me->path, keyStr));
if(pathStr == NULL)
{
OCDeallocate(ocDefaultAllocator, keyHexBytes);
continue;
}
ALPayloadChunkSerialize(plc, s);
FILE* fp = fopen(CO(pathStr), "a");
if(fp == NULL)
{
OCLog("Storage: Could not open file at %s", CO(pathStr));
OCDeallocate(ocDefaultAllocator, keyHexBytes);
continue;
}
OCSerializerWriteToStream(s, fp);
fclose(fp);
OCDeallocate(ocDefaultAllocator, keyHexBytes);
OCSerializerReset(s);
}
OCRelease(&me->toWritePLChunks);
OCAutoreleasePoolDestroy();
me->toWritePLChunks = OCListCreate();
}
while(1);
}
