PamCut/PamCutBase/PamCutBase.cpp

/*
 * PamCutBase.cpp
 *
 *  Created on: 12-feb-2009
 *      Author: Nicola Mori
 */

/*! @file PamCutBase.cpp Implementation for classes defined in PamCut.h */

#include "PamCutBase.h"

/* ************** *
 *     PAMCUT
 * ************** */
int PamCut::ApplyCut(PamLevel2 *event) {

  _nEv++;
  int result = Check(event);
  if (result == CUTOK) {
    _nGood++;
    OnGood(event);
  }
  else {
    OnBad(event, result);
  }
  return result;

}

void PamCut::Process(PamLevel2 *events, ULong_t firstEvent, ULong_t lastEvent) {

  // Check the range of events to analyze
  if (firstEvent > lastEvent) {
    return;
  }
  if (firstEvent < 0 || lastEvent > events->GetEntries() - 1) {
    return;
  }

  // Prepare the counters for the new analysis
  Setup(events);

  // Apply the cuts
  for (ULong_t iev = firstEvent; iev < lastEvent + 1; iev++) {
    events->GetEntry(iev);
    ApplyCut(events);
  }

  // Closes the analysis
  Finalize();

}
void PamCut::Setup(PamLevel2 *events) {
  _nEv = _nGood = 0;
}

const char* PamCut::GetName() const {
  return _cutName;
}

void PamCut::SetName(const char *newName) {
  _cutName = newName;
}

PamCut& PamCut::operator=(const PamCut &rightValue) {
  _cutName = rightValue._cutName;
  return *this;
}

/* ************************ *
 *     PAMCUTCOLLECTION
 * ************************ */
PamCutCollection::~PamCutCollection(){

  if (_owns){
    for (unsigned int i = 0; i < _cuts.size(); i++)
      if (_cuts[i] != NULL){
        delete _cuts[i];
        _cuts[i] = NULL;
      }
  }
}


void PamCutCollection::AddCut(PamCut *cut) {
  _cuts.push_back(cut);
}

int PamCutCollection::Check(PamLevel2 *event) {

  // Apply the cuts
  if (_cuts.size() == 0) {
    return CUTOK;
  }

  for (unsigned int icut = 0; icut < _cuts.size(); icut++) {
    if (_cuts[icut]->Check(event) != CUTOK) {
      return icut;
    }
  }

  return CUTOK;
}

int PamCutCollection::ApplyCut(PamLevel2 *event) {

  _nEv++;
  // Apply the cuts
  if (_cuts.size() == 0) {
    _nGood++;
    OnGood(event);
    return CUTOK;
  }

  for (unsigned int icut = 0; icut < _cuts.size(); icut++) {
    if (_cuts[icut]->ApplyCut(event) != CUTOK) {
      OnBad(event, icut);
      return icut;
    }
  }

  _nGood++;
  OnGood(event);
  return CUTOK;
}

PamCut *PamCutCollection::GetCut(unsigned int iCut) {
  if (_cuts.size() == 0)
    return NULL;
  if (iCut < 0 || iCut > _cuts.size() - 1)
    return NULL;
  else
    return _cuts[iCut];
}

PamCut *PamCutCollection::GetCut(const char *cutName) {
  if (_cuts.size() == 0)
    return NULL;
  for (unsigned int i = 0; i < _cuts.size(); i++){
    if (strcmp(_cuts[i]->GetName(), cutName) == 0)
      return _cuts[i];
  }

  return NULL;
}

unsigned int PamCutCollection::GetSize() {
  return (unsigned int) _cuts.size();

}

PamCutCollection& PamCutCollection::operator=(const PamCutCollection &rightValue) {

  PamCut::operator=(rightValue);
  _cuts = rightValue._cuts;
  return *this;
}

void PamCutCollection::Setup(PamLevel2 *events) {

  PamCut::Setup(events);

  for (unsigned int i = 0; i < GetSize(); i++) {
    _cuts[i]->Setup(events);
  }
}

