FiniteSitesDFE(Random & random, DFE dfe, int L): dfe(dfe), U0(dfe.U0), L(L), draw_label(0,L-1), fitness_effects(L,1), sign_flips(L,false){
for(auto & W : fitness_effects){
W = dfe.get_fitness_effect(random, Clone());
}
};
// Routing table tracking main
void RouteTrackingMain(SESSION *s)
{
ROUTE_TRACKING *t;
UINT64 now;
ROUTE_TABLE *table;
ROUTE_ENTRY *rs;
bool changed = false;
bool check = false;
bool any_modified = false;
// Validate arguments
if (s == NULL)
{
return;
}
if (s->ClientModeAndUseVLan == false)
{
return;
}
// Get the state
t = ((VLAN *)s->PacketAdapter->Param)->RouteState;
if (t == NULL)
{
return;
}
// Current time
PROBE_STR("RouteTrackingMain 1");
now = Tick64();
if (t->RouteChange != NULL)
{
if (t->NextRouteChangeCheckTime == 0 ||
t->NextRouteChangeCheckTime <= now)
{
t->NextRouteChangeCheckTime = now + 1000ULL;
check = IsRouteChanged(t->RouteChange);
if (check)
{
Debug("*** Routing Table Changed ***\n");
t->NextTrackingTime = 0;
}
}
}
if (t->NextTrackingTime != 0 && t->NextTrackingTime > now)
{
if (s->UseUdpAcceleration && s->UdpAccel != NULL && s->UdpAccel->NatT_IP_Changed)
{
// Check always if the IP address of the NAT-T server has changed
}
else
{
PROBE_STR("RouteTrackingMain 2");
return;
}
}
PROBE_STR("RouteTrackingMain 3");
if (s->UseUdpAcceleration && s->UdpAccel != NULL)
{
IP nat_t_ip;
s->UdpAccel->NatT_IP_Changed = false;
Zero(&nat_t_ip, sizeof(nat_t_ip));
Lock(s->UdpAccel->NatT_Lock);
{
Copy(&nat_t_ip, &s->UdpAccel->NatT_IP, sizeof(IP));
}
Unlock(s->UdpAccel->NatT_Lock);
// Add a route to the NAT-T server
if (IsZeroIp(&nat_t_ip) == false)
{
if (t->RouteToNatTServer == NULL)
{
if (t->RouteToEight != NULL)
{
ROUTE_ENTRY *e = Clone(t->RouteToEight, sizeof(ROUTE_ENTRY));
char ip_str[64];
char ip_str2[64];
Copy(&e->DestIP, &nat_t_ip, sizeof(IP));
e->Metric = e->OldIfMetric;
IPToStr(ip_str, sizeof(ip_str), &e->DestIP);
IPToStr(ip_str2, sizeof(ip_str2), &e->GatewayIP);
t->RouteToNatTServer = e;
if (AddRouteEntry(t->RouteToNatTServer))
{
Debug("Adding Static Route to %s via %s metric %u: ok.\n", ip_str, ip_str2, e->Metric);
}
else
{
FreeRouteEntry(t->RouteToNatTServer);
t->RouteToNatTServer = NULL;
}
}
}
}
}
// Get the current routing table
table = GetRouteTable();
rs = t->RouteToServer;
if (table != NULL)
{
UINT i;
bool route_to_server_erased = true;
bool is_vlan_want_to_be_default_gateway = false;
UINT vlan_default_gatewat_metric = 0;
UINT other_if_default_gateway_metric_min = INFINITE;
// Get whether the routing table have been changed
if (t->LastRoutingTableHash != table->HashedValue)
{
t->LastRoutingTableHash = table->HashedValue;
changed = true;
}
//DebugPrintRouteTable(table);
// Scan the routing table
for (i = 0;i < table->NumEntry;i++)
{
ROUTE_ENTRY *e = table->Entry[i];
if (rs != NULL)
{
if (CmpIpAddr(&e->DestIP, &rs->DestIP) == 0 &&
CmpIpAddr(&e->DestMask, &rs->DestMask) == 0
// && CmpIpAddr(&e->GatewayIP, &rs->GatewayIP) == 0
// && e->InterfaceID == rs->InterfaceID &&
// e->LocalRouting == rs->LocalRouting &&
// e->Metric == rs->Metric
)
{
// Routing entry to the server that added at the time of connection is found
route_to_server_erased = false;
}
}
// Search for the default gateway
if (IPToUINT(&e->DestIP) == 0 &&
IPToUINT(&e->DestMask) == 0)
{
Debug("e->InterfaceID = %u, t->VLanInterfaceId = %u\n",
e->InterfaceID, t->VLanInterfaceId);
if (e->InterfaceID == t->VLanInterfaceId)
{
// The virtual LAN card think that he want to be a default gateway
is_vlan_want_to_be_default_gateway = true;
vlan_default_gatewat_metric = e->Metric;
if (vlan_default_gatewat_metric >= 2 &&
t->OldDefaultGatewayMetric == (vlan_default_gatewat_metric - 1))
{
// Restore because the PPP server rewrites
// the routing table selfishly
DeleteRouteEntry(e);
e->Metric--;
AddRouteEntry(e);
Debug("** Restore metric destroyed by PPP.\n");
any_modified = true;
}
// Keep this entry
if (t->DefaultGatewayByVLan != NULL)
{
// Delete if there is one added last time
FreeRouteEntry(t->DefaultGatewayByVLan);
}
t->DefaultGatewayByVLan = ZeroMalloc(sizeof(ROUTE_ENTRY));
Copy(t->DefaultGatewayByVLan, e, sizeof(ROUTE_ENTRY));
t->OldDefaultGatewayMetric = vlan_default_gatewat_metric;
}
else
{
// There are default gateway other than the virtual LAN card
// Save the metric value of the default gateway
if (other_if_default_gateway_metric_min > e->Metric)
{
// Ignore the metric value of all PPP connection in the case of Windows Vista
if (MsIsVista() == false || e->PPPConnection == false)
{
other_if_default_gateway_metric_min = e->Metric;
}
else
{
// a PPP is used to Connect to the network
// in using Windows Vista
t->VistaAndUsingPPP = true;
}
}
}
}
}
if (t->VistaAndUsingPPP)
{
if (t->DefaultGatewayByVLan != NULL)
{
if (is_vlan_want_to_be_default_gateway)
{
if (t->VistaOldDefaultGatewayByVLan == NULL || Cmp(t->VistaOldDefaultGatewayByVLan, t->DefaultGatewayByVLan, sizeof(ROUTE_ENTRY)) != 0)
{
ROUTE_ENTRY *e;
// Add the route of 0.0.0.0/1 and 128.0.0.0/1
// to the system if the virtual LAN card should be
// the default gateway in the case of the connection
// using PPP in Windows Vista
if (t->VistaOldDefaultGatewayByVLan != NULL)
{
FreeRouteEntry(t->VistaOldDefaultGatewayByVLan);
}
if (t->VistaDefaultGateway1 != NULL)
{
DeleteRouteEntry(t->VistaDefaultGateway1);
FreeRouteEntry(t->VistaDefaultGateway1);
DeleteRouteEntry(t->VistaDefaultGateway2);
FreeRouteEntry(t->VistaDefaultGateway2);
}
t->VistaOldDefaultGatewayByVLan = Clone(t->DefaultGatewayByVLan, sizeof(ROUTE_ENTRY));
e = Clone(t->DefaultGatewayByVLan, sizeof(ROUTE_ENTRY));
SetIP(&e->DestIP, 0, 0, 0, 0);
SetIP(&e->DestMask, 128, 0, 0, 0);
t->VistaDefaultGateway1 = e;
e = Clone(t->DefaultGatewayByVLan, sizeof(ROUTE_ENTRY));
SetIP(&e->DestIP, 128, 0, 0, 0);
SetIP(&e->DestMask, 128, 0, 0, 0);
t->VistaDefaultGateway2 = e;
AddRouteEntry(t->VistaDefaultGateway1);
AddRouteEntry(t->VistaDefaultGateway2);
Debug("Vista PPP Fix Route Table Added.\n");
any_modified = true;
}
}
else
{
if (t->VistaOldDefaultGatewayByVLan != NULL)
{
FreeRouteEntry(t->VistaOldDefaultGatewayByVLan);
t->VistaOldDefaultGatewayByVLan = NULL;
}
if (t->VistaDefaultGateway1 != NULL)
{
Debug("Vista PPP Fix Route Table Deleted.\n");
DeleteRouteEntry(t->VistaDefaultGateway1);
FreeRouteEntry(t->VistaDefaultGateway1);
DeleteRouteEntry(t->VistaDefaultGateway2);
FreeRouteEntry(t->VistaDefaultGateway2);
any_modified = true;
t->VistaDefaultGateway1 = t->VistaDefaultGateway2 = NULL;
}
}
}
}
// If the virtual LAN card want to be the default gateway and
// there is no LAN card with smaller metric of 0.0.0.0/0 than
// the virtual LAN card, delete other default gateway entries
// to elect the virtual LAN card as the default gateway
// Debug("is_vlan_want_to_be_default_gateway = %u, rs = %u, route_to_server_erased = %u, other_if_default_gateway_metric_min = %u, vlan_default_gatewat_metric = %u\n",
// is_vlan_want_to_be_default_gateway, rs, route_to_server_erased, other_if_default_gateway_metric_min, vlan_default_gatewat_metric);
if (is_vlan_want_to_be_default_gateway && (rs != NULL && route_to_server_erased == false) &&
other_if_default_gateway_metric_min >= vlan_default_gatewat_metric)
{
// Scan the routing table again
for (i = 0;i < table->NumEntry;i++)
{
ROUTE_ENTRY *e = table->Entry[i];
if (e->InterfaceID != t->VLanInterfaceId)
{
if (IPToUINT(&e->DestIP) == 0 &&
IPToUINT(&e->DestMask) == 0)
{
char str[64];
// Default gateway is found
ROUTE_ENTRY *r = ZeroMalloc(sizeof(ROUTE_ENTRY));
Copy(r, e, sizeof(ROUTE_ENTRY));
// Put in the queue
InsertQueue(t->DeletedDefaultGateway, r);
// Delete this gateway entry once
DeleteRouteEntry(e);
IPToStr(str, sizeof(str), &e->GatewayIP);
Debug("Default Gateway %s Deleted.\n", str);
any_modified = true;
}
}
}
}
if (rs != NULL && route_to_server_erased)
{
// Physical entry to the server has disappeared
Debug("Route to Server entry ERASED !!!\n");
// Forced disconnection (reconnection enabled)
s->RetryFlag = true;
s->Halt = true;
}
// Release the routing table
FreeRouteTable(table);
}
// Set the time to perform the next track
if (t->NextTrackingTimeAdd == 0 || changed)
{
t->NextTrackingTimeAdd = TRACKING_INTERVAL_INITIAL;
}
else
{
UINT64 max_value = TRACKING_INTERVAL_MAX;
if (t->RouteChange != NULL)
{
max_value = TRACKING_INTERVAL_MAX_RC;
}
t->NextTrackingTimeAdd += TRACKING_INTERVAL_ADD;
if (t->NextTrackingTimeAdd >= max_value)
{
t->NextTrackingTimeAdd = max_value;
}
}
//Debug("t->NextTrackingTimeAdd = %I64u\n", t->NextTrackingTimeAdd);
t->NextTrackingTime = now + t->NextTrackingTimeAdd;
if (any_modified)
{
// Clear the DNS cache
Win32FlushDnsCache();
}
}
const CImageAttribute& CImageAttribute::operator=(const CImageAttribute& image)
{
Clone(image);
return *this;
}
Object c_Closure::t_bindto(const Variant& newthis, const Variant& scope) {
if (RuntimeOption::RepoAuthoritative &&
RuntimeOption::EvalAllowScopeBinding) {
raise_warning("Closure binding is not supported in RepoAuthoritative mode");
return Object{};
}
auto const cls = getVMClass();
auto const invoke = cls->getCachedInvoke();
ObjectData* od = nullptr;
if (newthis.isObject()) {
if (invoke->isStatic()) {
raise_warning("Cannot bind an instance to a static closure");
} else {
od = newthis.getObjectData();
}
} else if (!newthis.isNull()) {
raise_warning("Closure::bindto() expects parameter 1 to be object");
return Object{};
}
auto const curscope = invoke->cls();
auto newscope = curscope;
if (scope.isObject()) {
newscope = scope.getObjectData()->getVMClass();
} else if (scope.isString()) {
auto const className = scope.getStringData();
if (!className->equal(s_static.get())) {
newscope = Unit::loadClass(className);
if (!newscope) {
raise_warning("Class '%s' not found", className->data());
return Object{};
}
}
} else if (scope.isNull()) {
newscope = nullptr;
} else {
raise_warning("Closure::bindto() expects parameter 2 "
"to be string or object");
return Object{};
}
if (od && !newscope) {
// Bound closures should be scoped. If no scope is specified, scope it to
// the Closure class.
newscope = static_cast<Class*>(c_Closure::classof());
}
bool thisNotOfCtx = od && !od->getVMClass()->classof(newscope);
if (!RuntimeOption::EvalAllowScopeBinding) {
if (newscope != curscope) {
raise_warning("Re-binding closure scopes is disabled");
return Object{};
}
if (thisNotOfCtx) {
raise_warning("Binding to objects not subclassed from closure "
"context is disabled");
return Object{};
}
}
c_Closure* clone = Clone(this);
clone->setClass(nullptr);
Attr curattrs = invoke->attrs();
Attr newattrs = static_cast<Attr>(curattrs & ~AttrHasForeignThis);
if (od) {
od->incRefCount();
clone->setThis(od);
if (thisNotOfCtx) {
// If the bound $this is not a subclass of the context class, then we
// have to pessimize translation.
newattrs |= AttrHasForeignThis;
}
} else if (newscope) {
// If we attach a scope to a function with no bound $this we need to make
// the function static.
newattrs |= AttrStatic;
clone->setClass(newscope);
}
// If we are changing either the scope or the attributes of the closure, we
// need to re-scope its Closure subclass.
if (newscope != curscope || newattrs != curattrs) {
assert(newattrs != AttrNone);
auto newcls = cls->rescope(newscope, newattrs);
clone->setVMClass(newcls);
}
return Object(clone);
}
/**
* This method creates a copy of the current Message. It allocates the new one
* from the same Message Poll as the original Message and copies a full payload.
*
* @returns A pointer to the message or NULL if insufficient message buffers are available.
*/
Message *Clone(void) const { return Clone(GetLength()); };
Stack::Stack(const Stack& obj)
{
stack = nullptr;
Clone(obj);
}
void CSL_EfTInt::Apply(MSL_ExprEnv& aEnv, vector<string>& aArgs, vector<string>::iterator& aArgr, CSL_ExprBase& aArg, CSL_ExprBase*& aRes, const string& aReqType)
{
aRes = Clone();
aRes->AcceptArg();
aRes->SetData(aArg.Data());
}
UIButton *UIButton::CloneButton()
{
return (UIButton *)Clone();
}
void skiplightreweightdraw()
{
float beta = 0.045;//110/50 = 0.28;//FEXGSP = 0.4
float gamma = 1.182;//110/50 = 1.24;//FEXGSP = 0.4
auto f= new TFile("skiplightreweight.root");
auto h12all = (TH1F *)f->Get("h12all");
auto h12fcr = (TH1F *)f->Get("h12fcr");
auto h12fex = (TH1F *)f->Get("h12fex");
auto h12gsp = (TH1F *)f->Get("h12gsp");
auto hSLall = (TH1F *)f->Get("hSLall");
auto hSLfcr = (TH1F *)f->Get("hSLfcr");
auto hSLfex = (TH1F *)f->Get("hSLfex");
auto hSLgsp = (TH1F *)f->Get("hSLgsp");
auto h12data = (TH1F *)f->Get("h12data");
auto hSLdata = (TH1F *)f->Get("hSLdata");
auto h12dphiall = (TH1F *)f->Get("h12dphiall");
auto h12dphifcr = (TH1F *)f->Get("h12dphifcr");
auto h12dphifex = (TH1F *)f->Get("h12dphifex");
auto h12dphigsp = (TH1F *)f->Get("h12dphigsp");
auto hSLdphiall = (TH1F *)f->Get("hSLdphiall");
auto hSLdphifcr = (TH1F *)f->Get("hSLdphifcr");
auto hSLdphifex = (TH1F *)f->Get("hSLdphifex");
auto hSLdphigsp = (TH1F *)f->Get("hSLdphigsp");
auto h12dphidata = (TH1F *)f->Get("h12dphidata");
auto hSLdphidata = (TH1F *)f->Get("hSLdphidata");
auto h12dphiNSall = (TH1F *)f->Get("h12dphiNSall");
auto h12dphiNSfcr = (TH1F *)f->Get("h12dphiNSfcr");
auto h12dphiNSfex = (TH1F *)f->Get("h12dphiNSfex");
auto h12dphiNSgsp = (TH1F *)f->Get("h12dphiNSgsp");
auto hSLdphiNSall = (TH1F *)f->Get("hSLdphiNSall");
auto hSLdphiNSfcr = (TH1F *)f->Get("hSLdphiNSfcr");
auto hSLdphiNSfex = (TH1F *)f->Get("hSLdphiNSfex");
auto hSLdphiNSgsp = (TH1F *)f->Get("hSLdphiNSgsp");
auto h12dphiNSdata = (TH1F *)f->Get("h12dphiNSdata");
auto hSLdphiNSdata = (TH1F *)f->Get("hSLdphiNSdata");
auto h12ordall = (TH1F *)f->Get("h12ordall");
auto h12ordfcr = (TH1F *)f->Get("h12ordfcr");
auto h12ordfex = (TH1F *)f->Get("h12ordfex");
auto h12ordgsp = (TH1F *)f->Get("h12ordgsp");
auto hSLordall = (TH1F *)f->Get("hSLordall");
auto hSLordfcr = (TH1F *)f->Get("hSLordfcr");
auto hSLordfex = (TH1F *)f->Get("hSLordfex");
auto hSLordgsp = (TH1F *)f->Get("hSLordgsp");
auto h12orddata = (TH1F *)f->Get("h12orddata");
auto hSLorddata = (TH1F *)f->Get("hSLorddata");
auto h12reweighted = (TH1F *)h12all->Clone("h12reweighted");
auto hSLreweighted = (TH1F *)hSLall->Clone("hSLreweighted");
h12reweighted->Reset();h12reweighted->SetTitle("h12reweighted");
hSLreweighted->Reset();hSLreweighted->SetTitle("hSLreweighted");
auto h12dphiNSreweighted = (TH1F *)h12dphiNSall->Clone("h12dphiNSreweighted");
auto hSLdphiNSreweighted = (TH1F *)hSLdphiNSall->Clone("hSLdphiNSreweighted");
h12dphiNSreweighted->Reset();h12dphiNSreweighted->SetTitle("h12dphiNSreweighted");
hSLdphiNSreweighted->Reset();hSLdphiNSreweighted->SetTitle("hSLdphiNSreweighted");
auto h12dphireweighted = (TH1F *)h12dphiall->Clone("h12dphireweighted");
auto hSLdphireweighted = (TH1F *)hSLdphiall->Clone("hSLdphireweighted");
h12dphireweighted->Reset();h12dphireweighted->SetTitle("h12dphireweighted");
hSLdphireweighted->Reset();hSLdphireweighted->SetTitle("hSLdphireweighted");
auto h12ordreweighted = (TH1F *)h12ordall->Clone("h12ordreweighted");
auto hSLordreweighted = (TH1F *)hSLordall->Clone("hSLordreweighted");
h12ordreweighted->Reset();h12ordreweighted->SetTitle("h12ordreweighted");
hSLordreweighted->Reset();hSLordreweighted->SetTitle("hSLordreweighted");
h12reweighted->Add(h12fex,h12gsp,beta,gamma);
h12reweighted->Add(h12fcr);
hSLreweighted->Add(hSLfex,hSLgsp,beta,gamma);
hSLreweighted->Add(hSLfcr);
h12dphireweighted->Add(h12dphifex,h12dphigsp,beta,gamma);
h12dphireweighted->Add(h12dphifcr);
hSLdphireweighted->Add(hSLdphifex,hSLdphigsp,beta,gamma);
hSLdphireweighted->Add(hSLdphifcr);
h12dphiNSreweighted->Add(h12dphiNSfex,h12dphiNSgsp,beta,gamma);
h12dphiNSreweighted->Add(h12dphiNSfcr);
hSLdphiNSreweighted->Add(hSLdphiNSfex,hSLdphiNSgsp,beta,gamma);
hSLdphiNSreweighted->Add(hSLdphiNSfcr);
h12ordreweighted->Add(h12ordfex,h12ordgsp,beta,gamma);
h12ordreweighted->Add(h12ordfcr);
hSLordreweighted->Add(hSLordfex,hSLordgsp,beta,gamma);
hSLordreweighted->Add(hSLordfcr);
Normalize({h12data,h12all,hSLdata,hSLall,
h12dphiall,hSLdphiall,h12dphidata,hSLdphidata,
h12dphiNSall,hSLdphiNSall,h12dphiNSdata,hSLdphiNSdata,
h12ordall,hSLordall,h12orddata,hSLorddata});
SetMC({h12all,hSLall,h12dphiall,hSLdphiall});
ploteffectiveentries = false;
plotymax = 0.12;
plotylog = false;
plotputmean = true;
aktstring+="PF Jets R=0.4";
plotsecondline = "p_{T,1}>120GeV,p_{T,2}>30GeV";
plotthirdline = "#Delta#phi>2#pi/3, CSV>0.9";
plotfilenameend = "12";
DrawCompare(h12data,h12all);
plotfilenameend = "SL";
DrawCompare(hSLdata,hSLall);
Normalize({h12reweighted,hSLreweighted});
SetMC({h12reweighted,hSLreweighted});
plotfilenameend = "12";
DrawCompare(h12data,h12reweighted);
plotfilenameend = "SL";
DrawCompare(hSLdata,hSLreweighted);
plotfilenameend = "";
// vector<int> colors = {TColor::GetColor("#FA7200"),
// TColor::GetColor("#9ACD32"),
// TColor::GetColor("#0D98BA")};//{kGreen-9, kOrange+1,kBlue+3};
vector<int> colors = {TColor::GetColor(25,87,5),//18,58,5),
TColor::GetColor(255,109,24),//234,117,1),//255,117,24),
TColor::GetColor(77,135,232)};//{kGreen-9, kOrange+1,kBlue+3};
auto h12stack = stackhists({h12fcr,h12fex,h12gsp},colors,"h12stack","(P)");
DrawCompare(h12data,h12stack,"x_{J}");
h12fex->Scale(beta); h12gsp->Scale(gamma);
auto h12stack2 = stackhists({h12fcr,h12fex,h12gsp},colors,"h12stack2","(W)");
DrawCompare(h12data,h12stack2,"x_{J}");
auto hSLstack = stackhists({hSLfcr,hSLfex,hSLgsp},colors,"hSLstack","(P)");
DrawCompare(hSLdata,hSLstack,"x_{J}");
hSLfex->Scale(beta); hSLgsp->Scale(gamma);
auto hSLstack2 = stackhists({hSLfcr,hSLfex,hSLgsp},colors,"hSLstack2","(W)");
DrawCompare(hSLdata,hSLstack2,"x_{J}");
plotputmean = false;
plotylog = false;
plotymax = 1.1;
plotymin = 1E-5;
Normalize({hSLordreweighted,h12ordreweighted});
SetMC({hSLordreweighted,h12ordreweighted});
DrawCompare(h12orddata,h12ordreweighted);
DrawCompare(hSLorddata,hSLordreweighted);
auto h12ordstack = stackhists({h12ordfcr,h12ordfex,h12ordgsp},colors,"h12ordstack","(P)");
DrawCompare(h12orddata,h12ordstack,"skiplight order");
h12ordfex->Scale(beta); h12ordgsp->Scale(gamma);
auto h12ordstack2 = stackhists({h12ordfcr,h12ordfex,h12ordgsp},colors,"h12ordstack2","(W)");
DrawCompare(h12orddata,h12ordstack2,"skiplight order");
auto hSLordstack = stackhists({hSLordfcr,hSLordfex,hSLordgsp},colors,"hSLordstack","(P)");
DrawCompare(hSLorddata,hSLordstack,"skiplight order");
hSLordfex->Scale(beta); hSLordgsp->Scale(gamma);
auto hSLordstack2 = stackhists({hSLordfcr,hSLordfex,hSLordgsp},colors,"hSLordstack2","(W)");
DrawCompare(hSLorddata,hSLordstack2,"skiplight order");
plotylog = true;
plotymin = 9999;
plotputmean = false;
plotputwidth = true;
plotymax = 0.5;
plotthirdline = "CSV>0.9";
DrawCompare(h12dphidata,h12dphiall,"#Delta#phi");
DrawCompare(hSLdphidata,hSLdphiall,"#Delta#phi");
Normalize({hSLdphireweighted,h12dphireweighted});
SetMC({hSLdphireweighted,h12dphireweighted});
DrawCompare(h12dphidata,h12dphireweighted,"#Delta#phi");
DrawCompare(hSLdphidata,hSLdphireweighted,"#Delta#phi");
//plotymax = 0.5;
auto h12dphistack = stackhists({h12dphifcr,h12dphifex,h12dphigsp},colors,"h12dphistack","(P)");
DrawCompare(h12dphidata,h12dphistack,"#Delta#phi");
h12dphifex->Scale(beta); h12dphigsp->Scale(gamma);
auto h12dphistack2 = stackhists({h12dphifcr,h12dphifex,h12dphigsp},colors,"h12dphistack2","(W)");
DrawCompare(h12dphidata,h12dphistack2,"#Delta#phi");
auto hSLdphistack = stackhists({hSLdphifcr,hSLdphifex,hSLdphigsp},colors,"hSLdphistack","(P)");
DrawCompare(hSLdphidata,hSLdphistack,"#Delta#phi");
hSLdphifex->Scale(beta); hSLdphigsp->Scale(gamma);
auto hSLdphistack2 = stackhists({hSLdphifcr,hSLdphifex,hSLdphigsp},colors,"hSLdphistack2","(W)");
DrawCompare(hSLdphidata,hSLdphistack2,"#Delta#phi");
plotylog = false;
plotymax = 0.25;
//only interesting dphi region
DrawCompare(h12dphiNSdata,h12dphiNSall);
DrawCompare(hSLdphiNSdata,hSLdphiNSall);
Normalize({hSLdphiNSreweighted,h12dphiNSreweighted});
SetMC({hSLdphiNSreweighted,h12dphiNSreweighted});
DrawCompare(h12dphiNSdata,h12dphiNSreweighted);
DrawCompare(hSLdphiNSdata,hSLdphiNSreweighted);
auto h12dphiNSstack = stackhists({h12dphiNSfcr,h12dphiNSfex,h12dphiNSgsp},colors,"h12dphiNSstack","(P)");
DrawCompare(h12dphiNSdata,h12dphiNSstack,"#Delta#phi");
h12dphiNSfex->Scale(beta); h12dphiNSgsp->Scale(gamma);
auto h12dphiNSstack2 = stackhists({h12dphiNSfcr,h12dphiNSfex,h12dphiNSgsp},colors,"h12dphiNSstack2","(W)");
DrawCompare(h12dphiNSdata,h12dphiNSstack2,"#Delta#phi");
auto hSLdphiNSstack = stackhists({hSLdphiNSfcr,hSLdphiNSfex,hSLdphiNSgsp},colors,"hSLdphiNSstack","(P)");
DrawCompare(hSLdphiNSdata,hSLdphiNSstack,"#Delta#phi");
hSLdphiNSfex->Scale(beta); hSLdphiNSgsp->Scale(gamma);
auto hSLdphiNSstack2 = stackhists({hSLdphiNSfcr,hSLdphiNSfex,hSLdphiNSgsp},colors,"hSLdphiNSstack2","(W)");
DrawCompare(hSLdphiNSdata,hSLdphiNSstack2,"#Delta#phi");
// int nearsidebin1 = 1;
// int nearsidebin2 = hSLdphifex->GetNbinsX()/3;
// int awaysidebin1 = hSLdphifex->GetNbinsX()/3*2;
// int awaysidebin2 = hSLdphifex->GetNbinsX()-1;
// float NnsFEX = hSLdphifex->Integral(nearsidebin1,nearsidebin2);
// float NnsGSP = hSLdphigsp->Integral(nearsidebin1,nearsidebin2);
// float NasFEX = hSLdphifex->Integral(awaysidebin1,awaysidebin2);
// float NasGSP = hSLdphigsp->Integral(awaysidebin1,awaysidebin2);
// float NnsData = hSLdphidata->Integral(nearsidebin1,nearsidebin2);
// float NasData = hSLdphidata->Integral(awaysidebin1,awaysidebin2);
// float alpha = (NnsData - NnsGSP*(1+NasFEX/NasGSP))/(NnsFEX - NnsGSP*NasFEX/NasGSP);
// float beta2 = ((1-alpha)*NasFEX+NasGSP)/NasGSP;
// if (alpha<0) alpha =0;
// cout<<"!!!"<<alpha<<" "<<beta2<<endl;
// hSLdphifex->Scale(alpha); hSLdphigsp->Scale(beta2);
// auto hSLdphistack2_new = stackhists({hSLdphifcr,hSLdphifex,hSLdphigsp},colors,"hSLdphistack2_new");
// DrawCompare(hSLdphidata,hSLdphistack2_new,"#Delta#phi");
// cout<<" NasFEX+NasGSP = "<<NasFEX+NasGSP<<" ?= "<<
// hSLdphifex->Integral(awaysidebin1,awaysidebin2)+hSLdphigsp->Integral(awaysidebin1,awaysidebin2)<<endl;
// ploteffectiveentries = false;
// plotymax = 0.12;
// plotylog = false;
// plotputmean = true;
// aktstring+="PF Jets R=0.4";
// plotsecondline = "p_{T,1}>120GeV,p_{T,2}>30GeV";
// plotthirdline = "#Delta#phi>2#pi/3, CSV>0.9";
// auto h12reweightedtwice = (TH1F *)h12all->Clone("h12reweightedtwice");
// auto hSLreweightedtwice = (TH1F *)hSLall->Clone("hSLreweightedtwice");
// h12reweightedtwice->Reset();h12reweightedtwice->SetTitle("h12reweightedtwice");
// hSLreweightedtwice->Reset();hSLreweightedtwice->SetTitle("hSLreweightedtwice");
// h12reweightedtwice->Add(h12fex,h12gsp,alpha,beta2);
// h12reweightedtwice->Add(h12fcr);
// cout<<"h12reweightedtwice "<<h12reweightedtwice->GetMean()<<endl;
// hSLreweightedtwice->Add(hSLfex,hSLgsp,alpha,beta2);
// hSLreweightedtwice->Add(hSLfcr);
// cout<<"hSLreweightedtwice "<<hSLreweightedtwice->GetMean()<<endl;
// Normalize({h12reweightedtwice,hSLreweightedtwice});
// SetMC({h12reweightedtwice,hSLreweightedtwice});
// plotfilenameend = "12";
// DrawCompare(h12data,h12reweightedtwice);
// plotfilenameend = "SL";
// DrawCompare(hSLdata,hSLreweightedtwice);
// plotfilenameend="";
// hSLfex->Scale(alpha); hSLgsp->Scale(beta2);
// auto hSLstack2_new = stackhists({hSLfcr,hSLfex,hSLgsp},colors,"hSLstack2_new");
// DrawCompare(hSLdata,hSLstack2_new,"x_{J}");
// h12fex->Scale(alpha); h12gsp->Scale(beta2);
// auto h12stack2_new = stackhists({h12fcr,h12fex,h12gsp},colors,"h12stack2_new");
// DrawCompare(h12data,h12stack2_new,"x_{J}","___");
}
void checkclosure()
{
vector<TH1F *>hsig(Nbins);
vector<TH1F *>hasd(Nbins);
vector<TH1F *>hbkg(Nbins);
vector<TH1F *>hsub(Nbins);
vector<TH1F *>hhyj(Nbins);
vector<TH1F *>hshj(Nbins);
vector<TH1F *>hsbn(Nbins);
for (int i=0;i<Nbins;i++) {
seth(10,0,1);
hsig[i] = geth(Form("hsig%d",i),Form("Signal away-side %s;x_{J}",binnames[i].Data())) ;
hasd[i] = geth(Form("hasd%d",i),Form("Measured away-side %s;x_{J}",binnames[i].Data()));
hbkg[i] = geth(Form("hbkg%d",i),Form("Near-side %s;x_{J}",binnames[i].Data()));
hhyj[i] = geth(Form("hhyj%d",i),Form("Near-side hydjet %s;x_{J}",binnames[i].Data()));
hsub[i] = geth(Form("hsub%d",i),Form("Subtracted NS %s;x_{J}",binnames[i].Data()));
hshj[i] = geth(Form("hshj%d",i),Form("Subtracted Hydjet %s;x_{J}",binnames[i].Data()));
hsbn[i] = geth(Form("hsbn%d",i),Form("Subtracted Naive %s;x_{J}",binnames[i].Data()));
}
auto fmcPb = config.getfile_djt("mcPbbfa");
Fill(fmcPb,{"pthat","weight","jtpt1","refpt1","bProdCode","jtptSL","refptSL","dphiSL1","refparton_flavorForB1","subidSL","bin","pairCodeSL1","discr_csvV1_1","jteta1","jtetaSL"},[&] (dict d) {
if (d["pthat"]<pthatcut) return;
if (d["jtpt1"]>pt1cut && d["refpt1"]>50 && abs(d["refparton_flavorForB1"])==5 && d["jtptSL"]>pt2cut) {
int bin = getbinindex(d["bin"]);
float xj = d["jtptSL"]/d["jtpt1"];
float w = weight1SLPbPb(d);
if (AwaySide(d)) hasd[bin]->Fill(xj, w);
if (AwaySide(d) && IsSignal(d)) hsig[bin]->Fill(xj,w);
if (NearSide(d)) hbkg[bin]->Fill(xj,w);
if (NearSide(d) && !IsSignal(d)) hhyj[bin]->Fill(xj,w);
}
});
for (int i=0;i<Nbins;i++) {
hsub[i]->Add(hasd[i],hbkg[i],1,-1*bkgfractionInNearSide[i]);
hsbn[i]->Add(hasd[i],hbkg[i],1,-1);
hshj[i]->Add(hasd[i],hhyj[i],1,-1);
}
// for (int i=0;i<Nbins;i++)
// hincsub[i]->Add(hincasd[i],hincbkg[i],1,-1);
seth(bins);//Nbins,0,100);
auto hcentrSubSIG = geth("hcentrSubSIG","Signal;bin;#LTx_{J}#GT");
auto hcentrSubASD = geth("hcentrSubASD","Unsubtracted;bin;#LTx_{J}#GT");
auto hcentrSubBKS = geth("hcentrSubBKS","Subtracted w/o bkg scaling;bin;#LTx_{J}#GT");
auto hcentrSubCLS = geth("hcentrSubCLS","Subtracted with bkg scaling;bin;#LTx_{J}#GT");
auto hcentrSubHJS = geth("hcentrSubHJS","Subtracted Hydjet;bin;#LTx_{J}#GT");
plotlegendpos = BottomRight;
for (int i=0;i<Nbins;i++) {
hcentrSubSIG->SetBinContent(i+1,hsig[i]->GetMean());hcentrSubSIG->SetBinError(i+1,hsig[i]->GetMeanError());
hcentrSubASD->SetBinContent(i+1,hasd[i]->GetMean());hcentrSubASD->SetBinError(i+1,hasd[i]->GetMeanError());
hcentrSubBKS->SetBinContent(i+1,hsbn[i]->GetMean());hcentrSubBKS->SetBinError(i+1,hsbn[i]->GetMeanError());
hcentrSubCLS->SetBinContent(i+1,hsub[i]->GetMean());hcentrSubCLS->SetBinError(i+1,hsub[i]->GetMeanError());
hcentrSubHJS->SetBinContent(i+1,hshj[i]->GetMean());hcentrSubHJS->SetBinError(i+1,hshj[i]->GetMeanError());
Draw({hsig[i],hsub[i],hshj[i]});
}
plotymin = 0.55;//0.4;
plotymax = 0.7;//0.8;
plotlegendpos = BottomRight;
aktstring = "";
plotputmean = false;
//hcentrSubHJS - hydjet only subtraction
// SetMC({hcentrSubSIG, hcentrSubBKS, hcentrSubASD});
// SetData({hcentrSubCLS});
hcentrSubSIG->SetMarkerStyle(kOpenSquare);
hcentrSubBKS->SetMarkerStyle(kOpenSquare);
hcentrSubASD->SetMarkerStyle(kOpenSquare);
hcentrSubCLS->SetMarkerStyle(kFullCircle);
hcentrSubSIG->SetMarkerColor(TColor::GetColorDark(2)); hcentrSubSIG->SetLineColor(TColor::GetColorDark(2));
hcentrSubBKS->SetMarkerColor(TColor::GetColorDark(3)); hcentrSubBKS->SetLineColor(TColor::GetColorDark(3));
hcentrSubASD->SetMarkerColor(TColor::GetColorDark(4)); hcentrSubASD->SetLineColor(TColor::GetColorDark(4));
hcentrSubCLS->SetMarkerColor(TColor::GetColorDark(3)); hcentrSubCLS->SetLineColor(TColor::GetColorDark(3));
plotoverwritecolors = false;
plotlegenddx = -0.15;
Draw({hcentrSubSIG,hcentrSubASD, hcentrSubBKS, hcentrSubCLS});
auto syst = (TH1F *)hcentrSubSIG->Clone("syst");
syst->Add(hcentrSubCLS,-1);
map<TString,float> m;
for (unsigned i=0;i<bins.size()-1;i++) {
float misclosure = syst->GetBinContent(i+1);
float err = hcentrSubCLS->GetBinError(i+1);
m[Form("closure%d%d",(int)bins[i],(int)bins[i+1])]=sqrt(misclosure*misclosure+err*err);
}
WriteToFile(plotfoldername+"/hydjetclosuresyst.root",m);
}
pProperties->SetPropertyL(_L8("PropertyName4"), _L8("PropertyValue4"),
MSenLayeredProperties::ESenProviderSessionLayer);
pProperties->SetPropertyL(_L8("PropertyName5"), _L8("PropertyValue5"),
MSenLayeredProperties::ESenConsumerSessionLayer);
pProperties->SetPropertyL(_L8("PropertyName6"), _L8("PropertyValue6"),
MSenLayeredProperties::ESenMessageLayer);
TPtrC8 propertyValue;
pProperties->PropertyL(_L8("PropertyName1"), propertyValue);
pAsXml = pProperties->AsUtf8LC();
LOCAL_ASSERT( *pAsXml == KOutputString );
CleanupStack::PopAndDestroy(pAsXml);
TInt error;
pProperties2 = (CSenLayeredHttpTransportProperties*)pProperties->Clone(error);
LOCAL_ASSERT( error == KErrNone );
// Destroy cloned properties immediately after cloning
CleanupStack::PopAndDestroy(pProperties);
CleanupStack::PushL(pProperties2);
pAsXml = pProperties2->AsUtf8LC();
LOCAL_ASSERT( *pAsXml == KOutputString );
CleanupStack::PopAndDestroy(pAsXml);
CleanupStack::PopAndDestroy(pProperties2);
CleanupStack::PopAndDestroy(&stringPool);
return KErrNone;
}
Local<Value> UnbindOperation::CreateCompletionArg()
{
auto a = statement->UnbindParams();
auto ret = a->Clone();
return ret;
}
int plotUnfoldingMatrixRooUnfold(
int analysisIs2D,
const TString conf,
DYTools::TRunMode_t runMode=DYTools::NORMAL_RUN,
DYTools::TSystematicsStudy_t systMode=DYTools::NO_SYST,
TString rndStudyStr=""
) {
const double FSRmassDiff=1.; // largest energy of FSR photon to consider
// check whether it is a calculation
if (conf.Contains("_DebugRun_")) {
std::cout << "plotUnfoldingMatrix: _DebugRun_ detected. Terminating the script\n";
return retCodeOk;
}
// normal calculation
gBenchmark->Start("makeUnfoldingMatrix");
{
DYTools::printExecMode(runMode,systMode);
const int debug_print=1;
if (!DYTools::checkSystMode(systMode,debug_print,12,
DYTools::NO_SYST, DYTools::SYST_RND,
DYTools::RESOLUTION_STUDY, DYTools::FSR_STUDY,
DYTools::PU_STUDY,
DYTools::FSR_5plus, DYTools::FSR_5minus,
DYTools::PILEUP_5plus, DYTools::PILEUP_5minus,
//DYTools::ESCALE_STUDY,
DYTools::ESCALE_RESIDUAL,
DYTools::FSR_RND_STUDY, DYTools::PU_RND_STUDY))
return retCodeError;
}
if (!DYTools::setup(analysisIs2D)) {
std::cout << "failed to initialize the analysis\n";
return retCodeError;
}
int escaleResidual_global=1;
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
InputFileMgr_t inpMgr;
InputFileMgr_t *yieldInpMgr=NULL; // needed for ESCALE_RESIDUAL
if (!inpMgr.Load(conf)) return retCodeError;
// plotDetResponse uses escale!
if (systMode==DYTools::ESCALE_RESIDUAL) {
yieldInpMgr= new InputFileMgr_t(inpMgr);
// create a temporary object to set proper directories
EventSelector_t tmpEventSelector(*yieldInpMgr,runMode,
DYTools::APPLY_ESCALE,"","",EventSelector::_selectDefault);
if (escaleResidual_global) {
inpMgr.rootFileBaseDir("root_files_reg_EScaleResidualGlobal");
std::cout << "changed rootFileBaseDir to <" << inpMgr.rootFileBaseDir()
<< ">\n";
}
}
else if (systMode!=DYTools::RESOLUTION_STUDY) {
// no energy correction for this evaluation
inpMgr.clearEnergyScaleTag();
}
else {
if (inpMgr.energyScaleTag() == "UNCORRECTED") {
std::cout << "RESOLUTION_STUDY needs energy scale correction\n";
return retCodeError;
}
}
// Construct eventSelector, update mgr and plot directory
TString extraTag=rndStudyStr;
EventSelector_t evtSelector(inpMgr,runMode,systMode,
extraTag, "", EventSelector::_selectDefault);
evtSelector.setTriggerActsOnData(false);
// PU and FSR RND studies have to provide the seed externally
int globalSeed=-1;
for (int i=0; (globalSeed<=0) && (i<rndStudyStr.Length()); ++i) {
globalSeed=atoi(rndStudyStr.Data() + i);
}
// Event weight handler
EventWeight_t evWeight;
int res=evWeight.init(inpMgr.puReweightFlag(),inpMgr.fewzFlag(),
systMode,rndStudyStr);
// May 01, 2014: PU weights have to be applied at all steps
//EventWeight_t evWeightNoPU; // for FSR unfolding weights
//if (res) res=evWeightNoPU.init(0,inpMgr.fewzFlag(),systMode,rndStudyStr);
if (!res) {
std::cout << "failed to prepare weights\n";
return retCodeError;
}
// Prepare output directory
inpMgr.constDir(systMode,1);
int seedMin=inpMgr.userKeyValueAsInt("SEEDMIN");
int seedMax=inpMgr.userKeyValueAsInt("SEEDMAX");
int dSeed=1;
int seedDiff=(systMode==DYTools::FSR_STUDY) ? 3 : (seedMax-seedMin+1);
//std::cout << "seedMin..seedMax=" << seedMin << ".." << seedMax << "\n";
//return retCodeOk;
//--------------------------------------------------------------------------------------------------------------
// Main analysis code
//==============================================================================================================
std::cout << mainpart;
TRandom random;
std::vector<ElectronEnergyScale*> escaleV;
std::vector<EventWeight_t*> specEWeightsV;
std::vector<double> specReweightsV;
std::vector<EventSelector_t*> evtSelectorV;
std::vector<TH2D*> specTH2DWeightV; // used for ESCALE_RESIDUAL
double specWeight=1.;
int useSpecWeight=0;
if (systMode==DYTools::FSR_5plus) { specWeight=1.05; useSpecWeight=1; }
else if (systMode==DYTools::FSR_5minus) { specWeight=0.95; useSpecWeight=1; }
else if (systMode==DYTools::FSR_RND_STUDY) useSpecWeight=1;
// check random seed. Special weights use their own,
// built-in dependencies on seed
{
int startSeed=-1;
if (systMode==DYTools::SYST_RND) {
std::cout << "setting startSeed=" << globalSeed << "\n";
startSeed= globalSeed;
}
random.SetSeed(startSeed);
gRandom->SetSeed(startSeed);
}
// The random seeds are needed only if we are running this script in systematics mode
if (systMode==DYTools::FSR_STUDY) {
specReweightsV.reserve(seedDiff);
specEWeightsV.reserve(seedDiff);
for (int i=0; i<seedDiff; ++i) {
double specW= 1 + 0.05*(i-1);
specReweightsV.push_back(specW);
specEWeightsV.push_back(new EventWeight_t(evWeight));
}
}
else if (systMode==DYTools::PU_STUDY) {
if (inpMgr.puReweightFlag()==0) {
std::cout << "systMode=PU_STUDY needs puReweightFlag=1 in the input file\n";
return retCodeError;
}
specEWeightsV.reserve(2);
for (int i=0; i<2; ++i) {
DYTools::TSystematicsStudy_t study=(i==0) ? DYTools::PILEUP_5minus : DYTools::PILEUP_5plus;
EventWeight_t *ew=new EventWeight_t();
if (!ew->init(inpMgr.puReweightFlag(),inpMgr.fewzFlag(),study,rndStudyStr)) {
std::cout << "in plotUnfoldingMatrix.C\n";
return retCodeError;
}
specEWeightsV.push_back(ew);
}
}
else if (systMode==DYTools::SYST_RND) {
// nothing special about weights
}
else if (systMode==DYTools::RESOLUTION_STUDY) {
if (seedMax==-111) {
seedMin=-111;
seedMax= 111;
dSeed=seedMax-seedMin;
seedDiff=2;
}
if (seedMax < seedMin) {
printf("error: randomSeedMax=%d, seedMin=%d\n",seedMax,seedMin);
return retCodeError;
}
specEWeightsV.reserve(seedDiff); // not used, but needed as a check
escaleV.reserve(seedDiff);
for (int i=seedMin; i<=seedMax; i+=dSeed) {
TString escaleTag=inpMgr.energyScaleTag() +
TString(Form("_MIRROR_RANDOMIZED%d",i));
ElectronEnergyScale *ees= new ElectronEnergyScale(escaleTag);
if (1) {
std::cout << "randomSeed=" << i << ". EScale=";
ees->print();
std::cout<<"\n";
}
escaleV.push_back(ees);
specEWeightsV.push_back(new EventWeight_t(evWeight));
EventSelector_t *evtSel=new EventSelector_t(evtSelector,ees);
// correction acts like on data!
evtSel->setEScaleCorrectionType(DYTools::DATA,DYTools::ESCALE_STUDY_RND);
//evtSel->editECName().Append(Form("_idx%d",i+seedMin));
evtSelectorV.push_back(evtSel);
}
}
// prepare tools for ESCALE_RESIDUAL
TH2D* h2ShapeWeights=NULL;
if (systMode==DYTools::ESCALE_RESIDUAL) {
if (!yieldInpMgr) {
std::cout << "yieldInpMgr had to be created\n";
return retCodeError;
}
DYTools::TSystematicsStudy_t yieldSystMode=DYTools::APPLY_ESCALE;
TString shapeFName=yieldInpMgr->signalYieldFullFileName(yieldSystMode,1);
delete yieldInpMgr; // no longer needed
if (rndStudyStr.Length()) {
shapeFName.ReplaceAll(TString("__") + rndStudyStr,"");
}
TString subdir="ShapeReweight";
TString field="zeeMCShapeReweight_";
TString ddBkg=(inpMgr.userKeyValueAsInt("DDBKG")==1) ? "ddBkg" : "mcBkg";
field.Append(ddBkg);
std::cout << "Obtaining shape weights from <"
<< shapeFName << ">"
<< "(use" << ddBkg << ")\n";
h2ShapeWeights=LoadHisto2D(field,shapeFName,subdir,1);
if (!h2ShapeWeights) {
std::cout << "failed to find histo \"ZeeMCShapeReweight\"\n";
return retCodeError;
}
if ((DYTools::massBinningSet==DYTools::_MassBins_2012) &&
(DYTools::study2D==1)) {
HERE("set weights for the underflow bin to 1.");
int ibin=1;
for (int jbin=1; jbin<=24; jbin++) {
h2ShapeWeights->SetBinContent(ibin,jbin, 1.);
h2ShapeWeights->SetBinError (ibin,jbin, 0.);
}
}
std::cout << "shapeWeights:\n"; printHisto(h2ShapeWeights);
int ensembleSize= inpMgr.userKeyValueAsInt("RESIDUAL_STUDY_SIZE");
if (ensembleSize<=0) ensembleSize=100;
ensembleSize++;
std::cout << "EScale_residual ensemble size=" << ensembleSize
<< " (one added for non-randomized entry)\n";
std::vector<TString> tmpLabelV; // local variable for testing
specTH2DWeightV.reserve(ensembleSize);
tmpLabelV.reserve(ensembleSize);
specTH2DWeightV.push_back(Clone(h2ShapeWeights,
"h2NonRndShapeW","h2NonRndShapeW"));
tmpLabelV.push_back("NonRndShape");
if (!escaleResidual_global) {
TH2D *h2ResApply=Clone(h2ShapeWeights,"h2ResApply");
// vary randomly and independently in each bin
// prepare histo for randomization. Assume 10% error on the deviation
for (int ibin=1; ibin<=h2ResApply->GetNbinsX(); ++ibin) {
for (int jbin=1; jbin<=h2ResApply->GetNbinsY(); ++jbin) {
double dev=h2ResApply->GetBinContent(ibin,jbin);
//h2ResApply->SetBinError(ibin,jbin, 0.1*dev);
h2ResApply->SetBinError(ibin,jbin, 1.);
h2ResApply->SetBinError(ibin,jbin, dev);
}
}
HistoPair2D_t hpRnd("hpRnd",h2ResApply);
for (int i=1; i<ensembleSize; ++i) {
TString name=Form("rndShapeWeight_%d",i);
TH2D* h2Rnd=hpRnd.randomizedWithinErr(0,name);
specTH2DWeightV.push_back(h2Rnd);
tmpLabelV.push_back(name);
}
}
else { // global variation
for (int i=1; i<ensembleSize; ++i) {
double rnd=gRandom->Gaus(0,1.);
TString name=Form("rndShapeWeight_%d",i);
TH2D *h2Rnd=Clone(h2ShapeWeights,name);
for (int ibin=1; ibin<=h2Rnd->GetNbinsX(); ++ibin) {
for (int jbin=1; jbin<=h2Rnd->GetNbinsY(); ++jbin) {
double shW = h2ShapeWeights->GetBinContent(ibin,jbin);
double rndScale= 1 + rnd*(1-shW);
h2Rnd->SetBinContent(ibin,jbin, rndScale);
}
}
specTH2DWeightV.push_back(h2Rnd);
tmpLabelV.push_back(name);
}
}
if (0) {
specTH2DWeightV.push_back(h2ShapeWeights);
tmpLabelV.push_back("original");
TCanvas *cx= plotProfiles("cx",specTH2DWeightV,tmpLabelV,NULL,1,
"MC/data shape reweight");
cx->Update();
return retCodeStop;
}
}
//
// Set up histograms
//
std::vector<TH1D*> hMassv;
std::vector<TH1D*> hMassBinsv;
//TH1D *hSelEvents=NULL;
// debug distributions: 1GeV bins
//createAnyH1Vec(hMassv,"hMass_",inpMgr.sampleNames(),2500,0.,2500.,"M_{ee} [GeV]","counts/1GeV");
createAnyH1Vec(hMassv,"hMass_",inpMgr.mcSampleNames(),1490,10.,1500.,"M_{ee} [GeV]","counts/1GeV");
// debug distributions for current mass bin
createBaseH1Vec(hMassBinsv,"hMassBins_",inpMgr.mcSampleNames());
// debug: accumulate info about the selected events in the samples
//hSelEvents=createAnyTH1D("hSelEvents","hSelEvents",inpMgr.mcSampleCount(),0,inpMgr.mcSampleCount(),"sampleId","event count");
/*
TH1F *hMassDiff = new TH1F("hMassDiff","", 100, -30, 30);
TH1F *hMassDiffBB = new TH1F("hMassDiffBB","", 100, -30, 30);
TH1F *hMassDiffEB = new TH1F("hMassDiffEB","", 100, -30, 30);
TH1F *hMassDiffEE = new TH1F("hMassDiffEE","", 100, -30, 30);
// These histograms will contain (gen-reco) difference
// for each (mass, Y) bin in a flattened format
TH2F *hMassDiffV = new TH2F("hMassDiffV","",
nUnfoldingBins, -0.5, nUnfoldingBins-0.5,
100, -50.0, 50.0);
TH2F *hYDiffV = new TH2F("hYDiffV","",
nUnfoldingBins, -0.5, nUnfoldingBins-0.5,
100, -5.0, 5.0);
*/
// TH1F *hMassDiffV[nUnfoldingBins];
// for(int i=0; i<nUnfoldingBins; i++){
// sprintf(hname,"hMassDiffV_%d",i);
// hMassDiffV[i] = new TH1F(hname,"",100,-50,50);
// }
UnfoldingMatrix_t detResponse(UnfoldingMatrix::_cDET_Response,"detResponse");
UnfoldingMatrix_t detResponseExact(UnfoldingMatrix::_cDET_Response,"detResponseExact");
UnfoldingMatrix_t detResponseReversed(UnfoldingMatrix::_cDET_Response,"detResponseReversed");
UnfoldingMatrix_t fsrGood(UnfoldingMatrix::_cFSR, "fsrGood");
UnfoldingMatrix_t fsrExact(UnfoldingMatrix::_cFSR, "fsrExact");
UnfoldingMatrix_t fsrDET(UnfoldingMatrix::_cFSR_DET,"fsrDET"); // only relevant indices are checked for ini,fin
UnfoldingMatrix_t fsrDETexact(UnfoldingMatrix::_cFSR_DET,"fsrDETexact"); // all indices are checked
// a good working version: response matrix and invResponse are modified after the inversion
UnfoldingMatrix_t fsrDET_good(UnfoldingMatrix::_cFSR_DET,"fsrDETgood");
// Pretend to have a uniform binning
RooUnfoldResponse rooUnfDetRes(DYTools::nUnfoldingBins,
-0.5,DYTools::nUnfoldingBins-0.5,
"rooUnfDetRes","rooUnfDetRes");
rooUnfDetRes.UseOverflow(true);
std::vector<UnfoldingMatrix_t*> detRespV;
if (systMode==DYTools::NO_SYST) {}
else if (systMode==DYTools::SYST_RND) {
detRespV.reserve(2);
for (int ir=0; ir<2; ++ir) {
TString name=Form("detResponse_seed%d_replica%d",globalSeed,ir);
detRespV.push_back(new UnfoldingMatrix_t(UnfoldingMatrix::_cDET_Response,name));
}
}
else if (systMode==DYTools::RESOLUTION_STUDY) {
detRespV.reserve(escaleV.size());
for (int i=seedMin; i<=seedMax; i+=dSeed) {
TString name=Form("detResponse_seed%d",i);
detRespV.push_back(new UnfoldingMatrix_t(UnfoldingMatrix::_cDET_Response,name));
}
}
else if (systMode==DYTools::FSR_STUDY) {
detRespV.reserve(specReweightsV.size());
for (unsigned int i=0; i<specReweightsV.size(); i++) {
TString wStr=(i==0) ? Form("0%2.0f",specReweightsV[i]*100.) : Form("%3.0f",specReweightsV[i]*100.);
TString name=TString("detResponse_") + wStr;
detRespV.push_back(new UnfoldingMatrix_t(UnfoldingMatrix::_cDET_Response,name));
}
}
else if (systMode==DYTools::PU_STUDY) {
if (specEWeightsV.size()!=2) { std::cout << "expected specEWeights.size=2\n"; return retCodeError; }
detRespV.reserve(specEWeightsV.size());
for (unsigned int i=0; i<specEWeightsV.size(); i++) {
TString wStr=(i==0) ? "PU5minus" : "PU5plus";
TString name=TString("detResponse_") + wStr;
detRespV.push_back(new UnfoldingMatrix_t(UnfoldingMatrix::_cDET_Response,name));
}
}
else if (systMode==DYTools::ESCALE_RESIDUAL) {
unsigned int count=specTH2DWeightV.size();
detRespV.reserve(count);
for (unsigned int i=0; i<count; ++i) {
TString name=Form("detResponse_%s",niceNumber(i,count).Data());
if (i==0) name="detResponse_0_nonRnd";
detRespV.push_back(new UnfoldingMatrix_t(UnfoldingMatrix::_cDET_Response,name));
}
}
/*
else if (systMode==DYTools::ESCALE_STUDY) {
detRespV.reserve(escaleV.size());
for (unsigned int i=0; i<escaleV.size(); ++i) {
TString name=TString("detResponse_") + escaleV[i]->calibrationSetShortName();
detRespV.push_back(new UnfoldingMatrix_t(UnfoldingMatrix_t::_cDET_Response,name));
}
}
*/
if (detRespV.size()) {
std::cout << "names in detRespV:\n";
for (unsigned int i=0; i<detRespV.size(); ++i) {
std::cout << " - " << detRespV[i]->getName() << "\n";
}
}
// check
if ((systMode==DYTools::RESOLUTION_STUDY) ||
(systMode==DYTools::FSR_STUDY) ||
(systMode==DYTools::PU_STUDY)
//|| (systMode==DYTools::ESCALE_STUDY)
) {
if (//(detRespV.size() != escaleV.size()) ||
(detRespV.size() != specEWeightsV.size())) {
std::cout << "error: detRespV.size=" << detRespV.size()
//<< ", escaleV.size=" << escaleV.size()
//<< ", specReweightsV.size=" << specReweightsV.size()
<< ", specEWeightsV.size=" << specEWeightsV.size()
<< "\n";
assert(0);
}
}
//
// Access samples and fill histograms
//
AccessOrigNtuples_t accessInfo;
//
// loop over samples
//
if (DYTools::processData(runMode)) {
double extraWeightFactor=1.0;
EventCounterExt_t ecTotal("total");
for (unsigned int isample=0; isample<inpMgr.mcSampleCount(); ++isample) {
const CSample_t *mcSample=inpMgr.mcSampleInfo(isample);
std::cout << "Processing " << mcSample->getLabel() << "..." << std::endl;
std::cout << " of size " << mcSample->size() << "\n";
if (mcSample->size()!=1) {
std::cout << "mcSample->size is expected to be 1\n";
return retCodeError;
}
for (unsigned int ifile=0; ifile<mcSample->size(); ++ifile) {
// Read input file
TFile *infile= new TFile(mcSample->getFName(ifile),"read");
if (!infile || !infile->IsOpen()) {
TString skimName=inpMgr.convertSkim2Ntuple(mcSample->getFName(ifile));
std::cout << " .. failed. Trying <" << skimName << ">" << std::endl;
infile= new TFile(skimName,"read");
}
assert(infile->IsOpen());
// Get the TTrees
if (!accessInfo.setTree(*infile,"Events",true)) {
return retCodeError;
}
// Find weight for events for this file
// The first file in the list comes with weight 1*extraWeightFactor,
// all subsequent ones are normalized to xsection and luminosity
ULong_t maxEvents = accessInfo.getEntries();
// to match old version package (DYee 7TeV paper),
if (inpMgr.userKeyValueAsInt("USE7TEVMCWEIGHT") &&
(isample==0) && (ifile==0)) {
extraWeightFactor=maxEvents / (inpMgr.totalLumi() * inpMgr.mcSampleInfo(0)->getXsec(ifile));
//extraWeightFactor=maxEvents / inpMgr.mcSampleInfo(0)->getXsec(ifile);
}
//std::cout << "extraWeightFactor=" << extraWeightFactor << ", chk=" << (maxEvents0/inpMgr.mcSampleInfo(0)->getXsec(ifile)) << "\n";
//const double extraWeightFactor=1.0;
if (! evWeight.setWeight_and_adjustMaxEvents(maxEvents,
inpMgr.totalLumi(),
mcSample->getXsec(ifile),
extraWeightFactor, inpMgr.selectEventsFlag())) {
std::cout << "adjustMaxEvents failed\n";
return retCodeError;
}
std::cout << "mcSample xsec=" << mcSample->getXsec(ifile) << ", nEntries=" << maxEvents << "\n";
std::cout << " -> sample base weight is " << evWeight.baseWeight() << "\n";
for (unsigned int iSt=0; iSt<specEWeightsV.size(); ++iSt) {
specEWeightsV[iSt]->setBaseWeight(evWeight);
}
// loop through events
EventCounterExt_t ec(Form("%s_file%d",mcSample->name.Data(),ifile));
ec.setIgnoreScale(0); // 1 - count events, 0 - take weight in account
// adjust the scale in the counter
// if FEWZ weight should be considered, use evWeight.totalWeight() after
// the FEWZ weight has been identified (see a line below)
ec.setScale(evWeight.baseWeight());
std::cout << "numEntries = " << accessInfo.getEntriesFast()
<< ", " << maxEvents << " events will be used" << std::endl;
for(ULong_t ientry=0; ientry<maxEvents; ientry++) {
if (DYTools::isDebugMode(runMode) &&
(ientry>ULong_t(1000000)+DYTools::study2D*ULong_t(2000000))) break; // debug option
//if (DYTools::isDebugMode(runMode) && (ientry>100)) break; // debug option
printProgress(250000," ientry=",ientry,maxEvents);
ec.numEvents_inc();
// Load generator level info
accessInfo.GetGen(ientry);
// If the Z->ll leptons are not electrons, discard this event.
// This is needed for signal MC samples such as Madgraph Z->ll
// where all 3 lepton flavors are possible
if (!accessInfo.genLeptonsAreElectrons()) continue;
// Load event info
accessInfo.GetInfoEntry(ientry);
// Adjust event weight
// .. here "false" = "not data"
evWeight.set_PU_and_FEWZ_weights(accessInfo,false);
//evWeightNoPU.set_PU_and_FEWZ_weights(accessInfo,false);
if (useSpecWeight) {
evWeight.setSpecWeightValue(accessInfo,FSRmassDiff,specWeight);
//evWeightNoPU.setSpecWeightValue(accessInfo,FSRmassDiff,specWeight);
}
// FSR study correction for weight
if (systMode==DYTools::FSR_STUDY) {
for (unsigned int iSt=0; iSt<specEWeightsV.size(); ++iSt) {
specEWeightsV[iSt]->setSpecWeightValue(accessInfo,FSRmassDiff,specReweightsV[iSt]);
}
}
// setup spec weights
// .. here "false" = "not data"
for (unsigned int iSt=0; iSt<specEWeightsV.size(); ++iSt) {
specEWeightsV[iSt]->set_PU_and_FEWZ_weights(accessInfo,false);
}
if (ientry<20) {
std::cout << "ientry=" << ientry << ", "; evWeight.Print(0);
//printf("reweight=%4.2lf, fewz_weight=%4.2lf,dE_fsr=%+6.4lf\n",reweight,fewz_weight,(gen->mass-gen->vmass));
if (systMode!=DYTools::RESOLUTION_STUDY) {
for (unsigned int iSt=0; iSt<specEWeightsV.size(); ++iSt) {
std::cout << " specEWeight[" << iSt << "] = "; specEWeightsV[iSt]->Print(0); //std::cout << "\n";
}
}
std::cout << "\n";
}
// adjust the scale in the counter to include FEWZ
// (and possibly PU) weight
//ec.setScale(evWeight.totalWeight());
FlatIndex_t fiGenPreFsr, fiGenPostFsr;
fiGenPreFsr.setGenPreFsrIdx(accessInfo);
fiGenPostFsr.setGenPostFsrIdx(accessInfo);
// begin FSR unfolding block
fsrGood.fillIni(fiGenPreFsr , evWeight.totalWeight());
fsrGood.fillFin(fiGenPostFsr, evWeight.totalWeight());
if (fiGenPreFsr.isValid() && fiGenPostFsr.isValid()) {
fsrGood.fillMigration(fiGenPreFsr, fiGenPostFsr, evWeight.totalWeight());
fsrExact.fillIni(fiGenPreFsr , evWeight.totalWeight());
fsrExact.fillFin(fiGenPostFsr, evWeight.totalWeight());
fsrExact.fillMigration(fiGenPreFsr, fiGenPostFsr, evWeight.totalWeight());
}
int preFsrOk=0, postFsrOk=0;
if (evtSelector.inAcceptancePreFsr(accessInfo) &&
fiGenPreFsr.isValid()) {
preFsrOk=1;
fsrDET .fillIni(fiGenPreFsr, evWeight.totalWeight());
fsrDET_good.fillIni(fiGenPreFsr, evWeight.totalWeight());
}
if (evtSelector.inAcceptance(accessInfo) &&
fiGenPostFsr.isValid()) {
postFsrOk=1;
fsrDET .fillFin(fiGenPostFsr, evWeight.totalWeight());
fsrDET_good.fillFin(fiGenPostFsr, evWeight.totalWeight());
}
if (preFsrOk && postFsrOk) {
fsrDET.fillMigration(fiGenPreFsr, fiGenPostFsr, evWeight.totalWeight());
fsrDET_good.fillMigration(fiGenPreFsr, fiGenPostFsr, evWeight.totalWeight());
fsrDETexact.fillIni(fiGenPreFsr , evWeight.totalWeight());
fsrDETexact.fillFin(fiGenPostFsr, evWeight.totalWeight());
fsrDETexact.fillMigration(fiGenPreFsr, fiGenPostFsr, evWeight.totalWeight());
}
// end of FSR unfolding block
// check event trigger
if (!evtSelector.eventTriggerOk(accessInfo)) {
continue; // no trigger accept? Skip to next event...
}
ec.numEventsPassedEvtTrigger_inc();
// load dielectron array
accessInfo.GetDielectrons(ientry);
// loop through dielectrons
//int pass=0;
int candCount=0;
mithep::TDielectron uncorrDielectron;
for(Int_t i=0; i<accessInfo.dielectronCount(); i++) {
mithep::TDielectron *dielectron = accessInfo.editDielectronPtr(i);
ec.numDielectrons_inc();
// keep unmodified dielectron
if (escaleV.size()) uncorrDielectron.restoreEScaleModifiedValues(*dielectron);
// escale may modify dielectron! But it should not here
if (!evtSelector.testDielectron(dielectron,accessInfo.evtInfoPtr(),&ec)) continue;
//pass=1;
/******** We have a Z candidate! HURRAY! ********/
candCount++;
ec.numDielectronsPass_inc();
if (ec.numDielectronsOkSameSign_inc(dielectron->q_1,dielectron->q_2)) {
// same sign event
}
//
// Fill structures for response matrix
FlatIndex_t fiReco;
fiReco.setRecoIdx(dielectron);
// Fill the matrix of post-FSR generator level invariant mass and rapidity
double diWeight=evWeight.totalWeight();
detResponse.fillIni(fiGenPostFsr, diWeight);
detResponse.fillFin(fiReco , diWeight);
int bothFIValid=fiGenPostFsr.isValid() && fiReco.isValid();
if (bothFIValid) {
ec.numDielectronsGoodMass_inc();
detResponse.fillMigration(fiGenPostFsr, fiReco, diWeight);
detResponseExact.fillIni(fiGenPostFsr, diWeight);
detResponseExact.fillFin(fiReco , diWeight);
detResponseExact.fillMigration(fiGenPostFsr, fiReco, diWeight);
}
if (fiGenPostFsr.isValid()) {
if (fiReco.isValid()) {
rooUnfDetRes.Fill(fiReco.idx(),fiGenPostFsr.idx(), diWeight);
}
else {
rooUnfDetRes.Miss(fiGenPostFsr.idx(), diWeight);
}
}
else rooUnfDetRes.Fake(fiReco.idx(), diWeight);
detResponseReversed.fillIni(fiReco, diWeight);
detResponseReversed.fillFin(fiGenPostFsr, diWeight);
if (bothFIValid) {
detResponseReversed.fillMigration(fiReco,fiGenPostFsr, diWeight);
}
if (systMode != DYTools::RESOLUTION_STUDY) {
switch(systMode) {
case DYTools::SYST_RND: {
double rnd=gRandom->Gaus(0,1.);
if (rnd==double(0.)) rnd=gRandom->Gaus(0,1.);
int idx=(rnd<double(0.)) ? 0:1;
detRespV[idx]->fillIni( fiGenPostFsr, diWeight );
detRespV[idx]->fillFin( fiReco , diWeight );
if (bothFIValid) {
detRespV[idx]->fillMigration( fiGenPostFsr, fiReco, diWeight);
}
}
break;
case DYTools::ESCALE_RESIDUAL:
for (unsigned int iSt=0; iSt<detRespV.size(); ++iSt) {
const TH2D *h2Rnd= specTH2DWeightV[iSt];
double w=1.;
if (fiReco.isValid()) {
w=h2Rnd->GetBinContent(fiReco.iM()+1,fiReco.iY()+1);
if ((iSt==0) && (ientry<20)) {
std::cout << "dielectron(M,Y)=" << dielectron->mass
<< "," << dielectron->y << ", fiReco="
<< fiReco << ", specWeight=" << w << "\n";
}
}
double studyWeight= diWeight * w;
detRespV[iSt]->fillIni( fiGenPostFsr, studyWeight );
detRespV[iSt]->fillFin( fiReco , studyWeight );
if (bothFIValid) {
detRespV[iSt]->fillMigration( fiGenPostFsr, fiReco,
studyWeight);
}
}
break;
default:
for (unsigned int iSt=0; iSt<detRespV.size(); ++iSt) {
double studyWeight=specEWeightsV[iSt]->totalWeight();
detRespV[iSt]->fillIni( fiGenPostFsr, studyWeight );
detRespV[iSt]->fillFin( fiReco , studyWeight );
if (bothFIValid) {
detRespV[iSt]->fillMigration( fiGenPostFsr, fiReco,
studyWeight );
}
}
}
}
if (escaleV.size() && (systMode==DYTools::RESOLUTION_STUDY)) {
for (unsigned int iESc=0; iESc<escaleV.size(); ++iESc) {
dielectron->restoreEScaleModifiedValues(uncorrDielectron);
if (evtSelectorV[iESc]->testDielectron(dielectron,
accessInfo.evtInfoPtr())) {
FlatIndex_t fiRecoMdf;
fiRecoMdf.setRecoIdx(dielectron);
detRespV[iESc]->fillIni(fiGenPostFsr, diWeight);
detRespV[iESc]->fillFin(fiRecoMdf , diWeight);
if (fiGenPostFsr.isValid() && fiRecoMdf.isValid()) {
detRespV[iESc]->fillMigration(fiGenPostFsr,fiRecoMdf,
diWeight);
}
}
}
}
/*
Bool_t isB1 = DYTools::isBarrel(dielectron->scEta_1);
Bool_t isB2 = DYTools::isBarrel(dielectron->scEta_2);
hMassDiff->Fill(massResmeared - gen->mass);
if( isB1 && isB2 )
hMassDiffBB->Fill(massResmeared - gen->mass);
if( (isB1 && !isB2) || (!isB1 && isB2) )
hMassDiffEB->Fill(massResmeared - gen->mass);
if( !isB1 && !isB2 )
hMassDiffEE->Fill(massResmeared - gen->mass);
hMassDiffV->Fill(iIndexFlatGen, massResmeared - gen->mass);
hYDiffV ->Fill(iIndexFlatGen, dielectron->y - gen->y);
// if(iIndexFlatGen != -1){
// hMassDiffV[iIndexFlatGen]->Fill(massResmeared - gen->mass);
// }
*/
} // end loop over dielectrons
if (candCount>1) ec.numMultiDielectronsOk_inc();
} // end loop over events
infile->Close();
delete infile;
std::cout << ec << "\n";
ecTotal.add(ec);
} // end loop over files
std::cout << "total counts : " << ecTotal << "\n";
} // loop over iSample
} // runMode
UnfoldingMatrix_t fsrDETcorrections(UnfoldingMatrix::_cFSR_DETcorrFactors,"fsrCorrFactors");
if (DYTools::processData(runMode)) {
// Compute the errors on the elements of migration matrix
detResponse.finalizeDetMigrationErr();
detResponseExact.finalizeDetMigrationErr();
detResponseReversed.finalizeDetMigrationErr();
fsrGood.finalizeDetMigrationErr();
fsrExact.finalizeDetMigrationErr();
fsrDET.finalizeDetMigrationErr();
fsrDETexact.finalizeDetMigrationErr();
fsrDET_good.finalizeDetMigrationErr();
for (unsigned int i=0; i<detRespV.size(); ++i) detRespV[i]->finalizeDetMigrationErr();
// Find response matrix, which is simply the normalized migration matrix
std::cout << "find response matrix" << std::endl;
detResponse.computeResponseMatrix();
detResponseExact.computeResponseMatrix();
detResponseReversed.computeResponseMatrix();
fsrGood.computeResponseMatrix();
fsrExact.computeResponseMatrix();
fsrDET.computeResponseMatrix();
fsrDETexact.computeResponseMatrix();
fsrDET_good.computeResponseMatrix();
for (unsigned int i=0; i<detRespV.size(); ++i) detRespV[i]->computeResponseMatrix();
std::cout << "find inverted response matrix" << std::endl;
detResponse.invertResponseMatrix();
detResponseExact.invertResponseMatrix();
detResponseReversed.invertResponseMatrix();
fsrGood.invertResponseMatrix();
fsrExact.invertResponseMatrix();
fsrDET.invertResponseMatrix();
fsrDETexact.invertResponseMatrix();
fsrDET_good.invertResponseMatrix();
for (unsigned int i=0; i<detRespV.size(); ++i) detRespV[i]->invertResponseMatrix();
fsrDETcorrections.prepareFsrDETcorrFactors(fsrDET,fsrDETexact);
//fsrDETcorrections.printYields();
std::cout << "finalize fsrDET_good" << std::endl;
fsrGood.modifyDETResponseMatrices(fsrExact);
fsrDET_good.modifyDETResponseMatrices(fsrDETexact);
std::cout << "prepare flat-index arrays" << std::endl;
detResponse.prepareFIArrays();
detResponseExact.prepareFIArrays();
detResponseReversed.prepareFIArrays();
fsrGood.prepareFIArrays();
fsrExact.prepareFIArrays();
fsrDET.prepareFIArrays();
fsrDETexact.prepareFIArrays();
fsrDET_good.prepareFIArrays();
fsrDETcorrections.prepareFIArrays();
for (unsigned int i=0; i<detRespV.size(); ++i) detRespV[i]->prepareFIArrays();
}
//
// Store constants and reference arrays in files
//
if (DYTools::processData(runMode)) std::cout << "store constants in a file" << std::endl;
//TString outFile=inpMgr.correctionFullFileName("unfolding",systMode,0);
TString outputDir=inpMgr.constDir(systMode,0);
//int saveIdxMin=-1;
TString fnameTag=UnfoldingMatrix_t::generateFNameTag(systMode,globalSeed);
/*
{
TString u="_";
switch(systMode) {
case DYTools::NO_SYST:
fnameTag=DYTools::analysisTag;
break;
case DYTools::SYST_RND:
fnameTag=TString("_replica_") + DYTools::analysisTag;
//saveIdxMin=0;
//fnameTag+=seed;
break;
case DYTools::RESOLUTION_STUDY:
fnameTag=TString("_seed_") + DYTools::analysisTag;
//fnameTag+=seed;
break;
case DYTools::FSR_STUDY:
fnameTag=TString("_fsrStudy_") + DYTools::analysisTag;
//fnameTag=TString("_reweight_") + DYTools::analysisTag;
//fnameTag+= int(100*reweightFsr);
break;
case DYTools::PU_STUDY:
fnameTag=TString("_puStudy_") + DYTools::analysisTag;
break;
case DYTools::ESCALE_STUDY:
fnameTag=DYTools::analysisTag+TString("_escale") + u;
break;
case DYTools::ESCALE_RESIDUAL:
fnameTag=DYTools::analysisTag+TString("_escaleResidual");
break;
default:
std::cout<<"requested mode not recognized when determining fnameTag"<<std::endl;
assert(0);
}
}
*/
if (DYTools::isDebugMode(runMode)) fnameTag.Prepend("_DebugRun_");
std::cout << "fnameTag=<" << fnameTag << ">\n";
CPlot::sOutDir.Append(fnameTag);
CPlot::sOutDir.ReplaceAll(DYTools::analysisTag,"");
CPlot::sOutDir.Append(DYTools::analysisTag);
TString callingMacro="plotUnfoldingMatrix.systMode=";
callingMacro.Append(SystematicsStudyName(systMode));
if (DYTools::processData(runMode)) {
if (//(systMode!=DYTools::NORMAL_RND) &&
(systMode!=DYTools::RESOLUTION_STUDY) &&
//(systMode!=DYTools::FSR_STUDY) &&
(systMode!=DYTools::ESCALE_STUDY)) {
detResponse.autoSaveToFile(outputDir,fnameTag,callingMacro); // detResponse, reference mc arrays
detResponseExact.autoSaveToFile(outputDir,fnameTag,callingMacro);
detResponseReversed.autoSaveToFile(outputDir,fnameTag,callingMacro);
fsrGood.autoSaveToFile(outputDir,fnameTag,callingMacro);
fsrExact.autoSaveToFile(outputDir,fnameTag,callingMacro);
fsrDET.autoSaveToFile(outputDir,fnameTag,callingMacro);
fsrDETexact.autoSaveToFile(outputDir,fnameTag,callingMacro);
fsrDET_good.autoSaveToFile(outputDir,fnameTag,callingMacro);
fsrDETcorrections.autoSaveToFile(outputDir,fnameTag,callingMacro);
}
TString fname=Form("rooUnfDetRes_%s.root",DYTools::analysisTag.Data());
if (DYTools::isDebugMode(runMode))
fname.ReplaceAll(".root","_DebugRun.root");
TFile fout(fname,"recreate");
if (!fout.IsOpen()) {
std::cout << "failed to create the file <" << fout.GetName() << ">\n";
return retCodeError;
}
rooUnfDetRes.Write();
writeBinningArrays(fout,"plotUnfoldingMatrixRooUnfold");
std::cout << "file <" << fout.GetName() << "> created\n";
fout.Close();
for (unsigned int i=0; i<detRespV.size(); i++)
detRespV[i]->autoSaveToFile(outputDir,fnameTag,callingMacro);
// additional saving for systematics
if (systMode==DYTools::FSR_STUDY) {
detRespV[0]->autoSaveToFile(inpMgr.constDir(DYTools::FSR_5minus,0),
UnfoldingMatrix_t::generateFNameTag(DYTools::FSR_5minus,globalSeed),
callingMacro);
detRespV[2]->autoSaveToFile(inpMgr.constDir(DYTools::FSR_5plus,0),
UnfoldingMatrix_t::generateFNameTag(DYTools::FSR_5plus,globalSeed),
callingMacro);
}
else if (systMode==DYTools::PU_STUDY) {
TString dir0=inpMgr.constDir(DYTools::PILEUP_5minus,0);
TString tag0=UnfoldingMatrix_t::generateFNameTag(DYTools::PILEUP_5minus,
globalSeed);
TString dir1=inpMgr.constDir(DYTools::PILEUP_5plus,0);
TString tag1=UnfoldingMatrix_t::generateFNameTag(DYTools::PILEUP_5plus,
globalSeed);
detRespV[0]->autoSaveToFile(dir0,tag0,callingMacro);
detRespV[1]->autoSaveToFile(dir1,tag1,callingMacro);
}
}
else {
if (//(systMode!=DYTools::NORMAL_RND) &&
(systMode!=DYTools::RESOLUTION_STUDY) &&
//(systMode!=DYTools::FSR_STUDY) &&
(systMode!=DYTools::ESCALE_STUDY)) {
if (!detResponse.autoLoadFromFile(outputDir,fnameTag) ||
!detResponseExact.autoLoadFromFile(outputDir,fnameTag) ||
!detResponseReversed.autoLoadFromFile(outputDir,fnameTag) ||
!fsrGood.autoLoadFromFile(outputDir,fnameTag) ||
!fsrExact.autoLoadFromFile(outputDir,fnameTag) ||
!fsrDET.autoLoadFromFile(outputDir,fnameTag) ||
!fsrDETexact.autoLoadFromFile(outputDir,fnameTag) ||
!fsrDET_good.autoLoadFromFile(outputDir,fnameTag) ||
!fsrDETcorrections.autoLoadFromFile(outputDir,fnameTag)) {
std::cout << "loading failed\n";
return retCodeError;
}
}
for (unsigned int i=0; i<detRespV.size(); i++) detRespV[i]->autoLoadFromFile(outputDir,fnameTag);
}
UnfoldingMatrix_t detRespAvg(detResponse.kind, "detResponseAvg");
if (1 && detRespV.size()) { //computeAverage
const double weight=1/double(detRespV.size());
for (unsigned int i=0; i<detRespV.size(); ++i) {
TString name=Form("tmp_%d",i);
UnfoldingMatrix_t tmp(*detRespV[i],name);
tmp.squareDetMigrationErr();
detRespAvg.addMigration(tmp,weight);
}
detRespAvg.finalizeDetMigrationErr();
detRespAvg.computeResponseMatrix();
detRespAvg.invertResponseMatrix();
detRespAvg.prepareFIArrays();
detRespAvg.autoSaveToFile(outputDir,fnameTag,callingMacro); // detResponse, reference mc arrays
}
//--------------------------------------------------------------------------------------------------------------
// Make plots
//==============================================================================================================
/*
std::cout << "making plots" << std::endl;
TString unfoldingConstFileName, yieldsFileName;
detResponse.getFileNames(outputDir,fnameTag, unfoldingConstFileName, yieldsFileName);
TString unfoldingConstantsPlotFName=unfoldingConstFileName;
unfoldingConstantsPlotFName.Replace(unfoldingConstantsPlotFName.Index(".root"),
sizeof(".root"),
"_plots.root");
TFile *fPlots=new TFile(unfoldingConstantsPlotFName,"recreate");
if (!fPlots) {
std::cout << "failed to create a file <" << unfoldingConstantsPlotFName << ">\n";
}
#ifdef CrossSection_HH
if (1) { // study Ini and Fin vecs
std::vector<VXSectD_t*> dataV;
TString canvName="canvChk";
TString fewzTag=(useFewzWeights) ? "_withFEWZ" : "_noFEWZ";
if (useFewzWeights && regularizeFEWZ) fewzTag="_withMdfFEWZ";
canvName.Append(fewzTag);
const int twoPads=0;
TCanvas *c=new TCanvas(canvName,canvName,600*(1+twoPads),600);
if (twoPads) {
c->Divide(2,1);
c->GetPad(1)->SetLogx(1);
c->GetPad(2)->SetLogx(1);
c->GetPad(1)->SetLogy(1);
c->GetPad(2)->SetLogy(1);
}
else { c->SetLogx(1); c->SetLogy(1); }
int ok=1;
TH1F *hGenAvg=new TH1F("hGenAvg","hGenAvg",DYTools::nMassBins,DYTools::massBinLimits);
TH1F *hRecAvg=new TH1F("hRecAvg","hRecAvg",DYTools::nMassBins,DYTools::massBinLimits);
hGenAvg->SetDirectory(0);
hRecAvg->SetDirectory(0);
hGenAvg->Sumw2();
hRecAvg->Sumw2();
TH1F *hGenAvg_chk=NULL; //new TH1F("hGenAvg_chk","hGenAvg_chk",DYTools::nMassBins,DYTools::massBinLimits);
TH1F *hRecAvg_chk=NULL; //new TH1F("hRecAvg_chk","hRecAvg_chk",DYTools::nMassBins,DYTools::massBinLimits);
if (ok && hGenAvg_chk && hRecAvg_chk) {
hGenAvg_chk->SetDirectory(0);
hRecAvg_chk->SetDirectory(0);
VXSectD_t d("yields_repAvg",DYTools::nUnfoldingBinsMax);
TString matrixFName,yieldsFName;
detRespAvg.getFileNames(outputDir,fnameTag, matrixFName,yieldsFName);
ok=d.Load(matrixFName,"yieldsMcPostFsrGenFIArray","yieldsMcPostFsrRecFIArray","");
if (ok) ok= (d.FillHisto(hGenAvg_chk,1) && d.FillHistoWithError(hRecAvg_chk));
}
for (unsigned int i=0; ok && (i<detRespV.size()); ++i) {
TString name=Form("yields_rep%d",i);
VXSectD_t *d=new VXSectD_t(name,DYTools::nUnfoldingBinsMax);
dataV.push_back(d);
TString matrixFName,yieldsFName;
detRespV[i]->getFileNames(outputDir,fnameTag, matrixFName,yieldsFName);
ok=d->Load(matrixFName,"yieldsMcPostFsrGenFIArray","yieldsMcPostFsrRecFIArray","");
if (!ok) continue;
TString hGenName=Form("hGen_rep%d",i);
TString hRecName=Form("hRec_rep%d",i);
TH1F *hGen=new TH1F(hGenName,hGenName,DYTools::nMassBins,DYTools::massBinLimits);
TH1F *hRec=new TH1F(hRecName,hRecName,DYTools::nMassBins,DYTools::massBinLimits);
hGen->SetDirectory(0);
hRec->SetDirectory(0);
if (i==0) {
hGen->SetTitle(hGen->GetTitle() + fewzTag);
hRec->SetTitle(hRec->GetTitle() + fewzTag);
}
ok= (d->FillHisto(hGen,1) && d->FillHistoWithError(hRec));
if (!ok) continue;
hGenAvg->Add(hGen,1/double(detRespV.size()));
hRecAvg->Add(hRec,1/double(detRespV.size()));
TString opt="L";
if (i>0) opt.Append("same");
int color = i%(50-20) + 20;
hGen->SetLineColor(color);
hRec->SetLineColor(color);
hGen->GetYaxis()->SetRangeUser(5.,3.e6);
hRec->GetYaxis()->SetRangeUser(5.,3.e6);
if (twoPads) c->cd(1);
hGen->Draw(opt);
if (twoPads) c->cd(2);
else { if (i==0) opt.Append("same"); }
hRec->Draw(opt);
}
hGenAvg->SetLineColor(kAzure+1);
hRecAvg->SetLineColor(kRed+1);
if (twoPads) c->cd(1);
hGenAvg->Draw("L same");
if (hGenAvg_chk) hGenAvg_chk->Draw("L same");
if (twoPads) c->cd(2);
hRecAvg->Draw("L same");
if (hRecAvg_chk) hRecAvg_chk->Draw("L same");
c->Update();
return;
}
#endif
TCanvas *c = MakeCanvas("canvZmass1","canvZmass1",800,600);
// string buffers
char ylabel[50]; // y-axis label
//
// Draw DY candidate mass at the reconstruction level. Extra
// smearing is applied. This figure allows one to judge the
// correctness of the weights aplied to different samples from the
// smoothness of the combined result.
//
sprintf(ylabel,"a.u. / %.1f GeV/c^{2}",hZMassv[0]->GetBinWidth(1));
CPlot plotZMass1("zmass1","","m(ee) [GeV/c^{2}]",ylabel);
for(UInt_t i=0; i<fnamev.size(); i++) {
plotZMass1.AddHist1D(hZMassv[i],labelv[i],"hist",colorv[i],linev[i]);
}
plotZMass1.SetLogy();
plotZMass1.Draw(c);
SaveCanvas(c,"zmass1");
// plotZMass1.Draw(c,doSave,format);
// if (fPlots) { fPlots->cd(); c->Write(); }
//
// Draw a plot that illustrates the detector resolution effects.
// We plot (gen-rec)/gen as a function of mass and rapidity.
//
TMatrixD resolutionEffect(DYTools::nMassBins,DYTools::nYBinsMax);
resolutionEffect = 0;
for(int i=0; i < resolutionEffect.GetNrows(); i++){
for(int j=0; j < resolutionEffect.GetNcols(); j++){
double ngen = (*detResponse.yieldsIni)(i,j);
double nrec = (*detResponse.yieldsFin)(i,j);
if( ngen != 0 )
resolutionEffect(i,j) = (ngen-nrec)/ngen;
}
}
resolutionEffect.Print();
PlotMatrixVariousBinning(resolutionEffect, "resolution_effect", "LEGO2", NULL);
//
// Draw a plot that illustrates the losses due to reconstruction
// We plot (preFsrExact-preFsr)/preFsrExact as a
// function of mass and rapidity.
//
TMatrixD *unfRecoEffect=detResponseExact.getReconstructionEffect(detResponse);
unfRecoEffect->Print();
PlotMatrixVariousBinning(*unfRecoEffect, "reconstruction_effect", "LEGO2", NULL);
delete unfRecoEffect;
TMatrixD *unfFsrDETRecoEffect=fsrDETexact.getReconstructionEffect(fsrDET);
PlotMatrixVariousBinning(*unfFsrDETRecoEffect, "reconstruction_effect_fsrDET", "LEGO2", NULL);
delete unfFsrDETRecoEffect;
*/
// Plot response and inverted response matrices
//std::vector<TH2F*> hResponseV, hInvResponseV;
//std::vector<TCanvas*> canvV;
//std::vector<CPlot*> cpResponseV;
//TH2F *hR, *hIR;
//TCanvas *e2;
//CPlot *cpR, *cpIR;
detResponse.prepareHResponse();
fsrGood.prepareHResponse();
fsrExact.prepareHResponse();
fsrDET.prepareHResponse();
fsrDETexact.prepareHResponse();
fsrDET_good.prepareHResponse();
for (unsigned int iESc=0; iESc<detRespV.size(); ++iESc) {
detRespV[iESc]->prepareHResponse();
}
/*
// Create a plot of detector resolution without mass binning
TCanvas *g = MakeCanvas("canvMassDiff","canvMassDiff",600,600);
CPlot plotMassDiff("massDiff","","reco mass - gen post-FSR mass [GeV/c^{2}]","a.u.");
hMassDiffBB->Scale(1.0/hMassDiffBB->GetSumOfWeights());
hMassDiffEB->Scale(1.0/hMassDiffEB->GetSumOfWeights());
hMassDiffEE->Scale(1.0/hMassDiffEE->GetSumOfWeights());
plotMassDiff.AddHist1D(hMassDiffBB,"EB-EB","hist",kBlack);
plotMassDiff.AddHist1D(hMassDiffEB,"EE-EB","hist",kBlue);
plotMassDiff.AddHist1D(hMassDiffEE,"EE-EE","hist",kRed);
plotMassDiff.Draw(g);
SaveCanvas(g,"massDiff");
// if (fPlots) g->Write();
// Create a plot of reco - gen post-FSR mass and rapidity difference
TCanvas *h1 = MakeCanvas("canvMassDiffV","canvMassDiffV",600,600);
CPlot plotMassDiffV("massDiffV","",
"flat index",
"reco mass - gen post-FSR mass [GeV/c^{2}]");
plotMassDiffV.AddHist2D(hMassDiffV,"LEGO");
plotMassDiffV.Draw(h1);
SaveCanvas(h1,"hMassDiffV");
// Create a plot of reco - gen post-FSR mass and rapidity difference
TCanvas *h2 = MakeCanvas("canvYDiffV","canvYDiffV",600,600);
CPlot plotYDiffV("massDiffV","",
"flat index",
"reco Y - gen post-FSR Y");
plotYDiffV.AddHist2D(hYDiffV,"LEGO");
plotYDiffV.Draw(h2);
SaveCanvas(h2,"hYDiffV");
if (fPlots) {
fPlots->Close();
delete fPlots;
std::cout << "plots saved to a file <" << unfoldingConstantsPlotFName << ">\n";
}
//draw errors of Unfolding matrix
TCanvas *cErrorsResp = MakeCanvas("cErrorsResp","detResponse.DetInvertedResponseErr", 600,600);
detResponse.DetInvertedResponseErr->Draw("LEGO2");
cErrorsResp->Update();
SaveCanvas(cErrorsResp,"cErrorsResp");
TCanvas *cFsrErrorsResp = MakeCanvas("cErrorsFsr","fsr__.DetInvertedResponseErr", 1200, 600);
cFsrErrorsResp->Divide(2,1);
cFsrErrorsResp->cd(1);
fsrExact.DetInvertedResponseErr->Draw("LEGO2");
cFsrErrorsResp->cd(2);
fsrDET.DetInvertedResponseErr->Draw("LEGO2");
SaveCanvas(cFsrErrorsResp,"cErrorsFsr");
//--------------------------------------------------------------------------------------------------------------
// Summary print out
//==============================================================================================================
cout << endl;
cout << "*" << endl;
cout << "* SUMMARY" << endl;
cout << "*--------------------------------------------------" << endl;
cout << endl;
detResponse.printConditionNumber();
fsrExact.printConditionNumber();
fsrDET.printConditionNumber();
fsrDETexact.printConditionNumber();
if (0) {
//detResponse.printMatrices();
//fsr.printMatrices();
//fsrDET.printMatrices();
fsrDET_Mdf.printMatrices();
fsrDET_good.printMatrices();
}
//Print errors of the Unfolding matrix when they exceed 0.1
/
for (int iM=0; iM<DYTools::nMassBins; iM++)
for (int iY=0; iY<DYTools::nYBins[iM]; iY++)
for (int jM=0; jM<DYTools::nMassBins; jM++)
for (int jY=0; jY<DYTools::nYBins[jM]; jY++)
{
int i=DYTools::findIndexFlat(iM,iY);
int j=DYTools::findIndexFlat(jM,jY);
if (DetInvertedResponseErr(i,j)>0.1)
{
std::cout<<"DetInvertedResponseErr("<<i<<","<<j<<")="<<DetInvertedResponseErr(i,j);
std::cout<<", DetInvertedResponse("<<i<<","<<j<<")="<<DetInvertedResponse(i,j)<<std::endl;
std::cout<<"(iM="<<iM<<", iY="<<iY<<", jM="<<jM<<", jY="<<jY<<")"<<std::endl<<std::endl;
}
if (DetInvertedResponseErr2(i,j)>0.1)
{
std::cout<<"DetInvertedResponseErr2("<<i<<","<<j<<")="<<DetInvertedResponseErr2(i,j);
std::cout<<", DetInvertedResponse("<<i<<","<<j<<")="<<DetInvertedResponse(i,j)<<std::endl;
std::cout<<"(iM="<<iM<<", iY="<<iY<<", jM="<<jM<<", jY="<<jY<<")"<<std::endl<<std::endl;
}
}
/
/
if (0) {
// Printout of all constants, uncomment if needed
//printf("DetCorrFactor:\n"); DetCorrFactor.Print();
printf("DetMigration:\n"); DetMigration.Print();
printf("DetResponse:\n"); DetResponse.Print();
printf("DetInvertedResponse:\n"); DetInvertedResponse.Print();
//printf("DetInvertedResponseErr:\n"); DetInvertedResponseErr.Print();
//printf("DetResponseArr:\n"); DetResponseArr.Print();
//printf("DetInvertedResponseArr:\n"); DetInvertedResponseArr.Print();
//printf("DetInvertedResonseErrArr:\n"); DetInvertedResponseErrArr.Print();
// printf("Detector corr factor numerator:\n");
// DetCorrFactorNumerator.Print();
printf("yieldsMcPostFsrGen:\n");
yieldsMcPostFsrGen.Print();
printf("yieldsMcPostFsrRec:\n");
yieldsMcPostFsrRec.Print();
// printf("Detector corr factor denominator:\n");
// DetCorrFactorDenominator.Print();
// printf("yieldsMcPostFsrRecArr:\n");
// yieldsMcPostFsrRecArr.Print();
//printf("yieldsMcGen:\n");
//yieldsMcGen.Print();
}
/
if (0) {
detResponse.printYields();
fsrExact.printYields();
fsrDET.printYields();
}
*/
//gBenchmark->Show("makeUnfoldingMatrix");
ShowBenchmarkTime("makeUnfoldingMatrix");
return retCodeOk;
}
// パケットヘッダをコピーする
PKT *ClonePacket(PKT *p, bool copy_data)
{
PKT *ret;
// 引数チェック
if (p == NULL)
{
return NULL;
}
ret = ZeroMallocFast(sizeof(PKT));
ret->PacketSize = p->PacketSize;
// MAC ヘッダのコピー
ret->MacHeader = MallocFast(sizeof(MAC_HEADER));
Copy(ret->MacHeader, p->MacHeader, sizeof(MAC_HEADER));
// MAC フラグのコピー
ret->BroadcastPacket = p->BroadcastPacket;
ret->InvalidSourcePacket = p->InvalidSourcePacket;
// IPv6 関係構造体のコピー
Copy(&ret->IPv6HeaderPacketInfo, &p->IPv6HeaderPacketInfo, sizeof(IPV6_HEADER_PACKET_INFO));
Copy(&ret->ICMPv6HeaderPacketInfo, &p->ICMPv6HeaderPacketInfo, sizeof(ICMPV6_HEADER_INFO));
// Layer 3
ret->TypeL3 = p->TypeL3;
switch (ret->TypeL3)
{
case L3_ARPV4:
// ARP パケット
ret->L3.ARPv4Header = MallocFast(sizeof(ARPV4_HEADER));
Copy(ret->L3.ARPv4Header, p->L3.ARPv4Header, sizeof(ARPV4_HEADER));
break;
case L3_IPV4:
// IPv4 パケット
ret->L3.IPv4Header = MallocFast(sizeof(IPV4_HEADER));
Copy(ret->L3.IPv4Header, p->L3.IPv4Header, sizeof(IPV4_HEADER));
break;
case L3_IPV6:
// IPv6 パケット
ret->L3.IPv6Header = MallocFast(sizeof(IPV6_HEADER));
Copy(ret->L3.IPv6Header, p->L3.IPv6Header, sizeof(IPV6_HEADER));
ret->IPv6HeaderPacketInfo.IPv6Header = Clone(p->IPv6HeaderPacketInfo.IPv6Header,
sizeof(IPV6_HEADER));
ret->IPv6HeaderPacketInfo.HopHeader = Clone(p->IPv6HeaderPacketInfo.HopHeader,
sizeof(IPV6_OPTION_HEADER));
ret->IPv6HeaderPacketInfo.EndPointHeader = Clone(p->IPv6HeaderPacketInfo.EndPointHeader,
sizeof(IPV6_OPTION_HEADER));
ret->IPv6HeaderPacketInfo.RoutingHeader = Clone(p->IPv6HeaderPacketInfo.RoutingHeader,
sizeof(IPV6_OPTION_HEADER));
ret->IPv6HeaderPacketInfo.FragmentHeader = Clone(p->IPv6HeaderPacketInfo.FragmentHeader,
sizeof(IPV6_FRAGMENT_HEADER));
ret->IPv6HeaderPacketInfo.Payload = Clone(p->IPv6HeaderPacketInfo.Payload,
p->IPv6HeaderPacketInfo.PayloadSize);
break;
}
// Layer 4
ret->TypeL4 = p->TypeL4;
switch (ret->TypeL4)
{
case L4_ICMPV4:
// ICMPv4 パケット
ret->L4.ICMPHeader = MallocFast(sizeof(ICMP_HEADER));
Copy(ret->L4.ICMPHeader, p->L4.ICMPHeader, sizeof(ICMP_HEADER));
break;
case L4_ICMPV6:
// ICMPv6 パケット
ret->L4.ICMPHeader = MallocFast(sizeof(ICMP_HEADER));
Copy(ret->L4.ICMPHeader, p->L4.ICMPHeader, sizeof(ICMP_HEADER));
ret->ICMPv6HeaderPacketInfo.Data = Clone(p->ICMPv6HeaderPacketInfo.Data,
p->ICMPv6HeaderPacketInfo.DataSize);
ret->ICMPv6HeaderPacketInfo.EchoData = Clone(p->ICMPv6HeaderPacketInfo.EchoData,
p->ICMPv6HeaderPacketInfo.EchoDataSize);
switch (ret->ICMPv6HeaderPacketInfo.Type)
{
case ICMPV6_TYPE_ECHO_REQUEST:
case ICMPV6_TYPE_ECHO_RESPONSE:
break;
case ICMPV6_TYPE_ROUTER_SOLICIATION:
ret->ICMPv6HeaderPacketInfo.Headers.RouterSoliciationHeader =
Clone(p->ICMPv6HeaderPacketInfo.Headers.RouterSoliciationHeader,
sizeof(ICMPV6_ROUTER_SOLICIATION_HEADER));
break;
case ICMPV6_TYPE_ROUTER_ADVERTISEMENT:
ret->ICMPv6HeaderPacketInfo.Headers.RouterAdvertisementHeader =
Clone(p->ICMPv6HeaderPacketInfo.Headers.RouterAdvertisementHeader,
sizeof(ICMPV6_ROUTER_ADVERTISEMENT_HEADER));
break;
case ICMPV6_TYPE_NEIGHBOR_SOLICIATION:
ret->ICMPv6HeaderPacketInfo.Headers.NeighborSoliciationHeader =
Clone(p->ICMPv6HeaderPacketInfo.Headers.NeighborSoliciationHeader,
sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER));
break;
case ICMPV6_TYPE_NEIGHBOR_ADVERTISEMENT:
ret->ICMPv6HeaderPacketInfo.Headers.NeighborAdvertisementHeader =
Clone(p->ICMPv6HeaderPacketInfo.Headers.NeighborAdvertisementHeader,
sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER));
break;
}
CloneICMPv6Options(&ret->ICMPv6HeaderPacketInfo.OptionList,
&p->ICMPv6HeaderPacketInfo.OptionList);
break;
case L4_TCP:
// TCP パケット
ret->L4.TCPHeader = MallocFast(sizeof(TCP_HEADER));
Copy(ret->L4.TCPHeader, p->L4.TCPHeader, sizeof(TCP_HEADER));
break;
case L4_UDP:
// UDP パケット
ret->L4.UDPHeader = MallocFast(sizeof(UDP_HEADER));
Copy(ret->L4.UDPHeader, p->L4.UDPHeader, sizeof(UDP_HEADER));
break;
}
// Layer 7
ret->TypeL7 = p->TypeL7;
switch (ret->TypeL7)
{
case L7_DHCPV4:
// DHCP パケット
ret->L7.DHCPv4Header = MallocFast(sizeof(DHCPV4_HEADER));
Copy(ret->L7.DHCPv4Header, p->L7.DHCPv4Header, sizeof(DHCPV4_HEADER));
break;
}
// アドレスデータ
ret->MacAddressSrc = ret->MacHeader->SrcAddress;
ret->MacAddressDest = ret->MacHeader->DestAddress;
if (copy_data)
{
// パケット本体もコピー
ret->PacketData = MallocFast(p->PacketSize);
Copy(ret->PacketData, p->PacketData, p->PacketSize);
}
return ret;
}
// Parse the SSTP packet
SSTP_PACKET *SstpParsePacket(UCHAR *data, UINT size)
{
SSTP_PACKET *p;
USHORT len;
// Validate arguments
if (data == NULL || size == 0)
{
return NULL;
}
if (size < 4)
{
return NULL;
}
p = ZeroMalloc(sizeof(SSTP_PACKET));
// Version
p->Version = *((UCHAR *)data);
data++;
size--;
if (p->Version != SSTP_VERSION_1)
{
// Invalid version
SstpFreePacket(p);
return NULL;
}
// Flag
if ((*((UCHAR *)data)) & 0x01)
{
p->IsControl = true;
}
data++;
size--;
// Length
len = READ_USHORT(data) & 0xFFF;
data += sizeof(USHORT);
size -= sizeof(USHORT);
if (len < 4)
{
// Invalid size
SstpFreePacket(p);
return NULL;
}
if (((UINT)(len - 4)) > size)
{
// Oversized
SstpFreePacket(p);
return NULL;
}
// Data
p->DataSize = len - 4;
p->Data = Clone(data, p->DataSize);
if (p->IsControl)
{
// Parse the Attribute list
p->AttibuteList = SstpParseAttributeList(p->Data, p->DataSize, p);
if (p->AttibuteList == NULL)
{
// Failure of parsing list
SstpFreePacket(p);
return NULL;
}
}
return p;
}
//==================================================================
void SimplePrimitiveBase::Split( Hider &hider, bool uSplit, bool vSplit )
{
DASSERT( IsUsed() );
if ( mSplitCnt > 9 )
{
// $$$ too many splits !!!
(void)mSplitCnt;
return;
}
if ( uSplit )
{
// U split
SimplePrimitiveBase *pPrimsSU[2] =
{
Clone(),
Clone()
};
float uMid = (mURange[0] + mURange[1]) * 0.5f;
pPrimsSU[0]->mURange[1] = uMid;
pPrimsSU[1]->mURange[0] = uMid;
hider.InsertSplitted( pPrimsSU[0], *this );
hider.InsertSplitted( pPrimsSU[1], *this );
if ( vSplit )
{
// optional V split
float vMid = (mVRange[0] + mVRange[1]) * 0.5f;
// check.. because we can't be sure that the primitive didn't fail
// at insertion time
for (size_t i=0; i < 2; ++i)
{
if ( pPrimsSU[i]->IsUsed() )
{
SimplePrimitiveBase *pNewPrim = pPrimsSU[i]->Clone();
pPrimsSU[i]->mVRange[1] = vMid;
pNewPrim->mVRange[0] = vMid;
hider.InsertSplitted( pNewPrim, *pPrimsSU[i] );
}
}
}
}
else
{
// exclusive V split
if ( vSplit )
{
SimplePrimitiveBase *pPrim1 = Clone();
SimplePrimitiveBase *pPrim2 = Clone();
float vMid = (mVRange[0] + mVRange[1]) * 0.5f;
pPrim1->mVRange[1] = vMid;
pPrim2->mVRange[0] = vMid;
hider.InsertSplitted( pPrim1, *this );
hider.InsertSplitted( pPrim2, *this );
}
}
}
Stack& Stack::operator = (const Stack& obj)
{
if(this != &obj)
Clone(obj);
return *this;
}
CPDF_Object* CPDF_Object::CloneRef(CPDF_IndirectObjectHolder* pDoc) const {
if (m_ObjNum) {
return new CPDF_Reference(pDoc, m_ObjNum);
}
return Clone();
}
void
CloseDownClient(ClientRec *client)
{
int index_deleted = 0;
if (verbose) {
printf ("ICE Connection closed, IceConn fd = %d\n",
IceConnectionNumber (client->ice_conn));
printf ("\n");
}
SmsCleanUp (client->smsConn);
IceSetShutdownNegotiation (client->ice_conn, False);
IceCloseConnection (client->ice_conn);
client->ice_conn = NULL;
client->smsConn = NULL;
if (!shutdownInProgress && client_info_visible)
{
for (index_deleted = 0;
index_deleted < numClientListNames; index_deleted++)
{
if (clientListRecs[index_deleted] == client)
break;
}
}
ListSearchAndFreeOne (RunningList, (char *) client);
if (saveInProgress)
{
Status delStatus = ListSearchAndFreeOne (
WaitForSaveDoneList, (char *) client);
if (delStatus)
{
ListAddLast (FailedSaveList, (char *) client);
client->freeAfterBadSavePopup = True;
}
ListSearchAndFreeOne (WaitForInteractList, (char *) client);
ListSearchAndFreeOne (WaitForPhase2List, (char *) client);
if (delStatus && ListCount (WaitForSaveDoneList) == 0)
{
if (ListCount (FailedSaveList) > 0 && !checkpoint_from_signal)
PopupBadSave ();
else
FinishUpSave ();
}
else if (ListCount (WaitForInteractList) > 0 &&
OkToEnterInteractPhase ())
{
LetClientInteract (ListFirst (WaitForInteractList));
}
else if (!phase2InProgress &&
ListCount (WaitForPhase2List) > 0 && OkToEnterPhase2 ())
{
StartPhase2 ();
}
}
if (client->restartHint == SmRestartImmediately && !shutdownInProgress)
{
Clone (client, True /* use saved state */);
ListAddLast (RestartImmedList, (char *) client);
}
else if (client->restartHint == SmRestartAnyway)
{
ListAddLast (RestartAnywayList, (char *) client);
}
else if (!client->freeAfterBadSavePopup)
{
FreeClient (client, True /* free props */);
}
if (shutdownInProgress)
{
if (ListCount (RunningList) == 0)
EndSession (0);
}
else if (client_info_visible)
{
UpdateClientList ();
if (current_client_selected == index_deleted)
{
if (current_client_selected == numClientListNames)
current_client_selected--;
if (current_client_selected >= 0)
{
XawListHighlight (clientListWidget, current_client_selected);
ShowHint (clientListRecs[current_client_selected]);
if (client_prop_visible)
{
DisplayProps (clientListRecs[current_client_selected]);
}
}
}
else
{
if (index_deleted < current_client_selected)
current_client_selected--;
XawListHighlight (clientListWidget, current_client_selected);
}
}
}
/** Defines a column for a property.
*
* The following code defines an empty view with three properties:
* @code
* c4_IntProp p1, p2, p3;
* c4_View myView = (p1, p2, p3);
* @endcode
* @return the new view object (without any data rows)
* @sa c4_Property
*/
c4_View c4_View::operator, (const c4_Property& prop_) const
{
c4_View view = Clone();
view.AddProperty(prop_);
return view;
}
UIStaticText *UIStaticText::CloneStaticText()
{
return (UIStaticText *)Clone();
}
/** Create view with all duplicate rows omitted
*
* This view operation is based on a read-only custom viewer.
*/
c4_View c4_View::Unique() const
{
c4_IntProp count ("#N#");
return Counts(Clone(), count).ProjectWithout(count);
}
PolyMesh* PolyMesh::ToPolyMesh()
{
return (PolyMesh*)Clone();
}
void clone( const TrafficIPC::Disturbances& cloneThese,
TrafficIPC::Disturbances& toMe ) {
std::transform( cloneThese.begin(), cloneThese.end(),
std::back_inserter( toMe ), Clone() );
}
void XXObjectRectangle::cloneRect(XSWFCONTEXT&cnt,XXVARLIST&list)
{
cnt.pStack->Push((Clone()));
}
tuple(const tuple &rhs)
{
Clone(rhs);
return;
}
MyMat::MyMat(const MyMat &src):m_data(NULL)
{
Clone(src);
}
tuple & operator=(const tuple &rhs)
{
return Clone(rhs);
}
CImageAttribute::CImageAttribute(const CImageAttribute& image)
{
Clone(image);
}
// Process the received packet
BLOCK *UdpAccelProcessRecvPacket(UDP_ACCEL *a, UCHAR *buf, UINT size, IP *src_ip, UINT src_port)
{
UCHAR key[UDP_ACCELERATION_PACKET_KEY_SIZE];
UCHAR *iv;
CRYPT *c;
UINT64 my_tick, your_tick;
UINT inner_size;
UCHAR *inner_data = NULL;
UINT pad_size;
UCHAR *verify;
bool compress_flag;
BLOCK *b = NULL;
UINT cookie;
// Validate arguments
if (a == NULL || buf == NULL || size == 0 || src_ip == NULL)
{
return NULL;
}
if (a->PlainTextMode == false)
{
// IV
if (size < UDP_ACCELERATION_PACKET_IV_SIZE)
{
return NULL;
}
iv = buf;
buf += UDP_ACCELERATION_PACKET_IV_SIZE;
size -= UDP_ACCELERATION_PACKET_IV_SIZE;
// Calculate the key
UdpAccelCalcKey(key, a->YourKey, iv);
if (false)
{
char tmp1[256];
char tmp2[256];
char tmp3[256];
BinToStr(tmp1, sizeof(tmp1), a->YourKey, sizeof(a->YourKey));
BinToStr(tmp2, sizeof(tmp2), iv, UDP_ACCELERATION_PACKET_IV_SIZE);
BinToStr(tmp3, sizeof(tmp3), key, sizeof(key));
Debug("Your Key: %s\n"
"IV : %s\n"
"Comm Key: %s\n",
tmp1, tmp2, tmp3);
}
// Decryption
c = NewCrypt(key, UDP_ACCELERATION_PACKET_KEY_SIZE);
Encrypt(c, buf, buf, size);
FreeCrypt(c);
}
// Cookie
if (size < sizeof(UINT))
{
return NULL;
}
cookie = READ_UINT(buf);
buf += sizeof(UINT);
size -= sizeof(UINT);
if (cookie != a->MyCookie)
{
return NULL;
}
// My Tick
if (size < sizeof(UINT64))
{
return NULL;
}
my_tick = READ_UINT64(buf);
buf += sizeof(UINT64);
size -= sizeof(UINT64);
// Your Tick
if (size < sizeof(UINT64))
{
return NULL;
}
your_tick = READ_UINT64(buf);
buf += sizeof(UINT64);
size -= sizeof(UINT64);
// inner_size
if (size < sizeof(USHORT))
{
return NULL;
}
inner_size = READ_USHORT(buf);
buf += sizeof(USHORT);
size -= sizeof(USHORT);
// compress_flag
if (size < sizeof(UCHAR))
{
return NULL;
}
compress_flag = *((UCHAR *)buf);
buf += sizeof(UCHAR);
size -= sizeof(UCHAR);
if (size < inner_size)
{
return NULL;
}
// inner_data
if (inner_size >= 1)
{
inner_data = buf;
buf += inner_size;
size -= inner_size;
}
if (a->PlainTextMode == false)
{
// padding
if (size < UDP_ACCELERATION_PACKET_IV_SIZE)
{
return false;
}
pad_size = size - UDP_ACCELERATION_PACKET_IV_SIZE;
buf += pad_size;
size -= pad_size;
// verify
if (size != UDP_ACCELERATION_PACKET_IV_SIZE)
{
return NULL;
}
verify = buf;
if (IsZero(verify, UDP_ACCELERATION_PACKET_IV_SIZE) == false)
{
return NULL;
}
}
if (my_tick < a->LastRecvYourTick)
{
if ((a->LastRecvYourTick - my_tick) >= ((UINT64)UDP_ACCELERATION_WINDOW_SIZE_MSEC))
{
return NULL;
}
}
a->LastRecvMyTick = MAX(a->LastRecvMyTick, your_tick);
a->LastRecvYourTick = MAX(a->LastRecvYourTick, my_tick);
if (inner_size >= 1)
{
b = NewBlock(Clone(inner_data, inner_size), inner_size, compress_flag ? -1 : 0);
}
if (a->LastSetSrcIpAndPortTick < a->LastRecvYourTick)
{
a->LastSetSrcIpAndPortTick = a->LastRecvYourTick;
Copy(&a->YourIp, src_ip, sizeof(IP));
a->YourPort = src_port;
}
if (a->LastRecvMyTick != 0)
{
if ((a->LastRecvMyTick + (UINT64)(UDP_ACCELERATION_WINDOW_SIZE_MSEC)) >= a->Now)
{
a->LastRecvTick = a->Now;
a->IsReachedOnce = true;
if (a->FirstStableReceiveTick == 0)
{
a->FirstStableReceiveTick = a->Now;
}
}
}
return b;
}
