-/**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * *
- * Author: The ALICE Off-line Project. *
- * Contributors are mentioned in the code where appropriate. *
- * *
- * Permission to use, copy, modify and distribute this software and its *
- * documentation strictly for non-commercial purposes is hereby granted *
- * without fee, provided that the above copyright notice appears in all *
- * copies and that both the copyright notice and this permission notice *
- * appear in the supporting documentation. The authors make no claims *
- * about the suitability of this software for any purpose. It is *
- * provided "as is" without express or implied warranty. *
- **************************************************************************/
+//**************************************************************************
+// * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+// * *
+// * Author: The ALICE Off-line Project. *
+// * Contributors are mentioned in the code where appropriate. *
+// * *
+// * Permission to use, copy, modify and distribute this software and its *
+// * documentation strictly for non-commercial purposes is hereby granted *
+// * without fee, provided that the above copyright notice appears in all *
+// * copies and that both the copyright notice and this permission notice *
+//* appear in the supporting documentation. The authors make no claims *
+//* about the suitability of this software for any purpose. It is *
+//* provided "as is" without express or implied warranty. *
+//**************************************************************************/
/* $Id$ */
// in the function "FollowBackProlongation" (AliTRDtracker)
// Per default the functions to fill are off.
//
-// Author:
-// R. Bailhache (R.Bailhache@gsi.de)
+// Authors:
+// R. Bailhache (R.Bailhache@gsi.de, rbailhache@ikf.uni-frankfurt.de)
+// J. Book (jbook@ikf.uni-frankfurt.de)
//
//////////////////////////////////////////////////////////////////////////////////////
#include <TDirectory.h>
#include <TTreeStream.h>
#include <TVectorD.h>
+#include <TLinearFitter.h>
#include "AliLog.h"
#include "AliTRDCalibraVdriftLinearFit.h"
#include "AliTRDcalibDB.h"
#include "AliTRDCommonParam.h"
-#include "AliTRDmcmTracklet.h"
-#include "AliTRDmcm.h"
-#include "AliTRDtrigParam.h"
#include "AliTRDpadPlane.h"
#include "AliTRDcluster.h"
#include "AliTRDtrack.h"
#include "AliTRDtrackV1.h"
-#include "AliTRDrawStreamBase.h"
#include "AliRawReader.h"
#include "AliRawReaderDate.h"
#include "AliTRDgeometry.h"
#include "./Cal/AliTRDCalROC.h"
+#include "./Cal/AliTRDCalPad.h"
#include "./Cal/AliTRDCalDet.h"
+#include "AliTRDdigitsManager.h"
+#include "AliTRDdigitsParam.h"
+#include "AliTRDSignalIndex.h"
+#include "AliTRDarrayADC.h"
+
+#include "AliTRDrawStream.h"
+
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+
#ifdef ALI_DATE
#include "event.h"
#endif
AliTRDCalibraFillHisto::AliTRDCalibraFillHisto()
:TObject()
,fGeo(0)
- ,fMcmCorrectAngle(kFALSE)
+ ,fCalibDB(0)
+ ,fIsHLT(kFALSE)
,fCH2dOn(kFALSE)
,fPH2dOn(kFALSE)
,fPRF2dOn(kFALSE)
,fThresholdClusterPRF2(15.0)
,fLimitChargeIntegration(kFALSE)
,fFillWithZero(kFALSE)
+ ,fNormalizeNbOfCluster(kFALSE)
+ ,fMaxCluster(0)
+ ,fNbMaxCluster(0)
+ ,fVersionGainUsed(0)
+ ,fSubVersionGainUsed(0)
+ ,fVersionGainLocalUsed(0)
+ ,fSubVersionGainLocalUsed(0)
+ ,fVersionVdriftUsed(0)
+ ,fSubVersionVdriftUsed(0)
,fCalibraMode(new AliTRDCalibraMode())
,fDebugStreamer(0)
,fDebugLevel(0)
,fDetectorPreviousTrack(-1)
,fMCMPrevious(-1)
,fROBPrevious(-1)
- ,fNumberClusters(0)
+ ,fNumberClusters(1)
,fNumberClustersf(30)
+ ,fNumberClustersProcent(0.5)
+ ,fThresholdClustersDAQ(120.0)
+ ,fNumberRowDAQ(2)
+ ,fNumberColDAQ(4)
,fProcent(6.0)
,fDifference(17)
,fNumberTrack(0)
,fTimeMax(0)
,fSf(10.0)
- ,fNumberBinCharge(100)
- ,fNumberBinPRF(40)
- ,fNgroupprf(0)
+ ,fNumberBinCharge(50)
+ ,fNumberBinPRF(10)
+ ,fNgroupprf(3)
,fAmpTotal(0x0)
,fPHPlace(0x0)
,fPHValue(0x0)
fNumberUsedPh[1] = 0;
fGeo = new AliTRDgeometry();
-
+ fCalibDB = AliTRDcalibDB::Instance();
}
//______________________________________________________________________________________
AliTRDCalibraFillHisto::AliTRDCalibraFillHisto(const AliTRDCalibraFillHisto &c)
:TObject(c)
,fGeo(0)
- ,fMcmCorrectAngle(c.fMcmCorrectAngle)
+ ,fCalibDB(0)
+ ,fIsHLT(c.fIsHLT)
,fCH2dOn(c.fCH2dOn)
,fPH2dOn(c.fPH2dOn)
,fPRF2dOn(c.fPRF2dOn)
,fThresholdClusterPRF2(c.fThresholdClusterPRF2)
,fLimitChargeIntegration(c.fLimitChargeIntegration)
,fFillWithZero(c.fFillWithZero)
+ ,fNormalizeNbOfCluster(c.fNormalizeNbOfCluster)
+ ,fMaxCluster(c.fMaxCluster)
+ ,fNbMaxCluster(c.fNbMaxCluster)
+ ,fVersionGainUsed(c.fVersionGainUsed)
+ ,fSubVersionGainUsed(c.fSubVersionGainUsed)
+ ,fVersionGainLocalUsed(c.fVersionGainLocalUsed)
+ ,fSubVersionGainLocalUsed(c.fSubVersionGainLocalUsed)
+ ,fVersionVdriftUsed(c.fVersionVdriftUsed)
+ ,fSubVersionVdriftUsed(c.fSubVersionVdriftUsed)
,fCalibraMode(0x0)
,fDebugStreamer(0)
,fDebugLevel(c.fDebugLevel)
,fROBPrevious(c.fROBPrevious)
,fNumberClusters(c.fNumberClusters)
,fNumberClustersf(c.fNumberClustersf)
+ ,fNumberClustersProcent(c.fNumberClustersProcent)
+ ,fThresholdClustersDAQ(c.fThresholdClustersDAQ)
+ ,fNumberRowDAQ(c.fNumberRowDAQ)
+ ,fNumberColDAQ(c.fNumberColDAQ)
,fProcent(c.fProcent)
,fDifference(c.fDifference)
,fNumberTrack(c.fNumberTrack)
delete fGeo;
}
fGeo = new AliTRDgeometry();
+ fCalibDB = AliTRDcalibDB::Instance();
+
+ fNumberUsedCh[0] = 0;
+ fNumberUsedCh[1] = 0;
+ fNumberUsedPh[0] = 0;
+ fNumberUsedPh[1] = 0;
+
}
//____________________________________________________________________________________
TLinearFitter *f = (TLinearFitter*)fLinearFitterArray.At(idet);
if(f) { delete f;}
}
+ if(fLinearVdriftFit) delete fLinearVdriftFit;
if (fGeo) {
delete fGeo;
}
//
if ( fDebugStreamer ) delete fDebugStreamer;
+ fDebugStreamer = 0x0;
}
//_____________________________________________________________________________
// calibration with AliTRDtrackV1: Init, Update
//////////////////////////////////////////////////////////////////////////////////
//____________Functions for initialising the AliTRDCalibraFillHisto in the code_________
-Bool_t AliTRDCalibraFillHisto::Init2Dhistos()
+Bool_t AliTRDCalibraFillHisto::Init2Dhistos(Int_t nboftimebin)
{
//
// Init the histograms and stuff to be filled
}
// Some parameters
- fTimeMax = cal->GetNumberOfTimeBins();
+ if(nboftimebin > 0) fTimeMax = nboftimebin;
+ else fTimeMax = cal->GetNumberOfTimeBinsDCS();
+ if(fTimeMax <= 0) fTimeMax = 30;
+ printf("////////////////////////////////////////////\n");
+ printf("Number of time bins in calibration component %d\n",fTimeMax);
+ printf("////////////////////////////////////////////\n");
fSf = parCom->GetSamplingFrequency();
- fRelativeScale = 20;
+ if(!fNormalizeNbOfCluster) fRelativeScale = 20.0;
+ else fRelativeScale = 1.18;
fNumberClustersf = fTimeMax;
- fNumberClusters = (Int_t)(0.5*fTimeMax);
+ fNumberClusters = (Int_t)(fNumberClustersProcent*fTimeMax);
// Init linear fitter
if(!fLinearFitterTracklet) {
fLinearFitterTracklet = new TLinearFitter(2,"pol1");
- fLinearFitterTracklet->StoreData(kFALSE);
+ fLinearFitterTracklet->StoreData(kTRUE);
}
- //calib object from database used for reconstruction
- if( fCalDetGain ){
- fCalDetGain->~AliTRDCalDet();
- new(fCalDetGain) AliTRDCalDet(*(cal->GetGainFactorDet()));
- }else fCalDetGain = new AliTRDCalDet(*(cal->GetGainFactorDet()));
-
// Calcul Xbins Chambd0, Chamb2
Int_t ntotal0 = CalculateTotalNumberOfBins(0);
Int_t ntotal1 = CalculateTotalNumberOfBins(1);
fCalibraVector->SetDetCha0(k,fCalibraMode->GetDetChamb0(k));
fCalibraVector->SetDetCha2(k,fCalibraMode->GetDetChamb2(k));
}
- TString namech("Nz");
- namech += fCalibraMode->GetNz(0);
- namech += "Nrphi";
- namech += fCalibraMode->GetNrphi(0);
- fCalibraVector->SetNameCH((const char* ) namech);
- TString nameph("Nz");
- nameph += fCalibraMode->GetNz(1);
- nameph += "Nrphi";
- nameph += fCalibraMode->GetNrphi(1);
- fCalibraVector->SetNamePH((const char* ) nameph);
- TString nameprf("Nz");
- nameprf += fCalibraMode->GetNz(2);
- nameprf += "Nrphi";
- nameprf += fCalibraMode->GetNrphi(2);
- nameprf += "Ngp";
- nameprf += fNgroupprf;
- fCalibraVector->SetNamePRF((const char* ) nameprf);
+ fCalibraVector->SetNzNrphi(0,fCalibraMode->GetNz(0),fCalibraMode->GetNrphi(0));
+ fCalibraVector->SetNzNrphi(1,fCalibraMode->GetNz(1),fCalibraMode->GetNrphi(1));
+ fCalibraVector->SetNzNrphi(2,fCalibraMode->GetNz(2),fCalibraMode->GetNrphi(2));
+ fCalibraVector->SetNbGroupPRF(fNgroupprf);
}
// Create the 2D histos corresponding to the pad groupCalibration mode
}
}
if (fLinearFitterOn) {
- //fLinearFitterArray.Expand(540);
- fLinearFitterArray.SetName("ArrayLinearFitters");
- fEntriesLinearFitter = new Int_t[540];
- for(Int_t k = 0; k < 540; k++){
- fEntriesLinearFitter[k] = 0;
+ if(fLinearFitterDebugOn) {
+ fLinearFitterArray.SetName("ArrayLinearFitters");
+ fEntriesLinearFitter = new Int_t[540];
+ for(Int_t k = 0; k < 540; k++){
+ fEntriesLinearFitter[k] = 0;
+ }
}
fLinearVdriftFit = new AliTRDCalibraVdriftLinearFit();
}
}
}
+ return kTRUE;
+
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+Bool_t AliTRDCalibraFillHisto::InitCalDet()
+{
+ //
+ // Init the Gain Cal Det
+ //
+
+ // DB Setting
+ // Get cal
+ AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/ChamberGainFactor",AliCDBManager::Instance()->GetRun(),fVersionGainUsed,fSubVersionGainUsed);
+ if(!entry) {
+ AliError("No gain det calibration entry found");
+ return kFALSE;
+ }
+ AliTRDCalDet *calDet = (AliTRDCalDet *)entry->GetObject();
+ if(!calDet) {
+ AliError("No calDet gain found");
+ return kFALSE;
+ }
+
+
+ if( fCalDetGain ){
+ fCalDetGain->~AliTRDCalDet();
+ new(fCalDetGain) AliTRDCalDet(*(calDet));
+ }else fCalDetGain = new AliTRDCalDet(*(calDet));
+
+
+ // title CH2d
+ TString name("Ver");
+ name += fVersionGainUsed;
+ name += "Subver";
+ name += fSubVersionGainUsed;
+ name += "Nz";
+ name += fCalibraMode->GetNz(0);
+ name += "Nrphi";
+ name += fCalibraMode->GetNrphi(0);
+
+ fCH2d->SetTitle(name);
+
+ // title PH2d
+ TString namee("Ver");
+ namee += fVersionVdriftUsed;
+ namee += "Subver";
+ namee += fSubVersionVdriftUsed;
+ namee += "Nz";
+ namee += fCalibraMode->GetNz(1);
+ namee += "Nrphi";
+ namee += fCalibraMode->GetNrphi(1);
+
+ fPH2d->SetTitle(namee);
+
+
+ return kTRUE;
+
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////
+Bool_t AliTRDCalibraFillHisto::InitCalPad(Int_t detector)
+{
+ //
+ // Init the Gain Cal Pad
+ //
+
+ // DB Setting
+ // Get cal
+ AliCDBEntry *entry = AliCDBManager::Instance()->Get("TRD/Calib/LocalGainFactor",AliCDBManager::Instance()->GetRun(),fVersionGainLocalUsed,fSubVersionGainLocalUsed);
+ if(!entry) {
+ AliError("No gain pad calibration entry found");
+ return kFALSE;
+ }
+ AliTRDCalPad *calPad = (AliTRDCalPad *)entry->GetObject();
+ if(!calPad) {
+ AliError("No calPad gain found");
+ return kFALSE;
+ }
+ AliTRDCalROC *calRoc = (AliTRDCalROC *)calPad->GetCalROC(detector);
+ if(!calRoc) {
+ AliError("No calRoc gain found");
+ return kFALSE;
+ }
+
+ if( fCalROCGain ){
+ fCalROCGain->~AliTRDCalROC();
+ new(fCalROCGain) AliTRDCalROC(*(calRoc));
+ }else fCalROCGain = new AliTRDCalROC(*(calRoc));
+
+
+
+
+
return kTRUE;
}
//____________Offline tracking in the AliTRDtracker____________________________
-Bool_t AliTRDCalibraFillHisto::UpdateHistograms(AliTRDtrack *t)
+Bool_t AliTRDCalibraFillHisto::UpdateHistograms(const AliTRDtrack *t)
{
//
// Use AliTRDtrack for the calibration
}
// Get calib objects
- if( fCalROCGain ){
- fCalROCGain->~AliTRDCalROC();
- new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
- }else fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
+ if(!fIsHLT) InitCalPad(detector);
}
}
//____________Offline tracking in the AliTRDtracker____________________________
-Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(AliTRDtrackV1 *t)
+Bool_t AliTRDCalibraFillHisto::UpdateHistogramsV1(const AliTRDtrackV1 *t)
{
//
// Use AliTRDtrackV1 for the calibration
const AliTRDseedV1 *tracklet = 0x0; // tracklet per plane
AliTRDcluster *cl = 0x0; // cluster attached now to the tracklet
+ AliTRDcluster *cls = 0x0; // shared cluster attached now to the tracklet
Bool_t newtr = kTRUE; // new track
// Get cal
- AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
+ // AliTRDcalibDB *cal = AliTRDcalibDB::Instance();
+ /*
if (!cal) {
AliInfo("Could not get calibDB");
return kFALSE;
}
+*/
+ if (!fCalibDB) {
+ AliInfo("Could not get calibDB");
+ return kFALSE;
+ }
+
///////////////////////////
// loop over the tracklet
//Localise the detector bin
LocalisationDetectorXbins(detector);
// Get calib objects
- if( fCalROCGain ){
- fCalROCGain->~AliTRDCalROC();
- new(fCalROCGain) AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
- }else fCalROCGain = new AliTRDCalROC(*(cal->GetGainFactorROC(detector)));
-
+ if(!fIsHLT) InitCalPad(detector);
+
// reset
fDetectorPreviousTrack = detector;
}
// loop over the clusters
////////////////////////////
Int_t nbclusters = 0;
- for(int jc=0; jc<AliTRDseed::knTimebins; jc++){
+ for(int jc=0; jc<AliTRDseedV1::kNtb; jc++){
if(!(cl = tracklet->GetClusters(jc))) continue;
nbclusters++;
Int_t group[2] = {0,0};
if(fCH2dOn) group[0] = CalculateCalibrationGroup(0,row,col);
if(fPH2dOn) group[1] = CalculateCalibrationGroup(1,row,col);
- StoreInfoCHPHtrack(cl, tracklet->GetdQdl(jc),group,row,col);
+ // Add the charge if shared cluster
+ cls = tracklet->GetClusters(jc+AliTRDseedV1::kNtb);
+ //
+ StoreInfoCHPHtrack(cl, tracklet->GetdQdl(jc),group,row,col,cls);
}
////////////////////////////////////////
// Fill the stuffs if a good tracklet
////////////////////////////////////////
if (fGoodTracklet) {
-
+
// drift velocity unables to cut bad tracklets
Bool_t pass = FindP1TrackPHtrackletV1(tracklet, nbclusters);
+ //printf("pass %d and nbclusters %d\n",pass,nbclusters);
+
// Gain calibration
if (fCH2dOn) {
FillTheInfoOfTheTrackCH(nbclusters);
// Routine inside the update with AliTRDtrack
///////////////////////////////////////////////////////////////////////////////////
//____________Offine tracking in the AliTRDtracker_____________________________
-Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtracklet(AliTRDtrack *t, Int_t index0, Int_t index1)
+Bool_t AliTRDCalibraFillHisto::FindP1TrackPHtracklet(const AliTRDtrack *t, Int_t index0, Int_t index1)
{
//
// Drift velocity calibration:
Double_t tgl = t->GetTglPlane(GetLayer(detector)); // dz/dl and not dz/dx!
Double_t tnp = 0.0; // tan angle in the plan xy track
if( TMath::Abs(snp) < 1.){
- tnp = snp / (TMath::Sqrt(1-(snp*snp)));
+ tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
}
Float_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx now from dz/dl
// tilting pad and cross row
if(npoints < fNumberClusters) return kFALSE;
if(npoints > fNumberClustersf) return kFALSE;
if(pointError >= 0.1) return kFALSE;
- if(crossrow == 1) return kFALSE;
+ if(crossrow == 1) return kTRUE;
////////////////////////////
// fill
//Add to the linear fitter of the detector
if( TMath::Abs(snp) < 1.){
Double_t x = tnp-dzdx*tnt;
- (GetLinearFitter(detector,kTRUE))->AddPoint(&x,dydt);
if(fLinearFitterDebugOn) {
- fLinearVdriftFit->Update(detector,x,pars[1]);
+ (GetLinearFitter(detector,kTRUE))->AddPoint(&x,dydt);
+ fEntriesLinearFitter[detector]++;
}
- fEntriesLinearFitter[detector]++;
+ fLinearVdriftFit->Update(detector,x,pars[1]);
}
}
Double_t snp = tracklet->GetSnp(); // sin dy/dx at the end of the chamber
Double_t tnp = 0.0; // dy/dx at the end of the chamber
if( TMath::Abs(snp) < 1.){
- tnp = snp / (TMath::Sqrt(1-(snp*snp)));
+ tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
}
Double_t tgl = tracklet->GetTgl(); // dz/dl
Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx calculated from dz/dl
////////////////////////////
Int_t nbli = 0;
AliTRDcluster *cl = 0x0;
- for(int ic=0; ic<AliTRDseed::knTimebins; ic++){
+ //////////////////////////////
+ // Check no shared clusters
+ //////////////////////////////
+ for(int icc=AliTRDseedV1::kNtb; icc<AliTRDseedV1::kNclusters; icc++){
+ cl = tracklet->GetClusters(icc);
+ if(cl) crossrow = 1;
+ }
+ //////////////////////////////////
+ // Loop clusters
+ //////////////////////////////////
+ for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
if(!(cl = tracklet->GetClusters(ic))) continue;
if((fLimitChargeIntegration) && (!cl->IsInChamber())) continue;
fLinearFitterTracklet->AddPoint(&timeis,ycluster,1);
nbli++;
+
}
////////////////////////////////////
pointError = TMath::Sqrt(fLinearFitterTracklet->GetChisquare()/(nbli-2));
errorpar = fLinearFitterTracklet->GetParError(1)*pointError;
dydt = pars[1];
+ //printf("chis %f, nbli %d, pointError %f, parError %f, errorpar %f\n",fLinearFitterTracklet->GetChisquare(),nbli,pointError,fLinearFitterTracklet->GetParError(1),errorpar);
fLinearFitterTracklet->ClearPoints();
////////////////////////////////
Int_t layer = GetLayer(fDetectorPreviousTrack);
-
+
(* fDebugStreamer) << "FindP1TrackPHtrackletV1"<<
//"snpright="<<snpright<<
+ "nbli="<<nbli<<
"nbclusters="<<nbclusters<<
"detector="<<fDetectorPreviousTrack<<
"layer="<<layer<<
/////////////////////////
// Cuts quality
////////////////////////
-
+
if(nbclusters < fNumberClusters) return kFALSE;
if(nbclusters > fNumberClustersf) return kFALSE;
- if(pointError >= 0.1) return kFALSE;
- if(crossrow == 1) return kFALSE;
+ if(pointError >= 0.3) return kFALSE;
+ if(crossrow == 1) return kTRUE;
///////////////////////
// Fill
//Add to the linear fitter of the detector
if( TMath::Abs(snp) < 1.){
Double_t x = tnp-dzdx*tnt;
- (GetLinearFitter(fDetectorPreviousTrack,kTRUE))->AddPoint(&x,dydt);
if(fLinearFitterDebugOn) {
- fLinearVdriftFit->Update(fDetectorPreviousTrack,x,pars[1]);
+ (GetLinearFitter(fDetectorPreviousTrack,kTRUE))->AddPoint(&x,dydt);
+ fEntriesLinearFitter[fDetectorPreviousTrack]++;
}
- fEntriesLinearFitter[fDetectorPreviousTrack]++;
+ fLinearVdriftFit->Update(fDetectorPreviousTrack,x,pars[1]);
}
}
return kTRUE;
}
//____________Offine tracking in the AliTRDtracker_____________________________
-Bool_t AliTRDCalibraFillHisto::HandlePRFtracklet(AliTRDtrack *t, Int_t index0, Int_t index1)
+Bool_t AliTRDCalibraFillHisto::HandlePRFtracklet(const AliTRDtrack *t, Int_t index0, Int_t index1)
{
//
// PRF width calibration
Float_t dzdx = 0.0; // dzdx
Float_t tnp = 0.0;
if(TMath::Abs(snp) < 1.0){
- tnp = snp / (TMath::Sqrt(1-snp*snp));
+ tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
dzdx = tgl*TMath::Sqrt(1+tnp*tnp);
}
// linear fitter
for(Int_t k = 0; k < npoints; k++){
//Take the cluster
AliTRDcluster *cl = (AliTRDcluster *) t->GetCluster(k+index0);
+ if(!cl) continue;
Short_t *signals = cl->GetSignals();
- Double_t time = cl->GetLocalTimeBin();
+ Double_t time = cl->GetPadTime();
//Calculate x if possible
Float_t xcenter = 0.0;
Bool_t echec1 = kTRUE;
for(Int_t k = 0; k < npoints; k++){
//Take the cluster
AliTRDcluster *cl = (AliTRDcluster *) t->GetCluster(k+index0);
- Short_t *signals = cl->GetSignals(); // signal
- Double_t time = cl->GetLocalTimeBin(); // time bin
+ Short_t *signals = cl->GetSignals(); // signal
+ Double_t time = cl->GetPadTime(); // time bin
Float_t padPosTracklet = line[0]+line[1]*time; // reconstruct position from fit
Float_t padPos = cl->GetPadCol(); // middle pad
Double_t dpad = padPosTracklet - padPos; // reconstruct position relative to middle pad from fit
Double_t snp = tracklet->GetSnp(); // sin dy/dx at the end of the chamber
Double_t tnp = 0.0; // dy/dx at the end of the chamber
if( TMath::Abs(snp) < 1.){
- tnp = snp / (TMath::Sqrt(1-(snp*snp)));
+ tnp = snp / TMath::Sqrt((1.-snp)*(1.+snp));
}
Double_t tgl = tracklet->GetTgl(); // dz/dl
Double_t dzdx = tgl*TMath::Sqrt(1+tnp*tnp); // dz/dx calculated from dz/dl
//////////////////////
Int_t nb3pc = 0; // number of three pads clusters used for fit
- Double_t *padPositions; // to see the difference between the fit and the 3 pad clusters position
- padPositions = new Double_t[AliTRDseed::knTimebins];
- for(Int_t k = 0; k < AliTRDseed::knTimebins; k++){
- padPositions[k] = 0.0;
- }
+ // to see the difference between the fit and the 3 pad clusters position
+ Double_t padPositions[AliTRDseedV1::kNtb];
+ memset(padPositions, 0, AliTRDseedV1::kNtb*sizeof(Double_t));
fLinearFitterTracklet->ClearPoints();
//printf("loop clusters \n");
// loop over the clusters
////////////////////////////
AliTRDcluster *cl = 0x0;
- for(int ic=0; ic<AliTRDseed::knTimebins; ic++){
- if(!(cl = tracklet->GetClusters(ic))) continue;
-
- Double_t time = cl->GetLocalTimeBin();
+ for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
+ // reject shared clusters on pad row
+ if((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) {
+ cl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb);
+ if(cl) continue;
+ }
+ cl = tracklet->GetClusters(ic);
+ if(!cl) continue;
+ Double_t time = cl->GetPadTime();
if((time<=7) || (time>=21)) continue;
Short_t *signals = cl->GetSignals();
Float_t xcenter = 0.0;
// fit with a straight line
/////////////////////////////
if(nb3pc < 3){
- delete [] padPositions;
fLinearFitterTracklet->ClearPoints();
- delete [] padPositions;
return kFALSE;
}
fLinearFitterTracklet->Eval();
////////////////////////////////////////////////
// Fill the PRF: Second loop over clusters
//////////////////////////////////////////////
- for(int ic=0; ic<AliTRDseed::knTimebins; ic++){
- if(!(cl = tracklet->GetClusters(ic))) continue;
+ for(int ic=0; ic<AliTRDseedV1::kNtb; ic++){
+ // reject shared clusters on pad row
+ cl = tracklet->GetClusters(ic+AliTRDseedV1::kNtb);
+ if(((ic+AliTRDseedV1::kNtb) < AliTRDseedV1::kNclusters) && (cl)) continue;
+ //
+ cl = tracklet->GetClusters(ic);
+ if(!cl) continue;
Short_t *signals = cl->GetSignals(); // signal
- Double_t time = cl->GetLocalTimeBin(); // time bin
+ Double_t time = cl->GetPadTime(); // time bin
Float_t padPosTracklet = line[0]+line[1]*time; // reconstruct position from fit
Float_t padPos = cl->GetPadCol(); // middle pad
Double_t dpad = padPosTracklet - padPos; // reconstruct position relative to middle pad from fit
} // second loop over clusters
- delete [] padPositions;
return kTRUE;
-
}
///////////////////////////////////////////////////////////////////////////////////////
// Pad row col stuff: see if masked or not
///////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::CheckGoodTrackletV1(AliTRDcluster *cl)
+void AliTRDCalibraFillHisto::CheckGoodTrackletV1(const AliTRDcluster *cl)
{
//
// See if we are not near a masked pad
}
//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::CheckGoodTrackletV0(Int_t detector, Int_t row, Int_t col)
+void AliTRDCalibraFillHisto::CheckGoodTrackletV0(const Int_t detector,const Int_t row,const Int_t col)
{
//
// See if we are not near a masked pad
//
Int_t ntotal = 0;
+
+ // All together
+ if((fCalibraMode->GetNz(i)==100) && (fCalibraMode->GetNrphi(i)==100)){
+ ntotal = 1;
+ AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
+ return ntotal;
+ }
+
+ // Per Supermodule
+ if((fCalibraMode->GetNz(i)==10) && (fCalibraMode->GetNrphi(i)==10)){
+ ntotal = 18;
+ AliInfo(Form("Total number of Xbins: %d for i %d",ntotal,i));
+ return ntotal;
+ }
+
+ // More
fCalibraMode->ModePadCalibration(2,i);
fCalibraMode->ModePadFragmentation(0,2,0,i);
fCalibraMode->SetDetChamb2(i);
}
}
+
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetAllTogether(Int_t i)
+{
+ //
+ // Set the mode of calibration group all together
+ //
+ if(fVector2d == kTRUE) {
+ AliInfo("Can not work with the vector method");
+ return;
+ }
+ fCalibraMode->SetAllTogether(i);
+
+}
+
+//_____________________________________________________________________________
+void AliTRDCalibraFillHisto::SetPerSuperModule(Int_t i)
+{
+ //
+ // Set the mode of calibration group per supermodule
+ //
+ if(fVector2d == kTRUE) {
+ AliInfo("Can not work with the vector method");
+ return;
+ }
+ fCalibraMode->SetPerSuperModule(i);
+
+}
+
//____________Set the pad calibration variables for the detector_______________
Bool_t AliTRDCalibraFillHisto::LocalisationDetectorXbins(Int_t detector)
{
// Per tracklet: store or reset the info, fill the histos with the info
//////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
-void AliTRDCalibraFillHisto::StoreInfoCHPHtrack(AliTRDcluster *cl, Double_t dqdl, Int_t *group, Int_t row, Int_t col)
+void AliTRDCalibraFillHisto::StoreInfoCHPHtrack(const AliTRDcluster *cl,const Double_t dqdl,const Int_t *group,const Int_t row,const Int_t col,const AliTRDcluster *cls)
{
//
// Store the infos in fAmpTotal, fPHPlace and fPHValue
// Correct from the gain correction before
+ // cls is shared cluster if any
//
+ //printf("StoreInfoCHPHtrack\n");
+
// time bin of the cluster not corrected
Int_t time = cl->GetPadTime();
-
+ Float_t charge = TMath::Abs(cl->GetQ());
+ if(cls) {
+ charge += TMath::Abs(cls->GetQ());
+ //printf("AliTRDCalibraFillHisto::Add the cluster charge");
+ }
+
+ //printf("Store::time %d, amplitude %f\n",time,dqdl);
+
//Correct for the gain coefficient used in the database for reconstruction
- Float_t correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack)*fCalROCGain->GetValue(col,row);
+ Float_t correctthegain = 1.0;
+ if(fIsHLT) correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack);
+ else correctthegain = fCalDetGain->GetValue(fDetectorPreviousTrack)*fCalROCGain->GetValue(col,row);
Float_t correction = 1.0;
Float_t normalisation = 6.67;
// we divide with gain in AliTRDclusterizer::Transform...
// Fill the fAmpTotal with the charge
if (fCH2dOn) {
- if((!fLimitChargeIntegration) || (cl->IsInChamber())) fAmpTotal[(Int_t) group[0]] += correction;
+ if((!fLimitChargeIntegration) || (cl->IsInChamber())) {
+ //printf("Store::group %d, amplitude %f\n",group[0],correction);
+ fAmpTotal[(Int_t) group[0]] += correction;
+ }
}
// Fill the fPHPlace and value
if (fPH2dOn) {
fPHPlace[time] = group[1];
- fPHValue[time] = correction;
+ fPHValue[time] = charge;
}
}
Int_t fd = -1; // Premiere zone non nulle
Float_t totalcharge = 0.0; // Total charge for the supermodule histo
+ //printf("CH2d nbclusters %d, fNumberClusters %d, fNumberClustersf %d\n",nbclusters,fNumberClusters,fNumberClustersf);
+
if(nbclusters < fNumberClusters) return;
if(nbclusters > fNumberClustersf) return;
-
+
+
+ // Normalize with the number of clusters
+ Double_t normalizeCst = fRelativeScale;
+ if(fNormalizeNbOfCluster) normalizeCst = normalizeCst*nbclusters;
+
+ //printf("Number of groups in one detector %d\n",fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0));
// See if the track goes through different zones
for (Int_t k = 0; k < fCalibraMode->GetNfragZ(0)*fCalibraMode->GetNfragRphi(0); k++) {
+ //printf("fAmpTotal %f for %d\n",fAmpTotal[k],k);
if (fAmpTotal[k] > 0.0) {
totalcharge += fAmpTotal[k];
nb++;
}
}
+ //printf("CH2d: nb %d, fd %d, calibration group %d, amplitude %f, detector %d\n",nb,fd,fCalibraMode->GetXbins(0),fAmpTotal[fd]/normalizeCst,fDetectorPreviousTrack);
switch (nb)
{
fNumberUsedCh[0]++;
fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
if (fHisto2d) {
- FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
- //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+ FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
+ //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
}
if (fVector2d) {
- fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+ fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
}
break;
case 2:
// One of the two very big
if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+1]) {
if (fHisto2d) {
- FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
- //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+ FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
+ //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
}
if (fVector2d) {
- fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+ fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
}
fNumberUsedCh[1]++;
fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
}
if (fAmpTotal[fd+1] > fProcent*fAmpTotal[fd]) {
if (fHisto2d) {
- FillCH2d(fCalibraMode->GetXbins(0)+fd+1,fAmpTotal[fd+1]/fRelativeScale);
- //fCH2d->Fill(fAmpTotal[fd+1]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+1.5);
+ FillCH2d(fCalibraMode->GetXbins(0)+fd+1,fAmpTotal[fd+1]/normalizeCst);
+ //fCH2d->Fill(fAmpTotal[fd+1]/normalizeCst,fCalibraMode->GetXbins(0)+fd+1.5);
}
if (fVector2d) {
- fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+1,fAmpTotal[fd+1]/fRelativeScale);
+ fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+1,fAmpTotal[fd+1]/normalizeCst);
}
fNumberUsedCh[1]++;
fEntriesCH[fCalibraMode->GetXbins(0)+fd+1]++;
// One of the two very big
if (fAmpTotal[fd] > fProcent*fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]) {
if (fHisto2d) {
- FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/fRelativeScale);
- //fCH2d->Fill(fAmpTotal[fd]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+0.5);
+ FillCH2d(fCalibraMode->GetXbins(0)+fd,fAmpTotal[fd]/normalizeCst);
+ //fCH2d->Fill(fAmpTotal[fd]/normalizeCst,fCalibraMode->GetXbins(0)+fd+0.5);
}
if (fVector2d) {
- fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/fRelativeScale);
+ fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd,fAmpTotal[fd]/normalizeCst);
}
fNumberUsedCh[1]++;
fEntriesCH[fCalibraMode->GetXbins(0)+fd]++;
}
if (fAmpTotal[fd+fCalibraMode->GetNfragZ(0)] > fProcent*fAmpTotal[fd]) {
if (fHisto2d) {
- FillCH2d(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
- //fCH2d->Fill(fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale,fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)+0.5);
+ FillCH2d(fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst);
+ //fCH2d->Fill(fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst,fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)+0.5);
}
fNumberUsedCh[1]++;
fEntriesCH[fCalibraMode->GetXbins(0)+fd+fCalibraMode->GetNfragZ(0)]++;
if (fVector2d) {
- fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/fRelativeScale);
+ fCalibraVector->UpdateVectorCH(fDetectorPreviousTrack,fd+fCalibraMode->GetNfragZ(0),fAmpTotal[fd+fCalibraMode->GetNfragZ(0)]/normalizeCst);
}
}
}
}
}
+ // See if noise before and after
+ if(fMaxCluster > 0) {
+ if(fPHValue[0] > fMaxCluster) return;
+ if(fTimeMax > fNbMaxCluster) {
+ for(Int_t k = (fTimeMax-fNbMaxCluster); k < fTimeMax; k++){
+ if(fPHValue[k] > fMaxCluster) return;
+ }
+ }
+ }
+
//printf("nbclusters %d, low limit %d, high limit %d\n",nbclusters,fNumberClusters,fNumberClustersf);
if(nbclusters < fNumberClusters) return;
// DAQ process functions
/////////////////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________
-Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliTRDrawStreamBase *rawStream, Bool_t nocheck)
-{
+Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliRawReader *rawReader)
+ { //main
//
- // Event Processing loop - AliTRDrawStreamBase
- // TestBeam 2007 version
+ // Event Processing loop - AliTRDrawStream
+ //
// 0 timebin problem
// 1 no input
// 2 input
- //
// Same algorithm as TestBeam but different reader
//
-
+
+ AliTRDrawStream *rawStream = new AliTRDrawStream(rawReader);
+ rawStream->SetNoErrorWarning();
+ rawStream->SetSharedPadReadout(kFALSE);
+
+ AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE);
+ digitsManager->CreateArrays();
+
Int_t withInput = 1;
Double_t phvalue[16][144][36];
fDetectorPreviousTrack = -1;
fMCMPrevious = -1;
fROBPrevious = -1;
+
Int_t nbtimebin = 0;
Int_t baseline = 10;
-
- if(!nocheck){
fTimeMax = 0;
- while (rawStream->Next()) {
-
- Int_t idetector = rawStream->GetDet(); // current detector
- Int_t imcm = rawStream->GetMCM(); // current MCM
- Int_t irob = rawStream->GetROB(); // current ROB
-
- //printf("Detector %d\n",idetector);
-
- if((fDetectorPreviousTrack != idetector) && (fDetectorPreviousTrack != -1)){
-
- // Fill
- withInput = TMath::Max(FillDAQ(phvalue),withInput);
-
-
- // reset
- for(Int_t k = 0; k < 36; k++){
- for(Int_t j = 0; j < 16; j++){
- for(Int_t c = 0; c < 144; c++){
- phvalue[j][c][k] = 0.0;
- }
- }
- }
- }
+ Int_t det = 0;
+ while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) { //idetector
- fDetectorPreviousTrack = idetector;
- fMCMPrevious = imcm;
- fROBPrevious = irob;
-
- nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data
- if(nbtimebin == 0) return 0;
- if((fTimeMax != 0) && (nbtimebin != fTimeMax)) return 0;
- fTimeMax = nbtimebin;
-
- //baseline = rawStream->GetCommonAdditive(); // common additive baseline
- fNumberClustersf = fTimeMax;
- fNumberClusters = (Int_t)(0.6*fTimeMax);
-
-
- Int_t *signal = rawStream->GetSignals(); // current ADC signal
- Int_t col = rawStream->GetCol();
- Int_t row = rawStream->GetRow();
-
-
- //printf("detector %d, signal[0] %d, signal[1] %d, signal[2] %d, baseline %d\n",idetector,signal[0],signal[1],signal[2], baseline);
-
-
- for(Int_t itime = 0; itime < nbtimebin; itime++){
- phvalue[row][col][itime] = signal[itime]-baseline;
- }
- }
-
- // fill the last one
- if(fDetectorPreviousTrack != -1){
+ if (digitsManager->GetIndexes(det)->HasEntry()) {//QA
+ // printf("there is ADC data on this chamber!\n");
- // Fill
- withInput = TMath::Max(FillDAQ(phvalue),withInput);
-
- // reset
- for(Int_t k = 0; k < 36; k++){
- for(Int_t j = 0; j < 16; j++){
- for(Int_t c = 0; c < 144; c++){
- phvalue[j][c][k] = 0.0;
+ AliTRDarrayADC *digits = (AliTRDarrayADC *) digitsManager->GetDigits(det); //mod
+ if (digits->HasData()) { //array
+
+ AliTRDSignalIndex *indexes = digitsManager->GetIndexes(det);
+ if (indexes->IsAllocated() == kFALSE) {
+ AliError("Indexes do not exist!");
+ break;
}
- }
- }
- }
-
- }
- else{
-
- while (rawStream->Next()) {
-
- Int_t idetector = rawStream->GetDet(); // current detector
- Int_t imcm = rawStream->GetMCM(); // current MCM
- Int_t irob = rawStream->GetROB(); // current ROB
-
- //printf("Detector %d\n",idetector);
-
- if((fDetectorPreviousTrack != idetector) && (fDetectorPreviousTrack != -1)){
-
- // Fill
- withInput = TMath::Max(FillDAQ(phvalue),withInput);
-
- // reset
- for(Int_t k = 0; k < 36; k++){
- for(Int_t j = 0; j < 16; j++){
- for(Int_t c = 0; c < 144; c++){
- phvalue[j][c][k] = 0.0;
+ Int_t iRow = 0;
+ Int_t iCol = 0;
+ indexes->ResetCounters();
+
+ while (indexes->NextRCIndex(iRow, iCol)) { //column,row
+ //printf(" det %d \t row %d \t col %d \t digit\n",det,iRow,iCol);
+ //while (rawStream->Next()) {
+
+ Int_t idetector = det; // current detector
+ //Int_t imcm = rawStream->GetMCM(); // current MCM
+ //Int_t irob = rawStream->GetROB(); // current ROB
+
+
+ if((fDetectorPreviousTrack != idetector) && (fDetectorPreviousTrack != -1)) {
+ // Fill
+ withInput = TMath::Max(FillDAQ(phvalue),withInput);
+
+ // reset
+ for(Int_t k = 0; k < 36; k++){
+ for(Int_t j = 0; j < 16; j++){
+ for(Int_t c = 0; c < 144; c++){
+ phvalue[j][c][k] = 0.0;
+ }
+ }
+ }
}
- }
- }
- }
-
- fDetectorPreviousTrack = idetector;
- fMCMPrevious = imcm;
- fROBPrevious = irob;
-
- //baseline = rawStream->GetCommonAdditive(); // common baseline
-
- fTimeMax = rawStream->GetNumberOfTimeBins(); // number of time bins read from data
- fNumberClustersf = fTimeMax;
- fNumberClusters = (Int_t)(0.6*fTimeMax);
- Int_t *signal = rawStream->GetSignals(); // current ADC signal
- Int_t col = rawStream->GetCol();
- Int_t row = rawStream->GetRow();
-
-
- //printf("detector %d, signal[0] %d, signal[1] %d, signal[2] %d, baseline %d\n",idetector,signal[0],signal[1],signal[2], baseline);
-
- for(Int_t itime = 0; itime < fTimeMax; itime++){
- phvalue[row][col][itime] = signal[itime]-baseline;
- }
- }
-
- // fill the last one
- if(fDetectorPreviousTrack != -1){
-
- // Fill
- withInput = TMath::Max(FillDAQ(phvalue),withInput);
-
- // reset
- for(Int_t k = 0; k < 36; k++){
- for(Int_t j = 0; j < 16; j++){
- for(Int_t c = 0; c < 144; c++){
- phvalue[j][c][k] = 0.0;
- }
- }
- }
- }
- }
-
- return withInput;
-
-}
-//_____________________________________________________________________
-Int_t AliTRDCalibraFillHisto::ProcessEventDAQV1(AliTRDrawStreamBase *rawStream, Bool_t nocheck)
-{
- //
- // Event Processing loop - AliTRDrawStreamBase
- // Use old AliTRDmcmtracklet code
- // 0 timebin problem
- // 1 no input
- // 2 input
- //
- // Algorithm with mcm tracklet
- //
-
- Int_t withInput = 1;
-
- AliTRDmcm mcm = AliTRDmcm(0);
- AliTRDtrigParam *param = AliTRDtrigParam::Instance();
- rawStream->SetSharedPadReadout(kTRUE);
-
- fDetectorPreviousTrack = -1;
- fMCMPrevious = -1;
- fROBPrevious = -1;
- Int_t row = -1;
- Int_t nbtimebin = 0;
- Int_t baseline = 10;
-
-
- if(!nocheck){
-
- fTimeMax = 0;
-
- while (rawStream->Next()) {
-
- Int_t idetector = rawStream->GetDet(); // current detector
- Int_t imcm = rawStream->GetMCM(); // current MCM
- Int_t irob = rawStream->GetROB(); // current ROB
- row = rawStream->GetRow();
-
-
- if(((fDetectorPreviousTrack != idetector) || (fMCMPrevious != imcm) || (fROBPrevious != irob)) && (fDetectorPreviousTrack != -1)){
-
- // Fill
- withInput = TMath::Max(FillDAQ(&mcm),withInput);
-
-
- // reset
- mcm.Reset();
- mcm.SetRobId(irob);
- mcm.SetChaId(idetector);
- mcm.SetRow(row);
- mcm.SetColRange(0,21);
-
- }
- if(fDetectorPreviousTrack == -1){
-
- mcm.SetRobId(irob);
- mcm.SetChaId(idetector);
- mcm.SetRow(row);
- mcm.SetColRange(0,21);
-
- }
-
- fDetectorPreviousTrack = idetector;
- fMCMPrevious = imcm;
- fROBPrevious = irob;
-
- nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data
- if(nbtimebin == 0) return 0;
- if((fTimeMax != 0) && (nbtimebin != fTimeMax)) return 0;
- fTimeMax = nbtimebin;
- fNumberClustersf = fTimeMax;
- fNumberClusters = (Int_t)(0.6*fTimeMax);
- param->SetTimeRange(0,fTimeMax);
-
- //baseline = rawStream->GetCommonAdditive(); // common additive baseline
-
- Int_t *signal = rawStream->GetSignals(); // current ADC signal
- Int_t adc = rawStream->GetADC();
-
-
- //printf("detector %d, signal[0] %d, signal[1] %d, signal[2] %d, baseline %d\n",idetector,signal[0],signal[1],signal[2], baseline);
-
- for(Int_t itime = 0; itime < nbtimebin; itime++){
- mcm.SetADC(adc,itime,(signal[itime]-baseline));
- }
- }
-
- // fill the last one
- if(fDetectorPreviousTrack != -1){
-
- // Fill
- withInput = TMath::Max(FillDAQ(&mcm),withInput);
-
-
- // reset
- mcm.Reset();
- mcm.SetRobId(fROBPrevious);
- mcm.SetChaId(fDetectorPreviousTrack);
- mcm.SetRow(row);
- mcm.SetColRange(0,21);
-
- }
-
- }
- else{
-
- while (rawStream->Next()) {
-
- Int_t idetector = rawStream->GetDet(); // current detector
- Int_t imcm = rawStream->GetMCM(); // current MCM
- Int_t irob = rawStream->GetROB(); // current ROB
- row = rawStream->GetRow();
-
- if(((fDetectorPreviousTrack != idetector) || (fMCMPrevious != imcm) || (fROBPrevious != irob)) && (fDetectorPreviousTrack != -1)){
-
- // Fill
- withInput = TMath::Max(FillDAQ(&mcm),withInput);
-
-
- // reset
- mcm.Reset();
- mcm.SetRobId(irob);
- mcm.SetChaId(idetector);
- mcm.SetRow(row);
- mcm.SetColRange(0,21);
-
- }
-
- fDetectorPreviousTrack = idetector;
- fMCMPrevious = imcm;
- fROBPrevious = irob;
-
- //baseline = rawStream->GetCommonAdditive(); // common baseline
-
- fTimeMax = rawStream->GetNumberOfTimeBins(); // number of time bins read from data
- fNumberClustersf = fTimeMax;
- fNumberClusters = (Int_t)(0.6*fTimeMax);
- param->SetTimeRange(0,fTimeMax);
- Int_t *signal = rawStream->GetSignals(); // current ADC signal
- Int_t adc = rawStream->GetADC();
-
-
- //printf("detector %d, signal[0] %d, signal[1] %d, signal[2] %d, baseline %d\n",idetector,signal[0],signal[1],signal[2], baseline);
-
- for(Int_t itime = 0; itime < fTimeMax; itime++){
- mcm.SetADC(adc,itime,(signal[itime]-baseline));
- }
- }
-
- // fill the last one
- if(fDetectorPreviousTrack != -1){
-
- // Fill
- withInput = TMath::Max(FillDAQ(&mcm),withInput);
-
- // reset
- mcm.Reset();
- mcm.SetRobId(fROBPrevious);
- mcm.SetChaId(fDetectorPreviousTrack);
- mcm.SetRow(row);
- mcm.SetColRange(0,21);
-
- }
- }
-
- return withInput;
-
-}
-//_____________________________________________________________________
-Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(AliRawReader *rawReader, Bool_t nocheck)
-{
- //
- // Event processing loop - AliRawReader
- // Testbeam 2007 version
- //
-
- AliTRDrawStreamBase rawStream(rawReader);
-
- rawReader->Select("TRD");
-
- return ProcessEventDAQ(&rawStream, nocheck);
-}
-
-//_________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::ProcessEventDAQ(
-#ifdef ALI_DATE
- eventHeaderStruct *event,
- Bool_t nocheck
-#else
- eventHeaderStruct* /*event*/,
- Bool_t /*nocheck*/
-#endif
- )
-{
- //
- // process date event
- // Testbeam 2007 version
- //
-#ifdef ALI_DATE
- AliRawReader *rawReader = new AliRawReaderDate((void*)event);
- Int_t result=ProcessEventDAQ(rawReader, nocheck);
- delete rawReader;
- return result;
-#else
- Fatal("AliTRDCalibraFillHisto", "this class was compiled without DATE");
- return 0;
-#endif
-
-}
-//_____________________________________________________________________
-Int_t AliTRDCalibraFillHisto::ProcessEventDAQV1(AliRawReader *rawReader, Bool_t nocheck)
-{
- //
- // Event processing loop - AliRawReader
- // use the old mcm traklet code
- //
-
- AliTRDrawStreamBase rawStream(rawReader);
-
- rawReader->Select("TRD");
-
- return ProcessEventDAQV1(&rawStream, nocheck);
-}
-//_________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::ProcessEventDAQV1(
-#ifdef ALI_DATE
- eventHeaderStruct *event,
- Bool_t nocheck
-#else
- eventHeaderStruct* /*event*/,
- Bool_t /*nocheck*/
+ fDetectorPreviousTrack = idetector;
+ //fMCMPrevious = imcm;
+ //fROBPrevious = irob;
-#endif
- )
-{
- //
- // process date event
- // use the old mcm tracklet code
- //
-#ifdef ALI_DATE
- AliRawReader *rawReader = new AliRawReaderDate((void*)event);
- Int_t result=ProcessEventDAQV1(rawReader, nocheck);
- delete rawReader;
- return result;
-#else
- Fatal("AliTRDCalibraFillHisto", "this class was compiled without DATE");
- return 0;
-#endif
-
-}
+ // nbtimebin = rawStream->GetNumberOfTimeBins(); // number of time bins read from data
+ AliTRDdigitsParam *digitParam = (AliTRDdigitsParam *)digitsManager->GetDigitsParam();
+ nbtimebin = digitParam->GetNTimeBins(det); // number of time bins read from data
+ baseline = digitParam->GetADCbaseline(det); // baseline
+
+ if(nbtimebin == 0) return 0;
+ if((fTimeMax != 0) && (nbtimebin != fTimeMax)) return 0;
+ fTimeMax = nbtimebin;
+
+ fNumberClustersf = fTimeMax;
+ fNumberClusters = (Int_t)(fNumberClustersProcent*fTimeMax);
+
+
+ for(Int_t itime = 0; itime < nbtimebin; itime++) {
+ // phvalue[row][col][itime] = signal[itime]-baseline;
+ phvalue[iRow][iCol][itime] = (Short_t)(digits->GetData(iRow,iCol,itime) - baseline);
+ /*if(phvalue[iRow][iCol][itime] >= 20) {
+ printf("----------> phvalue[%d][%d][%d] %d baseline %d \n",
+ iRow,
+ iCol,
+ itime,
+ (Short_t)(digits->GetData(iRow,iCol,itime)),
+ baseline);
+ }*/
+ }
+
+ }//column,row
+
+ // fill the last one
+ if(fDetectorPreviousTrack != -1){
+
+ // Fill
+ withInput = TMath::Max(FillDAQ(phvalue),withInput);
+ // printf("\n ---> withinput %d\n\n",withInput);
+ // reset
+ for(Int_t k = 0; k < 36; k++){
+ for(Int_t j = 0; j < 16; j++){
+ for(Int_t c = 0; c < 144; c++){
+ phvalue[j][c][k] = 0.0;
+ }
+ }
+ }
+ }
+
+ }//array
+ }//QA
+ digitsManager->ClearArrays(det);
+ }//idetector
+ delete digitsManager;
+
+ delete rawStream;
+ return withInput;
+ }//main
+//_____________________________________________________________________
//////////////////////////////////////////////////////////////////////////////
// Routine inside the DAQ process
/////////////////////////////////////////////////////////////////////////////
//_______________________________________________________________________
-Int_t AliTRDCalibraFillHisto::FillDAQ(AliTRDmcm *mcm){
-
- //
- // Return 2 if some tracklets are found and used, 1 if nothing
- //
-
- Int_t nbev = 0;
-
- if(mcm->Run()){
-
- for (Int_t iSeed = 0; iSeed < 4; iSeed++) {
-
- if (mcm->GetSeedCol()[iSeed] < 0) {
- continue;
- }
-
- nbev += TestTracklet(mcm->GetChaId(),mcm->GetRow(),iSeed,mcm);
- }
-
- }
-
- if(nbev > 0) nbev = 2;
- else nbev = 1;
-
- return nbev;
-
-}
-//__________________________________________________________________________
-Int_t AliTRDCalibraFillHisto::TestTracklet( Int_t idet, Int_t row, Int_t iSeed, AliTRDmcm *mcm){
-
- //
- // Build the tracklet and return if the tracklet if finally used or not (1/0)
- //
-
- Int_t nbev = 0;
-
- AliTRDmcmTracklet mcmtracklet = AliTRDmcmTracklet();
- //mcmtracklet.Reset();
- mcmtracklet.SetDetector(idet);
- mcmtracklet.SetRow(row);
- mcmtracklet.SetN(0);
-
- Int_t iCol, iCol1, iCol2, track[3];
- iCol = mcm->GetSeedCol()[iSeed]; // 0....20 (MCM)
- mcm->GetColRange(iCol1,iCol2); // range in the pad plane
-
- Float_t amp[3];
- for (Int_t iTime = 0; iTime < fTimeMax; iTime++) {
-
- amp[0] = mcm->GetADC(iCol-1,iTime);
- amp[1] = mcm->GetADC(iCol ,iTime);
- amp[2] = mcm->GetADC(iCol+1,iTime);
-
- if(mcm->IsCluster(iCol,iTime)) {
-
- mcmtracklet.AddCluster(iCol+iCol1,iTime,amp,track);
-
- }
- else if ((iCol+1+1) < 21) {
-
- amp[0] = mcm->GetADC(iCol-1+1,iTime);
- amp[1] = mcm->GetADC(iCol +1,iTime);
- amp[2] = mcm->GetADC(iCol+1+1,iTime);
-
- if(mcm->IsCluster(iCol+1,iTime)) {
-
- mcmtracklet.AddCluster(iCol+1+iCol1,iTime,amp,track);
-
- }
-
- }
-
- }
-
-
- nbev = UpdateHistogramcm(&mcmtracklet);
-
- return nbev;
-
-}
-//____________Online trackling in AliTRDtrigger________________________________
-Int_t AliTRDCalibraFillHisto::UpdateHistogramcm(AliTRDmcmTracklet *trk)
-{
- //
- // Return if the tracklet is finally used or not (1/0) for calibration
- //
-
- Int_t used = 1;
-
- //fGoodTracklet = kTRUE;
-
- // Localisation of the Xbins involved
- Int_t idect = trk->GetDetector();
- Int_t idectrue = trk->GetDetector();
- //idect = 0;
-
- Int_t nbclusters = trk->GetNclusters();
-
- // Eventuelle correction due to track angle in z direction
- Float_t correction = 1.0;
- if (fMcmCorrectAngle) {
- Float_t z = trk->GetRowz();
- Float_t r = trk->GetTime0();
- correction = r / TMath::Sqrt((r*r+z*z));
- }
-
- //row
- Int_t row = trk->GetRow();
-
-
- // Boucle sur les clusters
- // Condition on number of cluster: don't come from the middle of the detector
-
- Double_t amph[36];
- for(Int_t k =0; k < 36; k++) amph[k]=0.0;
- Double_t ampTotal = 0.0;
-
- for (Int_t icl = 0; icl < trk->GetNclusters(); icl++) {
-
- Float_t amp[3] = { 0.0, 0.0, 0.0 };
- Int_t time = trk->GetClusterTime(icl);
- Int_t col = trk->GetClusterCol(icl);
-
- //CheckGoodTrackletV0(idect,row,col);
-
- amp[0] = trk->GetClusterADC(icl)[0] * correction;
- amp[1] = trk->GetClusterADC(icl)[1] * correction;
- amp[2] = trk->GetClusterADC(icl)[2] * correction;
-
- ampTotal += (Float_t) (amp[0]+amp[1]+amp[2]);
- amph[time]=amp[0]+amp[1]+amp[2];
-
- if(fDebugLevel > 0){
- if ( !fDebugStreamer ) {
- //debug stream
- TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
- if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
- }
-
- Double_t amp0 = amp[0];
- Double_t amp1 = amp[1];
- Double_t amp2 = amp[2];
-
- (* fDebugStreamer) << "UpdateHistogramcm0"<<
- "nbclusters="<<nbclusters<<
- "amp0="<<amp0<<
- "amp1="<<amp1<<
- "amp2="<<amp2<<
- "time="<<time<<
- "col="<<col<<
- "row="<<row<<
- "detector="<<idectrue<<
- "\n";
- }
-
- } // Boucle clusters
-
- if((amph[0] > 100.0) || (!fGoodTracklet) || (trk->GetNclusters() < fNumberClusters) || (trk->GetNclusters() > fNumberClustersf)) used = 0;
-
- if (used == 1) {
- for(Int_t k = 0; k < fTimeMax; k++) UpdateDAQ(idect,0,0,k,amph[k],fTimeMax);
- //((TH2I *)GetCH2d()->Fill(ampTotal/30.0,idect));
- } // Condition cut
-
-
- if(fDebugLevel > 0){
- if ( !fDebugStreamer ) {
- //debug stream
- TDirectory *backup = gDirectory;
- fDebugStreamer = new TTreeSRedirector("TRDdebugCalibraFill.root");
- if ( backup ) backup->cd(); //we don't want to be cd'd to the debug streamer
- }
-
- Double_t amph0 = amph[0];
- Double_t amphlast = amph[fTimeMax-1];
- Double_t rms = TMath::RMS(fTimeMax,amph);
- Int_t goodtracklet = (Int_t) fGoodTracklet;
-
- (* fDebugStreamer) << "UpdateHistogramcm1"<<
- "nbclusters="<<nbclusters<<
- "ampTotal="<<ampTotal<<
- "row="<<row<<
- "detector="<<idectrue<<
- "amph0="<<amph0<<
- "amphlast="<<amphlast<<
- "goodtracklet="<<goodtracklet<<
- "rms="<<rms<<
- "\n";
- }
-
- return used;
-
-}
-//_______________________________________________________________________
Int_t AliTRDCalibraFillHisto::FillDAQ(Double_t phvalue[16][144][36]){
//
for (Int_t ic = 2; ic <= 142; ic++)
{
Double_t integral = 0;
- for (Int_t ishiftR = 0; ishiftR < 2; ishiftR++)
+ for (Int_t ishiftR = 0; ishiftR < fNumberRowDAQ; ishiftR++)
{
- for (Int_t ishiftC = -2; ishiftC < 2; ishiftC++)
+ for (Int_t ishiftC = -fNumberColDAQ; ishiftC < fNumberColDAQ; ishiftC++)
{
if (ir + ishiftR >= 1 && ir + ishiftR <= 16 &&
ic + ishiftC >= 1 && ic + ishiftC <= 144)
} //addsignal
} //shiftC
} // shiftR
-
if (integralMax < integral)
{
imaxRow = ir;
imaxCol = ic;
integralMax = integral;
+
} // check max integral
} //ic
} // ir
- //printf("imaxRow %d, imaxCol %d, fTimeMax %d, integralMax %f\n",imaxRow,imaxCol,fTimeMax, integralMax);
+ // printf("imaxRow %d, imaxCol %d, fTimeMax %d, integralMax %f\n",imaxRow,imaxCol,fTimeMax, integralMax);
+ //if((imaxRow == 0) || (imaxRow >= 15) || (imaxCol <= 3) || (imaxCol >= 140)) {
+ // used=1;
+ // return used;
+ // }
- if((imaxRow == 0) || (imaxCol == 0)) {
+ if(((imaxRow + fNumberRowDAQ) > 16) || (imaxRow == 0) || ((imaxCol - fNumberColDAQ) <= 1) || ((imaxCol + fNumberColDAQ) >= 144)) {
used=1;
return used;
}
// ////////////////////////////////////////////////////
- for (Int_t ir = imaxRow - 1; ir < imaxRow + 1; ir++)
+
+ for (Int_t ishiftR = 0; ishiftR < fNumberRowDAQ; ishiftR++)
{
- for (Int_t ic = imaxCol - 2; ic < imaxCol + 2; ic++)
+ for (Int_t ishiftC = -fNumberColDAQ; ishiftC < fNumberColDAQ; ishiftC++)
{
- for(Int_t it = 0; it < fTimeMax; it++){
- sum[it] += phvalue[ir][ic][it];
- }
- }//ic
- }//ir
+ if (imaxRow + ishiftR >= 1 && imaxRow + ishiftR <= 16 &&
+ imaxCol + ishiftC >= 1 && imaxCol + ishiftC <= 144)
+ {
+ for(Int_t it = 0; it < fTimeMax; it++){
+ sum[it] += phvalue[imaxRow + ishiftR-1][imaxCol + ishiftC-1][it];
+ }
+ }
+ } // col shift
+ }// row shift
Int_t nbcl = 0;
Double_t sumcharge = 0.0;
for(Int_t it = 0; it < fTimeMax; it++){
sumcharge += sum[it];
- if(sum[it] > 20.0) nbcl++;
+ if(sum[it] > fThresholdClustersDAQ) nbcl++;
}
"clustera="<<clustera<<
"it="<<it<<
"rms="<<rms<<
+ "nbcl="<<nbcl<<
"\n";
}
}
////////////////////////////////////////////////////////
// fill
///////////////////////////////////////////////////////
+ //printf("fNumberClusters %d, fNumberClustersf %d\n",fNumberClusters,fNumberClustersf);
if(sum[0] > 100.0) used = 1;
if(nbcl < fNumberClusters) used = 1;
if(nbcl > fNumberClustersf) used = 1;
else{
if(sum[it] > 0.0) UpdateDAQ(fDetectorPreviousTrack,0,0,it,sum[it],fTimeMax);
}
+ //if(fFillWithZero) UpdateDAQ(0,0,0,it,sum[it],fTimeMax);
+ //else{
+ // if(sum[it] > 0.0) UpdateDAQ(0,0,0,it,sum[it],fTimeMax);
+ //}
}
}
}
if(fLinearFitterOn){
- AnalyseLinearFitter();
+ if(fLinearFitterDebugOn) AnalyseLinearFitter();
f.WriteTObject(fLinearVdriftFit);
}
//Debug
if(i > 1){
- if((!((Bool_t)nbEntries)) && (nentries > 0)){
- nbEntries = new TH1F("Number of entries","Number of entries"
- ,100,(Int_t)nentries/2,nentries*2);
+ if(nentries > 0){
+ if(!((Bool_t)nbEntries)) nbEntries = new TH1F("Number of entries","Number of entries",100,(Int_t)nentries/2,nentries*2);
nbEntries->SetDirectory(0);
- nbEntriesPerGroup = new TH1F("Number of entries per group","Number of entries per group"
- ,nbins,0,nbins);
+ nbEntries->Fill(nentries);
+ if(!((Bool_t)nbEntriesPerGroup)) nbEntriesPerGroup = new TH1F("Number of entries per group","Number of entries per group",nbins,0,nbins);
nbEntriesPerGroup->SetDirectory(0);
- nbEntriesPerSp = new TProfile("Number of entries per supermodule","Number of entries per supermodule"
- ,(Int_t)(nbins/18),0,(Int_t)(nbins/18));
- nbEntriesPerSp->SetDirectory(0);
- }
- if(nbEntries){
- if(nentries > 0) nbEntries->Fill(nentries);
nbEntriesPerGroup->Fill(idect+0.5,nentries);
+ if(!((Bool_t)nbEntriesPerSp)) nbEntriesPerSp = new TProfile("Number of entries per supermodule","Number of entries per supermodule",(Int_t)(nbins/18),0,(Int_t)(nbins/18));
+ nbEntriesPerSp->SetDirectory(0);
nbEntriesPerSp->Fill((idect%((Int_t)(nbins/18)))+0.5,nentries);
}
}
info[5] = meanstats;
info[6] = meanrelativerror;
- if(i > 1){
+ if(nbEntries && nbEntriesPerSp && nbEntriesPerGroup){
gStyle->SetPalette(1);
gStyle->SetOptStat(1111);
gStyle->SetPadBorderMode(0);
// 3 number of group with entries
//
- Double_t *stat = new Double_t[4];
+ Double_t *stat = new Double_t[4];
stat[3] = 0.0;
Int_t nbofgroups = CalculateTotalNumberOfBins(0);
- Double_t *weight = new Double_t[nbofgroups];
- Int_t *nonul = new Int_t[nbofgroups];
+
+ Double_t *weight = new Double_t[nbofgroups];
+ Double_t *nonul = new Double_t[nbofgroups];
for(Int_t k = 0; k < nbofgroups; k++){
if(fEntriesCH[k] > 0) {
stat[1] = TMath::Median(nbofgroups,fEntriesCH,weight);
stat[2] = TMath::RMS((Int_t)stat[3],nonul);
+ delete [] weight;
+ delete [] nonul;
+
return stat;
}
stat[1] = TMath::Median(nbofgroups,fEntriesLinearFitter,weight);
stat[2] = TMath::RMS((Int_t)stat[3],nonul);
+ delete [] weight;
+ delete [] nonul;
+
return stat;
}
// Create the 2D histos
//
- TString name("Nz");
+ TString name("Ver");
+ name += fVersionVdriftUsed;
+ name += "Subver";
+ name += fSubVersionVdriftUsed;
+ name += "Nz";
name += fCalibraMode->GetNz(1);
name += "Nrphi";
name += fCalibraMode->GetNrphi(1);
// Create the 2D histos
//
- TString name("Nz");
+ TString name("Ver");
+ name += fVersionGainUsed;
+ name += "Subver";
+ name += fSubVersionGainUsed;
+ name += "Nz";
name += fCalibraMode->GetNz(0);
name += "Nrphi";
name += fCalibraMode->GetNrphi(0);
-
+
fCH2d = new TH2I("CH2d",(const Char_t *) name
,fNumberBinCharge,0,300,nn,0,nn);
fCH2d->SetYTitle("Det/pad groups");
TVectorD *par = new TVectorD(2);
TVectorD pare = TVectorD(2);
TVectorD *parE = new TVectorD(3);
- linearfitter->Eval();
- linearfitter->GetParameters(*par);
- linearfitter->GetErrors(pare);
- Float_t ppointError = TMath::Sqrt(TMath::Abs(linearfitter->GetChisquare())/fEntriesLinearFitter[k]);
- (*parE)[0] = pare[0]*ppointError;
- (*parE)[1] = pare[1]*ppointError;
- (*parE)[2] = (Double_t) fEntriesLinearFitter[k];
- ((TObjArray *)fLinearVdriftFit->GetPArray())->AddAt(par,k);
- ((TObjArray *)fLinearVdriftFit->GetEArray())->AddAt(parE,k);
+ if((linearfitter->EvalRobust(0.8)==0)) {
+ //linearfitter->Eval();
+ linearfitter->GetParameters(*par);
+ //linearfitter->GetErrors(pare);
+ //Float_t ppointError = TMath::Sqrt(TMath::Abs(linearfitter->GetChisquare())/fEntriesLinearFitter[k]);
+ //(*parE)[0] = pare[0]*ppointError;
+ //(*parE)[1] = pare[1]*ppointError;
+
+ (*parE)[0] = 0.0;
+ (*parE)[1] = 0.0;
+ (*parE)[2] = (Double_t) fEntriesLinearFitter[k];
+ ((TObjArray *)fLinearVdriftFit->GetPArray())->AddAt(par,k);
+ ((TObjArray *)fLinearVdriftFit->GetEArray())->AddAt(parE,k);
+ }
}
}
}
+
+