AEvent.cpp 6.19 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 * AEvent.cpp
 *
 *  Created on: Dec 28, 2016
 *      Author: daria
 */

#include "AEvent.h"

10
AEvent::AEvent() : fNPoints(1024) {	//fNPoints is number of points in one event, 1024 or 1000
11 12 13 14 15 16

	Init();
	Reset();

}

17 18 19 20 21 22
AEvent::AEvent(const Int_t npoints) : fNPoints(npoints) {

	Init();
	Reset();
}

23 24
AEvent::~AEvent() {
	// TODO Auto-generated destructor stub
25 26
	delete fGraphSignal;
	delete fGraphCFD;
27
	delete fInputEvent;
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
}

void AEvent::SetRawDataFile(const char* inprawfile, const char* treename) {

	TString iFileName = inprawfile;
	TFile *fraw = new TFile(iFileName.Data());
	if ( !fraw->IsOpen() ) {
		Error("SetRawDataFile", "File %s was not opened and won't be processed", iFileName.Data());
	}
	TTree *traw = (TTree*)fraw->Get(treename);
	if (!traw) {
		Error("SetRawDataFile", "Tree %s was not found in file %s", treename, iFileName.Data());
	}
}

void AEvent::ProcessEvent() {

	if (fInputEvent == NULL) {
		Warning("AEvent::ProcessEvent", "Input event wasn't set. Function won't be processed.");
		return;
	}

	const Double_t *amp = fInputEvent->GetAmp();
	const Double_t *time = fInputEvent->GetTime();

53
	for(Int_t j = 0; j < fNPoints; j++) {
54 55 56 57
		fAmpPos[j] = amp[j]*(-1.);
		fTime[j] = time[j];
	}

58
	fZeroLevel = FindZeroLevel();
59
	for(Int_t j = 0; j < fNPoints; j++) {
60
		fAmpPos[j] = fAmpPos[j] - fZeroLevel;
61 62
	}

63
	SetMaxAmplitudes();
64

65
	SetGraphs();
66
	FindFrontProperties();
67
	SetGraphs();
68
	SetCFD();
69
	SetChargeCFD();
70

71 72 73 74 75 76
	return;

}

void AEvent::Reset() {

77
	for (Int_t i = 0; i < fNPoints; i++) {
78 79
		fAmpPos[i] = 0;
		fTime[i] = 0;
80
		fAmpCFD[i] = 0;
81 82
	}

83
	fEdgeSlope=0.;
84
	fEdgeSlope=-100.;
85 86
	fTime10=0.;
	fTime90=0.;
87 88
	fAmpMax = 0.;
	fTimeAmpMax = 0.;
89 90
	fTimeCFD = 0.;
	fZeroLevel = 0.;
91
	fChargeCFD = 0.;
92 93 94 95 96 97 98 99 100 101 102 103 104
}

void AEvent::SetInputEvent(RawEvent** event) {

	if (event == 0) {
		Warning("AEvent::SetInputEvent", "Input event was set as 0.");
	}
	fInputEvent = *event;

}

void AEvent::Init() {

105 106 107 108
	fAmpPos.Set(fNPoints);
	fTime.Set(fNPoints);
	fAmpCFD.Set(fNPoints);

109 110
	fGraphSignal = new TGraph();
	fGraphCFD = new TGraph();
111 112
	fInputEvent = 0;

113 114 115
	fCFratio = 0.;
	fCFtimeDelay = 0.;

116 117 118
	fNoiseRangeMin = 0.;
	fNoiseRangeMax = 1.;

119 120 121 122
}

void AEvent::SetGraphs() {

123
	fGraphSignal->Set(fNPoints);
124 125

	for (Int_t i=0; i<fNPoints; i++) {
126
		fGraphSignal->SetPoint(i, fTime[i], fAmpPos[i]);
127 128 129 130
	}

	return;
}
131

