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
 * ************************ */

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];
}

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	pam-fi	1.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
74			void PamCutCollection::AddCut(PamCut &cut) {
75			_cuts.push_back(&cut);
76			}
77
78			int PamCutCollection::Check(PamLevel2 *event) {
79
80			// Apply the cuts
81			if (_cuts.size() == 0) {
82			return CUTOK;
83			}
84
85			for (unsigned int icut = 0; icut < _cuts.size(); icut++) {
86			if (_cuts[icut]->Check(event) != CUTOK) {
87			return icut;
88			}
89			}
90
91			return CUTOK;
92			}
93
94			int PamCutCollection::ApplyCut(PamLevel2 *event) {
95
96			_nEv++;
97			// Apply the cuts
98			if (_cuts.size() == 0) {
99			_nGood++;
100			OnGood(event);
101			return CUTOK;
102			}
103
104			for (unsigned int icut = 0; icut < _cuts.size(); icut++) {
105			if (_cuts[icut]->ApplyCut(event) != CUTOK) {
106			OnBad(event, icut);
107			return icut;
108			}
109			}
110
111			_nGood++;
112			OnGood(event);
113			return CUTOK;
114			}
115
116			PamCut *PamCutCollection::GetCut(unsigned int iCut) {
117			if (_cuts.size() == 0)
118			return NULL;
119			if (iCut < 0 \|\| iCut > _cuts.size() - 1)
120			return NULL;
121			else
122			return _cuts[iCut];
123			}
124
125			unsigned int PamCutCollection::GetSize() {
126			return (unsigned int) _cuts.size();
127
128			}
129
130			PamCutCollection& PamCutCollection::operator=(const PamCutCollection &rightValue) {
131
132			PamCut::operator=(rightValue);
133			_cuts = rightValue._cuts;
134			return *this;
135			}
136
137
138			void PamCutCollection::Setup(PamLevel2 *events){
139
140			PamCut::Setup(events);
141
142			for (unsigned int i = 0; i < GetSize(); i++){
143			_cuts[i]->Setup(events);
144			}
145			}
146
147			void PamCutCollection::Finalize(){
148
149			// PamCut::Finalize() is currently void, but in future it could contain something, so it's good to place a call here.
150			PamCut::Finalize();
151
152			for (unsigned int i = 0; i < GetSize(); i++){
153			_cuts[i]->Finalize();
154			}
155			}