WaveData WaveReader::readData() {
WaveData data;
data.channelCount = info.channels;
data.dataLength = info.dataSize / data.channelCount;
data.data = new int*[data.channelCount];
for (int i = 0; i < data.channelCount; i++) {
data.data[i] = new int[data.dataLength];
}
int bytesPerSample;
switch (info.format) {
case PULSE_CODE_MODULATION:
case EXTENSIBLE:
default:
bytesPerSample = (info.bitDepth / data.channelCount) / 8;
break;
}
int byteCount = info.dataSize / data.channelCount;
for (int i = 0; i < byteCount; i++) {
for (int j = 0; j < data.channelCount; j++) {
data.data[j][i] = readSample(bytesPerSample);
}
}
return data;
}
// Called in loading thread
// Essentially a second ctor, doesn't need locks (?)
void QSample::load()
{
Q_ASSERT(QThread::currentThread()->objectName() == "QSampleCache::LoadingThread");
#ifdef QT_SAMPLECACHE_DEBUG
qDebug() << "QSample: load [" << m_url << "]";
#endif
m_stream = m_parent->networkAccessManager().get(QNetworkRequest(m_url));
connect(m_stream, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(decoderError()));
m_waveDecoder = new QWaveDecoder(m_stream);
connect(m_waveDecoder, SIGNAL(formatKnown()), SLOT(decoderReady()));
connect(m_waveDecoder, SIGNAL(invalidFormat()), SLOT(decoderError()));
connect(m_waveDecoder, SIGNAL(readyRead()), SLOT(readSample()));
}
uint64 Sampler::recordAllocationInfo(AvmPlusScriptableObject *obj, uintptr typeOrVTable)
{
AvmAssertMsg(sampling(), "How did we get here if sampling is disabled?");
if(!samplingNow)
return 0;
if( !samplingAllAllocs )
{
// Turn on momentarily to record the alloc for this object.
samplingAllAllocs = true;
recordAllocationSample(obj, 0);
samplingAllAllocs = false;
}
byte* old_sample = lastAllocSample;
Sample s;
readSample(old_sample, s);
old_sample = lastAllocSample;
if(typeOrVTable < 7 && core->codeContext() && core->codeContext()->domainEnv()) {
// and in toplevel
typeOrVTable |= (uintptr)core->codeContext()->domainEnv()->toplevel();
}
AvmAssertMsg(s.sampleType == NEW_AUX_SAMPLE, "Sample stream corrupt - can only add info to an AUX sample.\n");
AvmAssertMsg(s.ptr == (void*)obj, "Sample stream corrupt - last sample is not for same object.\n");
byte* pos = currentSample;
currentSample = old_sample;
// Rewrite the sample as a NEW_OBJECT_SAMPLE
writeRawSample(NEW_OBJECT_SAMPLE);
write(currentSample, s.id);
AvmAssertMsg( ptrSamples->get(obj)==0, "Missing dealloc sample - same memory alloc'ed twice.\n");
ptrSamples->add(obj, currentSample);
write(currentSample, s.ptr);
write(currentSample, typeOrVTable);
write(currentSample, s.alloc_size);
AvmAssertMsg((uintptr)currentSample % 4 == 0, "Alignment should have occurred at end of raw sample.\n");
currentSample = pos;
return s.id;
}
void ZInstrument::addRegion(SfzRegion& r)
{
for (int i = 0; i < 128; ++i) {
if (r.on_locc[i] != -1 || r.on_hicc[i] != -1) {
r.trigger = Trigger::CC;
break;
}
}
Zone* z = new Zone;
z->sample = readSample(r.sample, 0);
if (z->sample) {
qDebug("Sample Loop - start %d, end %d, mode %d", z->sample->loopStart(), z->sample->loopEnd(), z->sample->loopMode());
// if there is no opcode defining loop ranges, use sample definitions as fallback (according to spec)
if (r.loopStart == -1)
r.loopStart = z->sample->loopStart();
if (r.loopEnd == -1)
r.loopEnd = z->sample->loopEnd();
}
r.setZone(z);
if (z->sample)
addZone(z);
}
float Maxbotix::getRange()
{
float range;
readSample();
switch (filter) {
case MEDIAN:
range = getSampleMedian();
break;
case HIGHEST_MODE:
range = getSampleMode(true);
break;
case LOWEST_MODE:
range = getSampleMode(false);
break;
case SIMPLE:
while (sample[0] != sample[sample_size - 1])
pushToSample(readSensor());
range = sample[0];
break;
case BEST:
range = getSampleBest();
break;
case NONE:
default:
range = sample[0];
break;
}
return range;
}
void
BasicDeviceDriver::updateStateMachine(void)
{
switch (dequeueState())
{
// Wait for activation.
case SM_IDLE:
break;
// Begin activation sequence.
case SM_ACT_BEGIN:
setEntityState(IMC::EntityState::ESTA_NORMAL, Status::CODE_ACTIVATING);
m_wdog.setTop(getActivationTime());
queueState(SM_ACT_POWER_ON);
break;
// Turn power on.
case SM_ACT_POWER_ON:
turnPowerOn();
queueState(SM_ACT_POWER_WAIT);
break;
// Wait for power to be on.
case SM_ACT_POWER_WAIT:
if (isPowered())
{
m_power_on_timer.setTop(m_post_power_on_delay);
queueState(SM_ACT_DEV_WAIT);
}
if (m_wdog.overflow())
{
failActivation(DTR("failed to turn power on"));
queueState(SM_IDLE);
}
break;
// Connect to device.
case SM_ACT_DEV_WAIT:
if (m_wdog.overflow())
{
failActivation(DTR("failed to connect to device"));
queueState(SM_IDLE);
}
else if (m_power_on_timer.overflow())
{
if (connect())
queueState(SM_ACT_DEV_SYNC);
}
break;
// Synchronize with device.
case SM_ACT_DEV_SYNC:
if (m_wdog.overflow())
{
failActivation(DTR("failed to synchronize with device"));
queueState(SM_IDLE);
}
else
{
if (synchronize())
queueState(SM_ACT_LOG_REQUEST);
}
break;
// Request log name.
case SM_ACT_LOG_REQUEST:
if (m_wdog.overflow())
{
failActivation(DTR("failed to request current log name"));
queueState(SM_IDLE);
}
else
{
closeLog();
requestLogName();
queueState(SM_ACT_LOG_WAIT);
}
break;
// Wait for log name.
case SM_ACT_LOG_WAIT:
if (m_wdog.overflow())
{
failActivation(DTR("failed to retrieve current log name"));
queueState(SM_IDLE);
}
else
{
if (m_log_opened)
queueState(SM_ACT_DONE);
}
break;
// Activation procedure is complete.
case SM_ACT_DONE:
activate();
queueState(SM_ACT_SAMPLE);
break;
// Read samples.
case SM_ACT_SAMPLE:
readSample();
break;
// Start deactivation procedure.
case SM_DEACT_BEGIN:
setEntityState(IMC::EntityState::ESTA_NORMAL, Status::CODE_DEACTIVATING);
m_wdog.setTop(getDeactivationTime());
queueState(SM_DEACT_DISCONNECT);
break;
// Gracefully disconnect from device.
case SM_DEACT_DISCONNECT:
disconnect();
closeLog();
m_power_off_timer.setTop(m_power_off_delay);
queueState(SM_DEACT_POWER_OFF);
break;
// Turn power off.
case SM_DEACT_POWER_OFF:
if (m_power_off_timer.overflow() || m_wdog.overflow())
{
turnPowerOff();
queueState(SM_DEACT_POWER_WAIT);
}
break;
// Wait for power to be turned off.
case SM_DEACT_POWER_WAIT:
if (!isPowered())
queueState(SM_DEACT_DONE);
break;
// Deactivation is complete.
case SM_DEACT_DONE:
deactivate();
queueState(SM_IDLE);
break;
}
}
void muJetVariable_NoWeightNoFilter(std::string inputFile, std::string outputFile){
// read the ntuples (in pcncu)
std::vector<string> infiles;
readSample(inputFile, infiles);
TreeReader data(infiles);
// Declare the histogram
Int_t nBin = 20;
TH1D* h_nVtx = new TH1D("h_nVtx", "nVtx", 100, -1, 99);
TH1D* h_FATjetPt = new TH1D("h_FATjetPt", "FATjetPt", nBin, 100, 1000);
TH1D* h_FATjetEta = new TH1D("h_FATjetEta", "FATjetEta", nBin, -4, 4);
TH1D* h_FATjetCISVV2 = new TH1D("h_FATjetCISVV2", "FATjetCISVV2", nBin, 0, 1.2);
TH1D* h_FATjetSDmass = new TH1D("h_FATjetSDmass", "FATjetSDmass", nBin, 0, 200);
TH1D* h_FATjetPRmass = new TH1D("h_FATjetPRmass", "FATjetPRmass", nBin, 0, 200);
TH1D* h_FATjetPRmassCorr = new TH1D("h_FATjetPRmassCorr", "FATjetPRmassCorr", nBin, 0, 200);
TH1D* h_FATjetTau1 = new TH1D("h_FATjetTau1", "FATjetTau1", nBin, 0, 1);
TH1D* h_FATjetTau2 = new TH1D("h_FATjetTau2", "FATjetTau2", nBin, 0, 1);
TH1D* h_FATjetTau2dvTau1 = new TH1D("h_FATjetTau2dvTau1", "FATjetTau2dvTau1", nBin, 0, 1);
TH1D* h_FATsubjetPt = new TH1D("h_FATsubjetPt", "FATsubjetPt", nBin, 0, 800);
TH1D* h_FATsubjetEta = new TH1D("h_FATsubjetEta", "FATsubjetEta", nBin, -4, 4);
TH1D* h_FATsubjetSDCSV = new TH1D("h_FATsubjetSDCSV", "FATsubjetSDCSV", nBin, 0, 1.2);
TH1D* h_eventWeight = new TH1D("h_eventWeight", "eventWeight", 2, -1, 1);
h_nVtx ->Sumw2();
h_FATjetPt ->Sumw2();
h_FATjetEta ->Sumw2();
h_FATjetCISVV2 ->Sumw2();
h_FATjetSDmass ->Sumw2();
h_FATjetPRmass ->Sumw2();
h_FATjetPRmassCorr->Sumw2();
h_FATjetTau1 ->Sumw2();
h_FATjetTau2 ->Sumw2();
h_FATjetTau2dvTau1->Sumw2();
h_FATsubjetPt ->Sumw2();
h_FATsubjetEta ->Sumw2();
h_FATsubjetSDCSV ->Sumw2();
h_nVtx ->GetXaxis()->SetTitle("nVtx");
h_FATjetPt ->GetXaxis()->SetTitle("FATjetPt");
h_FATjetEta ->GetXaxis()->SetTitle("FATjetEta");
h_FATjetCISVV2 ->GetXaxis()->SetTitle("FATjetCISVV2");
h_FATjetSDmass ->GetXaxis()->SetTitle("FATjetSDmass");
h_FATjetPRmass ->GetXaxis()->SetTitle("FATjetPRmass");
h_FATjetPRmassCorr->GetXaxis()->SetTitle("FATjetPRmassL2L3Corr");
h_FATjetTau1 ->GetXaxis()->SetTitle("FATjetTau1");
h_FATjetTau2 ->GetXaxis()->SetTitle("FATjetTau2");
h_FATjetTau2dvTau1->GetXaxis()->SetTitle("FATjetTau2dvTau1");
h_FATsubjetPt ->GetXaxis()->SetTitle("FATsubjetPt");
h_FATsubjetEta ->GetXaxis()->SetTitle("FATsubjetEta");
h_FATsubjetSDCSV ->GetXaxis()->SetTitle("FATsubjetSDCSV");
// begin of event loop
for( Long64_t ev = 0; ev < data.GetEntriesFast(); ev++ ){
if( ev % 1000000 == 0 )
fprintf(stderr, "Processing event %lli of %lli\n", ev + 1, data.GetEntriesFast());
data.GetEntry(ev);
Int_t nVtx = data.GetInt("nVtx");
Bool_t isData = data.GetBool("isData");
TClonesArray* muP4 = (TClonesArray*) data.GetPtrTObject("muP4");
Int_t FATnJet = data.GetInt("FATnJet");
Int_t* FATnSubSDJet = data.GetPtrInt("FATnSubSDJet");
Float_t* FATjetCISVV2 = data.GetPtrFloat("FATjetCISVV2");
Float_t* FATjetSDmass = data.GetPtrFloat("FATjetSDmass");
Float_t* FATjetPRmass = data.GetPtrFloat("FATjetPRmass");
Float_t* FATjetPRmassCorr = data.GetPtrFloat("FATjetPRmassL2L3Corr");
Float_t* FATjetTau1 = data.GetPtrFloat("FATjetTau1");
Float_t* FATjetTau2 = data.GetPtrFloat("FATjetTau2");
TClonesArray* FATjetP4 = (TClonesArray*) data.GetPtrTObject("FATjetP4");
vector<bool>& FATjetPassIDLoose = *((vector<bool>*) data.GetPtr("FATjetPassIDLoose"));
vector<float>* FATsubjetSDPx = data.GetPtrVectorFloat("FATsubjetSDPx", FATnJet);
vector<float>* FATsubjetSDPy = data.GetPtrVectorFloat("FATsubjetSDPy", FATnJet);
vector<float>* FATsubjetSDPz = data.GetPtrVectorFloat("FATsubjetSDPz", FATnJet);
vector<float>* FATsubjetSDE = data.GetPtrVectorFloat("FATsubjetSDE", FATnJet);
vector<float>* FATsubjetSDCSV = data.GetPtrVectorFloat("FATsubjetSDCSV", FATnJet);
// remove event which is no hard interaction (noise)
if( nVtx < 1 ) continue;
// Correct the pile-up shape of MC
//Double_t eventWeight = correctMCWeight(isData, nVtx);
Float_t mcWeight = data.GetFloat("mcWeight");
Double_t eventWeight = mcWeight;
if( inputFile.find("DYJets") != std::string::npos ){
if( eventWeight > 0 ) eventWeight = 1;
else if( eventWeight < 0 ) eventWeight = -1;
}
else
eventWeight = 1;
h_eventWeight->Fill(0.,eventWeight);
// data filter and trigger cut
bool muTrigger = TriggerStatus(data, "HLT_Mu45");
bool CSCT = FilterStatus(data, "Flag_CSCTightHaloFilter");
bool eeBadSc = FilterStatus(data, "Flag_eeBadScFilter");
bool Noise = FilterStatus(data, "Flag_HBHENoiseFilter");
bool NoiseIso = FilterStatus(data, "Flag_HBHENoiseIsoFilter");
if( !muTrigger ) continue;
// if( isData && !CSCT ) continue;
// if( isData && !eeBadSc ) continue;
// if( isData && !Noise ) continue;
// if( isData && !NoiseIso ) continue;
// select good muons
vector<Int_t> goodMuID;
if( !isPassZmumu(data, goodMuID) ) continue;
TLorentzVector* thisMu = (TLorentzVector*)muP4->At(goodMuID[0]);
TLorentzVector* thatMu = (TLorentzVector*)muP4->At(goodMuID[1]);
// select good FATjet
Int_t goodFATJetID = -1;
TLorentzVector* thisJet = NULL;
for(Int_t ij = 0; ij < FATnJet; ij++){
thisJet = (TLorentzVector*)FATjetP4->At(ij);
if( thisJet->Pt() < 200 ) continue;
if( fabs(thisJet->Eta()) > 2.4 ) continue;
if( !FATjetPassIDLoose[ij] ) continue;
if( thisJet->DeltaR(*thisMu) < 0.8 || thisJet->DeltaR(*thatMu) < 0.8 ) continue;
if( FATjetPRmassCorr[ij] > 65 && FATjetPRmassCorr[ij] < 145 ) continue;
goodFATJetID = ij;
break;
}
if( goodFATJetID < 0 ) continue;
h_nVtx ->Fill(nVtx,eventWeight);
h_FATjetPt ->Fill(thisJet->Pt(),eventWeight);
h_FATjetEta ->Fill(thisJet->Eta(),eventWeight);
h_FATjetCISVV2 ->Fill(FATjetCISVV2[goodFATJetID],eventWeight);
h_FATjetSDmass ->Fill(FATjetSDmass[goodFATJetID],eventWeight);
h_FATjetPRmass ->Fill(FATjetPRmass[goodFATJetID],eventWeight);
h_FATjetPRmassCorr->Fill(FATjetPRmassCorr[goodFATJetID],eventWeight);
h_FATjetTau1 ->Fill(FATjetTau1[goodFATJetID],eventWeight);
h_FATjetTau2 ->Fill(FATjetTau2[goodFATJetID],eventWeight);
h_FATjetTau2dvTau1->Fill(FATjetTau2[goodFATJetID]/FATjetTau1[goodFATJetID],eventWeight);
for(Int_t is = 0; is < FATnSubSDJet[goodFATJetID]; is++){
TLorentzVector l4_subjet(0,0,0,0);
l4_subjet.SetPxPyPzE(FATsubjetSDPx[goodFATJetID][is],
FATsubjetSDPy[goodFATJetID][is],
FATsubjetSDPz[goodFATJetID][is],
FATsubjetSDE [goodFATJetID][is]);
h_FATsubjetPt ->Fill(l4_subjet.Pt(),eventWeight);
h_FATsubjetEta ->Fill(l4_subjet.Eta(),eventWeight);
h_FATsubjetSDCSV->Fill(FATsubjetSDCSV[goodFATJetID][is],eventWeight);
}
} // end of event loop
fprintf(stderr, "Processed all events\n");
TFile* outFile = new TFile(Form("%s_jetmumuVariableNoWeightNoFilter.root",outputFile.c_str()), "recreate");
h_nVtx ->Write("nVtx");
h_FATjetPt ->Write("FATjetPt");
h_FATjetEta ->Write("FATjetEta");
h_FATjetCISVV2 ->Write("FATjetCISVV2");
h_FATjetSDmass ->Write("FATjetSDmass");
h_FATjetPRmass ->Write("FATjetPRmass");
h_FATjetPRmassCorr->Write("FATjetPRmassCorr");
h_FATjetTau1 ->Write("FATjetTau1");
h_FATjetTau2 ->Write("FATjetTau2");
h_FATjetTau2dvTau1->Write("FATjetTau2dvTau1");
h_FATsubjetPt ->Write("FATsubjetPt");
h_FATsubjetEta ->Write("FATsubjetEta");
h_FATsubjetSDCSV ->Write("FATsubjetSDCSV");
h_eventWeight ->Write("eventWeight");
outFile->Write();
}
int main(int argc, char *argv[ ])
{
FILE *infile, *outfile;
char prefix[4];
char fileFormat[4];
char ckID[4];
unsigned long nChunkSize;
short wFormatTag;
short nChannels;
unsigned long nSamplesPerSecond;
unsigned long nBytesPerSecond;
unsigned long nOutputSamplesPerSecond;
short nBlockAlign;
short nBitsPerSample;
int i, j;
if (argc < 3)
{
printf("WavToRaw %s - Stephane Dallongeville - copyright 2014\n", version);
printf("\n");
printf("Usage: wav2raw sourceFile destFile <outRate>\n");
printf("Output rate is given in Hz.\n");
printf("Success returns errorlevel 0. Error return greater than zero.\n");
printf("\n");
printf("Ex: wav2raw input.wav output.raw 11025\n");
exit(1);
}
/* Open source for binary read (will fail if file does not exist) */
if ((infile = fopen( argv[1], "rb" )) == NULL)
{
printf("The source file %s was not opened\n", argv[1]);
exit(2);
}
if (argc > 3)
nOutputSamplesPerSecond = atoi(argv[3]);
else
nOutputSamplesPerSecond = 0;
/* Read the header bytes. */
fscanf( infile, "%4s", prefix );
fscanf( infile, "%4c", &nChunkSize );
fscanf( infile, "%4c", fileFormat );
fscanf( infile, "%4c", ckID );
fscanf( infile, "%4c", &nChunkSize );
fscanf( infile, "%2c", &wFormatTag );
fscanf( infile, "%2c", &nChannels );
fscanf( infile, "%4c", &nSamplesPerSecond );
fscanf( infile, "%4c", &nBytesPerSecond );
fscanf( infile, "%2c", &nBlockAlign );
fscanf( infile, "%2c", &nBitsPerSample );
// pass extra bytes in bloc
for(i = 0; i < nChunkSize - 0x10; i++)
fscanf( infile, "%1c", &j);
fscanf( infile, "%4c", ckID );
fscanf( infile, "%4c", &nChunkSize );
if (nOutputSamplesPerSecond == 0)
nOutputSamplesPerSecond = nSamplesPerSecond;
/* Open output for write */
if( (outfile = fopen( argv[2], "wb" )) == NULL )
{
printf("The output file %s was not opened\n", argv[2]);
exit(3);
}
int nBytesPerSample = nBitsPerSample / 8;
int size = nChunkSize / (nChannels * nBytesPerSample);
const double *data = readSample(infile, nChunkSize, nBytesPerSample, nChannels);
int iOffset;
double offset;
double step;
double value;
double lastSample;
step = nSamplesPerSecond;
step /= nOutputSamplesPerSecond;
value = 0;
lastSample = 0;
iOffset = 0;
for(offset = 0; offset < size; offset += step)
{
char byte;
double sample = 0;
// extrapolation
if (step > 1.0)
{
if (value < 0) sample += lastSample * -value;
value += step;
while(value > 0)
{
lastSample = data[iOffset++];
if (value >= 1)
sample += lastSample;
else
sample += lastSample * value;
value--;
}
sample /= step;
}
// interpolation
else
{
// if (floor(offset) == offset)
sample = data[(int) offset];
// else
// {
// double sample0 = data[(int) floor(offset)];
// double sample1 = data[(int) ceil(offset)];
//
// sample += sample0 * (ceil(offset) - offset);
// sample += sample1 * (offset - floor(offset));
// }
}
byte = round(sample);
fwrite(&byte, 1, 1, outfile);
}
fclose(infile);
fclose(outfile);
return 0;
}
void eleZVariable(std::string inputFile, std::string outputFile){
//void eleZVariable(){
// std::string inputFile = "/data7/yuchang/NCUGlobalTuples_80X/SingleElectron";
// read the ntuples (in pcncu) and combine TTree
std::vector<string> infiles;
readSample(inputFile, infiles);
cout<<"infiles.size():"<< infiles.size() << endl;
TChain* tree = new TChain("tree/treeMaker");
std::string open_root;
for(unsigned int i=0 ; i<infiles.size() ; i++ ){
// for(unsigned int i=0 ; i<5 ; i++ ){
// open_root="root://" + infiles[0] ;
open_root="root://" + infiles[i] ;
// cout<<"open_root: "<< open_root<< endl;
tree->Add( open_root.c_str() );
}
cout<<"tree->GetEntries(): "<< tree->GetEntries() << endl;
// read TTree
TreeReader data( tree );
// Declare the histogram
TFile* f = new TFile(inputFile.data());
TH1D* h_totalEvents = new TH1D("h_totalEv" , "totalEvents", 10 ,0, 10);
TH1D* h_1stEle_pt_1 = new TH1D("h_1stEle_pt_1", "Leading_pt_stage1", 30, 0, 300);
TH1D* h_1stEle_pt_2 = new TH1D("h_1stEle_pt_2", "Leading_pt_stage2", 30, 0, 300);
TH1D* h_1stEle_pt_3 = new TH1D("h_1stEle_pt_3", "Leading_pt_stage3", 30, 0, 300);
TH1D* h_2ndEle_pt_2 = new TH1D("h_2ndEle_pt_2", "SubLeading_pt_stage2", 30, 0, 300);
TH1D* h_1stEle_eta_2 = new TH1D("h_1stEle_eta_2", "Leading_eta_stage2", 60 , -3 , 3);
TH1D* h_2ndEle_eta_2 = new TH1D("h_2ndEle_eta_2", "SubLeading_eta_stage2", 60 , -3 , 3);
TH1D* h_Zpt_1 = new TH1D("h_Zpt_1", "Zpt", 60, 0, 600);
TH1D* h_Zpt_2 = new TH1D("h_Zpt_2", "Zpt_stage2", 60, 0, 600);
TH1D* h_Zpt_3 = new TH1D("h_Zpt_3", "Zpt_stage3", 60, 0, 600);
TH1D* h_Zmass_1 = new TH1D("h_Zmass_1", "Zmass", 30, 60, 120);
TH1D* h_Zmass_2 = new TH1D("h_Zmass_2", "Zmass_stage2", 30, 60, 120);
TH1D* h_Zmass_3 = new TH1D("h_Zmass_3", "Zmass_stage3", 30, 60, 120);
h_1stEle_pt_2->Sumw2();
h_1stEle_pt_3->Sumw2();
h_2ndEle_pt_2->Sumw2();
h_1stEle_eta_2->Sumw2();
h_2ndEle_eta_2->Sumw2();
h_Zpt_2->Sumw2();
h_Zpt_3->Sumw2();
h_Zmass_2->Sumw2();
h_Zmass_3->Sumw2();
h_1stEle_pt_2->GetXaxis()->SetTitle("leadElePt");
h_1stEle_pt_3->GetXaxis()->SetTitle("leadElePt");
h_2ndEle_pt_2->GetXaxis()->SetTitle("subleadElePt");
h_1stEle_eta_2->GetXaxis()->SetTitle("leadEleEta");
h_2ndEle_eta_2->GetXaxis()->SetTitle("subleadEleEta");
h_Zpt_2->GetXaxis()->SetTitle("Zpt");
h_Zpt_3->GetXaxis()->SetTitle("Zpt");
h_Zmass_2->GetXaxis()->SetTitle("Zmass");
h_Zmass_3->GetXaxis()->SetTitle("Zmass");
// counter
int counter_0=0;
int counter_1=0;
int counter_2=0;
int counter_3=0;
// begin of event loop
// int Number_to_print = 100000;
int Number_to_print = 100000;
int Max_number_to_read = 1000000;
// int Max_number_to_read = 1000;
// int Max_number_to_read = 100;
for( Long64_t ev = 0; ev < data.GetEntriesFast(); ev++ ){
if( ev % Number_to_print == 0 )
fprintf(stderr, "Processing event %lli of %lli\n", ev + 1, data.GetEntriesFast());
if( ev > Max_number_to_read) break;
data.GetEntry(ev);
h_totalEvents->Fill(1,1);
// ------ counter0 --------
unsigned long eventId = data.GetLong64("eventId");
unsigned long runId = data.GetLong64("runId");
unsigned long lumiSection = data.GetLong64("lumiSection");
Bool_t isData = data.GetBool("isData");
Int_t nVtx = data.GetInt("nVtx");
std::string* trigName = data.GetPtrString("hlt_trigName");
vector<bool>& trigResult = *((vector<bool>*) data.GetPtr("hlt_trigResult"));
bool triggerStat = false;
std::string TRIGGERNAME = "HLT_Ele105";// HLT_Ele105_CaloIdVT_GsfTrkIdT_v3
if (isData){ // apply HLT on data
for(int it = 0; it < data.GetPtrStringSize(); it++){
std::string thisTrig = trigName[it];
bool results = trigResult[it];
if( thisTrig.find(TRIGGERNAME) != std::string::npos && results ){
triggerStat = true;
break;
}
}
}// if isData
else triggerStat = true; // don't apply HLT on MC temporarily
if( nVtx < 1 ) continue;
// if( !triggerStat ) continue;
counter_0++;
// cout<<"isData: "<< isData << endl;
// ------ counter1 --------
const Int_t nEle = data.GetInt("nEle");
const Int_t* eleCharge = data.GetPtrInt("eleCharge");
const Float_t* eleScEta = data.GetPtrFloat("eleScEta");
const Float_t* eleMiniIsoEA = data.GetPtrFloat("eleMiniIsoEA");
const vector<bool>& eleIsPassHEEPNoIso = *((vector<bool>*) data.GetPtr("eleIsPassHEEPNoIso"));
const vector<bool>& eleIsPassLoose = *((vector<bool>*) data.GetPtr("eleIsPassLoose"));
const TClonesArray* eleP4 = (TClonesArray*) data.GetPtrTObject("eleP4");
if (nEle >1){
counter_1++;
TLorentzVector* Ele1 = (TLorentzVector*)eleP4->At(0);
TLorentzVector* Ele2 = (TLorentzVector*)eleP4->At(1);
if ( Ele1->Pt() < Ele2->Pt() ){cout<<" ele[1] pt > ele[0] "<<endl; }
TLorentzVector Z_boson = (*Ele1+*Ele2);
h_1stEle_pt_1->Fill( Ele1->Pt() );
h_Zpt_1 ->Fill( Z_boson.Pt() );
h_Zmass_1 ->Fill( Z_boson.M() );
}
// ------ counter2 --------
// select good electrons
std::vector<Int_t> goodElectrons;
goodElectrons.clear();
for(Int_t ie = 0; ie < nEle; ie++){
TLorentzVector* myEle = (TLorentzVector*)eleP4->At(ie);
if( !(fabs(eleScEta[ie]) < 1.4442 || fabs(eleScEta[ie]) > 1.566) ) continue;
if( fabs(eleScEta[ie]) > 2.5 ) continue;
if( myEle->Pt() < 35 ) continue;
if( !eleIsPassLoose[ie] ) continue;
goodElectrons.push_back(ie);
}
if ( goodElectrons.size() >1 ){
counter_2++;
TLorentzVector* Ele1 = (TLorentzVector*)eleP4->At( goodElectrons[0] );
TLorentzVector* Ele2 = (TLorentzVector*)eleP4->At( goodElectrons[1] );
TLorentzVector Z_boson = (*Ele1+*Ele2);
h_1stEle_pt_2->Fill( Ele1->Pt() );
h_2ndEle_pt_2->Fill( Ele2->Pt() );
h_1stEle_eta_2->Fill( eleScEta[ goodElectrons[0] ] );
h_2ndEle_eta_2->Fill( eleScEta[ goodElectrons[1] ] );
h_Zpt_2 ->Fill( Z_boson.Pt() );
h_Zmass_2 ->Fill( Z_boson.M() );
}
// ------ counter3 --------
// select good Z boson
vector<Int_t> goodEleID;
goodEleID.clear();
bool findEPair = false;
TLorentzVector* thisEle = NULL;
TLorentzVector* thatEle = NULL;
// std::cout<<" goodElectrons.size = "<<goodElectrons.size()<<std::endl;
for(unsigned int i = 0; i < goodElectrons.size(); i++){
Int_t ie = goodElectrons[i];
thisEle = (TLorentzVector*)eleP4->At(ie);
for(unsigned int j = 0; j < i; j++){
Int_t je = goodElectrons[j];
thatEle = (TLorentzVector*)eleP4->At(je);
Float_t pt1 = thisEle->Pt();
Float_t pt2 = thatEle->Pt();
Float_t mll = (*thisEle+*thatEle).M();
Float_t ptll = (*thisEle+*thatEle).Pt();
if( eleCharge[ie]*eleCharge[je] > 0 ) continue;
if( TMath::Max(pt1,pt2) < 115 ) continue;
if( mll < 70 || mll > 110 ) continue;
if( ptll < 200 ) continue;
if( !findEPair ){
goodEleID.push_back( (pt1 > pt2) ? ie : je );
goodEleID.push_back( (pt1 > pt2) ? je : ie );
}// end if
findEPair = true;
break;
}// loop j
}// loop i
if ( goodEleID.size() >1 ){
// std::cout<<" goodEleID.size = "<<goodEleID.size()<<std::endl;
counter_3++;
TLorentzVector* Ele1 = (TLorentzVector*)eleP4->At( goodEleID[0] );
TLorentzVector* Ele2 = (TLorentzVector*)eleP4->At( goodEleID[1] );
TLorentzVector Z_boson = (*Ele1+*Ele2);
/*
cout<<"eventId: "<< eventId << endl;
cout<<"runId: "<< runId << endl;
cout<<"lumiSection: "<< lumiSection << endl;
std::cout<<" px = "<<Ele1->Px()
<<" py = "<<Ele1->Py()
<<" pz = "<<Ele1->Pz()
<<" E = "<<Ele1->E()
<<std::endl;
std::cout<<" Z pt = "<< Z_boson.Pt()
<<" Z mass = "<<Z_boson.M()
<<std::endl;
*/
h_1stEle_pt_3->Fill( Ele1->Pt() );
h_Zpt_3 ->Fill( Z_boson.Pt() );
h_Zmass_3 ->Fill( Z_boson.M() );
// cout<<endl;
// cout<<"ev: "<< ev <<endl;
// cout<<"Ele1->Pt(): " << Ele1->Pt() << endl;
// cout<<"Z_boson.Pt(): "<< Z_boson.Pt() << endl;
// cout<<"Z_boson.M(): " << Z_boson.M() << endl;
}
} // end of event loop
cout<<"counter_0: "<< counter_0 << endl;
cout<<"counter_1: "<< counter_1 << endl;
cout<<"counter_2: "<< counter_2 << endl;
cout<<"counter_3: "<< counter_3 << endl;
fprintf(stderr, "Processed all events\n");
// TFile* outFile = new TFile("test_Ele_data.root", "recreate");
TFile* outFile = new TFile(Form("%s_NoCut.root",outputFile.c_str()), "recreate");
// h_1stEle_pt_1 ->Write();
// h_1stEle_pt_2 ->Write();
h_1stEle_pt_3 ->Write("Leading_pt_stage3");
// h_Zpt_1 ->Write();
// h_Zpt_2 ->Write();
h_Zpt_3 ->Write("Zpt_stage3");
// h_Zmass_1 ->Write();
// h_Zmass_2 ->Write();
h_Zmass_3 ->Write("Zmass_stage3");
/*
h_1stEle_pt_2 ->Write("Leading_pt_stage2");
h_2ndEle_pt_2 ->Write("SubLeading_pt_stage2");
h_1stEle_eta_2 ->Write("Leading_eta_stage2");
h_2ndEle_eta_2 ->Write("SubLeading_eta_stage2");
h_Zpt_2 ->Write("Zpt_stage2");
h_Zmass_2 ->Write("Zmass_stage2");
*/
h_totalEvents ->Write("totalEvents");
outFile->Write();
delete f;
delete outFile;
}
int Xform::eachSample(const SampleCallback & cb)
{
if (getSummary().type == XformSummary::Type::TRS) {
// gather time samples
std::map<Time, int> times;
eachAttribute([×](Attribute *a) {
if (strncmp(a->getName(), "xformOp:translate", 17) == 0) {
auto ts = a->getTimeSamples();
int flag = (int)XformData::Flags::UpdatedPosition;
if (ts.empty()) {
times[usdiDefaultTime()] |= flag;
}
else
{
for (auto& t : ts) { times[t] |= flag; }
}
}
else if (strncmp(a->getName(), "xformOp:scale", 13) == 0) {
auto ts = a->getTimeSamples();
int flag = (int)XformData::Flags::UpdatedScale;
if (ts.empty()) {
times[usdiDefaultTime()] |= flag;
}
else {
for (auto& t : ts) { times[t] |= flag; }
}
}
else if (strncmp(a->getName(), "xformOp:rotate", 14) == 0 || strncmp(a->getName(), "xformOp:orient", 14) == 0) {
auto ts = a->getTimeSamples();
int flag = (int)XformData::Flags::UpdatedRotation;
if (ts.empty()) {
times[usdiDefaultTime()] |= flag;
}
else {
for (auto& t : ts) { times[t] |= flag; }
}
}
});
XformData data;
for (const auto& t : times) {
readSample(data, t.first);
data.flags = t.second;;
cb(data, t.first);
}
return (int)times.size();
}
else {
// gather time samples
std::map<Time, int> times;
eachAttribute([×](Attribute *a) {
if (strncmp(a->getName(), "xformOp:", 8) == 0) {
auto ts = a->getTimeSamples();
if (ts.empty()) {
times[usdiDefaultTime()] = 0;
}
else {
for (auto& t : ts) { times[t] = 0; }
}
}
});
XformData data;
for (const auto& t : times) {
readSample(data, t.first);
cb(data, t.first);
}
return (int)times.size();
}
}
void mZHmuLimitV1C1(std::string inputFile, std::string outputFile){
// read the ntuples (in pcncu)
std::vector<string> infiles;
readSample(inputFile, infiles);
TreeReader data(infiles);
// Declare the histogram
TH1D* h_mZprime = new TH1D("h_mZprime", "mZprime", 100, 400, 5000);
TH1D* h_eventWeight = new TH1D("h_eventWeight", "eventWeight", 2, -1, 1);
h_mZprime->Sumw2();
h_mZprime->GetXaxis()->SetTitle("mZprime");
// begin of event loop
for( Long64_t ev = 0; ev < data.GetEntriesFast(); ev++){
if( ev % 1000000 == 0 )
fprintf(stderr, "Processing event %lli of %lli\n", ev + 1, data.GetEntriesFast());
data.GetEntry(ev);
Int_t nVtx = data.GetInt("nVtx");
Bool_t isData = data.GetBool("isData");
Float_t pu_nTrueInt = data.GetFloat("pu_nTrueInt");
TClonesArray* muP4 = (TClonesArray*) data.GetPtrTObject("muP4");
Int_t FATnJet = data.GetInt("FATnJet");
Int_t* FATnSubSDJet = data.GetPtrInt("FATnSubSDJet");
Float_t* corrPRmass = data.GetPtrFloat("FATjetPRmassL2L3Corr");
TClonesArray* FATjetP4 = (TClonesArray*) data.GetPtrTObject("FATjetP4");
vector<bool>& FATjetPassIDLoose = *((vector<bool>*) data.GetPtr("FATjetPassIDLoose"));
vector<float>* FATsubjetSDPx = data.GetPtrVectorFloat("FATsubjetSDPx", FATnJet);
vector<float>* FATsubjetSDPy = data.GetPtrVectorFloat("FATsubjetSDPy", FATnJet);
vector<float>* FATsubjetSDPz = data.GetPtrVectorFloat("FATsubjetSDPz", FATnJet);
vector<float>* FATsubjetSDE = data.GetPtrVectorFloat("FATsubjetSDE", FATnJet);
vector<float>* FATsubjetSDCSV = data.GetPtrVectorFloat("FATsubjetSDCSV", FATnJet);
// remove event which is no hard interaction (noise)
if( nVtx < 1 ) continue;
// Correct the pile-up shape of MC
Double_t eventWeight = pileupWeight(isData, (Int_t)pu_nTrueInt);
h_eventWeight->Fill(0.,eventWeight);
// data filter (to filter non-collision bkg (ECAL/HCAL noise)) and trigger cut
bool muTrigger = TriggerStatus(data, "HLT_Mu45");
bool CSCT = FilterStatus(data, "Flag_CSCTightHaloFilter");
bool eeBadSc = FilterStatus(data, "Flag_eeBadScFilter");
bool Noise = FilterStatus(data, "Flag_HBHENoiseFilter");
bool NoiseIso = FilterStatus(data, "Flag_HBHENoiseIsoFilter");
if( !muTrigger ) continue;
if( isData && !CSCT ) continue;
if( isData && !eeBadSc ) continue;
if( isData && !Noise ) continue;
if( isData && !NoiseIso ) continue;
// select good muons
vector<Int_t> goodMuID;
if( !isPassZmumu(data, goodMuID) ) continue;
TLorentzVector* thisMu = (TLorentzVector*)muP4->At(goodMuID[0]);
TLorentzVector* thatMu = (TLorentzVector*)muP4->At(goodMuID[1]);
// select good FATjet
Int_t goodJetID = -1;
TLorentzVector* thisJet = NULL;
for(Int_t ij = 0; ij < FATnJet; ij++){
thisJet = (TLorentzVector*)FATjetP4->At(ij);
if( thisJet->Pt() < 200 ) continue;
if( fabs(thisJet->Eta()) > 2.4 ) continue;
if( corrPRmass[ij] < 105 || corrPRmass[ij] > 135 ) continue;
if( !FATjetPassIDLoose[ij] ) continue;
if( thisJet->DeltaR(*thisMu) < 0.8 || thisJet->DeltaR(*thatMu) < 0.8 ) continue;
Int_t nsubBjet = 0;
for(Int_t is = 0; is < FATnSubSDJet[ij]; is++){
if( FATsubjetSDCSV[ij][is] > 0.605 ) nsubBjet++;
}
Double_t subjetDeltaR = -1;
if( nsubBjet == 2 ){
TLorentzVector l4_subjet0(0,0,0,0);
TLorentzVector l4_subjet1(0,0,0,0);
l4_subjet0.SetPxPyPzE(FATsubjetSDPx[ij][0],
FATsubjetSDPy[ij][0],
FATsubjetSDPz[ij][0],
FATsubjetSDE [ij][0]);
l4_subjet1.SetPxPyPzE(FATsubjetSDPx[ij][1],
FATsubjetSDPy[ij][1],
FATsubjetSDPz[ij][1],
FATsubjetSDE [ij][1]);
subjetDeltaR = l4_subjet0.DeltaR(l4_subjet1);
}
// deltaR depends loose cut
// if( subjetDeltaR < 0.3 && nsubBjet < 1 ) continue;
// if( subjetDeltaR > 0.3 && nsubBjet < 2 ) continue;
// category one
if( subjetDeltaR > 0.3 ) continue;
if( nsubBjet < 1 ) continue;
goodJetID = ij;
break;
}
if( goodJetID < 0 ) continue;
Float_t mllbb = (*thisMu+*thatMu+*thisJet).M();
if( mllbb < 700 ) continue;
h_mZprime->Fill(mllbb,eventWeight);
} // end of event loop
fprintf(stderr, "Processed all events\n");
TFile* outFile = new TFile(Form("%s_mZHmuSignal_catOne.root",outputFile.c_str()), "recreate");
h_mZprime ->Write("mZprime");
h_eventWeight->Write("eventWeight");
outFile->Write();
}
// discardMissing means any data with 1 or more missing attributes will be
// discarded. Note that this may make the dataset returned inconsistent
// with what dataSummary() returns.
Data* new_readData(const char dataName[], int discardMissing)
{
Data *data;
int nSamples, nAttributes, targetIndex;
Array<int> attNValues(1), hasMissingValues(1), isDiscrete(1);
Array<double> maxVals(1), minVals(1);
readDataInfo(dataName, &nSamples, &nAttributes, attNValues, hasMissingValues,
isDiscrete, maxVals, minVals, &targetIndex);
// nAttributes counts target as an attribute as well.
// for class Data, we'll need to subtract 1 back off for data->nAttributes;
// allocate space for and set up internals of data
data = new Data(nSamples, nAttributes-1);
// nAttributes-1 because class Data does not count
// target as an attribute, whereas our file format does.
assert(data != NULL);
int dex=0;
for (int att=0; att < nAttributes; att++)
{
if (att == targetIndex)
{
data->targetIsContinuous = !isDiscrete[att];
assert(!hasMissingValues[att]); // missing values not allowed in target
// printf("[%d]", hasMissingValues[att]);
data->targetNValues = attNValues[att];
}
else
{
data->attIsContinuous[dex] = !isDiscrete[att];
data->hasMissingValues[dex] = hasMissingValues[att];
// printf("(%d)", hasMissingValues[att]);
data->attNValues[dex] = attNValues[att];
dex++;
}
}
assert(dex == nAttributes-1);
// start reading the data
char datFilename[4096];
strcpy(datFilename, DATADIR); strcat(datFilename, dataName);
strcat(datFilename, "/"); strcat(datFilename, dataName);
strcat(datFilename, ".dat"); // ".../data/foo/foo.dat"
FILE *fp = safe_fopen(datFilename, "rt");
int sampleDex=0, nHasMissingAtt=0;
for (int ctr=0; ctr < nSamples; ctr++)
{
int hasMissingAtt = readSample(fp, data, nAttributes, targetIndex, hasMissingValues, sampleDex);
if (discardMissing && hasMissingAtt)
nHasMissingAtt++;
else
sampleDex++;
}
fclose(fp);
// If some samples were discarded, then shrink the datastructures to reflect
// that we didn't actually get nSamples examples read in.
if (!discardMissing)
assert(nHasMissingAtt==0 && sampleDex==nSamples);
if (discardMissing)
{
data->nSamples = nSamples - nHasMissingAtt;
if (data->nSamples == 0)
error("new_readData: After discarding missing, have no data left!");
for (int dex=0; dex < data->nAttributes; dex++)
data->hasMissingValues[dex] = 0;
Matrix temp(data->nSamples, data->nAttributes);
for (int i=0; i < data->nSamples; i++) for (int j=0; j < data->nAttributes; j++)
temp[i][j] = data->dataSample[i][j];
data->dataSample.resize(data->nSamples, data->nAttributes);
data->dataSample = temp;
}
data->shuffleSample();
assert(data->nAttributes == nAttributes-1);
return data;
}