132
void AEvent::SetCFD() {
133 134

	Double_t level = 100.;	//is necessary to find cfd amplitude value closest to zero
135 136 137 138 139 140

	fGraphCFD->Set(fNPoints);

	//working variables
	Double_t maxCFD = 0., minCFD = 0.;
	Int_t imax = 0, imin = 0;
141 142 143

	for (Int_t i=0; i<fNPoints; i++) {

144 145 146 147 148
		//CFD method
		if(i>fCFtimeDelay) {
			fAmpCFD[i] = fAmpPos[i]*fCFratio*(-1);
			fAmpCFD[i] = fAmpCFD[i] + fAmpPos[i - fCFtimeDelay];
			fGraphCFD->SetPoint(i, fTime[i], fAmpCFD[i]);
149 150
		}

151
		//point for max CFD amplitude
152
		if(fAmpCFD[i] > maxCFD) {
153 154
			maxCFD = fAmpCFD[i];
			imax = i;
155 156
		}

157
		//point for min CFD amplitude
158
		if(fAmpCFD[i] < minCFD) {
159 160
			minCFD = fAmpCFD[i];
			imin = i;
161 162 163 164 165 166
		}

	}

	//finding "zero" of CFD amplitude
	for(Int_t j = imin; j < imax; j++) {   
167 168
		if(abs(fAmpCFD[j]) < level) {
			level = abs(fAmpCFD[j]);
169
			fTimeCFD = fTime[j];
170
		}
171
	}
Muzalevsky I.A's avatar
Muzalevsky I.A committed
172
}
173 174 175
/////// trying to create method
void AEvent::FindFrontProperties() {

176 177 178 179 180
	//in percents
	const Double_t minHeight = 0.1;
	const Double_t maxHeight = 0.9;

	const Double_t timeStep = 0.05;	//in ns
181
	Double_t time = 0;			//in ns
182
//	Int_t NumM = 0.;
183

184
	if (!fGraphSignal) {
185
		Warning("AEvent::FindFrontProperties", "Graph was not set");
186 187 188
		return;
	}

189 190
	//TODO search of minimum should be done from the lower edge on the time axis
//	cout << "Event!!!!!!!!!!!!!" << endl;
191 192
//	while( fGraphSignal->Eval(time) >= minHeight*fAmpMax && time>0) {
	while (fGraphSignal->Eval(time) <= maxHeight*fAmpMax && time<200.) {
193 194
//		cout << fAmpMax << "\t" << fGraphSignal->Eval(time) << "\t" << fTimeAmpMax << "\t" << time << endl;
		fTime90 = time;
195 196 197 198 199 200
		time = time + timeStep;
	};

	time = fTime90;
	while( fGraphSignal->Eval(time) >= minHeight*fAmpMax && time>0) {
		fTime10 = time;
201
		time = time - timeStep;
202
	}
203 204 205
//	cout << "Found time10 " << fTime10 << "\t" << fGraphSignal->Eval(fTime10) << "\t" << minHeight*fAmpMax << "\t" << fAmpMax << endl;
//	cout << "Found time10 " << fTime10 << "\t" << TMath::Abs(fGraphSignal->Eval(fTime10) - minHeight*fAmpMax) / fAmpMax * 100 << endl;
//	cout << "Found time90 " << fTime90 << "\t" << GetT_90() << endl;
206 207 208

//	cout<< "Time90 - time10 "<< fTime90 - fTime10 << endl;
//	if(fTime90 - fTime10 == 0.25 ) { cout<< "Zero !!"<<endl; }
209

210
	TF1 *fit1 = new TF1("fit1","[1]*x+[0]");	//function for one parameter fitting in the range of pmin-pmax
211
	fit1->SetRange(fTime10,fTime90);
212 213
//	fGraphSignal->Fit(fit1,"RQ","goff");
	fGraphSignal->Fit(fit1,"RQN","goff");
214
	fEdgeSlope = fit1->GetParameter(1);
215 216 217 218

	delete fit1;
}
////////
219
Double_t AEvent::FindZeroLevel() {
220 221 222

	SetGraphs();
	Double_t correction = 0;
223
	TF1 *fit1 = new TF1("fit1","[0]");	//function for one parameter fitting in the range of pmin-pmax
224
	fit1->SetRange(fNoiseRangeMin,fNoiseRangeMax);
225 226 227 228 229

	if (!fGraphSignal) {
		Warning("AEvent::FindZeroLevel", "Graph was not set");
		return 0;
	}
230

231 232
	fGraphSignal->Fit(fit1,"RQN","goff");
	correction = fit1->GetParameter(0);
233

234 235
	delete fit1;
	return correction;
236
}
237

238 239
void AEvent::SetChargeCFD(Int_t tmin, Int_t tmax) {
	
240 241 242 243
	Double_t integral = 0.;					//voltage
	Double_t time_sig = 0;					//approximate signal duration in seconds
	const Double_t res = 50.; 				//resistance 50 Om
	time_sig = (double)(-tmin + tmax)*(1e-9);
244 245

	for(Int_t i = 0; i < fNPoints; i++) {
246
		if( fTime[i] > (fTimeCFD + tmin) && fTime[i] < (fTimeCFD + tmax) ) {
247 248 249
			integral = integral + fAmpPos[i];
		}
	}
250
	fChargeCFD = integral*time_sig/res;
251 252 253 254 255 256 257
//	cout<<fCharge<<endl;
//	printf("\nIntegral is %f , charge is %lf \n", integral, fCharge);

	return;

}

Muzalevsky I.A's avatar
Muzalevsky I.A committed
258
Double_t AEvent::GetfCFD() {
259
		return fTimeCFD;
Muzalevsky I.A's avatar
Muzalevsky I.A committed
260 261 262 263 264
}

Double_t AEvent::GetOnefTime(Int_t i) {
		return fTime[i];
}
265

Muzalevsky I.A's avatar
Muzalevsky I.A committed
266 267
Double_t AEvent::GetOnefAmpPos(Int_t i) {
		return fAmpPos[i];
268
}
269 270

Double_t AEvent::GetT_10() {
271
		return fTime10;
272 273 274
}

Double_t AEvent::GetT_90() {
275
		return fTime90;
276 277 278
}

Double_t AEvent::GetEdgeSlope() {
279 280
		return fEdgeSlope;
}
281

282 283 284 285 286 287 288 289 290 291 292 293 294
void AEvent::SetMaxAmplitudes() {
	Double_t maxAmp = 0.;
	Double_t maxAmpT = 0.;

	maxAmp = fAmpPos[0];
	for(Int_t j=0; j < fNPoints; j++) {
		if(fAmpPos[j] > maxAmp) {
			maxAmp = fAmpPos[j];
			maxAmpT = fTime[j];
		}
	}
	fAmpMax = maxAmp;
	fTimeAmpMax = maxAmpT;
295

296
}