void
PrintAlignment()
{
AliCDBManager* cdb = AliCDBManager::Instance();
cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
AliCDBEntry* align = cdb->Get("FMD/Align/Data");
if (!align) {
Error("PrintAlignment","didn't alignment data from CDB");
return;
}
TClonesArray* array = dynamic_cast<TClonesArray*>(align->GetObject());
if (!array) {
Warning("PrintAlignement", "Invalid align data from CDB");
return;
}
Int_t nAlign = array->GetEntries();
for (Int_t i = 0; i < nAlign; i++) {
AliAlignObjParams* a = static_cast<AliAlignObjParams*>(array->At(i));
Double_t ang[3];
Double_t trans[3];
a->GetAngles(ang);
a->GetTranslation(trans);
std::cout << a->GetVolPath() << "\n"
<< " translation: "
<< "(" << std::setw(12) << trans[0]
<< "," << std::setw(12) << trans[1]
<< "," << std::setw(12) << trans[2] << ")\n"
<< " rotation: "
<< "(" << std::setw(12) << ang[0]
<< "," << std::setw(12) << ang[1]
<< "," << std::setw(12) << ang[2] << ")" << std::endl;
// a->Print();
}
}
void tclwrite(Int_t split)
{
// Generate a Tree with a TClonesArray
// The array can be split or not
TFile f("tcl.root","recreate");
f.SetCompressionLevel(1); //try level 2 also
TTree T("T","test tcl");
TClonesArray *arr = new TClonesArray("TLine");
TClonesArray &ar = *arr;
T.Branch("tcl",&arr,256000,split);
//By default a TClonesArray is created with its BypassStreamer bit set.
//However, because TLine has a custom Streamer, this bit was reset
//by TTree::Branch above. We set again this bit because the current
//version of TLine uses the automatic Streamer.
//BypassingStreamer saves space and time.
arr->BypassStreamer();
for (Int_t ev=0;ev<10000;ev++) {
ar.Clear();
Int_t nlines = Int_t(gRandom->Gaus(50,10));
if(nlines < 0) nlines = 1;
for (Int_t i=0;i<nlines;i++) {
Float_t x1 = gRandom->Rndm();
Float_t y1 = gRandom->Rndm();
Float_t x2 = gRandom->Rndm();
Float_t y2 = gRandom->Rndm();
new(ar[i]) TLine(x1,y1,x2,y2);
}
T.Fill();
}
T.Print();
T.Write();
}
Int_t printDigits()
{
AliRunLoader *rl = AliRunLoader::Open("galice.root");
AliPHOSLoader *prl = (AliPHOSLoader*)rl->GetDetectorLoader("PHOS");
prl->LoadDigits("READ");
//prl->LoadDigits();
Int_t nDigits = 0;
Int_t nSimEvents = rl->GetNumberOfEvents();
for (Int_t ev = 0; ev < nSimEvents; ev++)
{
rl->GetEvent(ev);
Int_t nPhosDigits = prl->Digits()->GetEntries();
//Int_t nDigsFound = 0;
std::cout << "Number of digits found: " << nPhosDigits << std::endl;
TClonesArray *phosDigits = prl->Digits();
for (Int_t iDig = 0; iDig < nPhosDigits; iDig++)
{
//const AliPHOSDigit *digit = prl->Digit(iDig);
AliPHOSDigit *digit = (AliPHOSDigit*)phosDigits->At(iDig);
nDigits++;
//if(digit->GetTime() > 1.4e-08 && digit->GetTime() < 1.6e-08)
std::cout <<"#: " << iDig << " ID: " << digit->GetId() << " " << "Energy: " << digit->GetEnergy() << " Time: " << digit->GetTime() << " N_prim: " << digit->GetNprimary() << " " << digit->GetTimeR() << std::endl;
}
}
return 0;
}
void decayAndFill(int const kf, TLorentzVector* b, double const weight, TClonesArray& daughters)
{
pydecay->Decay(kf, b);
pydecay->ImportParticles(&daughters);
TLorentzVector p1Mom;
TLorentzVector p2Mom;
TVector3 v00;
int nTrk = daughters.GetEntriesFast();
for (int iTrk = 0; iTrk < nTrk; ++iTrk)
{
TParticle* ptl0 = (TParticle*)daughters.At(iTrk);
switch (ptl0->GetPdgCode())
{
//Will only have pions
case 211:
ptl0->Momentum(p1Mom);
v00.SetXYZ(ptl0->Vx() * 1000., ptl0->Vy() * 1000., ptl0->Vz() * 1000.); // converted to μm
break;
case -211:
ptl0->Momentum(p2Mom);
break;
default:
break;
}
}
daughters.Clear();
fill(kf, b, weight, p1Mom, p2Mom, v00);
}
void MakeSTRUCTZeroMisAlignment(){
// Create TClonesArray of zero misalignment objects for all STRUCTures
// (presently this includes only FRAME)
//
const char* macroname = "MakeSTRUCTZeroMisAlignment.C";
TClonesArray *array = new TClonesArray("IlcAlignObjParams",20);
Int_t iIndex=0; //let all modules have index=0 in a layer with no LUT
IlcGeomManager::ELayerID iLayer = IlcGeomManager::kInvalidLayer;
UShort_t dvoluid = IlcGeomManager::LayerToVolUID(iLayer,iIndex); //dummy vol id
const char* basepath ="ILCM_1/B077_1/BSEGMO";
TString segmpath;
for(Int_t sm=0; sm<18; sm++){
segmpath=basepath;
segmpath+=sm;
segmpath+="_1";
cout<<segmpath.Data()<<endl;
new((*array)[sm]) IlcAlignObjParams(segmpath.Data(),dvoluid,0.,0.,0.,0.,0.,0.,kTRUE);
}
if( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ){
// save on file
const char* filename = "STRUCTzeroMisalignment.root";
TFile f(filename,"RECREATE");
if(!f){
Error(macroname,"cannot open file for output\n");
return;
}
Info(macroname,"Saving alignment objects in %s", filename);
f.cd();
f.WriteObject(array,"STRUCTAlignObjs","kSingleKey");
f.Close();
}else{
// save in CDB storage
TString Storage = gSystem->Getenv("STORAGE");
if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
return;
}
Info(macroname,"Saving alignment objects in CDB storage %s",Storage.Data());
IlcCDBManager* cdb = IlcCDBManager::Instance();
IlcCDBStorage* storage = cdb->GetStorage(Storage.Data());
if(!storage){
Error(macroname,"Unable to open storage %s\n",Storage.Data());
return;
}
IlcCDBMetaData* md = new IlcCDBMetaData();
md->SetResponsible("Grosso Raffaele");
md->SetComment("Zero misalignment for STRUCT: presently includes objects for FRAME");
md->SetIlcRootVersion(gSystem->Getenv("ARVERSION"));
IlcCDBId id("GRP/Align/Data",0,IlcCDBRunRange::Infinity());
storage->Put(array,id,md);
}
array->Delete();
}
void UEAnalysisMPI::mpiAnalysisMC(Float_t weight,Float_t etaRegion,Float_t ptThreshold, TClonesArray& ChargedJet)
{
std::vector<TLorentzVector*> JetMC;
JetMC.clear();
for(int j=0;j<ChargedJet.GetSize();++j){
TLorentzVector *v = (TLorentzVector*)ChargedJet.At(j);
if(fabs(v->Eta())<etaRegion){
JetMC.push_back(v);
}
}
std::vector<AssociatedObject> assoJetMC;
assoJetMC.clear();
while(JetMC.size()>1){
int oldSize = JetMC.size();
std::vector<TLorentzVector*>::iterator itH = JetMC.begin();
if((*itH)->Pt()>=ptThreshold){
for(std::vector<TLorentzVector*>::iterator it=JetMC.begin();it!=JetMC.end();it++){
float azimuthDistanceJet = fabs( (*itH)->Phi() - (*it)->Phi() );
if((*it)->Pt()/(*itH)->Pt()>=0.3){
if( (piG - rangePhi) < azimuthDistanceJet && azimuthDistanceJet < (piG + rangePhi)) {
AssociatedObject tmpPair((*itH),(*it));
assoJetMC.push_back(tmpPair);
JetMC.erase(it);
int newSize = oldSize -1;
oldSize = newSize;
JetMC.resize(newSize);
break;
}
}
}
}
JetMC.erase(itH);
int newSize = oldSize -1;
JetMC.resize(newSize);
}
if(assoJetMC.size()){
fNumbMPIMC->Fill(assoJetMC.size());
std::vector<AssociatedObject>::iterator at= assoJetMC.begin();
const TLorentzVector* leadingJet((*at).first);
const TLorentzVector* secondJet((*at).second);
pPtRatio_vs_PtJleadMC->Fill(leadingJet->Pt(),(secondJet->Pt()/leadingJet->Pt()));
pPtRatio_vs_EtaJleadMC->Fill(fabs(leadingJet->Eta()),(secondJet->Pt()/leadingJet->Pt()));
pPtRatio_vs_PhiJleadMC->Fill(leadingJet->Phi(),(secondJet->Pt()/leadingJet->Pt()));
fdEtaLeadingPairMC->Fill(leadingJet->Eta()-secondJet->Eta());
float dPhiJet = fabs(leadingJet->Phi()-secondJet->Phi());
if(dPhiJet> piG) dPhiJet = 2*piG -dPhiJet;
dPhiJet = (180*dPhiJet)/piG;
fdPhiLeadingPairMC->Fill(dPhiJet);
fptRatioLeadingPairMC->Fill(secondJet->Pt()/leadingJet->Pt());
}
}
void analyzer()
{
TString processName = "ZJets";
TFile* f = TFile::Open(Form("hist_%s.root", processName.Data()), "recreate");
// Create chain of root trees
TChain chain("DelphesMA5tune");
//kisti
//chain.Add("/cms/home/tjkim/fcnc/sample/ZToLL50-0Jet_sm-no_masses/events_*.root");
//hep
chain.Add("/Users/tjkim/Work/fcnc/samples/ZToLL50-0Jet_sm-no_masses/events_*.root");
// Create object of class ExRootTreeReader
ExRootTreeReader *treeReader = new ExRootTreeReader(&chain);
Long64_t numberOfEntries = treeReader->GetEntries();
// Get pointers to branches used in this analysis
TClonesArray *branchMuon = treeReader->UseBranch("DelphesMA5tuneMuon");
// Book histograms
TH1 *histDiMuonMass = new TH1F("dimuon_mass","Di-Muon Invariant Mass (GeV)",100, 50, 150);
// Loop over all events
for(Int_t entry = 0; entry < numberOfEntries; ++entry)
{
// Load selected branches with data from specified event
treeReader->ReadEntry(entry);
int nmuon = 0;
for( int i = 0; i < branchMuon->GetEntries(); i++)
{
Muon *muon = (Muon*) branchMuon->At(i);
if( muon->PT <= 20 || abs(muon->Eta) >= 2.4 ) continue;
nmuon = nmuon + 1 ;
}
if( nmuon >= 2){
Muon *mu1 = (Muon*) branchMuon->At(0);
Muon *mu2 = (Muon*) branchMuon->At(1);
// Plot di-muon invariant mass
histDiMuonMass->Fill(((mu1->P4()) + (mu2->P4())).M());
}
}
// Show resulting histograms
histDiMuonMass->Write();
f->Close();
}
//_____________________________________________________________________________
void THaVDC::CorrectTimeOfFlight(TClonesArray& tracks)
{
const static Double_t v = 3.0e-8; // for now, assume that everything travels at c
// get scintillator planes
THaScintillator* s1 = static_cast<THaScintillator*>
( GetApparatus()->GetDetector("s1") );
THaScintillator* s2 = static_cast<THaScintillator*>
( GetApparatus()->GetDetector("s2") );
if( (s1 == NULL) || (s2 == NULL) )
return;
// adjusts caluculated times so that the time of flight to S1
// is the same as a track going through the middle of the VDC
// (i.e. x_det = 0) at a 45 deg angle (theta_t and phi_t = 0)
// assumes that at least the coarse tracking has been performed
Int_t n_exist = tracks.GetLast()+1;
//cerr<<"num tracks: "<<n_exist<<endl;
for( Int_t t = 0; t < n_exist; t++ ) {
THaTrack* track = static_cast<THaTrack*>( tracks.At(t) );
// calculate the correction, since it's on a per track basis
Double_t s1_dist, vdc_dist, dist, tdelta;
if(!s1->CalcPathLen(track, s1_dist))
s1_dist = 0.0;
if(!CalcPathLen(track, vdc_dist))
vdc_dist = 0.0;
// since the z=0 of the transport coords is inclined with respect
// to the VDC plane, the VDC correction depends on the location of
// the track
if( track->GetX() < 0 )
dist = s1_dist + vdc_dist;
else
dist = s1_dist - vdc_dist;
tdelta = ( fCentralDist - dist) / v;
//cout<<"time correction: "<<tdelta<<endl;
// apply the correction
Int_t n_clust = track->GetNclusters();
for( Int_t i = 0; i < n_clust; i++ ) {
THaVDCUVTrack* the_uvtrack =
static_cast<THaVDCUVTrack*>( track->GetCluster(i) );
if( !the_uvtrack )
continue;
//FIXME: clusters guaranteed to be nonzero?
the_uvtrack->GetUCluster()->SetTimeCorrection(tdelta);
the_uvtrack->GetVCluster()->SetTimeCorrection(tdelta);
}
}
}
bool
convertEvtToTree(const string& evtFileName = "testEvents.evt",
const string& outFileName = "testEvents.root",
const long int maxNmbEvents = -1,
const string& outTreeName = "rootPwaEvtTree",
const string& prodKinPartNamesObjName = "prodKinParticles",
const string& prodKinMomentaLeafName = "prodKinMomenta",
const string& decayKinPartNamesObjName = "decayKinParticles",
const string& decayKinMomentaLeafName = "decayKinMomenta",
const bool debug = false)
{
// open input file
printInfo << "opening input file '" << evtFileName << "'" << endl;
ifstream evtFile(evtFileName.c_str());
if (not evtFile or not evtFile.good()) {
printWarn << "cannot open input file '" << evtFileName << "'" << endl;
return false;
}
// create output file
printInfo << "creating output file '" << outFileName << "'" << endl;
TFile* outFile = TFile::Open(outFileName.c_str(), "RECREATE");
if (not outFile) {
printErr << "cannot open output file '" << outFileName << "'" << endl;
return false;
}
// create tree
TTree* tree = new TTree(outTreeName.c_str(), outTreeName.c_str());
if (not tree) {
printErr << "problems creating tree '" << outTreeName << "' "
<< "in file '" << outFileName << "'" << endl;
return false;
}
// doit
TClonesArray* prodKinPartNames = new TClonesArray("TObjString");
TClonesArray* decayKinPartNames = new TClonesArray("TObjString");
const bool success = fillTreeFromEvt(evtFile, *tree,
*prodKinPartNames, *decayKinPartNames,
maxNmbEvents,
prodKinMomentaLeafName, decayKinMomentaLeafName,
debug);
tree->Write();
prodKinPartNames->Write (prodKinPartNamesObjName.c_str (), TObject::kSingleKey);
decayKinPartNames->Write(decayKinPartNamesObjName.c_str(), TObject::kSingleKey);
outFile->Close();
if (success)
printSucc << "wrote events to file '" << outFileName << "'" << endl;
else
printWarn << "problems processing events" << endl;
return success;
}
//______________________________________________________________________________
void alice_esd_read()
{
// Read tracks and associated clusters from current event.
AliESDRun *esdrun = (AliESDRun*) esd->fESDObjects->FindObject("AliESDRun");
TClonesArray *tracks = (TClonesArray*) esd->fESDObjects->FindObject("Tracks");
// This needs further investigation. Clusters not shown.
// AliESDfriend *frnd = (AliESDfriend*) esd->fESDObjects->FindObject("AliESDfriend");
// printf("Friend %p, n_tracks:%d\n", frnd, frnd->fTracks.GetEntries());
if (track_list == 0) {
track_list = new TEveTrackList("ESD Tracks");
track_list->SetMainColor(6);
//track_list->SetLineWidth(2);
track_list->SetMarkerColor(kYellow);
track_list->SetMarkerStyle(4);
track_list->SetMarkerSize(0.5);
gEve->AddElement(track_list);
}
TEveTrackPropagator* trkProp = track_list->GetPropagator();
trkProp->SetMagField( 0.1 * esdrun->fMagneticField ); // kGaus to Tesla
gProgress->Reset();
gProgress->SetMax(tracks->GetEntriesFast());
for (Int_t n=0; n<tracks->GetEntriesFast(); ++n)
{
AliESDtrack* at = (AliESDtrack*) tracks->At(n);
// If ITS refit failed, take track parameters at inner TPC radius.
AliExternalTrackParam* tp = at;
if (! trackIsOn(at, kITSrefit)) {
tp = at->fIp;
}
TEveTrack* track = esd_make_track(trkProp, n, at, tp);
track->SetAttLineAttMarker(track_list);
track_list->AddElement(track);
// This needs further investigation. Clusters not shown.
// if (frnd)
// {
// AliESDfriendTrack* ft = (AliESDfriendTrack*) frnd->fTracks->At(n);
// printf("%d friend = %p\n", ft);
// }
gProgress->Increment(1);
}
track_list->MakeTracks();
}
//_____________________________________________________________________________
Int_t THaVDC::FindVertices( TClonesArray& tracks )
{
// Calculate the target location and momentum at the target.
// Assumes that CoarseTrack() and FineTrack() have both been called.
Int_t n_exist = tracks.GetLast()+1;
for( Int_t t = 0; t < n_exist; t++ ) {
THaTrack* theTrack = static_cast<THaTrack*>( tracks.At(t) );
CalcTargetCoords(theTrack, kRotatingTransport);
}
return 0;
}
void testTDime(Int_t nev = 100) {
gSystem->Load("libEVGEN");
gSystem->Load("libTDime");
gSystem->Load("libdime");
TDime* dime = new TDime();
dime->SetEnergyCMS(7000.0);
dime->SetYRange(-2.0, 2.0); // Set rapidity range of mesons
dime->SetMinPt(0.1); // Minimum pT of mesons
dime->Initialize();
// (pi+pi-) histograms
TH1* hM = new TH1D("hM", "DIME #pi^{+}#pi^{-};M_{#pi^{+}#pi^{-}} #[]{GeV/#it{c}^{2}}", 100, 0.0, 5.0);
TClonesArray* particles = new TClonesArray("TParticle", 6);
TParticle* part = NULL;
TLorentzVector v[2];
TLorentzVector vSum;
// Event loop
for (Int_t i = 0; i < nev; ++i) {
dime->GenerateEvent();
Int_t np = dime->ImportParticles(particles, "All");
printf("\n DIME Event %d: Imported %3d particles \n", i, np);
Int_t nPrimary = 0;
// Loop over pion (j = 4,5) tracks
for (Int_t j = 4; j < 6; ++j) {
part = (TParticle*) particles->At(j); // Choose the particle
part->Print();
part->Momentum(v[nPrimary]); // Copy content to v
nPrimary++;
}
//particles.Clear();
// 4-vector sum
vSum = v[0] + v[1];
// Fill pi+pi- histograms
hM->Fill(vSum.M());
}
// Save plots as pdf
hM->Draw(); c1->SaveAs("massTDime.pdf");
}
addObjectDuringAODCreation() {
// add an object to an aod and write it
TFile *aodFile = TFile::Open("addAOD.root", "RECREATE");
// create an IlcAOD object
IlcAODEvent *aod = new IlcAODEvent();
aod->CreateStdContent();
// add new information, we use IlcESDtracks for now
TClonesArray *tracks = new TClonesArray("IlcESDtrack", 0);
aod->AddObject(tracks);
// go to the file
aodFile->cd();
// create the tree
TTree *aodTree = new TTree("aodTree", "IlcAOD tree");
aodTree->Branch(aod->GetList());
for (Int_t iEvent = 0; iEvent < 10; ++iEvent) {
// add (part of) standard information
IlcAODHeader *header = aod->GetHeader();
tracks->Delete(); // delete old objects
tracks->Expand(iEvent+5/* just to make it a different number each time*/); // expand container (just for speed)
// fill TClonesArray
TClonesArray &rTracks = *tracks;
for (Int_t i = 0; i< iEvent+5; i++) {
new(rTracks[i]) IlcESDtrack();
}
// fill the tree for this event
aodTree->Fill();
} // end of event loop
aodTree->GetUserInfo()->Add(aod);
// write the tree to the specified file
aodFile = aodTree->GetCurrentFile();
aodFile->cd();
aodTree->Write();
}
//_____________________________________________________________________________
Int_t THaReacPointFoil::Process( const THaEvData& )
{
// Calculate the vertex coordinates.
if( !IsOK() ) return -1;
Int_t ntracks = fSpectro->GetNTracks();
if( ntracks == 0 ) return 0;
TClonesArray* tracks = fSpectro->GetTracks();
if( !tracks ) return -2;
TVector3 beam_org, beam_ray( 0.0, 0.0, 1.0 );
if( fBeam ) {
beam_org = fBeam->GetPosition();
beam_ray = fBeam->GetDirection();
}
static const TVector3 yax( 0.0, 1.0, 0.0 );
static const TVector3 xax( 1.0, 0.0, 0.0 );
TVector3 org, v;
Double_t t;
for( Int_t i = 0; i<ntracks; i++ ) {
THaTrack* theTrack = static_cast<THaTrack*>( tracks->At(i) );
// Ignore junk tracks
if( !theTrack || !theTrack->HasTarget() )
continue;
org.SetX( 0. );
org.SetZ( 0. );
org.SetY( 0. );
if( !IntersectPlaneWithRay( xax, yax, org,
beam_org, beam_ray, t, v ))
continue; // Oops, track and beam parallel?
theTrack->SetVertex(v);
// FIXME: preliminary
if( theTrack == fSpectro->GetGoldenTrack() ) {
fVertex = theTrack->GetVertex();
fVertexOK = kTRUE;
}
// FIXME: calculate vertex coordinate errors here (need beam errors)
}
return 0;
}
int saModuleDimuonDYDarshana::GetNumberofTracklets(DSTReader *fvtx_trk_map, const DiMuon *dimuon)
{
if(!fvtx_trk_map){
cout<<"EXCEPTION: "<<PHWHERE<<endl;
return NULL;
}
int ntrklets = 0;
TClonesArray *array = fvtx_trk_map->get_FvtxCompactTrk();
for (int i = 0; i < array->GetSize(); i++) {
TFvtxCompactTrk *tracklet = dynamic_cast<TFvtxCompactTrk*> (array->At(i));
if(!tracklet){
//cout<<"No tracklet"<<__LINE__<<"size: "<<array->GetSize()<<endl;
break;
}
if(_use_cut_tracklet_chi2 && (tracklet->get_chi2_ndf() > _cut_tracklet_chi2)) continue;
if(!_use_2_hit_tracklet && tracklet->get_nhits() <= 2) continue;
SingleMuon *muon0 = singlemuoncontainer->get_SingleMuon(0);
SingleMuon *muon1 = singlemuoncontainer->get_SingleMuon(1);
float xx0 = tracklet->get_fvtx_vtx().getX()-(tracklet->get_fvtx_vtx().getZ()- dimuons->get_Evt_fvtxZ())*
tan(tracklet->get_fvtx_theta())*cos(tracklet->get_fvtx_phi());
float yy0 = tracklet->get_fvtx_vtx().getY()-(tracklet->get_fvtx_vtx().getZ()- dimuons->get_Evt_fvtxZ())*
tan(tracklet->get_fvtx_theta())*sin(tracklet->get_fvtx_phi());
float x0y0=sqrt((xx0 - dimuons->get_Evt_fvtxX())*(xx0 - dimuons->get_Evt_fvtxX()) +
(yy0 - dimuons->get_Evt_fvtxY())*(yy0 - dimuons->get_Evt_fvtxY()));
if (fabs(TMath::ATan2(sqrt(muon0->get_px_fvtxmutr()*muon0->get_px_fvtxmutr()+
muon0->get_py_fvtxmutr()*muon0->get_py_fvtxmutr()),muon0->get_pz_fvtxmutr())-
tracklet->get_fvtx_theta()) >0.001 && fabs(TMath::ATan2(sqrt(muon1->get_px_fvtxmutr()*
muon1->get_px_fvtxmutr()+muon1->get_py_fvtxmutr()*muon1->get_py_fvtxmutr()),
muon1->get_pz_fvtxmutr())-tracklet->get_fvtx_theta()) >0.001 && fabs(TMath::ATan2(muon0->get_py_fvtxmutr(),
muon0->get_px_fvtxmutr())-tracklet->get_fvtx_phi())>0.001 && fabs(TMath::ATan2(muon1->get_py_fvtxmutr(),
muon1->get_px_fvtxmutr())-tracklet->get_fvtx_phi())>0.001 && tracklet->get_fvtx_theta()+0!=0 &&
x0y0 < 1.5){
ntrklets++;
}
}
return ntrklets;
}
int main(int argc, char* argv[])
{
//Upload the file with the data
TFile* file = TFile::Open("/Users/Fer/Documents/traajo/samples/NeroNtuples_9.root"); // TFile::Open() instead of a constructor since it works over xrootd etc.
//Upload the tree with the event data
TTree *tree=(TTree*)file->Get("nero/events");
//Create the vector to store all the particle identifiers
std::vector<Int_t> * lepPdgId;
//Create a variable to store all the lepton event data
TClonesArray *leptondata = new TClonesArray("leptondata");
//Specify where all the lepton event data will be stores
tree->SetBranchAddress("lepP4", &leptondata);
//Specify where all the lepton identifiers will be stored
tree->SetBranchAddress("lepPdgId", &lepPdgId);
//Get how many events we have to loop through
int nentries = tree->GetEntries();
//Loop through all the events
for(int ientry = 0; ientry < nentries; ientry++)
{
//Reset the lepton data
leptondata->Clear();
//This line stores the proper data both in "leptondata" and in "lepPdgId"
tree->GetEntry(ientry);
//Only if "leptondata" is not empty continue, this is to avoid segmentation errors
if(leptondata->GetSize() == 0) continue;
//Loop through all the entries in the current event
for(int j=0; j<leptondata->GetEntriesFast()-1; j++)
{
//Only if the identifier of the particle is + or - 11 (electron or antielectron) store the data in electrondata
if(abs(lepPdgId->at(j))==11) continue;
//Store all the data of the electron in this variable
TLorentzVector *electrondata = (TLorentzVector *)leptondata->At(j);
//Get some specific property such as momentum, position or energy
cout << electrondata->E() << endl;
}
}
return 0;
}
void AnalyseEvents(ExRootTreeReader *treeReader, MyPlots *plots)
{
TClonesArray *branchJet = treeReader->UseBranch("Jet");
TClonesArray *branchElectron = treeReader->UseBranch("Electron");
TClonesArray *branchMissingET = treeReader->UseBranch("MissingET");
Long64_t allEntries = treeReader->GetEntries();
cout << "** Chain contains " << allEntries << " events" << endl;
Jet *jet[2];
MissingET *met;
Electron *electron;
Long64_t entry;
Int_t i;
// Loop over all events
for(entry = 0; entry < allEntries; ++entry)
{
// Load selected branches with data from specified event
treeReader->ReadEntry(entry);
// Analyse two leading jets
if(branchJet->GetEntriesFast() >= 2)
{
jet[0] = (Jet*) branchJet->At(0);
jet[1] = (Jet*) branchJet->At(1);
plots->fJetPT[0]->Fill(jet[0]->PT);
plots->fJetPT[1]->Fill(jet[1]->PT);
}
// Analyse missing ET
if(branchMissingET->GetEntriesFast() > 0)
{
met = (MissingET*) branchMissingET->At(0);
plots->fMissingET->Fill(met->MET);
}
// Loop over all electrons in event
for(i = 0; i < branchElectron->GetEntriesFast(); ++i)
{
electron = (Electron*) branchElectron->At(i);
plots->fElectronPT->Fill(electron->PT);
}
}
}
void LHCOWriter::AnalyseEvent()
{
Event *element;
element = static_cast<Event*>(fBranchEvent->At(0));
fprintf(fOutputFile, "%4d %13lld %8d\n", 0, element->Number, 0);
++fIntParam[0];
}
void digitsTOF(Int_t nevents, Int_t nfiles){
TH1F *hadc = new TH1F("hadc","ADC [bin]",200, -100., 10000.);
TH1F *hadclog = new TH1F("hadclog","ADC [bin]",200, -1., 7.);
TTree *treeD=0x0;
TClonesArray *digits =0x0;
for (Int_t event=0; event<nevents; event++) {
cout << "Event " << event << endl;
treeD = GetTreeD(event, "TOF", nfiles);
if ( ! treeD ) {
cerr << "Event directory not found in " << nfiles << " files" << endl;
exit(1);
}
digits = NULL;
treeD->SetBranchAddress("TOF", &digits);
for(Int_t iev=0; iev<treeD->GetEntries(); iev++){
treeD->GetEntry(iev);
for (Int_t j = 0; j < digits->GetEntries(); j++) {
IlcTOFdigit* dig = dynamic_cast<IlcTOFdigit*> (digits->At(j));
hadc->Fill(dig->GetAdc());
if(dig->GetAdc()>0)hadclog->Fill(TMath::Log10(dig->GetAdc()));
}
}
}
TFile fc("digits.TOF.root","RECREATE");
fc.cd();
hadc->Write();
hadclog->Write();
fc.Close();
}
//_____________________________________________________________________________
void THaVDC::FindBadTracks(TClonesArray& tracks)
{
// Flag tracks that don't intercept S2 scintillator as bad
THaScintillator* s2 = static_cast<THaScintillator*>
( GetApparatus()->GetDetector("s2") );
if(s2 == NULL) {
//cerr<<"Could not find s2 plane!!"<<endl;
return;
}
Int_t n_exist = tracks.GetLast()+1;
for( Int_t t = 0; t < n_exist; t++ ) {
THaTrack* track = static_cast<THaTrack*>( tracks.At(t) );
Double_t x2, y2;
// project the current x and y positions into the s2 plane
if(!s2->CalcInterceptCoords(track, x2, y2)) {
x2 = 0.0;
y2 = 0.0;
}
// if the tracks go out of the bounds of the s2 plane,
// toss the track out
if( (TMath::Abs(x2 - s2->GetOrigin().X()) > s2->GetSize()[0]) ||
(TMath::Abs(y2 - s2->GetOrigin().Y()) > s2->GetSize()[1]) ) {
// for now, we just flag the tracks as bad
track->SetFlag( track->GetFlag() | kBadTrack );
//tracks.RemoveAt(t);
#ifdef WITH_DEBUG
//cout << "Track " << t << " deleted.\n";
#endif
}
}
// get rid of the slots for the deleted tracks
//tracks.Compress();
}
void MakeMFTZeroMisAlignment(TString Storage = "alien://folder=/alice/cern.ch/user/a/auras/OCDB/") {
// Create TClonesArray of zero misalignment objects for MFT
const char* macroname = "MakeMFTZeroMisAlignment.C";
TClonesArray *array = new TClonesArray("AliAlignObjParams",10);
TClonesArray &alobj = *array;
Double_t dx=0, dy=0, dz=0, dpsi=0, dtheta=0, dphi=0;
Int_t iIndex=0;
AliGeomManager::ELayerID iLayer = AliGeomManager::kInvalidLayer;
UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,iIndex);
TString MFT("MFT");
new (alobj[0]) AliAlignObjParams(MFT.Data(), volid, dx, dy, dz, dpsi, dtheta, dphi, kTRUE);
// save in CDB storage
if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
return;
}
Info(macroname,"Saving alignment objects in CDB storage %s", Storage.Data());
AliCDBManager* cdb = AliCDBManager::Instance();
AliCDBStorage* storage = cdb->GetStorage(Storage.Data());
if(!storage){
Error(macroname,"Unable to open storage %s\n",Storage.Data());
return;
}
AliCDBMetaData* md = new AliCDBMetaData();
md->SetResponsible("Antonio Uras");
md->SetComment("Alignment objects for MFT zero-misalignment");
md->SetAliRootVersion(gROOT->GetVersion());
AliCDBId id("MFT/Align/Data",0,AliCDBRunRange::Infinity());
storage->Put(array,id,md);
array->Delete();
}
void testPicoD0EventRead(TString filename)
{
gROOT->LoadMacro("$STAR/StRoot/StMuDSTMaker/COMMON/macros/loadSharedLibraries.C");
loadSharedLibraries();
gSystem->Load("StPicoDstMaker");
gSystem->Load("StPicoD0Maker");
TFile* f = new TFile(filename.Data());
TTree* T = (TTree*)f->Get("T");
StPicoD0Event* event = new StPicoD0Event();
T->SetBranchAddress("dEvent",&event);
TFile ff("read_test.root","RECREATE");
TNtuple* nt = new TNtuple("nt","","m:pt:eta:phi:theta:"
"decayL:kDca:pDca:dca12:cosThetaStar");
StKaonPion* kp = 0;
for(Int_t i=0;i<100000;++i)
{
T->GetEntry(i);
TClonesArray* arrKPi = event->kaonPionArray();
for(int idx=0;idx<event->nKaonPion();++idx)
{
kp = (StKaonPion*)arrKPi->At(idx);
nt->Fill(kp->m(),kp->pt(),kp->eta(),kp->phi(),kp->pointingAngle(),
kp->decayLength(),kp->kaonDca(),kp->pionDca(),kp->dcaDaughters(),kp->cosThetaStar());
}
}
nt->Write();
ff.Close();
}
void digitsPHOS(Int_t nevents, Int_t nfiles)
{
TH1F * hadc = new TH1F ("hadc", "hadc", 100, -10, 200);
TH1F * hadcLog = new TH1F ("hadclog", "hadclog", 100, -2, 4);
IlcRunLoader* runLoader = IlcRunLoader::Open("gilc.root","Event","READ");
IlcPHOSLoader * phosLoader = dynamic_cast<IlcPHOSLoader*>(runLoader->GetLoader("PHOSLoader"));
for (Int_t ievent=0; ievent <nevents; ievent++) {
// for (Int_t ievent = 0; ievent < runLoader->GetNumberOfEvents(); ievent++) {
runLoader->GetEvent(ievent) ;
phosLoader->CleanDigits() ;
phosLoader->LoadDigits("READ") ;
TClonesArray * digits = phosLoader->Digits() ;
printf("Event %d contains %d digits\n",ievent,digits->GetEntriesFast());
for (Int_t j = 0; j < digits->GetEntries(); j++) {
IlcPHOSDigit* dig = dynamic_cast<IlcPHOSDigit*> (digits->At(j));
//cout << dig->GetEnergy() << endl;
hadc->Fill(dig->GetEnergy());
if(dig->GetEnergy()>0)
hadcLog->Fill(TMath::Log10(dig->GetEnergy()));
}
}
TFile fc("digits.PHOS.root","RECREATE");
fc.cd();
hadc->Write();
hadcLog->Write();
fc.Close();
}
void LHCOWriter::AnalyseMissingET()
{
MissingET *element;
element = static_cast<MissingET*>(fBranchMissingET->At(0));
Reset();
fIntParam[1] = 6;
fDblParam[1] = element->Phi;
fDblParam[2] = element->MET;
Write();
}
void tclread()
{
// read file generated by tclwrite
// loop on all entries.
// histogram center of lines
TFile *f = new TFile("tcl.root");
TTree *T = (TTree*)f->Get("T");
TH2F *h2 = new TH2F("h2","center of lines",40,0,1,40,0,1);
TClonesArray *arr = new TClonesArray("TLine");
T->GetBranch("tcl")->SetAutoDelete(kFALSE);
T->SetBranchAddress("tcl",&arr);
Long64_t nentries = T->GetEntries();
for (Long64_t ev=0;ev<nentries;ev++) {
arr->Clear();
T->GetEntry(ev);
Int_t nlines = arr->GetEntriesFast();
for (Int_t i=0;i<nlines;i++) {
TLine *line = (TLine*)arr->At(i);
h2->Fill(0.5*(line->GetX1()+line->GetX2()), 0.5*(line->GetY1()+line->GetY2()));
}
}
h2->Draw("lego");
}
void MergeSetsOfIlcgnObjs(const char* filename1, const char* filename2, const char* det="ITS")
{
// example macro: building an array by merging the non-SSD entries
// from one file (or OCDB entry) with the remaining SSD entries taken
// from another file (or OCDB entry); the first two arguments can be local filenames
// or URLs of the OCDB folders
//
const char* macroname = "MergeSetsOfIlcgnObjs";
TClonesArray* array1 = 0;
TClonesArray* array2 = 0;
TString arName(det);
arName+="AlignObjs";
TString path(det);
path+="/Align/Data";
TString f1(filename1);
TString f2(filename2);
IlcCDBStorage* stor1 = 0;
IlcCDBStorage* stor2 = 0;
Bool_t fromOcdb1=kFALSE;
Bool_t fromOcdb2=kFALSE;
if(f1.Contains("alien://folder=") || f1.Contains("local://")) fromOcdb1=kTRUE;
if(f2.Contains("alien://folder=") || f2.Contains("local://")) fromOcdb2=kTRUE;
IlcCDBManager* cdb = IlcCDBManager::Instance();
cdb->SetDefaultStorage("local://$ILC_ROOT/OCDB");
cdb->SetRun(0);
if(fromOcdb1){
stor1 = cdb->GetStorage(f1.Data());
IlcCDBEntry* entry = stor1->Get(path.Data(),0);
array1 = (TClonesArray*) entry->GetObject();
}else{
TFile* filein1 = TFile::Open(f1.Data(),"READ");
if(!filein1)
{
Info(macroname,Form("Unable to open file %s! Exiting ...", f1.Data()));
return;
}
array1 = (TClonesArray*) filein1->Get(arName.Data());
}
if(array1){
Info(macroname,Form("First array has %d entries", array1->GetEntriesFast()));
}else{
Info(macroname,"Unable to get first array! Exiting ...");
return;
}
if(fromOcdb2){
stor2 = cdb->GetStorage(f2.Data());
IlcCDBEntry* entry = stor2->Get(path.Data(),0);
array2 = (TClonesArray*) entry->GetObject();
}else{
TFile* filein2 = TFile::Open(f2.Data(),"READ");
if(!filein2)
{
Info(macroname,Form("Unable to open file %s! Exiting ...", f2.Data()));
return;
}
array2 = (TClonesArray*) filein2->Get(arName.Data());
}
if(array2){
Info(macroname,Form("Second array has %d entries", array2->GetEntriesFast()));
}else{
Info(macroname,"Unable to get second array! Exiting ...");
return;
}
TClonesArray *mergedArr = new TClonesArray("IlcAlignObjParams",3000);
Info(macroname,"Merging objects for SPD and SDD from the first array ...");
// SSD starts from 500
for(Int_t i=0; i<500; i++)
{
(*mergedArr)[i] = (IlcAlignObjParams*) array1->UncheckedAt(i);
}
Info(macroname,"Merging objects for SSD from the second array ...");
for(Int_t i=500; i<array2->GetEntriesFast(); i++)
{
(*mergedArr)[i] = (IlcAlignObjParams*) array2->UncheckedAt(i);
}
TString foutName("merged");
foutName+=det;
foutName+="Alignment.root";
Info(macroname,Form("... in a single array into the file %s", foutName.Data()));
TFile* fileout = TFile::Open(foutName.Data(),"RECREATE");
fileout->cd();
fileout->WriteObject(mergedArr,arName.Data(),"kSingleKey");
fileout->Close();
mergedArr->Delete();
}
void MakeTRDResMisAlignment(){
// Create TClonesArray of residual misalignment objects for TRD
//
const char* macroname = "MakeTRDResMisAlignment.C";
TClonesArray *array = new TClonesArray("AliAlignObjParams",1000);
TClonesArray &alobj = *array;
// Activate CDB storage and load geometry from CDB
AliCDBManager* cdb = AliCDBManager::Instance();
if(!cdb->IsDefaultStorageSet()) cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
cdb->SetRun(0);
AliCDBStorage* storage;
if( TString(gSystem->Getenv("TOCDB")) == TString("kTRUE") ){
TString Storage = gSystem->Getenv("STORAGE");
if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
Error(macroname,"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data());
return;
}
storage = cdb->GetStorage(Storage.Data());
if(!storage){
Error(macroname,"Unable to open storage %s\n",Storage.Data());
return;
}
AliCDBPath path("GRP","Geometry","Data");
AliCDBEntry *entry = storage->Get(path.GetPath(),cdb->GetRun());
if(!entry) Fatal(macroname,"Could not get the specified CDB entry!");
entry->SetOwner(0);
TGeoManager* geom = (TGeoManager*) entry->GetObject();
AliGeomManager::SetGeometry(geom);
}
else {
AliGeomManager::LoadGeometry(); //load geom from default CDB storage
}
// sigmas for the chambers
Double_t chdx = 0.002; // 20 microns
Double_t chdy = 0.003; // 30 microns
Double_t chdz = 0.007; // 70 microns
Double_t chrx = 0.0005 / 1000.0 / TMath::Pi()*180; // 0 mrad
Double_t chry = 0.0005 / 1000.0 / TMath::Pi()*180; // 0 mrad
Double_t chrz = 0.1 / 1000.0 / TMath::Pi()*180; // 0.1 mrad
// Truncation for the chambers
Double_t cutChdx = 3.0 * chdx;
Double_t cutChdy = 3.0 * chdy;
Double_t cutChdz = 0.14 * chdz;
Int_t sActive[18]={1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1};
Double_t dx=0.,dy=0.,dz=0.,rx=0.,ry=0.,rz=0.;
Int_t j=0;
UShort_t volid;
const char* symname;
// create the supermodules' alignment objects
for (Int_t iSect=0; iSect<18; iSect++) {
TString sm_symname(Form("TRD/sm%02d",iSect));
if( (TString(gSystem->Getenv("REALSETUP")) == TString("kTRUE")) && !sActive[iSect] ) continue;
new((*array)[j++])
AliAlignObjParams(sm_symname.Data(),0,dx,dy,dz,rx,ry,rz,kTRUE);
}
// create the chambers' alignment objects
Int_t chId;
for (Int_t iLayer = AliGeomManager::kTRD1; iLayer <= AliGeomManager::kTRD6; iLayer++) {
chId=-1;
for (Int_t iSect = 0; iSect < 18; iSect++){
for (Int_t iCh = 0; iCh < 5; iCh++) {
dx = AliMathBase::TruncatedGaus(0.0,chdx,cutChdx);
dy = AliMathBase::TruncatedGaus(0.0,chdy,cutChdy);
dz = AliMathBase::TruncatedGaus(0.0,chdz,cutChdz);
rx = gRandom->Rndm() * 2.0*chrx - chrx;
ry = gRandom->Rndm() * 2.0*chry - chry;
rz = gRandom->Rndm() * 2.0*chrz - chrz;
chId++;
if ((iSect==13 || iSect==14 || iSect==15) && iCh==2) continue;
volid = AliGeomManager::LayerToVolUID(iLayer,chId);
if( (TString(gSystem->Getenv("REALSETUP")) == TString("kTRUE")) && !sActive[iSect] ) continue;
symname = AliGeomManager::SymName(volid);
new(alobj[j++]) AliAlignObjParams(symname,volid,dx,dy,dz,rx,ry,rz,kFALSE);
}
}
}
if ( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ) {
// save on file
const char* filename = "TRDresidualMisalignment.root";
TFile f(filename,"RECREATE");
if(!f){
Error(macroname,"cannot open file for output\n");
return;
}
Info(macroname,"Saving alignment objects to the file %s", filename);
f.cd();
f.WriteObject(array,"TRDAlignObjs","kSingleKey");
f.Close();
}
else {
// save in CDB storage
AliCDBMetaData* md = new AliCDBMetaData();
md->SetResponsible("Dariusz Miskowiec");
md->SetComment("Residual misalignment for TRD");
md->SetAliRootVersion(gSystem->Getenv("ARVERSION"));
AliCDBId id("TRD/Align/Data",0,AliCDBRunRange::Infinity());
storage->Put(array,id,md);
}
array->Delete();
}
void pythia8(Int_t nev = 100, Int_t ndeb = 1)
{
const char *p8dataenv = gSystem->Getenv("PYTHIA8DATA");
if (!p8dataenv) {
const char *p8env = gSystem->Getenv("PYTHIA8");
if (!p8env) {
Error("pythia8.C",
"Environment variable PYTHIA8 must contain path to pythia directory!");
return;
}
TString p8d = p8env;
p8d += "/xmldoc";
gSystem->Setenv("PYTHIA8DATA", p8d);
}
const char* path = gSystem->ExpandPathName("$PYTHIA8DATA");
if (gSystem->AccessPathName(path)) {
Error("pythia8.C",
"Environment variable PYTHIA8DATA must contain path to $PYTHIA8/xmldoc directory !");
return;
}
// Load libraries
#ifndef G__WIN32 // Pythia8 is a static library on Windows
if (gSystem->Getenv("PYTHIA8")) {
gSystem->Load("$PYTHIA8/lib/libpythia8");
} else {
gSystem->Load("libpythia8");
}
#endif
gSystem->Load("libEG");
gSystem->Load("libEGPythia8");
// Histograms
TH1F* etaH = new TH1F("etaH", "Pseudorapidity", 120, -12., 12.);
TH1F* ptH = new TH1F("ptH", "pt", 50, 0., 10.);
// Array of particles
TClonesArray* particles = new TClonesArray("TParticle", 1000);
// Create pythia8 object
TPythia8* pythia8 = new TPythia8();
// Configure
pythia8->ReadString("HardQCD:all = on");
// Initialize
pythia8->Initialize(2212 /* p */, 2212 /* p */, 14000. /* TeV */);
// Event loop
for (Int_t iev = 0; iev < nev; iev++) {
pythia8->GenerateEvent();
if (iev < ndeb) pythia8->EventListing();
pythia8->ImportParticles(particles,"All");
Int_t np = particles->GetEntriesFast();
// Particle loop
for (Int_t ip = 0; ip < np; ip++) {
TParticle* part = (TParticle*) particles->At(ip);
Int_t ist = part->GetStatusCode();
// Positive codes are final particles.
if (ist <= 0) continue;
Int_t pdg = part->GetPdgCode();
Float_t charge = TDatabasePDG::Instance()->GetParticle(pdg)->Charge();
if (charge == 0.) continue;
Float_t eta = part->Eta();
Float_t pt = part->Pt();
etaH->Fill(eta);
if (pt > 0.) ptH->Fill(pt, 1./(2. * pt));
}
}
pythia8->PrintStatistics();
TCanvas* c1 = new TCanvas("c1","Pythia8 test example",800,800);
c1->Divide(1, 2);
c1->cd(1);
etaH->Scale(5./Float_t(nev));
etaH->Draw();
etaH->SetXTitle("#eta");
etaH->SetYTitle("dN/d#eta");
c1->cd(2);
gPad->SetLogy();
ptH->Scale(5./Float_t(nev));
ptH->Draw();
ptH->SetXTitle("p_{t} [GeV/c]");
ptH->SetYTitle("dN/dp_{t}^{2} [GeV/c]^{-2}");
}
void pythia8_susy() {
Int_t maxEvts = 100; // Maximo numero de eventos
char* path = gSystem->ExpandPathName("$PYTHIA8DATA");
if (gSystem->AccessPathName(path)) {
Warning("pythia8.C",
"Environment variable PYTHIA8DATA must contain path to pythi8100/xmldoc directory !");
return;
}
// Load libraries
gSystem->Load("$PYTHIA8/lib/libpythia8");
gSystem->Load("$PYTHIA8/lib/liblhapdfdummy");
gSystem->Load("libEG");
gSystem->Load("libEGPythia8");
//Definir archivo de salida
TFile * outfile = new TFile("eventos_pythia8_SUSY.root","RECREATE");
// Array of particles
TClonesArray* particles = new TClonesArray("TParticle", 5000);
//Definir el TTree
TTree*tree= new TTree("tree","Arbol con particulas segun Pythia8");
tree->Branch("particles",&particles);
// Create pythia8 object
TPythia8* pythia8 = new TPythia8();
//*Configurar: Aqui seleccione el proceso que quiere simular
pythia8->ReadString("SUSY:all = on"); //Todos los procesos susy posibles
//pythia8->ReadString("SUSY:qqbar2chi+-chi0 = on"); //Un proceso en especial
//Importante: pasar a Pythia8 el nombre del archivo SLHA
pythia8->ReadString("SLHA:file = SUSY_LM2_sftsht.slha"); //insertar aqui el nombre del archivo SLHA
// Initialize
pythia8->Initialize(2212 /* p */, 2212 /* p */, 7000. /* TeV */);
int iev = 0;
// Event loop
while( iev < maxEvts ) {
pythia8->GenerateEvent();
if (iev < 1) pythia8->EventListing();
pythia8->ImportParticles(particles,"All");
Int_t np = particles->GetEntriesFast();
// Particle loop
for (Int_t ip = 0; ip < np; ip++) {
TParticle* part = (TParticle*) particles->At(ip);
Int_t ist = part->GetStatusCode();
Int_t pdg = part->GetPdgCode();
}
tree->Fill();
++iev;
}
pythia8->PrintStatistics();
outfile->Write();
outfile->Close();
}
void selectWe(const TString conf, // input file
const TString outputDir, // output directory
const Bool_t doScaleCorr // apply energy scale corrections?
) {
gBenchmark->Start("selectWe");
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
const Double_t PT_CUT = 20;
const Double_t ETA_CUT = 2.5;
const Double_t ELE_MASS = 0.000511;
const Double_t ECAL_GAP_LOW = 1.4442;
const Double_t ECAL_GAP_HIGH = 1.566;
const Double_t escaleNbins = 6;
const Double_t escaleEta[] = { 0.4, 0.8, 1.2, 1.4442, 2, 2.5 };
const Double_t escaleCorr[] = { 1.00284, 1.00479, 1.00734, 1.00851, 1.00001, 0.982898 };
//--------------------------------------------------------------------------------------------------------------
// Main analysis code
//==============================================================================================================
vector<TString> snamev; // sample name (for output files)
vector<CSample*> samplev; // data/MC samples
//
// parse .conf file
//
confParse(conf, snamev, samplev);
const Bool_t hasData = (samplev[0]->fnamev.size()>0);
// Create output directory
gSystem->mkdir(outputDir,kTRUE);
const TString ntupDir = outputDir + TString("/ntuples");
gSystem->mkdir(ntupDir,kTRUE);
//
// Declare output ntuple variables
//
UInt_t runNum, lumiSec, evtNum;
UInt_t npv, npu;
Float_t genVPt, genVPhi, genVy, genVMass;
Float_t genLepPt, genLepPhi;
Float_t scale1fb;
Float_t met, metPhi, sumEt, mt, u1, u2;
Int_t q;
LorentzVector *lep=0;
///// electron specific /////
Float_t trkIso, emIso, hadIso;
Float_t pfChIso, pfGamIso, pfNeuIso, pfCombIso;
Float_t sigieie, hovere, eoverp, fbrem, ecalE;
Float_t dphi, deta;
Float_t d0, dz;
UInt_t isConv, nexphits, typeBits;
LorentzVector *sc=0;
// Data structures to store info from TTrees
mithep::TEventInfo *info = new mithep::TEventInfo();
mithep::TGenInfo *gen = new mithep::TGenInfo();
TClonesArray *electronArr = new TClonesArray("mithep::TElectron");
TClonesArray *pvArr = new TClonesArray("mithep::TVertex");
TFile *infile=0;
TTree *eventTree=0;
//
// loop over samples
//
for(UInt_t isam=0; isam<samplev.size(); isam++) {
// Assume data sample is first sample in .conf file
// If sample is empty (i.e. contains no ntuple files), skip to next sample
if(isam==0 && !hasData) continue;
CSample* samp = samplev[isam];
//
// Set up output ntuple
//
TString outfilename = ntupDir + TString("/") + snamev[isam] + TString("_select.root");
if(isam==0 && !doScaleCorr) outfilename = ntupDir + TString("/") + snamev[isam] + TString("_select.raw.root");
TFile *outFile = new TFile(outfilename,"RECREATE");
TTree *outTree = new TTree("Events","Events");
outTree->Branch("runNum", &runNum, "runNum/i"); // event run number
outTree->Branch("lumiSec", &lumiSec, "lumiSec/i"); // event lumi section
outTree->Branch("evtNum", &evtNum, "evtNum/i"); // event number
outTree->Branch("npv", &npv, "npv/i"); // number of primary vertices
outTree->Branch("npu", &npu, "npu/i"); // number of in-time PU events (MC)
outTree->Branch("genVPt", &genVPt, "genVPt/F"); // GEN boson pT (signal MC)
outTree->Branch("genVPhi", &genVPhi, "genVPhi/F"); // GEN boson phi (signal MC)
outTree->Branch("genVy", &genVy, "genVy/F"); // GEN boson rapidity (signal MC)
outTree->Branch("genVMass", &genVMass, "genVMass/F"); // GEN boson mass (signal MC)
outTree->Branch("genLepPt", &genLepPt, "genLepPt/F"); // GEN lepton pT (signal MC)
outTree->Branch("genLepPhi",&genLepPhi,"genLepPhi/F"); // GEN lepton phi (signal MC)
outTree->Branch("scale1fb", &scale1fb, "scale1fb/F"); // event weight per 1/fb (MC)
outTree->Branch("met", &met, "met/F"); // MET
outTree->Branch("metPhi", &metPhi, "metPhi/F"); // phi(MET)
outTree->Branch("sumEt", &sumEt, "sumEt/F"); // Sum ET
outTree->Branch("mt", &mt, "mt/F"); // transverse mass
outTree->Branch("u1", &u1, "u1/F"); // parallel component of recoil
outTree->Branch("u2", &u2, "u2/F"); // perpendicular component of recoil
outTree->Branch("q", &q, "q/I"); // lepton charge
outTree->Branch("lep", "ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double> >", &lep); // lepton 4-vector
///// electron specific /////
outTree->Branch("trkIso", &trkIso, "trkIso/F"); // track isolation of tag lepton
outTree->Branch("emIso", &emIso, "emIso/F"); // ECAL isolation of tag lepton
outTree->Branch("hadIso", &hadIso, "hadIso/F"); // HCAL isolation of tag lepton
outTree->Branch("pfChIso", &pfChIso, "pfChIso/F"); // PF charged hadron isolation of lepton
outTree->Branch("pfGamIso", &pfGamIso, "pfGamIso/F"); // PF photon isolation of lepton
outTree->Branch("pfNeuIso", &pfNeuIso, "pfNeuIso/F"); // PF neutral hadron isolation of lepton
outTree->Branch("pfCombIso", &pfCombIso, "pfCombIso/F"); // PF combined isolation of electron
outTree->Branch("sigieie", &sigieie, "sigieie/F"); // sigma-ieta-ieta of electron
outTree->Branch("hovere", &hovere, "hovere/F"); // H/E of electron
outTree->Branch("eoverp", &eoverp, "eoverp/F"); // E/p of electron
outTree->Branch("fbrem", &fbrem, "fbrem/F"); // brem fraction of electron
outTree->Branch("dphi", &dphi, "dphi/F"); // GSF track - ECAL dphi of electron
outTree->Branch("deta", &deta, "deta/F"); // GSF track - ECAL deta of electron
outTree->Branch("ecalE", &ecalE, "ecalE/F"); // ECAL energy of electron
outTree->Branch("d0", &d0, "d0/F"); // transverse impact parameter of electron
outTree->Branch("dz", &dz, "dz/F"); // longitudinal impact parameter of electron
outTree->Branch("isConv", &isConv, "isConv/i"); // conversion filter flag of electron
outTree->Branch("nexphits", &nexphits, "nexphits/i"); // number of missing expected inner hits of electron
outTree->Branch("typeBits", &typeBits, "typeBits/i"); // electron type of electron
outTree->Branch("sc", "ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double> >", &sc); // electron Supercluster 4-vector
//
// loop through files
//
const UInt_t nfiles = samp->fnamev.size();
for(UInt_t ifile=0; ifile<nfiles; ifile++) {
// Read input file and get the TTrees
cout << "Processing " << samp->fnamev[ifile] << " [xsec = " << samp->xsecv[ifile] << " pb] ... "; cout.flush();
infile = new TFile(samp->fnamev[ifile]);
assert(infile);
Bool_t hasJSON = kFALSE;
mithep::RunLumiRangeMap rlrm;
if(samp->jsonv[ifile].CompareTo("NONE")!=0) {
hasJSON = kTRUE;
rlrm.AddJSONFile(samp->jsonv[ifile].Data());
}
eventTree = (TTree*)infile->Get("Events");
assert(eventTree);
eventTree->SetBranchAddress("Info", &info); TBranch *infoBr = eventTree->GetBranch("Info");
eventTree->SetBranchAddress("Electron", &electronArr); TBranch *electronBr = eventTree->GetBranch("Electron");
eventTree->SetBranchAddress("PV", &pvArr); TBranch *pvBr = eventTree->GetBranch("PV");
Bool_t hasGen = eventTree->GetBranchStatus("Gen");
TBranch *genBr=0;
if(hasGen) {
eventTree->SetBranchAddress("Gen", &gen);
genBr = eventTree->GetBranch("Gen");
}
// Compute MC event weight per 1/fb
Double_t weight = 1;
const Double_t xsec = samp->xsecv[ifile];
if(xsec>0) weight = 1000.*xsec/(Double_t)eventTree->GetEntries();
//
// loop over events
//
Double_t nsel=0, nselvar=0;
for(UInt_t ientry=0; ientry<eventTree->GetEntries(); ientry++) {
infoBr->GetEntry(ientry);
if(genBr) genBr->GetEntry(ientry);
// check for certified lumi (if applicable)
mithep::RunLumiRangeMap::RunLumiPairType rl(info->runNum, info->lumiSec);
if(hasJSON && !rlrm.HasRunLumi(rl)) continue;
// trigger requirement
ULong64_t trigger = kHLT_Ele22_CaloIdL_CaloIsoVL;
ULong64_t trigObj = kHLT_Ele22_CaloIdL_CaloIsoVL_EleObj;
if(!(info->triggerBits & trigger)) continue;
// good vertex requirement
if(!(info->hasGoodPV)) continue;
pvArr->Clear();
pvBr->GetEntry(ientry);
//
// SELECTION PROCEDURE:
// (1) Look for 1 good electron matched to trigger
// (2) Reject event if another electron is present passing looser cuts
//
electronArr->Clear();
electronBr->GetEntry(ientry);
Int_t nLooseLep=0;
const mithep::TElectron *goodEle=0;
Bool_t passSel=kFALSE;
for(Int_t i=0; i<electronArr->GetEntriesFast(); i++) {
const mithep::TElectron *ele = (mithep::TElectron*)((*electronArr)[i]);
// check ECAL gap
if(fabs(ele->scEta)>=ECAL_GAP_LOW && fabs(ele->scEta)<=ECAL_GAP_HIGH) continue;
Double_t escale=1;
if(doScaleCorr && isam==0) {
for(UInt_t ieta=0; ieta<escaleNbins; ieta++) {
if(fabs(ele->scEta)<escaleEta[ieta]) {
escale = escaleCorr[ieta];
break;
}
}
}
if(fabs(ele->scEta) > 2.5) continue; // loose lepton |eta| cut
if(escale*(ele->scEt) < 20) continue; // loose lepton pT cut
if(passEleLooseID(ele,info->rhoLowEta)) nLooseLep++; // loose lepton selection
if(nLooseLep>1) { // extra lepton veto
passSel=kFALSE;
break;
}
if(fabs(ele->scEta) > ETA_CUT) continue; // lepton |eta| cut
if(escale*(ele->scEt) < PT_CUT) continue; // lepton pT cut
if(!passEleID(ele,info->rhoLowEta)) continue; // lepton selection
if(!(ele->hltMatchBits & trigObj)) continue; // check trigger matching
passSel=kTRUE;
goodEle = ele;
}
if(passSel) {
/******** We have a W candidate! HURRAY! ********/
nsel+=weight;
nselvar+=weight*weight;
Double_t escale=1;
if(doScaleCorr && isam==0) {
for(UInt_t ieta=0; ieta<escaleNbins; ieta++) {
if(fabs(goodEle->scEta)<escaleEta[ieta]) {
escale = escaleCorr[ieta];
break;
}
}
}
LorentzVector vLep(escale*(goodEle->pt), goodEle->eta, goodEle->phi, ELE_MASS);
LorentzVector vSC(escale*(goodEle->scEt), goodEle->scEta, goodEle->scPhi, ELE_MASS);
//
// Fill tree
//
runNum = info->runNum;
lumiSec = info->lumiSec;
evtNum = info->evtNum;
npv = pvArr->GetEntriesFast();
npu = info->nPU;
genVPt = 0;
genVPhi = 0;
genVy = 0;
genVMass = 0;
genLepPt = 0;
genLepPhi= 0;
u1 = 0;
u2 = 0;
if(hasGen) {
genVPt = gen->vpt;
genVPhi = gen->vphi;
genVy = gen->vy;
genVMass = gen->vmass;
TVector2 vWPt((gen->vpt)*cos(gen->vphi),(gen->vpt)*sin(gen->vphi));
TVector2 vLepPt(vLep.Px(),vLep.Py());
TVector2 vMet((info->pfMET)*cos(info->pfMETphi), (info->pfMET)*sin(info->pfMETphi));
TVector2 vU = -1.0*(vMet+vLepPt);
u1 = ((vWPt.Px())*(vU.Px()) + (vWPt.Py())*(vU.Py()))/(gen->vpt); // u1 = (pT . u)/|pT|
u2 = ((vWPt.Px())*(vU.Py()) - (vWPt.Py())*(vU.Px()))/(gen->vpt); // u2 = (pT x u)/|pT|
if(abs(gen->id_1)==EGenType::kElectron) { genLepPt = gen->vpt_1; genLepPhi = gen->vphi_1; }
if(abs(gen->id_2)==EGenType::kElectron) { genLepPt = gen->vpt_2; genLepPhi = gen->vphi_2; }
}
scale1fb = weight;
met = info->pfMET;
metPhi = info->pfMETphi;
sumEt = info->pfSumET;
mt = sqrt( 2.0 * (vLep.Pt()) * (info->pfMET) * (1.0-cos(toolbox::deltaPhi(vLep.Phi(),info->pfMETphi))) );
q = goodEle->q;
lep = &vLep;
///// electron specific /////
sc = &vSC;
trkIso = goodEle->trkIso03;
emIso = goodEle->emIso03;
hadIso = goodEle->hadIso03;
pfChIso = goodEle->pfChIso03;
pfGamIso = goodEle->pfGamIso03;
pfNeuIso = goodEle->pfNeuIso03;
pfCombIso = goodEle->pfChIso03 + TMath::Max(goodEle->pfNeuIso03 + goodEle->pfGamIso03 - (info->rhoLowEta)*getEffArea(goodEle->scEta), 0.);
sigieie = goodEle->sigiEtaiEta;
hovere = goodEle->HoverE;
eoverp = goodEle->EoverP;
fbrem = goodEle->fBrem;
dphi = goodEle->deltaPhiIn;
deta = goodEle->deltaEtaIn;
d0 = goodEle->d0;
dz = goodEle->dz;
isConv = goodEle->isConv;
nexphits = goodEle->nExpHitsInner;
typeBits = goodEle->typeBits;
outTree->Fill();
}
}
delete infile;
infile=0, eventTree=0;
cout << nsel << " +/- " << sqrt(nselvar);
if(isam!=0) cout << " per 1/fb";
cout << endl;
}
outFile->Write();
outFile->Close();
}
delete info;
delete gen;
delete electronArr;
delete pvArr;
//--------------------------------------------------------------------------------------------------------------
// Output
//==============================================================================================================
cout << "*" << endl;
cout << "* SUMMARY" << endl;
cout << "*--------------------------------------------------" << endl;
cout << " W -> e nu" << endl;
cout << " pT > " << PT_CUT << endl;
cout << " |eta| < " << ETA_CUT << endl;
if(doScaleCorr)
cout << " *** Scale corrections applied ***" << endl;
cout << endl;
cout << endl;
cout << " <> Output saved in " << outputDir << "/" << endl;
cout << endl;
gBenchmark->Show("selectWe");
}