#include "hrpcdigitizer.h"
#include "hades.h"
#include "hphysicsconstants.h"
#include "hruntimedb.h"
#include "hdebug.h"
#include "hspectrometer.h"
#include "hrpcdetector.h"
#include "hevent.h"
#include "hcategory.h"
#include "hiterator.h"
#include "hlocation.h"
#include "rpcdef.h"
#include "hgeantkine.h"
#include "hrpccalsim.h"
#include "hrpccal.h"
#include "hrpcdigipar.h"
#include "hrpcgeomcellpar.h"
#include "TRandom.h"
#include <iostream>
#include <iomanip>
using namespace std;
Float_t HRpcDigitizer::fCropDistance = 1.65;
HRpcDigitizer::HRpcDigitizer(void) {
initVars();
}
HRpcDigitizer::HRpcDigitizer(const Text_t *name, const Text_t *title) :
HReconstructor(name,title) {
initVars();
}
HRpcDigitizer::~HRpcDigitizer(void) {
if(iterGeantRpc) delete iterGeantRpc;
if(iterRpcCal) delete iterRpcCal;
clearObjects();
cellobjects.clear();
rpcobjects.clear();
}
void HRpcDigitizer::initVars(){
fGeantRpcCat = 0;
fCalCat = 0;
fKineCat = 0;
fGeomCellPar = 0;
fDigiPar = 0;
fLoc.set(3,0,0,0);
iterGeantRpc = 0;
iterRpcCal = 0;
}
Bool_t HRpcDigitizer::initParContainer() {
fGeomCellPar=(HRpcGeomCellPar *)gHades->getRuntimeDb()->getContainer("RpcGeomCellPar");
if(!fGeomCellPar){
Error("HRpcDigitizer::init()","No RpcGeomCellPar Parameters");
return kFALSE;
}
fDigiPar =(HRpcDigiPar *) gHades->getRuntimeDb()->getContainer("RpcDigiPar");
if(!fDigiPar){
Error("HRpcDigitizer::init()","No RpcDigiPar Parameters");
return kFALSE;
}
return kTRUE;
}
Bool_t HRpcDigitizer::init(void) {
HRpcDetector* rpc = (HRpcDetector*)(gHades->getSetup()->getDetector("Rpc"));
if(!rpc){
Error("HRpcDigitizer::init()","No Rpc Detector found");
return kFALSE;
}
maxCol = rpc->getMaxColumns();
maxCell = rpc->getMaxCells();
rpcobjects.resize(6*maxCol*maxCell, 0 );
cellobjects.resize(6*maxCol*maxCell, 0 );
if(!initParContainer()) return kFALSE;
fKineCat = gHades->getCurrentEvent()->getCategory(catGeantKine);
if(!fKineCat) {
Error("HRpcDigitizer::init()","HGeant kine input missing");
return kFALSE;
}
fGeantRpcCat = gHades->getCurrentEvent()->getCategory(catRpcGeantRaw);
if(!fGeantRpcCat) {
Error("HRpcDigitizer::init()","HGeant RPC input missing");
return kFALSE;
}
if(gHades->getEmbeddingMode()>0) {
fCalCat = gHades->getCurrentEvent()->getCategory(catRpcCalTmp);
if(!fCalCat) {
fCalCat=rpc->buildMatrixCategory("HRpcCalSim",0.5);
gHades->getCurrentEvent()->addCategory(catRpcCalTmp,fCalCat,"Rpc");
}
} else {
fCalCat = gHades->getCurrentEvent()->getCategory(catRpcCal);
if(!fCalCat) {
fCalCat=rpc->buildMatrixCategory("HRpcCalSim",0.5);
gHades->getCurrentEvent()->addCategory(catRpcCal,fCalCat,"Rpc");
}
}
iterGeantRpc = (HIterator *)fGeantRpcCat->MakeIterator("native");
iterRpcCal = (HIterator *)fCalCat ->MakeIterator("native");
return kTRUE;
}
Int_t HRpcDigitizer::execute(void) {
HGeantRpc* geantrpc = 0;
HRpcCalSim* cal = 0;
Float_t mass;
Int_t RefL=-1,trackNumber,gpid,mode,ngap,HGeantRpc_version=-1;
Int_t nHGeantRpc=0,nDigitizedRpc=0;
vprop = fDigiPar->getVprop();
sigma_el = (fDigiPar->getSigmaX()) / vprop;
sigma0_T = (fDigiPar->getSigmaT()) / 1000.;
sigma1_T = (fDigiPar->getSigmaT1()) / 1000.;
sigma2_T = (fDigiPar->getSigmaT2());
sigma3_T = (fDigiPar->getSigmaT3());
t_offset = (fDigiPar->getToff()) / 1000.;
Qmean0 = (fDigiPar->getQmean());
Qmean1 = (fDigiPar->getQmean1());
Qmean2 = (fDigiPar->getQmean2());
Qwid0 = (fDigiPar->getQwid());
Qwid1 = (fDigiPar->getQwid1());
Qwid2 = (fDigiPar->getQwid2());
Eff0 = (fDigiPar->getEff());
Eff1 = (fDigiPar->getEff1());
Eff2 = (fDigiPar->getEff2());
Eff3 = (fDigiPar->getEff3());
Eff4 = (fDigiPar->getEff4());
Eff5 = (fDigiPar->getEff5());
gap = fDigiPar->getGap();
mode = fDigiPar->getMode();
if((sigma1_T<=0.)||(sigma2_T<=0.)||(sigma3_T<=0.)) {
sigma_el *= TMath::Sqrt2();
}
clearObjects();
iterGeantRpc->Reset();
nHGeantRpc=0;
nDigitizedRpc=0;
while ((geantrpc=(HGeantRpc *)iterGeantRpc->Next()) != 0) {
geantrpc->setVersion(5);
if(geantrpc->getDetectorID() < 0) continue;
if(getDistanceToXedge(geantrpc)<fCropDistance) continue;
nHGeantRpc++;
if(HGeantRpc_version==-1) {
HGeantRpc_version = geantrpc->getVersion();
if(HGeantRpc_version<=4) {
calc_eff_hit(-1);
} else {
calc_eff_hit(-2);
}
}
if(HGeantRpc_version<=4) {
geantrpc->getHitDigi(geaX, geaTof, geaMom, geaLocLen);
} else {
geantrpc->getCellAverageDigi(gap, geaX, geaTof, geaMom, geaLocLen);
}
if(geaLocLen<0.) {
geaLocLen=gap;
geaLocLenNorm=1.;
} else {
geaLocLenNorm=geaLocLen/gap;
}
trackNumber = geantrpc->getTrack();
HGeantKine* kine = (HGeantKine*)fKineCat->getObject(trackNumber-1);
if(!kine) {
Warning("HRpcDigitizer::execute()",
"missing kine entry for track %i, assuming beta=0",trackNumber);
beta=0.;
} else {
gpid = kine->getID();
mass = HPhysicsConstants::mass(gpid);
if(mass <= 0 ){
if(mass < 0 ) Warning("HRpcDigitizer::execute()",
"unknown particle id %i, assuming proton mass",gpid);
mass = HPhysicsConstants::mass(14);
}
beta=mass/geaMom;
beta=1./TMath::Sqrt(1.+beta*beta);
}
fLoc[0] = geantrpc->getSector();
fLoc[1] = geantrpc->getColumn();
fLoc[2] = geantrpc->getCell();
if(HGeantRpc_version<=4) {
calc_eff_hit(1);
} else {
calc_eff_hit(2);
}
efhits hite;
Float_t axe = -9999;
Float_t aye = -9999;
Float_t aze = -9999;
Float_t ate = -9999;
geantrpc->getCellAverage(axe, aye, aze, ate);
Float_t rnd = gRandom->Uniform(1);
hite.set(fLoc[0], fLoc[1], fLoc[2], axe, aye, ate, rnd<=eff_hit);
Int_t efprev = -1;
for(UInt_t e=0;e<effi_vec.size();e++) {
if(fLoc[0]==effi_vec[e].sector &&
fLoc[1]==effi_vec[e].module &&
fLoc[2]==effi_vec[e].cell &&
fabs(axe-effi_vec[e].x)<2. &&
fabs(aye-effi_vec[e].y)<2. &&
fabs(ate-effi_vec[e].time)<2.)
efprev = effi_vec[e].effi;
}
if(efprev==0) {
continue;
}
if(efprev==-1 && rnd > eff_hit) {
effi_vec.push_back(hite);
continue;
}
if(efprev==-1 && rnd <= eff_hit) {
effi_vec.push_back(hite);
}
if((mode==0)||(HGeantRpc_version==5)) {
Int_t ind = fLoc[0] * maxCol * maxCell + fLoc[1] * maxCell + fLoc[2];
if(rpcobjects[ind] == 0) {
rpcobjects[ind] = new rpcdat;
rpcobjects[ind]->sec = fLoc[0];
rpcobjects[ind]->col = fLoc[1];
rpcobjects[ind]->cell = fLoc[2];
}
rpcdat* dat = rpcobjects[ind];
gaptrack* left = new gaptrack;
gaptrack* right = new gaptrack;
left ->reset();
right->reset();
dat->left .push_back(left);
dat->right.push_back(right);
left ->refDgtr = fGeantRpcCat->getIndex(geantrpc);
left ->trackDgtr = ((HGeantRpc*)fGeantRpcCat->getObject(left->refDgtr))->getTrack();
right->refDgtr = left->refDgtr;
right->trackDgtr = left->trackDgtr;
RefL = findMother(left->refDgtr);
if(RefL < 0){
left ->ref = left ->refDgtr;
left ->track = left ->trackDgtr;
left ->isAtBox = kFALSE;
right->ref = left ->refDgtr;
right->track = left ->trackDgtr;
right->isAtBox = kFALSE;
Warning("HRpcDigitizer::execute()",
"mother of track not found in RPC box! will use RefLDgtr=%i, TrackLDgtr=%i",
left->refDgtr,left->trackDgtr);
} else {
left ->track = ((HGeantRpc*)fGeantRpcCat->getObject(RefL))->getTrack();
left ->ref = RefL;
left ->isAtBox = kTRUE;
right->track = left->track;
right->ref = left->ref;
right->isAtBox = kTRUE;
}
D = fGeomCellPar->getLength(fLoc[1],fLoc[2]);
if(HGeantRpc_version<=4) {
digitize_one_hit(left,right,0);
} else {
digitize_one_hit(left,right,1);
}
nDigitizedRpc++;
} else {
Int_t ind = fLoc[0] * maxCol * maxCell + fLoc[1] * maxCell + fLoc[2];
if(cellobjects[ind] == 0) {
cellobjects[ind] = new celldat;
cellobjects[ind]->sec = fLoc[0];
cellobjects[ind]->col = fLoc[1];
cellobjects[ind]->cell = fLoc[2];
}
celldat* cdat = cellobjects[ind];
celltrack* celltr;
if(cdat->celltr.size()==0) {
celltr = new celltrack;
celltr->reset();
cdat->celltr.push_back(celltr);
} else {
for(UInt_t i=0;i<cdat->celltr.size();i++){
celltr = cdat->celltr[i];
if(celltr->track == trackNumber) break;
}
if(celltr->track != trackNumber) {
celltr = new celltrack;
celltr->reset();
cdat->celltr.push_back(celltr);
}
}
ngap = geantrpc->getGap();
if(celltr->gaptime[ngap]==0.) {
celltr->gaptime[ngap] = geaTof;
celltr->gappos[ngap] = geaX;
celltr->gapltln[ngap] = geaLocLenNorm;
celltr->gapbeta[ngap] = beta;
celltr->track = trackNumber;
celltr->geantrpcIndex = fGeantRpcCat->getIndex(geantrpc);
} else if(celltr->gaptime[ngap]<geaTof) {
celltr->gaptime[ngap] = geaTof;
celltr->gappos[ngap] = geaX;
celltr->gapltln[ngap] = geaLocLenNorm;
celltr->gapbeta[ngap] = beta;
celltr->track = trackNumber;
celltr->geantrpcIndex = fGeantRpcCat->getIndex(geantrpc);
Warning("HRpcDigitizer::execute()",
"reentry of track=%i in Sector=%i Module=%i Cell=%i",
trackNumber,fLoc[0],fLoc[1],fLoc[2]);
}
}
}
if((mode>0)&&(HGeantRpc_version<=4)&&(nHGeantRpc>0)) {
for(UInt_t i = 0; i < cellobjects.size(); i ++) {
celldat* cdat = cellobjects[i];
if(cdat){
fLoc[0] = cdat->sec;
fLoc[1] = cdat->col;
fLoc[2] = cdat->cell;
D = fGeomCellPar->getLength(fLoc[1],fLoc[2]);
Int_t ind = fLoc[0] * maxCol * maxCell + fLoc[1] * maxCell + fLoc[2];
if(rpcobjects[ind] == 0) {
rpcobjects[ind] = new rpcdat;
rpcobjects[ind]->sec = fLoc[0];
rpcobjects[ind]->col = fLoc[1];
rpcobjects[ind]->cell = fLoc[2];
}
rpcdat* dat = rpcobjects[ind];
for(UInt_t j = 0; j < cdat->celltr.size(); j ++) {
celltrack* celltr = cdat->celltr[j];
celltr->calcMeans();
gaptrack* left = new gaptrack;
gaptrack* right = new gaptrack;
left ->reset();
right->reset();
dat->left .push_back(left);
dat->right.push_back(right);
left ->refDgtr = celltr->geantrpcIndex;
left ->trackDgtr = ((HGeantRpc*)fGeantRpcCat->getObject(left->refDgtr))->getTrack();
right->refDgtr = left->refDgtr;
right->trackDgtr = left->trackDgtr;
RefL = findMother(left->refDgtr);
if(RefL < 0){
left ->ref = left ->refDgtr;
left ->track = left ->trackDgtr;
left ->isAtBox = kFALSE;
right->ref = left ->refDgtr;
right->track = left ->trackDgtr;
right->isAtBox = kFALSE;
Warning("HRpcDigitizer::execute()",
"mother of track not found in RPC box! will use RefLDgtr=%i, TrackLDgtr=%i",
left->refDgtr,left->trackDgtr);
} else {
left ->track = ((HGeantRpc*)fGeantRpcCat->getObject(RefL))->getTrack();
left ->ref = RefL;
left ->isAtBox = kTRUE;
right->track = left->track;
right->ref = left->ref;
right->isAtBox = kTRUE;
}
geaX = celltr->pos;
geaTof = celltr->time;
geaLocLenNorm = celltr->ltln;
beta = celltr->beta;
digitize_one_hit(left,right,1);
nDigitizedRpc++;
}
}
}
}
if(nDigitizedRpc>0) {
Int_t Track [10];
Int_t TrackDgtr[10];
Bool_t isAtBox [10];
vector <Int_t> tracklist;
tracklist.reserve(20);
for(UInt_t i = 0; i < rpcobjects.size(); i ++) {
rpcdat* dat = rpcobjects[i];
if(dat){
fLoc[0] = dat->sec;
fLoc[1] = dat->col;
fLoc[2] = dat->cell;
cal = (HRpcCalSim*) fCalCat->getObject(fLoc);
if(cal) {
gaptrack* left = new gaptrack;
gaptrack* right = new gaptrack;
left ->reset();
right->reset();
dat->left .push_back(left);
dat->right.push_back(right);
left ->time = cal->getLeftTime();
left ->gtime = cal->getLeftTime();
left ->charge = cal->getLeftCharge();
left ->track = gHades->getEmbeddingRealTrackId();
left ->trackDgtr = gHades->getEmbeddingRealTrackId();
left ->isAtBox = kTRUE;
right->time = cal->getRightTime();
right->gtime = cal->getRightTime();
right->charge = cal->getRightCharge();
right->track = gHades->getEmbeddingRealTrackId();
right->trackDgtr = gHades->getEmbeddingRealTrackId();
right->isAtBox = kTRUE;
} else {
cal = (HRpcCalSim*) fCalCat->getSlot(fLoc);
if(!cal) Error("execute()","Error: could not allocate a new slot in HRpcCalSim!");
cal = new(cal) HRpcCalSim;
cal->setAddress(fLoc[0], fLoc[1], fLoc[2]);
}
dat->sortTime(kTRUE);
dat->sortTime(kFALSE);
if(((mode==0)&&((sigma1_T<=0.)||(sigma2_T<=0.)||(sigma3_T<=0.)))
||(mode>0)||(HGeantRpc_version==5)) {
cal->setRightTime(dat->getSmallestTof(kTRUE ));
cal->setLeftTime (dat->getSmallestTof(kFALSE));
} else {
cal->setRightTime(dat->getMeanTof(kTRUE ));
cal->setLeftTime (dat->getMeanTof(kFALSE));
}
cal->setRightCharge(dat->getSumCharge(kTRUE ));
cal->setLeftCharge (dat->getSumCharge(kFALSE));
cal->setRefR (dat->right[0]->ref);
cal->setRefRDgtr(dat->right[0]->refDgtr);
cal->setRefL (dat->left [0]->ref);
cal->setRefLDgtr(dat->left [0]->refDgtr);
tracklist.clear();
Int_t ct = 0;
for(UInt_t j = 0; j < 10; j ++) {
Track[j] = TrackDgtr[j] = -999;
isAtBox[j] = kFALSE;
}
for(UInt_t j = 0; j < dat->right.size() && ct < 10; j ++ ){
Int_t tr = dat->right[j]->track;
if(find(tracklist.begin(),tracklist.end(),tr ) == tracklist.end()){
Track [ct] = tr;
TrackDgtr[ct] = dat->right[j]->trackDgtr;
isAtBox [ct] = dat->right[j]->isAtBox;
tracklist.push_back(tr);
ct ++;
}
}
cal->setTrackRArray (Track);
cal->setTrackRDgtrArray(TrackDgtr);
cal->setRisAtBoxArray (isAtBox);
cal->setNTracksR(ct);
tracklist.clear();
ct = 0;
for(UInt_t j = 0; j < 10; j ++) {
Track[j] = TrackDgtr[j] = -999;
isAtBox[j] = kFALSE;
}
for(UInt_t j = 0; j < dat->left.size() && ct < 10 ; j ++ ){
Int_t tr = dat->left[j]->track;
if(find(tracklist.begin(),tracklist.end(),tr) == tracklist.end()){
Track [ct] = tr;
TrackDgtr[ct] = dat->left[j]->trackDgtr;
isAtBox [ct] = dat->left[j]->isAtBox;
tracklist.push_back(tr);
ct ++;
}
}
cal->setTrackLArray (Track);
cal->setTrackLDgtrArray(TrackDgtr);
cal->setLisAtBoxArray (isAtBox);
cal->setNTracksL(ct);
}
}
}
return 0;
}
void HRpcDigitizer::clearObjects(){
effi_vec.clear();
for(UInt_t i = 0; i < rpcobjects.size(); i ++){
if(rpcobjects[i]){
rpcobjects[i]->reset();
delete rpcobjects[i];
rpcobjects[i] = 0;
}
}
for(UInt_t i = 0; i < cellobjects.size(); i ++){
if(cellobjects[i]){
cellobjects[i]->reset();
delete cellobjects[i];
cellobjects[i] = 0;
}
}
}
Int_t HRpcDigitizer::findMother(Int_t Ref_initial) {
Int_t detectorID = 0, track_mother = -1, Ref_final = -1;
HGeantRpc* geantrpc = 0;
HGeantKine* kine = 0;
track_mother = ((HGeantRpc*)fGeantRpcCat->getObject(Ref_initial))->getTrack();
kine = (HGeantKine*)fKineCat ->getObject(track_mother - 1);
while(kine && detectorID >= 0){
if(track_mother == 0) {
Ref_final = -999;
break;
}
kine = (HGeantKine*)fKineCat->getObject(track_mother - 1);
if(kine && kine->getNRpcHits() == 0) {
track_mother = kine->getParentTrack();
continue;
}
Ref_final = kine->getFirstRpcHit();
geantrpc = (HGeantRpc*)fGeantRpcCat->getObject(Ref_final);
detectorID = geantrpc->getDetectorID();
track_mother = kine->getParentTrack();
}
return Ref_final;
}
void HRpcDigitizer::calc_eff_hit(Int_t mode) {
if(mode<0) {
if((Eff1==0.)||(Eff2<=0.)||(Eff3<=0.)) {
if(mode==-1) {
ineff_hit_n = TMath::Sqrt(TMath::Sqrt(1. - fDigiPar->getEff()));
} else {
ineff_hit_n = 1. - fDigiPar->getEff();
}
} else {
ineff_hit_n = 0.;
}
} else {
if((Eff1==0.)||(Eff2<=0.)||(Eff3<=0.)) {
ineff_hit = TMath::Power(ineff_hit_n,geaLocLenNorm);
} else {
eff_hit = Eff0+Eff1/(1.+TMath::Exp(-Eff2*(beta-Eff3))) + TMath::Exp(Eff4*beta+Eff5);
if(mode==1) {
ineff_hit = TMath::Sqrt(TMath::Sqrt(1. - eff_hit));
} else {
ineff_hit = 1. - eff_hit;
}
ineff_hit = TMath::Power(ineff_hit,(geaLocLenNorm));
}
eff_hit = 1. - ineff_hit;
}
}
void HRpcDigitizer::digitize_one_hit(gaptrack* left,gaptrack* right,Int_t mode) {
Float_t geaXLoc = 0.;
Float_t beta2,corr_ngap,sigma_T,sigma_el_here,X_smearing,T_smearing;
Float_t Qmean,Qwid,Qgap;
geaXLoc = fGeomCellPar->getX(fLoc[1],fLoc[2]) - geaX;
left->gtime = geaTof + geaXLoc / vprop;
right->gtime = geaTof + (D-geaXLoc) / vprop;
if((sigma1_T<=0.)||(sigma2_T<=0.)||(sigma3_T<=0.)) {
T_smearing = gRandom->Gaus(t_offset, sigma0_T);
left ->time = left ->gtime + T_smearing + gRandom->Gaus(0.,sigma_el);
right->time = right->gtime + T_smearing + gRandom->Gaus(0.,sigma_el);
} else {
sigma_T = sigma0_T+sigma1_T/(1.+TMath::Exp(-sigma2_T*(beta-sigma3_T)));
sigma_el_here=sigma_el;
if(mode==0) {
Float_t norm=0.;
corr_ngap=0.;
for(Int_t i = 1; i < 5; i ++) {
Float_t w4i=TMath::Binomial(4,i)*TMath::Power(eff_hit,i)*TMath::Power(ineff_hit,4-i);
norm += w4i;
corr_ngap += w4i/TMath::Sqrt((Float_t)i);
}
corr_ngap = norm/corr_ngap;
sigma_T *= corr_ngap;
sigma_el_here *= corr_ngap;
}
T_smearing = gRandom->Gaus(t_offset,sigma_T);
X_smearing = gRandom->Gaus(0.,sigma_el_here);
left ->time = left ->gtime + T_smearing + X_smearing;
right->time = right->gtime + T_smearing - X_smearing;
}
if(Qwid0<=0.) {
Qgap = (gRandom->Uniform(1)) * (2. * Qmean0) / 4. * geaLocLenNorm;
} else {
beta2 = beta*beta;
Qmean = Qmean0+Qmean1*beta+Qmean2*beta2;
Qwid = Qwid0 +Qwid1*beta +Qwid2*beta2;
if(mode==0) {
Float_t norm=0.;
corr_ngap=0.;
for(Int_t i = 1; i < 5; i ++) {
Float_t w4i=TMath::Binomial(4,i)*TMath::Power(eff_hit,i)*TMath::Power(ineff_hit,4-i);
norm += w4i;
corr_ngap += w4i*TMath::Sqrt((Float_t)i);
}
corr_ngap = norm/corr_ngap;
Qmean /= (4.*eff_hit);
Qwid *= corr_ngap;
}
Qmean *= geaLocLenNorm;
Qwid *= geaLocLenNorm;
Qgap = gRandom->Landau(Qmean,Qwid);
}
left ->charge = Qgap;
right->charge = Qgap;
}
Float_t HRpcDigitizer::getDistanceToXedge(HGeantRpc * gea) {
if(!fGeomCellPar || gea->getDetectorID() < 0) {
return -1.;
}
Int_t module = gea->getColumn();
Int_t cell = gea->getCell();
if(module<0 || cell<0) {
return -1.;
}
Float_t axHit = 0.;
Float_t ayHit = 0.;
Float_t azHit = 0.;
Float_t atofHit = 0.;
gea->getCellAverage(axHit, ayHit, azHit, atofHit);
Float_t xCorner = fGeomCellPar->getX(module,cell);
Float_t yCorner = fGeomCellPar->getY(module,cell);
Float_t length = fGeomCellPar->getLength(module,cell);
Float_t rxCorner = xCorner - length;
Int_t trackNumber = gea->getTrack();
HGeantKine* kine = (HGeantKine*)fKineCat->getObject(trackNumber-1);
if(!kine) return 0;
Float_t xCornerL=-1e5;
Float_t lengthL=-1e5;
Float_t yCornerL=-1e5;
Float_t rxCornerL=1e-5;
if(cell>0) {
xCornerL = fGeomCellPar->getX(module,cell-1);
lengthL = fGeomCellPar->getLength(module,cell-1);
yCornerL = fGeomCellPar->getY(module,cell-1);
rxCornerL = xCornerL - lengthL;
}
Float_t angle1 = 0.;
Float_t angle2 = 0.;
if(lengthL>0) {
angle1 = atan2(xCorner-xCornerL ,yCorner-yCornerL);
angle2 = atan2(rxCorner-rxCornerL,yCorner-yCornerL);
if(cell<30 && cell>27) {
if(xCorner == fGeomCellPar->getX(module,cell+1)) {
angle1 = 0.;
}
if(rxCorner == (fGeomCellPar->getX(module,cell+1) - fGeomCellPar->getLength(module,cell+1)) ) {
angle2 = 0.;
}
}
} else {
xCornerL = fGeomCellPar->getX(module,cell+1);
yCornerL = fGeomCellPar->getY(module,cell+1);
lengthL = fGeomCellPar->getLength(module,cell+1);
rxCornerL = xCornerL + lengthL;
angle1 = atan2( xCornerL-xCorner,yCornerL-yCorner);
angle2 = atan2(rxCornerL-rxCorner,yCornerL-yCorner);
}
Float_t distL = -axHit + (xCorner + sin(angle1) * (ayHit-yCorner));
Float_t distR = axHit - (rxCorner + sin(angle2) * (ayHit-yCorner));
return distL<distR ? distL : distR;
}
ClassImp(HRpcDigitizer)