vector<float> calculateWeightsBjet(TString filenamedj)
{
cout<<"Calculating b-jet trigger weights"<<endl;
TFile *f0 = new TFile(filenamedj);
auto nt = (TTree *)f0->Get("nt");
int Njt80 = nt->GetEntries("triggermatched && hltCSV80");
int Njt80and60 = nt->GetEntries("triggermatched && hltCSV80 && hltCSV60");
vector<float> w = {(float)Njt80/Njt80and60, 1};
return w;
}
void updateweight(TString filename)
{
auto f = new TFile(filename,"update");
auto nt = (TTree *)f->Get("nt");
float prew, weight;
TBranch *bw;
bw = nt->Branch("weight",&weight);
nt->SetBranchAddress("prew",&prew);
int n = nt->GetEntries();
int onep = n/100;
for (int i=0;i<n;i++) {
if (i%onep==0) cout<<i/onep<<endl;
nt->GetEntry(i);
weight = prew;
bw->Fill();
}
nt->Write();
f->Close();
}
// Calo Matching -----------------------------------------
void HiForest::matchTrackCalo(bool allEvents){
if(allEvents || currentEvent == 0){
towerEt = new Float_t[maxEntry];
towerdR = new Float_t[maxEntry];
hbheEt = new Float_t[maxEntry];
hbhedR = new Float_t[maxEntry];
trackTree->Branch("towerEt",towerEt,"towerEt[nTrk]/F");
trackTree->Branch("towerdR",towerdR,"towerdR[nTrk]/F");
trackTree->Branch("hbhedR",hbheEt,"hbhedR[nTrk]/F");
trackTree->Branch("hbheEt",hbheEt,"hbheEt[nTrk]/F");
}
for (int i=0; allEvents ? i<GetEntries() : 1;i++){
if(allEvents) GetEntry(i);
for (int j=0;j<track.nTrk;j++) {
int matchedTower = getMatchedCaloTowerAllowReuse(j);
int matchedHBHE = getMatchedHBHEAllowReuse(j);
float matchedTowerdR = deltaR(track.trkEta[j],track.trkPhi[j],tower.eta[matchedTower],tower.phi[matchedTower]);
float matchedHbhedR = deltaR(track.trkEta[j],track.trkPhi[j],hbhe.eta[matchedHBHE],hbhe.phi[matchedHBHE]);
towerEt[j]=tower.et[matchedTower];
towerdR[j]=matchedTowerdR;
hbheEt[j]=hbhe.et[matchedHBHE];
hbhedR[j]=matchedHbhedR;
}
trackTree->Fill();
}
}
int GetEntries(void ** out, OctTreeNode *node, const Vector *coords, double radius) {
int count = 0;
Vector diff;
subVect(&diff, coords, &node->center);
if (lengthSquaredVect(&diff) > (node->radius+radius)*(node->radius+radius)) {
return 0;
}
if (!node->numVertices) {
if (diff.x < radius) {
if (diff.y < radius) {
if (node->children[0] && diff.z < radius) {
count += GetEntries(out, node->children[0], coords, radius);
}
if (node->children[4] && diff.z >= -radius) {
count += GetEntries(out+count, node->children[4], coords, radius);
}
}
if (diff.y >= -radius) {
if (node->children[2] && diff.z < radius) {
count += GetEntries(out+count, node->children[2], coords, radius);
}
if (node->children[6] && diff.z >= -radius) {
count += GetEntries(out+count, node->children[6], coords, radius);
}
}
}
if (diff.x >= -radius) {
if (diff.y < radius) {
if (node->children[1] && diff.z < radius) {
count += GetEntries(out+count, node->children[1], coords, radius);
}
if (node->children[5] && diff.z >= -radius) {
count += GetEntries(out+count, node->children[5], coords, radius);
}
}
if (diff.y >= -radius) {
if (node->children[3] && diff.z < radius) {
count += GetEntries(out+count, node->children[3], coords, radius);
}
if (node->children[7] && diff.z >= -radius) {
count += GetEntries(out+count, node->children[7], coords, radius);
}
}
}
return count;
}
else {
int i;
for (i=node->numVertices-1; i>=0; i--) {
out[i] = node->vertices[i];
}
return node->numVertices;
}
}
bool Menu_Delete(){
WPAD_Rumble(0,0);
self.rumbleAmt = 0;
struct discHdr *header = NULL;
char gameName[31];
/* No game list */
if (!self.gameCnt)
return false;
/* Selected game */
header = &self.gameList[self.gameSelected];
char title[MAX_TITLE_LEN];
if(self.usingTitlesTxt){
sprintf(title, "%s", header->title);
getTitle(titleList, (char*)header->id, title);
}
else
sprintf(title, "%s", (header->title));
if(strlen(title) < 30) {
sprintf(gameName, "%s", title);
}
else
{
strncpy(gameName, title, 27);
gameName[27] = '\0';
strncat(gameName, "...", 3);
}
//if(WindowPrompt(TX.askDelete, gameName, &yesButton, &noButton))
if(WindowPromptInstall((char*)header->id, gameName, TX.askDelete, &yesButton, &noButton, 1))
{
BUFFER_KillBuffer();
if(0 > WBFS_RemoveGame(header->id))
{
InitializeBuffer(self.gameList,self.gameCnt,BUFFER_WINDOW,COVER_COUNT/2.0 +self.shift,(settings.covers3d+settings.hq));
BUFFER_InitBuffer();
WindowPrompt(TX.errorDelete, TX.cantDelete, &okButton, 0);
}
else
{
GetEntries();
InitializeBuffer(self.gameList,self.gameCnt,BUFFER_WINDOW,COVER_COUNT/2.0 +self.shift,(settings.covers3d+settings.hq));
BUFFER_InitBuffer();
WindowPrompt(TX.successDelete, TX.pressOkContinue, &okButton, 0);
WBFS_DiskSpace(&self.usedSpace, &self.freeSpace);
return true;
}
}
return false;
}
char SyncLogger::getModDependingOnOtherEntries(const char* pszHash, const string strFilePath, const char chType) {
/* get the whole list with iterator */
list<SyncLogEntry> entrylist = GetEntries(pszHash, strFilePath);
list<SyncLogEntry>::iterator iter;
char modType = (char)0;
/* search for entries on given path and delete ALL... */
for (iter = entrylist.begin(); iter != entrylist.end(); iter++) {
SyncLogEntry sle = (SyncLogEntry)*iter;
if (sle == strFilePath) {
/* ... but store FIRST modification type */
if ((int)modType == 0)
modType = sle.GetModType();
RemoveEntry(pszHash, sle);
}
}
/* determine the correct modtype of the entry */
switch (modType) {
case 'c': //Not Exist
if (chType == 'c')
return 'c'; //c + c => c
else if (chType == 'm')
return 'c'; //c + m => c
else if (chType == 'd')
return 'x'; //c + d => none (nothing to do)
break;
case 'm': //Exist
if (chType == 'c')
return 'm'; //m + c => m
else if (chType == 'm')
return 'm'; //m + m => m
else if (chType == 'd')
return 'd'; //m + d => d
break;
case 'd': //Exist
if (chType == 'c')
return 'm'; //d + c => m
else if (chType == 'm')
return 'm'; //d + m => m
else if (chType == 'd')
return 'd'; //d + d => d
break;
default: //no earlier entry found
return chType; //return new entry type
}
return chType; //return unknown change type
}
HRESULT CLR_RT_HeapBlock_XmlNameTable::Grow()
{
TINYCLR_HEADER();
CLR_RT_HeapBlock_Array* oldEntries;
CLR_RT_HeapBlock newEntriesHB;
CLR_RT_HeapBlock_Array* newEntries;
CLR_RT_HeapBlock_XmlNameTable_Entry* entry;
CLR_RT_HeapBlock_XmlNameTable_Entry* next;
CLR_RT_HeapBlock* newEntryHB;
CLR_UINT32 i;
CLR_INT32 newIndex;
CLR_INT32 newMask;
newMask = GetMask() * 2 + 1;
// allocate a new instance of Entry array
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( newEntriesHB, newMask + 1, g_CLR_RT_WellKnownTypes.m_XmlNameTable_Entry ));
newEntries = newEntriesHB.DereferenceArray();
oldEntries = GetEntries();
// Go through the old buckets, and resort them
for(i = 0; i < oldEntries->m_numOfElements; i++)
{
entry = (CLR_RT_HeapBlock_XmlNameTable_Entry*)((CLR_RT_HeapBlock*)oldEntries->GetElement( i ))->Dereference();
while(entry != NULL)
{
newIndex = entry->GetHashCode() & newMask;
next = entry->GetNext();
newEntryHB = (CLR_RT_HeapBlock*)newEntries->GetElement( newIndex );
entry->SetNext( (CLR_RT_HeapBlock_XmlNameTable_Entry*)newEntryHB->Dereference() );
newEntryHB->SetObjectReference( entry );
entry = next;
}
}
SetEntries( newEntries );
SetMask ( newMask );
TINYCLR_NOCLEANUP();
}
int main() {
// MacOSX may generate connection to WindowServer errors
gROOT->SetBatch(kTRUE);
TString hsimpleLocation = gROOT->GetTutorialsDir();
hsimpleLocation+="/hsimple.root";
std::unique_ptr<TFile> fp(TFile::Open(hsimpleLocation));
TTree* tree;
fp->GetObject("ntuple",tree);
ROOT::TProcessExecutor pool(2);
auto res = pool.ProcTree(*tree, myMacro);
std::cout << res->GetEntries() << std::endl;
return 0;
}
void updatePbPbBtriggerweight(TString filename, vector<float> w)
{
auto f = new TFile(filename,"update");
auto nt = (TTree *)f->Get("nt");
float csv60, csv80;
float triggermatched;
float weight;
TBranch *bw;
bw = nt->Branch("weight",&weight);
nt->SetBranchAddress("hltCSV60",&csv60);
nt->SetBranchAddress("hltCSV80",&csv80);
nt->SetBranchAddress("triggermatched",&triggermatched);
int n = nt->GetEntries();
int onep = n/100;
for (int i=0;i<n;i++) {
if (i%onep==0) cout<<i/onep<<endl;
nt->GetEntry(i);
weight = 0;
if (triggermatched && csv80) weight = w[1];
if (triggermatched && csv60 && !csv80) weight = w[0];
bw->Fill();
}
nt->Write();
f->Close();
}
HRESULT CLR_RT_HeapBlock_XmlNameTable::AddEntry( CLR_RT_HeapBlock_String*& str, CLR_INT32 hashCode )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock newEntryHB;
CLR_RT_HeapBlock_XmlNameTable_Entry* newEntry;
CLR_RT_HeapBlock* entryHB;
CLR_INT32 count;
// create a new instance of the Entry object
TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( newEntryHB, g_CLR_RT_WellKnownTypes.m_XmlNameTable_Entry ));
newEntry = (CLR_RT_HeapBlock_XmlNameTable_Entry*)newEntryHB.Dereference();
// attach it to the front of the bucket
entryHB = (CLR_RT_HeapBlock*)GetEntries()->GetElement( GetMask() & hashCode );
newEntry->SetStr( str );
newEntry->SetHashCode( hashCode );
newEntry->SetNext( (CLR_RT_HeapBlock_XmlNameTable_Entry*)entryHB->Dereference() );
entryHB->SetObjectReference( newEntry );
count = GetCount() + 1;
SetCount( count );
// if we reach the threshold, we'll grow the buckets
if(count == GetMask())
{
Grow();
}
TINYCLR_NOCLEANUP();
}
{
double a =0;
double e = 0;
double sf = 1.;
TFile * f = 0;
TTree * t = 0;
f = TFile::Open("DYjets_M10to50_Summer12_final_4_4.root");
t = (TTree*)f->Get("rds_zbb");
cout<<f->GetName()<<"\t"<<t->GetEntries()*8.09254/sf<<" +/- "<<sqrt(t->GetEntries())*8.09254/sf<<endl;
a +=t->GetEntries()*8.09254/sf;
e+=t->GetEntries()*(8.09254/sf)*8.09254/sf;
f = TFile::Open("DYjets_Summer12_final_4_4.root");
t = (TTree*)f->Get("rds_zbb");
cout<<f->GetName()<<"\t"<<t->GetEntries()*2.40059<<" +/- "<<sqrt(t->GetEntries())*2.40059<<endl;
a+=t->GetEntries()*2.40059;
e+=t->GetEntries()*2.40059*2.40059;
f = TFile::Open("TTFullLept_Summer12_final_4_4.root");
t = (TTree*)f->Get("rds_zbb");
cout<<f->GetName()<<"\t"<<t->GetEntries()*0.0363674<<" +/- "<<sqrt(t->GetEntries())*0.0363674<<endl;
a+=t->GetEntries()*0.0363674;
e+=t->GetEntries()*0.0363674*0.0363674;
f = TFile::Open("TTSemiLept_Summer12_final_4_4.root");
t = (TTree*)f->Get("rds_zbb");
cout<<f->GetName()<<"\t"<<t->GetEntries()*0.0621829<<" +/- "<<sqrt(t->GetEntries())*0.0621829<<endl;
a+=t->GetEntries()*0.0621829;
e+=t->GetEntries()*0.0621829*0.0621829;
f = TFile::Open("Wtbar_Summer12_final_4_4.root");
t = (TTree*)f->Get("rds_zbb");
cout<<f->GetName()<<"\t"<<t->GetEntries()*0.410553<<" +/- "<<sqrt(t->GetEntries())*0.410553<<endl;
a+=t->GetEntries()*0.410553;
e+=t->GetEntries()*0.410553*0.410553;
MatchedBlockPair *FindBestSet (MatchedBlockPair *matches, int numMatches, MultipleAlignment *a1, MultipleAlignment *a2, ScoreData *s) {
Vector min, max = {0.0,0.0,0.0};
MemoryManagementInfo info = {0,0};
MatchedBlockPair **list = (MatchedBlockPair **) malloc(numMatches * sizeof(MatchedBlockPair *));
double displacementRange = s->displacement * 2;
int best = 0;
int i;
int pos;
OctTreeNode *trees = (OctTreeNode *) malloc(a2->numResidues * sizeof(OctTreeNode));
double maxBonus = MAX_BONUS;
double maxPosBonus = MAX_POS_BONUS;
if (!numMatches) return 0;
for (i=0; i<a1->numResidues; i++) {
/* Currently allow missing positions only in single-structure "alignments."
* May allow farther on or remove them altogether. Currently no benefit from
* not just removing residues with no alpha carbon coordinates.
*/
if (a1->numChains > 1 || a1->residues[0].res[i].exists) {
max = a1->averages[i++];
break;
}
}
min = max;
for (; i<a1->numResidues; i++) {
/* Safety check. */
if (a1->numChains == 1 && !a1->residues[0].res[i].exists) continue;
if (a1->averages[i].x < min.x) {
min.x = a1->averages[i].x;
}
else if (a1->averages[i].x > max.x) {
max.x = a1->averages[i].x;
}
if (a1->averages[i].y < min.y) {
min.y = a1->averages[i].y;
}
else if (a1->averages[i].y > max.y) {
max.y = a1->averages[i].y;
}
if (a1->averages[i].z < min.z) {
min.z = a1->averages[i].z;
}
else if (a1->averages[i].z > max.z) {
max.z = a1->averages[i].z;
}
}
for (i=0; i<a2->numResidues; i++) {
InitOctTreeNode(&trees[i], &min, &max);
}
for (i=0; i<numMatches; i++) {
Vector v, first;
MatchedBlockPair *match = &matches[i];
match->bestPreviousMatch = -1;
/* In this case, don't allow it to be added without a previous strand,
* unless it's the first strand.
*/
if (s->firstStrandLocked) {
if (i) {
match->bestAssembledScore = -5000;
}
else {
/* Otherwise, keep previous assembled score. Means I can
* just insert into old alignments without changing scores.
*/
match->bestAssembledScore -= match->score;
}
}
else
match->bestAssembledScore = 0;
transformVect(&first, &match->m, &a2->averages[match->p2]);
for (pos=4; pos<match->p2; pos++) {
int hits, j;
transformVect(&v, &match->m, &a2->averages[pos]);
hits = GetEntries((void**)list, &trees[pos], &v, displacementRange);
for (j=0; j < hits; j++) {
Vector v1, v2;
MatchedBlockPair *match2 = list[j];
double score, invCosHalfTest, angle, displacement;
if (match2->p1 + match2->len > match->p1) {
continue;
}
if (match2->p2 + match2->len > a2->conflictMap[match->p2][0]) {
if (match2->p2 + match2->len-1 == a2->conflictMap[match->p2][0] ||
a2->conflictMap[match->p2][match2->p2 + match2->len-1 - a2->conflictMap[match->p2][0]])
continue;
}
if (match2->p1 + match2->len > a1->conflictMap[match->p1][0]) {
if (match2->p1 + match2->len-1 == a1->conflictMap[match->p1][0] ||
a1->conflictMap[match->p1][match2->p1 + match2->len-1 - a1->conflictMap[match->p1][0]])
continue;
}
score = match2->bestAssembledScore;
if (score + maxBonus < match->bestAssembledScore) continue;
invCosHalfTest = invHalfCosQuat(&match->q, &match2->q);
if (invCosHalfTest < s->angleCos) continue;
angle = 0;
if (invCosHalfTest<1) angle = 2*acos(invCosHalfTest);
score += AngleScore(angle);
if (score + maxPosBonus < match->bestAssembledScore) continue;
subVect(&v1, &match2->last, &v);
transformVect(&v2, &match2->m, &a2->averages[match->p2]);
subVect(&v2, &first, &v2);
displacement = (lengthVect(&v1) + lengthVect(&v2))/2;
if (displacement > s->displacement) continue;
score += DisplacementScore(displacement);
if (score < match->bestAssembledScore) continue;
match->bestAssembledScore = (float) score;
match->bestPreviousMatch = (int)(match2 - matches);
}
}
if (match->bestAssembledScore < 0) continue;
match->bestAssembledScore += match->score;
if (match->bestAssembledScore > matches[best].bestAssembledScore)
best = i;
pos = match->p2 + match->len-1;
AddEntry(&trees[pos], &match->last, &info);
}
FreeAllMemory(&info);
free(trees);
free(list);
if (!s->lastStrandLocked)
return &matches[best];
else
return &matches[numMatches-1];
}
void GmtEfficiency::runEfficiency(int nEvents, std::string outFileName) {
system("mkdir -p results");
TFile *outFile = new TFile(std::string("results/" + outFileName + ".root").c_str() ,"recreate");
std::vector<EfficiencyPlotter *> plotters;
plotters.push_back(new EfficiencyPlotter(outFile,outFileName,"Pt16",16));
plotters.push_back(new EfficiencyPlotter(outFile,outFileName,"Pt20",20));
plotters.push_back(new EfficiencyPlotter(outFile,outFileName,"Pt25",25));
plotters.push_back(new EfficiencyPlotter(outFile,outFileName,"Pt30",30));
ControlPlotter *controlPlots = new ControlPlotter(outFile,outFileName,"ControlPlots");
int nevents = nEvents == 0 ? GetEntries() : nEvents;
std::cout << "File size is " << nevents << " events." << std::endl;
for (Long64_t event=0; event<nevents; ++event)
{
Long64_t eventEntry = LoadTree(event);
if (eventEntry < 0) break;
GetEntry(event);
if (event%50000 == 0)
std::cout << "Processed " << event << " events." << std::endl;
TriggeredMuons trigMuons(recoMuon_,gmt_);
trigMuons.findTightMuons(controlPlots) &&
trigMuons.findProbes() &&
trigMuons.runTriggerMatching(controlPlots);
triggeredMuonsIt trigMuonsIt = trigMuons.my_triggered_muons.begin();
triggeredMuonsIt trigMuonsEnd = trigMuons.my_triggered_muons.end();
for(;trigMuonsIt!=trigMuonsEnd;++trigMuonsIt)
{
std::vector<EfficiencyPlotter*>::const_iterator plotterIt = plotters.begin();
std::vector<EfficiencyPlotter*>::const_iterator plotterEnd = plotters.end();
for(;plotterIt!=plotterEnd;++plotterIt)
{
(*plotterIt)->fill(trigMuonsIt,(doreco ? recoVertex_ : 0));
}
}
} // end event loop
std::vector<EfficiencyPlotter*>::const_iterator plotterIt = plotters.begin();
std::vector<EfficiencyPlotter*>::const_iterator plotterEnd = plotters.end();
for(;plotterIt!=plotterEnd;++plotterIt)
{
(*plotterIt)->plotAndSave();
}
plotAndSaveAll(plotters,(outFileName + "/All").c_str(),"EffVsPt");
plotAndSaveAll(plotters,(outFileName + "/All").c_str(),"EffVsPtBarrel");
plotAndSaveAll(plotters,(outFileName + "/All").c_str(),"EffVsPtOverlap");
plotAndSaveAll(plotters,(outFileName + "/All").c_str(),"EffVsPtEndcap");
plotAndSaveAll(plotters,(outFileName + "/All").c_str(),"EffVsEta");
plotAndSaveAll(plotters,(outFileName + "/All").c_str(),"EffVsPhi");
controlPlots->plotAndSave();
outFile->Write();
}
BOOL SQLReadFileDSN( LPCSTR pszFileName,
LPCSTR pszAppName,
LPCSTR pszKeyName,
LPSTR pszString,
WORD nString,
WORD *pnString )
{
HINI hIni;
int nBufPos = 0;
char szValue[INI_MAX_PROPERTY_VALUE+1];
char szFileName[ODBC_FILENAME_MAX+1];
inst_logClear();
/* SANITY CHECKS */
if ( pszString == NULL || nString < 1 )
{
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL, ODBC_ERROR_INVALID_BUFF_LEN, "" );
return FALSE;
}
if ( pszFileName == NULL && pszAppName == NULL && pszKeyName == NULL )
{
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL, ODBC_ERROR_GENERAL_ERR, "" );
return FALSE;
}
if ( pszAppName == NULL && pszKeyName != NULL )
{
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL, ODBC_ERROR_INVALID_REQUEST_TYPE, "" );
return FALSE;
}
if ( pszFileName && strlen( pszFileName ) > ODBC_FILENAME_MAX ) {
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL, ODBC_ERROR_INVALID_PATH, "" );
return FALSE;
}
*pszString = '\0';
/*****************************************************
* GATHER ALL RELEVANT DSN INFORMATION INTO AN hIni
*****************************************************/
if ( pszFileName && pszFileName[0] == '/' )
{
strcpy( szFileName, pszFileName );
if ( strlen( szFileName ) < 4 || strcmp( szFileName + strlen( szFileName ) - 4, ".dsn" ))
{
strcat( szFileName, ".dsn" );
}
/* on OS/2 the file DSN is a text file */
#ifdef __OS2__
if ( iniOpen( &hIni, (char*)szFileName, "#;", '[', ']', '=', TRUE, 0L )
!= INI_SUCCESS )
#else
if ( iniOpen( &hIni, (char*)szFileName, "#;", '[', ']', '=', TRUE )
!= INI_SUCCESS )
#endif
{
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL,
ODBC_ERROR_INVALID_PATH, "" );
return FALSE;
}
}
else if ( pszFileName )
{
char szPath[ODBC_FILENAME_MAX+1];
*szPath = '\0';
_odbcinst_FileINI( szPath );
sprintf( szFileName, "%s/%s", szPath, pszFileName );
if ( strlen( szFileName ) < 4 || strcmp( szFileName + strlen( szFileName ) - 4, ".dsn" ))
{
strcat( szFileName, ".dsn" );
}
/* on OS/2 the file DSN is a text file */
#ifdef __OS2__
if ( iniOpen( &hIni, (char*) szFileName, "#;", '[', ']', '=', TRUE, 0L )
!= INI_SUCCESS )
#else
if ( iniOpen( &hIni, (char*) szFileName, "#;", '[', ']', '=', TRUE )
!= INI_SUCCESS )
#endif
{
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL,
ODBC_ERROR_INVALID_PATH, "" );
return FALSE;
}
}
if ( pszAppName == NULL && pszKeyName == NULL )
{
GetSections( hIni, pszString, nString );
}
else if ( pszAppName != NULL && pszKeyName == NULL )
{
GetEntries( hIni, pszAppName, pszString, nString );
}
else
{
/* TRY TO GET THE ONE ITEM MATCHING Section & Entry */
if ( iniPropertySeek( hIni, (char *)pszAppName, (char *)pszKeyName, "" ) != INI_SUCCESS )
{
inst_logPushMsg( __FILE__, __FILE__, __LINE__, LOG_CRITICAL,
ODBC_ERROR_REQUEST_FAILED, "" );
return FALSE;
}
else
{
iniValue( hIni, szValue );
strncpy( pszString, szValue, nString );
pszString[ nString - 1 ] = '\0';
nBufPos = strlen( szValue );
}
}
if ( pszFileName )
{
iniClose( hIni );
}
if ( pnString )
{
*pnString = strlen( pszString );
}
return TRUE;
}
// May Trigger GC if get is false, str, if not NULL, needs to be rooted prior to calling Add()
HRESULT CLR_RT_HeapBlock_XmlNameTable::Add( LPCSTR key, CLR_UINT32 length, CLR_RT_HeapBlock_String*& str, bool get )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock_XmlNameTable_Entry* entry;
CLR_RT_HeapBlock_String* match;
CLR_INT32 hashCode;
CLR_UINT32 i;
if(length == 0)
{
// if length is 0, return String.Empty
str = CLR_RT_HeapBlock_String::GetStringEmpty();
TINYCLR_SET_AND_LEAVE(S_OK);
}
// Calculating the hash code
hashCode = length + GetRandomizer();
for(i = 0; i < length; i++)
{
hashCode += (hashCode << 7) ^ key[ i ];
}
hashCode -= hashCode >> 17;
hashCode -= hashCode >> 11;
hashCode -= hashCode >> 5;
// Retrieve the entry (or entries) that hash to that bucket
entry = (CLR_RT_HeapBlock_XmlNameTable_Entry*)(((CLR_RT_HeapBlock*)GetEntries()->GetElement( hashCode & GetMask() ))->Dereference());
// Go through all the entries in the singly linked list to make sure there's no match
while(entry != NULL)
{
if(entry->GetHashCode() == hashCode)
{
match = entry->GetStr();
if((hal_strncmp_s( match->StringText(), key, length ) == 0) && (match->StringText()[ length ] == '\0'))
{
// if we find a match, we return the matched string
str = match;
TINYCLR_SET_AND_LEAVE(S_OK);
}
}
entry = entry->GetNext();
}
if(get)
{
// we're only getting, so return null if no string is found
str = NULL;
TINYCLR_SET_AND_LEAVE(S_OK);
}
else
{
// we'll re-use the String object if we were given one, if not, we'll create it here
if(str == NULL)
{
CLR_RT_HeapBlock strHB;
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance( strHB, key, length ));
str = strHB.DereferenceString();
// Attach the new string to the managed handle to prevent it from being GC when we allocate the Entry object in AddEntry()
SetTmp( str );
}
TINYCLR_SET_AND_LEAVE(AddEntry( str, hashCode ));
}
TINYCLR_NOCLEANUP();
}
void WaveHisto()
{
TFile *f = new TFile("WaterCherenkov.root","READ");
TTree *fTree = (TTree *)f->Get("fTree");
Int_t nrebin = 10;
Int_t NHits;
Int_t NPhotons;
Double_t Wavelength_nm[10000];
Double_t PlaneX_cm[10000];
Double_t PlaneY_cm[10000];
Double_t PlaneZ_cm[10000];
Double_t PrimePosX_cm;
Double_t PrimePosY_cm;
Double_t PrimePosZ_cm;
fTree->SetBranchAddress("fNHits",&NHits);
fTree->SetBranchAddress("fNPhotons",&NPhotons);
fTree->SetBranchAddress("fPlaneX_cm",PlaneX_cm);
fTree->SetBranchAddress("fPlaneY_cm",PlaneY_cm);
fTree->SetBranchAddress("fPlaneZ_cm",PlaneZ_cm);
fTree->SetBranchAddress("fPrimePosX_cm",&PrimePosX_cm);
fTree->SetBranchAddress("fPrimePosY_cm",&PrimePosY_cm);
fTree->SetBranchAddress("fPrimePosZ_cm",&PrimePosZ_cm);
fTree->SetBranchAddress("fWavelength_nm",Wavelength_nm);
// Histos
TH1D *Wavelength = new TH1D
("Wavelength","Wavelength", 100, 0, 1000);
TH1D *PlaneX = new TH1D
("X","X", 100, 0, 1000);
TH1D *PlaneY = new TH1D
("Y","Y", 100, 0, 1000);
TH1D *PlaneZ = new TH1D
("Z","Z", 100, 0, 1000);
// Fill
for(int i=0; i<fTree->GetEntries(); i++){
fTree->GetEntry(i);
double r = sqrt(PrimePosX_cm*PrimePosX_cm+PrimePosY_cm*PrimePosY_cm);
for(int j=0; j<fPlaneX_cm[]->GetEntries(); j++) {
// Fill tree with Plane Positions
PlaneX->Fill(PlaneX_cm);
}
for(int j=0; j<fPlaneY_cm[]->GetEntries(); j++) {
// Fill tree with Plane Positions
PlaneX->Fill(PlaneY_cm);
}
for(int j=0; j<fPlaneZ_cm[]->GetEntries(); j++) {
// Fill tree with Plane Positions
PlaneX->Fill(PlaneZ_cm);
}
}
}
void HiForest::fakeRejection(TTree *jetTree, Jets &jets, bool allEvents)
{
std::vector<TBranch *> branch;
branch.push_back(jetTree->Branch("fr01Chg", jets.fr01Chg,
"fr01Chg[nref]/F"));
branch.push_back(jetTree->Branch("fr01EM", jets.fr01EM,
"fr01EM[nref]/F"));
branch.push_back(jetTree->Branch("fr01", jets.fr01,
"fr01[nref]/F"));
for (int i = 0; i < (allEvents ? GetEntries() : 1); i++) {
if (allEvents) {
jetTree->GetEntry(i);
trackTree->GetEntry(i);
photonTree->GetEntry(i);
if (i % 1000 == 0) {
std::cout << i <<" / "<< GetEntries() << endl;
}
}
for (int j = 0; j < jets.nref; j++) {
float pseudorapidity_adapt = jets.jteta[j];
float azimuth_adapt = jets.jtphi[j];
float max_weighted_perp = 0;
float sum;
jets.fr01Chg[j] = 0;
jets.fr01EM[j] = 0;
// Unadapted discriminant with adaption search
sum = 0;
for (int k = 0; k < track.nTrk; k++) {
const float dpseudorapidity =
track.trkEta[k] - jets.jteta[j];
const float dazimuth =
deltaPhi(track.trkPhi[k], jets.jtphi[j]);
const float angular_weight =
exp(-50.0F * (dpseudorapidity * dpseudorapidity +
dazimuth * dazimuth));
const float weighted_perp =
angular_weight * track.trkPt[k] * track.trkPt[k];
const float weighted_perp_square =
weighted_perp * track.trkPt[k];
sum += weighted_perp_square;
if (weighted_perp >= max_weighted_perp) {
pseudorapidity_adapt = track.trkEta[k];
azimuth_adapt = track.trkPhi[k];
max_weighted_perp = weighted_perp;
}
}
jets.fr01Chg[j] = std::max(jets.fr01Chg[j], sum);
sum = 0;
for (int k = 0; k < photon.nPhotons; k++) {
const float dpseudorapidity =
photon.eta[k] - jets.jteta[j];
const float dazimuth =
deltaPhi(photon.phi[k], jets.jtphi[j]);
const float angular_weight =
exp(-50.0F * (dpseudorapidity * dpseudorapidity +
dazimuth * dazimuth));
const float weighted_perp =
angular_weight * photon.pt[k] * photon.pt[k];
const float weighted_perp_square =
weighted_perp * photon.pt[k];
sum += weighted_perp_square;
if (weighted_perp >= max_weighted_perp) {
pseudorapidity_adapt = photon.eta[k];
azimuth_adapt = photon.phi[k];
max_weighted_perp = weighted_perp;
}
}
jets.fr01EM[j] = std::max(jets.fr01EM[j], sum);
// (First order) adapted discriminant
sum = 0;
for (int k = 0; k < track.nTrk; k++) {
const float dpseudorapidity =
track.trkEta[k] - pseudorapidity_adapt;
const float dazimuth =
deltaPhi(track.trkPhi[k], azimuth_adapt);
const float angular_weight =
exp(-50.0F * (dpseudorapidity * dpseudorapidity +
dazimuth * dazimuth));
const float weighted_perp =
angular_weight * track.trkPt[k] * track.trkPt[k];
const float weighted_perp_square =
weighted_perp * track.trkPt[k];
sum += weighted_perp_square;
}
jets.fr01Chg[j] = std::max(jets.fr01Chg[j], sum);
sum = 0;
for (int k = 0; k < photon.nPhotons; k++) {
const float dpseudorapidity =
photon.eta[k] - jets.jteta[j];
const float dazimuth =
deltaPhi(photon.phi[k], jets.jtphi[j]);
const float angular_weight =
exp(-50.0F * (dpseudorapidity * dpseudorapidity +
dazimuth * dazimuth));
const float weighted_perp =
angular_weight * photon.pt[k] * photon.pt[k];
const float weighted_perp_square =
weighted_perp * photon.pt[k];
sum += weighted_perp_square;
if (weighted_perp >= max_weighted_perp) {
pseudorapidity_adapt = photon.eta[k];
azimuth_adapt = photon.phi[k];
max_weighted_perp = weighted_perp;
}
}
jets.fr01EM[j] = std::max(jets.fr01EM[j], sum);
// Combine charged track and ECAL energy (HCAL is too
// coarse for fake rejection purpose)
jets.fr01[j] = jets.fr01Chg[j] + jets.fr01EM[j];
}
for(std::vector<TBranch *>::const_iterator iterator =
branch.begin();
iterator != branch.end(); iterator++) {
(*iterator)->Fill();
}
}
}
void HiForest::correlateTracks(TTree* jetTree, Jets& jets, bool allEvents, bool smeared){
vector<TBranch*> branches(0);
if(allEvents || currentEvent == 0){
if(1){
jtChg = new Float_t[maxEntry];
jtNeut = new Float_t[maxEntry];
jtEM = new Float_t[maxEntry];
jtChgGen = new Float_t[maxEntry];
jtNeutGen = new Float_t[maxEntry];
jtEMGen = new Float_t[maxEntry];
jtPtMax = new Float_t[maxEntry];
jtPtMean = new Float_t[maxEntry];
jtPtMeanW = new Float_t[maxEntry];
jtLeadType = new Int_t[maxEntry];
}
tjDeltaEtaLead = new Float_t[maxEntryTrack];
tjDeltaPhiLead = new Float_t[maxEntryTrack];
zLead = new Float_t[maxEntryTrack];
tjDeltaEtaSubLead = new Float_t[maxEntryTrack];
tjDeltaPhiSubLead = new Float_t[maxEntryTrack];
zSubLead = new Float_t[maxEntryTrack];
zOldLead = new Float_t[maxEntryTrack];
zOldSubLead = new Float_t[maxEntryTrack];
zSingleLead = new Float_t[maxEntryTrack];
zLabLead = new Float_t[maxEntryTrack];
tjDeltaThetaLead = new Float_t[maxEntryTrack];
tjDeltaThetaLabLead = new Float_t[maxEntryTrack];
tjDeltaThetaSingleLead = new Float_t[maxEntryTrack];
zSingleSubLead = new Float_t[maxEntryTrack];
zLabSubLead = new Float_t[maxEntryTrack];
tjDeltaThetaSubLead = new Float_t[maxEntryTrack];
tjDeltaThetaLabSubLead = new Float_t[maxEntryTrack];
tjDeltaThetaSingleSubLead = new Float_t[maxEntryTrack];
corrLead = new Float_t[maxEntryTrack];
corrSubLead = new Float_t[maxEntryTrack];
branches.push_back(jetTree->Branch("jtChg",jtChg,"jtChg[nref]/F"));
branches.push_back(jetTree->Branch("jtNeut",jtNeut,"jtNeut[nref]/F"));
branches.push_back(jetTree->Branch("jtEM",jtEM,"jtEM[nref]/F"));
branches.push_back(jetTree->Branch("jtChgGen",jtChgGen,"jtChgGen[nref]/F"));
branches.push_back(jetTree->Branch("jtNeutGen",jtNeutGen,"jtNeutGen[nref]/F"));
branches.push_back(jetTree->Branch("jtEMGen",jtEMGen,"jtEMGen[nref]/F"));
branches.push_back(jetTree->Branch("jtPtMax",jtPtMax,"jtPtMax[nref]/F"));
branches.push_back(jetTree->Branch("jtPtMean",jtPtMean,"jtPtMean[nref]/F"));
branches.push_back(jetTree->Branch("jtPtMeanW",jtPtMeanW,"jtPtMeanW[nref]/F"));
branches.push_back(jetTree->Branch("jtLeadType",jtLeadType,"jtLeadType[nref]/I"));
branches.push_back(trackTree->Branch("tjDetaLead",tjDeltaEtaLead,"tjDetaLead[nTrk]/F"));
branches.push_back(trackTree->Branch("tjDphiLead",tjDeltaPhiLead,"tjDphiLead[nTrk]/F"));
branches.push_back(trackTree->Branch("zLead",zLead,"zLead[nTrk]/F"));
branches.push_back(trackTree->Branch("tjDetaSubLead",tjDeltaEtaSubLead,"tjDetaSubLead[nTrk]/F"));
branches.push_back(trackTree->Branch("tjDphiSubLead",tjDeltaPhiSubLead,"tjDphiSubLead[nTrk]/F"));
branches.push_back(trackTree->Branch("zSubLead",zSubLead,"zSubLead[nTrk]/F"));
branches.push_back(trackTree->Branch("zOldLead",zOldLead,"zOldLead[nTrk]/F"));
branches.push_back(trackTree->Branch("zOldSubLead",zOldSubLead,"zOldSubLead[nTrk]/F"));
branches.push_back(trackTree->Branch("zSingleLead",zSingleLead,"zSingleLead[nTrk]/F"));
branches.push_back(trackTree->Branch("zSingleSubLead",zSingleSubLead,"zSingleSubLead[nTrk]/F"));
branches.push_back(trackTree->Branch("zLabLead",zLabLead,"zLabLead[nTrk]/F"));
branches.push_back(trackTree->Branch("zLabSubLead",zSubLead,"zLabSubLead[nTrk]/F"));
branches.push_back(trackTree->Branch("tjDthetaLead",tjDeltaThetaLead,"tjDthetaLead[nTrk]/F"));
branches.push_back(trackTree->Branch("tjDthetaLabLead",tjDeltaThetaLabLead,"tjDthetaLabLead[nTrk]/F"));
branches.push_back(trackTree->Branch("tjDthetaSingleLead",tjDeltaThetaSingleLead,"tjDthetaSingleLead[nTrk]/F"));
branches.push_back(trackTree->Branch("tjDthetaSubLead",tjDeltaThetaSubLead,"tjDthetaSubLead[nTrk]/F"));
branches.push_back(trackTree->Branch("tjDthetaLabSubLead",tjDeltaThetaLabSubLead,"tjDthetaLabSubLead[nTrk]/F"));
branches.push_back(trackTree->Branch("tjDthetaSingleSubLead",tjDeltaThetaSingleSubLead,"tjDthetaSingleSubLead[nTrk]/F"));
branches.push_back(trackTree->Branch("corrLead",corrLead,"corrLead[nTrk]/F"));
branches.push_back(trackTree->Branch("corrSubLead",corrSubLead,"corrSubLead[nTrk]/F"));
jetTree->SetAlias("jtFracChg","jtChg/jtpt");
jetTree->SetAlias("jtFracNeut","jtNeut/jtpt");
jetTree->SetAlias("jtFracEM","jtFracEM/jtpt");
jetTree->SetAlias("refFracChg","jtChg/refpt");
jetTree->SetAlias("refFracNeut","jtNeut/refpt");
jetTree->SetAlias("refFracEM","jtFracEM/refpt");
jetTree->SetAlias("jtFracChgGen","jtChgGen/jtpt");
jetTree->SetAlias("jtFracNeutGen","jtNeutGen/refpt");
jetTree->SetAlias("jtFracEMGen","jtFracEMGen/refpt");
trackTree->SetAlias("tjDRlead","sqrt(tjDetaLead*tjDetaLead+tjDphiLead*tjDphiLead)");
trackTree->SetAlias("tjDRsublead","sqrt(tjDetaSubLead*tjDetaSubLead+tjDphiSubLead*tjDphiSubLead)");
}
double correctionFactors[4] = {0,0,0,0};
for (int i=0; allEvents ? i<GetEntries() : 1;i++){
if(i % 1000 == 0) cout<<"Processing Event : "<<i<<endl;
if(allEvents){
jetTree->GetEntry(i);
trackTree->GetEntry(i);
hltTree->GetEntry(i);
}
int cbin = evt.hiBin;
if(collisionMode == cPP) cbin = 33;
double eventEta = 0;
if(hasDiJet(jets)) eventEta = (jets.jteta[jtLead]+jets.jteta[jtSubLead])/2.;
for(int j = 0; j < jets.nref; ++j){
jtChg[j] = 0;
jtNeut[j] = 0;
jtEM[j] = 0;
jtPtMax[j] = 0;
jtPtMean[j] = 0;
jtPtMeanW[j] = 0;
jtLeadType[j] = 0;
for (int t = 0; t < track.nTrk; ++t) {
double jetPt = jets.jtpt[j];
if(smeared)jetPt = jets.smpt[j];
if(j == jtLead){
tjDeltaEtaLead[t] = track.trkEta[t] - jets.jteta[j];
tjDeltaPhiLead[t] = deltaPhi(track.trkPhi[t],jets.jtphi[j]);
zOldLead[t] = track.trkPt[t]/jetPt;
zLead[t] = getProjectedZ(jetPt,jets.jteta[j],jets.jtphi[j],track.trkPt[t],track.trkEta[t],track.trkPhi[t],eventEta);
// cout<<"jtpt : "<<jets.jtpt[j]<<" spt : "<<jets.smpt[j]<<endl;
corrLead[t] = trackCorrections[0]->GetCorr(track.trkPt[t],track.trkEta[t],jetPt,cbin,correctionFactors);
}
if(j == jtSubLead){
tjDeltaEtaSubLead[t] = track.trkEta[t] - jets.jteta[j];
tjDeltaPhiSubLead[t] = deltaPhi(track.trkPhi[t],jets.jtphi[j]);
zSubLead[t] = getProjectedZ(jetPt,jets.jteta[j],jets.jtphi[j],track.trkPt[t],track.trkEta[t],track.trkPhi[t],eventEta);
zOldSubLead[t] = track.trkPt[t]/jetPt;
corrSubLead[t] = trackCorrections[1]->GetCorr(track.trkPt[t],track.trkEta[t],jetPt,cbin,correctionFactors);
}
double dr = deltaR(track.trkEta[t],track.trkPhi[t],jets.jteta[j],jets.jtphi[j]);
if(dr > cone) continue;
if(jtPtMax[j] < track.trkPt[t]) jtPtMax[j] = track.trkPt[t];
jtChg[j] += track.trkPt[t];
}
}
for(unsigned int ib = 0; ib < branches.size(); ++ib){
branches[ib]->Fill();
}
}
return;
}
void HiForest::sortJets(TTree* jetTree, Jets& jets, double etaMax, double ptMin, bool allEvents, int smearType){
jetsmear::JetResolution* res = 0;
if(smearType==0){
res = new jetsmear::JetResolution();
}
vector<TBranch*> branches(0);
if(allEvents || currentEvent == 0){
branches.push_back(jetTree->Branch("Lead",&jtLead,"Lead/I"));
branches.push_back(jetTree->Branch("SubLead",&jtSubLead,"SubLead/I"));
branches.push_back(jetTree->Branch("HasDijet",&jtHasDijet,"HasDijet/O"));
branches.push_back(jetTree->Branch("HasLeadingJet",&jtHasLeadingJet,"HasLeadingJet/O"));
if(smearType==0 && !mc){
branches.push_back(jetTree->Branch("smpt",jets.smpt,"smpt[nref]/F"));
}
jetTree->SetAlias("AJ","(jtpt[Lead]-jtpt[SubLead])/(jtpt[Lead]+jtpt[SubLead])");
jetTree->SetAlias("dijetEta","(jteta[Lead]+jteta[SubLead])/2.");
}
vector<JetIndex> vecs;
vecs.reserve(maxEntry);
for (int i=0; allEvents ? i<GetEntries() : 1;i++){
if(verbose && i % 50000 == 0) cout<<"Processing Event : "<<i<<endl;
if(allEvents){
jetTree->GetEntry(i);
}
vecs.clear();
if(smearType == 0)res->roll();
for(int j = 0; j < jets.nref; ++j){
// if(jets.jtpt[j] < ptMin) continue;
if(fabs(jets.jteta[j]) > etaMax) continue;
JetIndex entry;
entry.pt = jets.jtpt[j];
entry.index = j;
if(smearType == 0){
entry.pt += res->getFluct(jets,j);
if(collisionMode == cPbPb && i>=0) cout<<"Flucted"<<endl;
jets.smpt[j] = entry.pt;
jets.jtpt[j] = entry.pt;
}
vecs.push_back(entry);
}
sort(vecs.begin(),vecs.end(),comparePt);
jtLead=-1;
jtSubLead=-1;
jtHasLeadingJet = 0;
jtHasDijet = 0;
if(vecs.size() > 0){
jtLead = vecs[0].index;
if(smearType == 0 && jets.smpt[jtLead] > 100) jtHasLeadingJet = 1;
if(smearType != 0 && jets.jtpt[jtLead] > 100) jtHasLeadingJet = 1;
}
if(vecs.size() > 1){
jtSubLead = vecs[1].index;
if(smearType == 0 &&jets.smpt[jtSubLead] > 40){
jtHasDijet = jtHasLeadingJet && fabs(deltaPhi(jets.jtphi[jtLead],jets.jtphi[jtSubLead])) > 2.*3.1415926/3.;
}
if(smearType != 0 && jets.jtpt[jtSubLead] > 40){
jtHasDijet = jtHasLeadingJet && fabs(deltaPhi(jets.jtphi[jtLead],jets.jtphi[jtSubLead])) > 2.*3.1415926/3.;
}
}
for(int ib = 0; ib < branches.size(); ++ib){
branches[ib]->Fill();
}
}
return;
}
Char_t *tr3 = "skimanalysis/HltTree";
Char_t *tr4 = "hltanalysis/HltTree";
//Char_t *tr5 = "hfrechits/hfTree";
//tree.AddFriend(tr2);
tree.AddFriend(tr3);
tree.AddFriend(tr4);
//tree.AddFriend(tr5);
Float_t hiHF, vz;
Float_t hiHFminus4, hiHFplus4;
Long_t Nevent;
Int_t Ntrack, n, pcollisionEventSelection, HLT_PAZeroBiasPixel_SingleTrack_v1, phltPixelClusterShapeFilter, phfPosFilter1, phfNegFilter1, pprimaryvertexFilter, pBeamScrapingFilter, pVertexFilterCutGplus;
Int_t Nskim=0;
Nevent=tree->GetEntries();
tree->SetBranchAddress("hiNtracks",&Ntrack);//number of tracks
tree->SetBranchAddress("hiHF",&hiHF);//HF energy
tree->SetBranchAddress("hiHFplusEta4",&hiHFplus4);//HF energy positive 4 to 5
tree->SetBranchAddress("hiHFminusEta4",&hiHFminus4);//HF energy negative -5 to -4
tree->SetBranchAddress("vz",&vz);
tree->SetBranchAddress("pcollisionEventSelection",&pcollisionEventSelection);
//tree->SetBranchAddress("n",&n);//HF hits
//tree->SetBranchAddress("HLT_PAZeroBiasPixel_SingleTrack_v1",&HLT_PAZeroBiasPixel_SingleTrack_v1);
//tree->SetBranchAddress("phltPixelClusterShapeFilter",&phltPixelClusterShapeFilter);
tree->SetBranchAddress("phfPosFilter3",&phfPosFilter1);
tree->SetBranchAddress("phfNegFilter3",&phfNegFilter1);
tree->SetBranchAddress("pprimaryVertexFilter",&pprimaryvertexFilter);
//tree->SetBranchAddress("pBeamScrapingFilter",&pBeamScrapingFilter);
//tree->SetBranchAddress("pVertexFilterCutGplus",&pVertexFilterCutGplus);