void PamCutCollection::Finalize() {

  // PamCut::Finalize() is currently void, but in future it could contain something, so it's good to place a call here.
  PamCut::Finalize();

  for (unsigned int i = 0; i < GetSize(); i++) {
    _cuts[i]->Finalize();
  }
}
1	/*
2	* PamCutBase.cpp
3	*
4	* Created on: 12-feb-2009
5	* Author: Nicola Mori
6	*/
7
8	/! @file PamCutBase.cpp Implementation for classes defined in PamCut.h /
9
10	#include "PamCutBase.h"
11
12	/* ************** *
13	* PAMCUT
14	* ************** */
15	int PamCut::ApplyCut(PamLevel2 *event) {
16
17	_nEv++;
18	int result = Check(event);
19	if (result == CUTOK) {
20	_nGood++;
21	OnGood(event);
22	}
23	else {
24	OnBad(event, result);
25	}
26	return result;
27
28	}
29
30	void PamCut::Process(PamLevel2 *events, ULong_t firstEvent, ULong_t lastEvent) {
31
32	// Check the range of events to analyze
33	if (firstEvent > lastEvent) {
34	return;
35	}
36	if (firstEvent < 0 \|\| lastEvent > events->GetEntries() - 1) {
37	return;
38	}
39
40	// Prepare the counters for the new analysis
41	Setup(events);
42
43	// Apply the cuts
44	for (ULong_t iev = firstEvent; iev < lastEvent + 1; iev++) {
45	events->GetEntry(iev);
46	ApplyCut(events);
47	}
48
49	// Closes the analysis
50	Finalize();
51
52	}
53	void PamCut::Setup(PamLevel2 *events) {
54	_nEv = _nGood = 0;
55	}
56
57	const char* PamCut::GetName() const {
58	return _cutName;
59	}
60
61	void PamCut::SetName(const char *newName) {
62	_cutName = newName;
63	}
64
65	PamCut& PamCut::operator=(const PamCut &rightValue) {
66	_cutName = rightValue._cutName;
67	return *this;
68	}
69
70	/* ************************ *
71	* PAMCUTCOLLECTION
72	* ************************ */
73	PamCutCollection::~PamCutCollection(){
74
75	if (_owns){
76	for (unsigned int i = 0; i < _cuts.size(); i++)
77	if (_cuts[i] != NULL){
78	delete _cuts[i];
79	_cuts[i] = NULL;
80	}
81	}
82	}
83
84
85	void PamCutCollection::AddCut(PamCut *cut) {
86	_cuts.push_back(cut);
87	}
88
89	int PamCutCollection::Check(PamLevel2 *event) {
90
91	// Apply the cuts
92	if (_cuts.size() == 0) {
93	return CUTOK;
94	}
95
96	for (unsigned int icut = 0; icut < _cuts.size(); icut++) {
97	if (_cuts[icut]->Check(event) != CUTOK) {
98	return icut;
99	}
100	}
101
102	return CUTOK;
103	}
104
105	int PamCutCollection::ApplyCut(PamLevel2 *event) {
106
107	_nEv++;
108	// Apply the cuts
109	if (_cuts.size() == 0) {
110	_nGood++;
111	OnGood(event);
112	return CUTOK;
113	}
114
115	for (unsigned int icut = 0; icut < _cuts.size(); icut++) {
116	if (_cuts[icut]->ApplyCut(event) != CUTOK) {
117	OnBad(event, icut);
118	return icut;
119	}
120	}
121
122	_nGood++;
123	OnGood(event);
124	return CUTOK;
125	}
126
127	PamCut *PamCutCollection::GetCut(unsigned int iCut) {
128	if (_cuts.size() == 0)
129	return NULL;
130	if (iCut < 0 \|\| iCut > _cuts.size() - 1)
131	return NULL;
132	else
133	return _cuts[iCut];
134	}
135
136	PamCut PamCutCollection::GetCut(const char cutName) {
137	if (_cuts.size() == 0)
138	return NULL;
139	for (unsigned int i = 0; i < _cuts.size(); i++){
140	if (strcmp(_cuts[i]->GetName(), cutName) == 0)
141	return _cuts[i];
142	}
143
144	return NULL;
145	}
146
147	unsigned int PamCutCollection::GetSize() {
148	return (unsigned int) _cuts.size();
149
150	}
151
152	PamCutCollection& PamCutCollection::operator=(const PamCutCollection &rightValue) {
153
154	PamCut::operator=(rightValue);
155	_cuts = rightValue._cuts;
156	return *this;
157	}
158
159	void PamCutCollection::Setup(PamLevel2 *events) {
160
161	PamCut::Setup(events);
162
163	for (unsigned int i = 0; i < GetSize(); i++) {
164	_cuts[i]->Setup(events);
165	}
166	}
167
168	void PamCutCollection::Finalize() {
169
170	// PamCut::Finalize() is currently void, but in future it could contain something, so it's good to place a call here.
171	PamCut::Finalize();
172
173	for (unsigned int i = 0; i < GetSize(); i++) {
174	_cuts[i]->Finalize();
175	}
176	}