00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065 #include "StSsdUtil/StSsdWafer.hh"
00066 #include <Stiostream.h>
00067 #include "TMath.h"
00068 #include "StMessMgr.h"
00069
00070
00071 StSsdWafer::StSsdWafer(Int_t nid) : TGeoHMatrix(), mDebug(0) {
00072 memset(first, 0, last-first);
00073 mId = nid;
00074
00075 mStripP = new StSsdStripList();
00076 mStripN = new StSsdStripList();
00077 mNoiseP = new StSpaListNoise();
00078 mNoiseN = new StSpaListNoise();
00079 mClusterP = new StSsdClusterList();
00080 mClusterN = new StSsdClusterList();
00081 mPackage = new StSsdPackageList();
00082 mPoint = new StSsdPointList();
00083 }
00084
00085 StSsdWafer::~StSsdWafer() {
00086 delete mStripP;
00087 delete mStripN;
00088 delete mNoiseP;
00089 delete mNoiseN;
00090 delete mClusterP;
00091 delete mClusterN;
00092 delete mPackage;
00093 delete mPoint;
00094 }
00095
00096 void StSsdWafer::Reset() {
00097 delete mStripP;
00098 delete mStripN;
00099 delete mNoiseP;
00100 delete mNoiseN;
00101 delete mClusterP;
00102 delete mClusterN;
00103 delete mPackage;
00104 delete mPoint;
00105 mStripP = new StSsdStripList();
00106 mStripN = new StSsdStripList();
00107 mNoiseP = new StSpaListNoise();
00108 mNoiseN = new StSpaListNoise();
00109 mClusterP = new StSsdClusterList();
00110 mClusterN = new StSsdClusterList();
00111 mPackage = new StSsdPackageList();
00112 mPoint = new StSsdPointList();
00113 }
00114
00120 void StSsdWafer::init(Int_t rId, Double_t *rD, Double_t *rT, Double_t *rN, Double_t *rX)
00121 {
00122 if (rId != mId) cout<<" Can not initialize wafer number : "<<mId<<" with "<<rId<<"\n";
00123 else {
00124 SetName(Form("R%04i",rId));
00125 Double_t rot[9] = {
00126 rD[0], rT[0], rN[0],
00127 rD[1], rT[1], rN[1],
00128 rD[2], rT[2], rN[2]
00129 };
00130 SetRotation(rot);
00131 SetTranslation(rX);
00132 }
00133 }
00134
00135 void StSsdWafer::debugStrips()
00136 {
00137 StSsdStrip *currentStripP = 0;
00138 cout<<"List of "<<mStripP->getSize()<<" strips on the P side "<<endl;
00139 if (mStripP->getSize()>0) currentStripP = mStripP->first();
00140 for (Int_t i=0;i<mStripP->getSize();i++) {
00141 cout<<" id,sig,noise : "<<currentStripP->getNStrip()
00142 <<" "<<currentStripP->getDigitSig()
00143 <<" "<<currentStripP->getSigma()<<endl;
00144 if (currentStripP!=mStripP->last()) currentStripP = mStripP->next(currentStripP);
00145 }
00146
00147 StSsdStrip *currentStripN = 0;
00148 cout<<"List of "<<mStripN->getSize()<<" strips on the N side "<<endl;
00149 if (mStripN->getSize()>0) currentStripN = mStripN->first();
00150 for (Int_t i=0;i<mStripN->getSize();i++) {
00151 cout<<" id,sig,noise : "<<currentStripN->getNStrip()
00152 <<" "<<currentStripN->getDigitSig()
00153 <<" "<<currentStripN->getSigma()<<endl;
00154 if (currentStripN!=mStripN->last()) currentStripN = mStripN->next(currentStripN);
00155 }
00156 }
00157
00158 void StSsdWafer::debugClusters()
00159 {
00160 StSsdCluster *currentClusterP = 0;
00161 cout<<"List of "<<mClusterP->getSize()<<" clusters on the P side "<<endl;
00162 if (mClusterP->getSize()>0) currentClusterP = mClusterP->first();
00163 for (Int_t i=0;i<mClusterP->getSize();i++) {
00164 cout<<"N,Size,FirstStrip,StripMean,TotAdc,FirstAdc,LastAdc,TotNoise : "<<currentClusterP->getNCluster()
00165 <<" "<<currentClusterP->getClusterSize()
00166 <<" "<<currentClusterP->getFirstStrip()
00167 <<" "<<currentClusterP->getStripMean()
00168 <<" "<<currentClusterP->getTotAdc()
00169 <<" "<<currentClusterP->getFirstAdc()
00170 <<" "<<currentClusterP->getLastAdc()
00171 <<" "<<currentClusterP->getTotNoise()<<endl;
00172 if (currentClusterP!=mClusterP->last()) currentClusterP = mClusterP->next(currentClusterP);
00173 }
00174
00175 StSsdCluster *currentClusterN = 0;
00176 cout<<"List of "<<mClusterN->getSize()<<" clusters on the P side "<<endl;
00177 if (mClusterN->getSize()>0) currentClusterN = mClusterN->first();
00178 for (Int_t i=0;i<mClusterN->getSize();i++) {
00179 cout<<"N,Size,FirstStrip,StripMean,TotAdc,FirstAdc,LastAdc,TotNoise : "<<currentClusterN->getNCluster()
00180 <<" "<<currentClusterN->getClusterSize()
00181 <<" "<<currentClusterN->getFirstStrip()
00182 <<" "<<currentClusterN->getStripMean()
00183 <<" "<<currentClusterN->getTotAdc()
00184 <<" "<<currentClusterN->getFirstAdc()
00185 <<" "<<currentClusterN->getLastAdc()
00186 <<" "<<currentClusterN->getTotNoise()<<endl;
00187 if (currentClusterN!=mClusterN->last()) currentClusterN = mClusterN->next(currentClusterN);
00188 }
00189
00190 }
00191
00195 void StSsdWafer::addStrip(StSsdStrip *ptr, Int_t iSide)
00196 {
00197 if (iSide)
00198 { mStripN->addNewStrip(ptr); }
00199 else
00200 { mStripP->addNewStrip(ptr); }
00201 }
00202
00206 void StSsdWafer::addCluster(StSsdCluster *ptr, Int_t iSide)
00207 {
00208 if (iSide)
00209 { mClusterN->addNewCluster(ptr); }
00210 else
00211 { mClusterP->addNewCluster(ptr); }
00212 }
00213
00217 void StSsdWafer::addPackage(StSsdPackage *ptr)
00218 { mPackage->addNewPackage(ptr); }
00219
00223 void StSsdWafer::addPoint(StSsdPoint *ptr)
00224 { mPoint->addNewPoint(ptr); }
00225
00226 void StSsdWafer::setPedestalSigmaStrip(Int_t iStrip, Int_t iSide, Int_t iPedestal, Int_t iSigma, StSsdDynamicControl *dynamicControl)
00227 {
00228 if (iSide)
00229 { mStripN->setPedestalSigma(iStrip, iPedestal, iSigma, dynamicControl); }
00230 else
00231 { mStripP->setPedestalSigma(iStrip, iPedestal, iSigma, dynamicControl); }
00232 }
00233
00237 void StSsdWafer::sortStrip()
00238 {
00239 mStripP->sortStrip();
00240 mStripN->sortStrip();
00241 }
00242
00246 void StSsdWafer::sortCluster()
00247 {
00248 mClusterP->sortCluster();
00249 mClusterN->sortCluster();
00250 }
00251
00255 void StSsdWafer::sortPoint()
00256 { mPoint->sortPoint(); }
00257
00264 void StSsdWafer::doClusterisation(Int_t *NClusterPerSide, StSsdClusterControl *clusterControl)
00265 {
00266 Int_t iSide = 0;
00267 doFindCluster(clusterControl, iSide);
00268 NClusterPerSide[0] = doClusterSplitting(clusterControl, iSide);
00269 iSide = 1;
00270 doFindCluster(clusterControl, iSide);
00271 NClusterPerSide[1] = doClusterSplitting(clusterControl, iSide);
00272 }
00273
00274 void StSsdWafer::doCleanListStrip(StSsdStripList *myStripList)
00275 {
00276 Int_t lowCut = 3;
00277
00278 StSsdStripList *cleanListStrip;
00279
00280 cleanListStrip = myStripList;
00281 StSsdStrip *myStrip = 0;
00282 StSsdStrip *copyStrip = cleanListStrip->first();
00283 int size = cleanListStrip->getSize();
00284 for(Int_t i=0;i<size;i++){
00285
00286 myStrip = copyStrip;
00287 copyStrip = myStripList->next(copyStrip);
00288 if((myStrip->getSigma()==0)||(myStrip->getDigitSig()<lowCut*myStrip->getSigma())){
00289 cleanListStrip->removeStrip(myStrip);
00290 }
00291 }
00292 }
00293
00303 Int_t StSsdWafer::doFindCluster(StSsdClusterControl *clusterControl, Int_t iSide)
00304 {
00305 StSsdStripList *CurrentStripList = 0;
00306 StSsdClusterList *CurrentClusterList = 0;
00307
00308 switch (iSide)
00309 {
00310 case 0:
00311 CurrentStripList = mStripP;
00312 CurrentClusterList = mClusterP;
00313 break;
00314 case 1:
00315 CurrentStripList = mStripN;
00316 CurrentClusterList = mClusterN;
00317 break;
00318 }
00319 if(!CurrentStripList->getSize()) return 0;
00320
00321 Int_t nCluster = 0;
00322 Int_t atTheEnd = 0;
00323
00324 doCleanListStrip(CurrentStripList);
00325
00326 StSsdStrip *CurrentStrip = CurrentStripList->first();
00327 StSsdStrip *ScanStrip = 0;
00328 StSsdStrip *LastScanStrip = 0;
00329 StSsdStrip *tmpStrip = CurrentStripList->first();
00330 for(Int_t i = 0; i<CurrentStripList->getSize(); i++)
00331 { tmpStrip = CurrentStripList->next(tmpStrip); }
00332
00333 while(CurrentStrip)
00334 {
00335 if((CurrentStrip->getDigitSig()>(clusterControl->getHighCut()*CurrentStrip->getSigma()))&&(CurrentStrip->getSigma()>0))
00336 {
00337 LastScanStrip = 0;
00338 StSsdCluster *newCluster = new StSsdCluster(CurrentClusterList->getSize());
00339 nCluster++;
00340 newCluster->update(CurrentStrip,1.);
00341 ScanStrip = CurrentStripList->prev(CurrentStrip);
00342 while(ScanStrip)
00343 {
00344 if(((ScanStrip->getNStrip())-((CurrentStripList->next(ScanStrip))->getNStrip()))==-1)
00345 {
00346 newCluster->update(ScanStrip,1.);
00347 ScanStrip = CurrentStripList->prev(ScanStrip);
00348 }
00349 else
00350 { ScanStrip = 0; }
00351 }
00352 ScanStrip = CurrentStripList->next(CurrentStrip);
00353 while(ScanStrip)
00354 {
00355 if(((ScanStrip->getNStrip())-((CurrentStripList->prev(ScanStrip))->getNStrip()))==1)
00356 {
00357 newCluster->update(ScanStrip,1.);
00358 ScanStrip = CurrentStripList->next(ScanStrip);
00359 if (!ScanStrip) atTheEnd = 1;
00360 }
00361 else
00362 {
00363 LastScanStrip = ScanStrip;
00364 ScanStrip = 0;
00365 }
00366 }
00367 CurrentClusterList->addNewCluster(newCluster);
00368 if(LastScanStrip)
00369 { CurrentStrip = LastScanStrip; }
00370 else
00371 {
00372 if (atTheEnd)
00373 { CurrentStrip = 0; }
00374 else
00375 { CurrentStrip = CurrentStripList->next(CurrentStrip); }
00376 }
00377 }
00378 else
00379 { CurrentStrip = CurrentStripList->next(CurrentStrip); }
00380 }
00381 return nCluster;
00382 }
00383
00389 Int_t StSsdWafer::doClusterSplitting(StSsdClusterControl *clusterControl, Int_t iSide)
00390 {
00391 StSsdStripList *CurrentStripList = 0;
00392 StSsdClusterList *CurrentClusterList = 0;
00393
00394 switch (iSide)
00395 {
00396 case 0:
00397 CurrentStripList = mStripP;
00398 CurrentClusterList = mClusterP;
00399 break;
00400 case 1:
00401 CurrentStripList = mStripN;
00402 CurrentClusterList = mClusterN;
00403 break;
00404 }
00405
00406 Int_t ClusterListSize = CurrentClusterList->getSize();
00407 if(!ClusterListSize) return 0;
00408
00409 Int_t iCluster = 0;
00410 StSsdCluster *CurrentCluster = CurrentClusterList->first();
00411
00412 for(iCluster = 0 ; iCluster < ClusterListSize ; iCluster++)
00413 {
00414
00415 Int_t *ListAdc = CurrentStripList->getListAdc(CurrentCluster->getFirstStrip(),CurrentCluster->getClusterSize());
00416 Int_t toBeDeleted = CurrentClusterList->splitCluster(clusterControl,CurrentCluster,ListAdc,CurrentStripList);
00417 if(toBeDeleted)
00418 {
00419 StSsdCluster *TempCluster = CurrentCluster;
00420 CurrentCluster = CurrentClusterList->next(CurrentCluster);
00421 CurrentClusterList->removeCluster(TempCluster);
00422 }
00423 else
00424 {
00425 CurrentCluster = CurrentClusterList->next(CurrentCluster);
00426 }
00427
00428 delete [] ListAdc;
00429 }
00430 CurrentClusterList->renumCluster();
00431 return CurrentClusterList->getSize();
00432 }
00433
00434
00440 void StSsdWafer::doLorentzShift(ssdDimensions_st *dimensions,Float_t mShift_hole,Float_t mShift_elec)
00441 {
00442 Int_t rejected_sideP = 0 ;
00443 Int_t rejected_sideN = 0 ;
00444 Int_t iSide = 0;
00445 if (Debug()) LOG_DEBUG <<Form("in doLorentzShift ShiftHole =%f ShiftElec =%f",mShift_hole,mShift_elec)<<endm;
00446 rejected_sideP = doLorentzShiftSide(iSide,mShift_hole,dimensions);
00447 iSide = 1;
00448 rejected_sideN = doLorentzShiftSide(iSide,mShift_elec,dimensions);
00449 if (Debug()) LOG_DEBUG<<Form("Rejected side P = %d Rejected side N =%d",rejected_sideP,rejected_sideN)<<endm;
00450 }
00451
00452 Int_t StSsdWafer::doLorentzShiftSide(Int_t side,Float_t shift,ssdDimensions_st *dimensions){
00453 StSsdClusterList *CurrentClusterList = 0;
00454 Float_t pitch = dimensions[0].stripPitch;
00455 Float_t waferActLength = dimensions[0].waferHalfActLength;
00456 switch (side)
00457 {
00458 case 0:
00459 CurrentClusterList = mClusterP;
00460 break;
00461 case 1:
00462 CurrentClusterList = mClusterN;
00463 break;
00464 }
00465
00466 Int_t ClusterListSize = CurrentClusterList->getSize();
00467 if(!ClusterListSize) return 0;
00468 Int_t iCluster = 0;
00469 Int_t n_rejected = 0;
00470 StSsdCluster *CurrentCluster = CurrentClusterList->first();
00471
00472 for(iCluster = 0 ; iCluster < ClusterListSize ; iCluster++)
00473 {
00474 Float_t StripMean = CurrentCluster->getStripMean();
00475 CurrentCluster->setStripMean(StripMean-(shift/pitch));
00476 if(CurrentCluster->getStripMean()*pitch>waferActLength) {n_rejected++;}
00477 CurrentCluster = CurrentClusterList->next(CurrentCluster);
00478 }
00479 return n_rejected;
00480 }
00481
00486 Int_t StSsdWafer::doFindPackage(ssdDimensions_st *dimensions, StSsdClusterControl *clusterControl)
00487 {
00488 StSsdPackageList *currentPackageList = 0;
00489 StSsdCluster *currentClusterP = 0;
00490 StSsdCluster *currentClusterN = 0;
00491 StSsdCluster *scanClusterP = 0;
00492 StSsdCluster *scanClusterN = 0;
00493 StSsdCluster *lastMatchedN = 0;
00494 StSsdCluster *nextMatchedN = 0;
00495
00496
00497
00498 Int_t maxMatchedInPackage = clusterControl->getClusterTreat();
00499 Int_t numPackage = 0;
00500 Int_t numUnMatched = 0;
00501 Int_t numCurrentClusterP = 0;
00502 Int_t numCurrentClusterN = 0;
00503 Int_t numScanClusterP = 0;
00504 Int_t numScanClusterN = 0;
00505 Int_t numLastMatchedN = 0;
00506 Int_t numNextMatchedN = 0;
00507 Int_t matchedOk = 0;
00508 Int_t keepPackage = 0;
00509
00510 currentPackageList = mPackage;
00511 currentClusterP = mClusterP->first();
00512 currentClusterN = mClusterN->first();
00513
00514 if (!mClusterP->getSize() || !mClusterN->getSize()) return 0;
00515 StSsdPackage *currentPackage = new StSsdPackage(0, clusterControl);
00516
00517 while (currentClusterP)
00518 {
00519 matchedOk = 0;
00520 keepPackage = 0;
00521 scanClusterP = currentClusterP ;
00522 currentPackage->addNewMatched(currentClusterP, maxMatchedInPackage);
00523 currentPackage->addKindPackage(numCurrentClusterP+1,0, maxMatchedInPackage);
00524 scanClusterN = currentClusterN ;
00525 while (scanClusterN)
00526 {
00527 if (geoMatched(dimensions, scanClusterP, scanClusterN))
00528 {
00529 matchedOk++;
00530 currentPackage->addNewMatched(scanClusterN, maxMatchedInPackage);
00531 currentPackage->addKindPackage(numLastMatchedN+1,1, maxMatchedInPackage);
00532 lastMatchedN = scanClusterN;
00533 numLastMatchedN++;
00534 }
00535 scanClusterN = mClusterN->next(scanClusterN);
00536 }
00537 if (!(numScanClusterP == mClusterP->getSize()-1))
00538 {
00539 scanClusterP = mClusterP->next(scanClusterP);
00540 numScanClusterP++;
00541 scanClusterN = lastMatchedN;
00542 numScanClusterN = numLastMatchedN;
00543 while (scanClusterN)
00544 {
00545 if (geoMatched(dimensions, scanClusterP, scanClusterN))
00546 {
00547 keepPackage = 1;
00548 nextMatchedN = scanClusterN;
00549 numScanClusterN--;
00550 numNextMatchedN = numScanClusterN;
00551 }
00552 scanClusterN = mClusterN->prev(scanClusterN);
00553 }
00554 if (!keepPackage)
00555 {
00556 numCurrentClusterP = 0;
00557 numCurrentClusterN = 0;
00558 numScanClusterP = 0;
00559 numScanClusterN = 0;
00560 numLastMatchedN = 0;
00561 if (!matchedOk)
00562 {
00563 numUnMatched++;
00564 currentPackage->purgePackage();
00565 }
00566 else
00567 {
00568 currentClusterN = mClusterN->next(lastMatchedN);
00569 if (currentPackage)
00570 {
00571 StSsdPackage *newPackage = new StSsdPackage(currentPackageList->getSize(), currentPackage->getSize());
00572 newPackage->takeMatcheds(currentPackage);
00573 currentPackageList->addNewPackage(newPackage);
00574 currentPackage->purgePackage();
00575 numPackage++;
00576 }
00577 }
00578 }
00579 else
00580 {
00581 currentClusterN = nextMatchedN;
00582 numCurrentClusterP++;
00583 numCurrentClusterN++;
00584 numLastMatchedN = numNextMatchedN;
00585 }
00586 }
00587 else
00588 {
00589 if (currentPackage)
00590 {
00591 StSsdPackage *newPackage = new StSsdPackage(currentPackageList->getSize(), currentPackage->getSize());
00592 newPackage->takeMatcheds(currentPackage);
00593 currentPackageList->addNewPackage(newPackage);
00594 currentPackage->purgePackage();
00595 numPackage++;
00596 }
00597 }
00598 currentClusterP = mClusterP->next(currentClusterP);
00599 }
00600 delete currentPackage;
00601 return numPackage;
00602 }
00603
00604 Int_t StSsdWafer::doSolvePerfect(ssdDimensions_st *dimensions, StSsdClusterControl *clusterControl,Float_t CalibArray)
00605 {
00606 Int_t nPerfect = 0;
00607 StSsdPackage *currentPackage = 0;
00608 char *currentKind = 0;
00609 currentPackage = mPackage->first();
00610 while(currentPackage)
00611 {
00612 currentKind = currentPackage->getKind();
00613 Int_t numMatched = strlen(currentKind)/2;
00614 Float_t *Adc = new float[numMatched];
00615 for(Int_t i=0;i<numMatched;i++)
00616 Adc[i]=(currentPackage->getMatched(i))->getTotAdc();
00617
00618 if(!strcmp(currentKind,"1p1n"))
00619 {
00620 StSsdPoint *newPoint = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 11);
00621 newPoint->setFlag(100);
00622 setMatcheds(dimensions, newPoint, currentPackage->getMatched(0), currentPackage->getMatched(1));
00623 newPoint->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
00624 mPoint->addNewPoint(newPoint);
00625 nPerfect++;
00626 }
00627
00628 delete [] Adc;
00629 currentPackage=mPackage->next(currentPackage);
00630 }
00631 return nPerfect;
00632 }
00633
00634 void StSsdWafer::doStatPerfect(Int_t nPerfectPoint, StSsdClusterControl *clusterControl)
00635 {
00636 Float_t store = 0;
00637 StSsdPoint *currentPerfect = 0;
00638 currentPerfect = mPoint->first();
00639 while(currentPerfect)
00640 {
00641 store += currentPerfect->getDe(1);
00642 currentPerfect = mPoint->next(currentPerfect);
00643 }
00644 mPerfectMean = store/nPerfectPoint;
00645
00646 store = 0;
00647 currentPerfect = mPoint->first();
00648 while(currentPerfect)
00649 {
00650 store += (currentPerfect->getDe(1)-mPerfectMean)*(currentPerfect->getDe(1)-mPerfectMean);
00651 currentPerfect=mPoint->next(currentPerfect);
00652 }
00653 mPerfectSigma = store/nPerfectPoint;
00654 }
00655
00656 Int_t StSsdWafer::doSolvePackage(ssdDimensions_st *dimensions, StSsdClusterControl *clusterControl,Float_t CalibArray)
00657 {
00658 Int_t nSolved = 0;
00659 StSsdPackage *currentPackage = 0;
00660 char *currentKind = 0;
00661 currentPackage = mPackage->first();
00662 while(currentPackage)
00663 {
00664 currentKind = currentPackage->getKind();
00665 Int_t numMatched = strlen(currentKind)/2;
00666 Float_t *Adc = new float[numMatched];
00667 for(Int_t i=0;i<numMatched;i++) Adc[i]=(currentPackage->getMatched(i))->getTotAdc();
00668
00669 if(!strcmp(currentKind,"1p1n"))
00670 {
00671 }
00672
00673 else if(!strcmp(currentKind,"1p1n2n"))
00674 {
00675 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 12);
00676 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
00677 newPointA->setEnergyLossCorrected(Adc[0]-Adc[2], Adc[1],CalibArray);
00678 newPointA->setFlag(100);
00679 mPoint->addNewPoint(newPointA);
00680
00681 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 12);
00682 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
00683 newPointB->setEnergyLossCorrected(Adc[0]-Adc[1], Adc[2],CalibArray);
00684 newPointB->setFlag(100);
00685 mPoint->addNewPoint(newPointB);
00686 nSolved++;
00687 }
00688
00689 else if(!strcmp(currentKind,"1p1n2p1n"))
00690 {
00691 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 21);
00692 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
00693 newPointA->setEnergyLossCorrected(Adc[0], Adc[1]-Adc[2],CalibArray);
00694 newPointA->setFlag(100);
00695 mPoint->addNewPoint(newPointA);
00696
00697 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 21);
00698 setMatcheds(dimensions, newPointB, currentPackage->getMatched(2), currentPackage->getMatched(1));
00699 newPointB->setEnergyLossCorrected(Adc[2], Adc[1]-Adc[0],CalibArray);
00700 newPointB->setFlag(100);
00701 mPoint->addNewPoint(newPointB);
00702 nSolved++;
00703 }
00704
00705 else if(!strcmp(currentKind,"1p1n2n3n"))
00706 {
00707 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 13);
00708 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
00709 newPointA->setEnergyLossCorrected(Adc[0]-Adc[2]-Adc[3], Adc[1],CalibArray);
00710 newPointA->setFlag(100);
00711 mPoint->addNewPoint(newPointA);
00712
00713 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 13);
00714 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
00715 newPointB->setEnergyLossCorrected(Adc[0]-Adc[1]-Adc[3], Adc[2],CalibArray);
00716 newPointB->setFlag(100);
00717 mPoint->addNewPoint(newPointB);
00718
00719 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 13);
00720 setMatcheds(dimensions, newPointC, currentPackage->getMatched(0), currentPackage->getMatched(3));
00721 newPointC->setEnergyLossCorrected(Adc[0]-Adc[1]-Adc[2], Adc[3],CalibArray);
00722 newPointC->setFlag(100);
00723 mPoint->addNewPoint(newPointC);
00724 nSolved++;
00725 }
00726
00727 else if(!strcmp(currentKind,"1p1n2p1n3p1n"))
00728 {
00729 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 31);
00730 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
00731 newPointA->setEnergyLossCorrected(Adc[0], Adc[1]-Adc[2]-Adc[4],CalibArray);
00732 newPointA->setFlag(100);
00733 mPoint->addNewPoint(newPointA);
00734
00735 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 31);
00736 setMatcheds(dimensions, newPointB, currentPackage->getMatched(2), currentPackage->getMatched(1));
00737 newPointB->setEnergyLossCorrected(Adc[2], Adc[1]-Adc[0]-Adc[4],CalibArray);
00738 newPointB->setFlag(100);
00739 mPoint->addNewPoint(newPointB);
00740
00741 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 31);
00742 setMatcheds(dimensions, newPointC, currentPackage->getMatched(4), currentPackage->getMatched(1));
00743 newPointC->setEnergyLossCorrected(Adc[4], Adc[1]-Adc[0]-Adc[2],CalibArray);
00744 newPointC->setFlag(100);
00745 mPoint->addNewPoint(newPointC);
00746 nSolved++;
00747 }
00748
00749 else if(!strcmp(currentKind,"1p1n2n2p2n"))
00750 {
00751 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 221);
00752 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
00753 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
00754 newPointA->setFlag(100);
00755 mPoint->addNewPoint(newPointA);
00756
00757 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 221);
00758 setMatcheds(dimensions, newPointB, currentPackage->getMatched(3), currentPackage->getMatched(2));
00759 newPointB->setEnergyLossCorrected(Adc[3], Adc[2],CalibArray);
00760 newPointB->setFlag(100);
00761 mPoint->addNewPoint(newPointB);
00762 nSolved++;
00763 }
00764
00765 else if(!strcmp(currentKind,"1p1n2p1n2n"))
00766 {
00767 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 222);
00768 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
00769 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
00770 newPointA->setFlag(100);
00771 mPoint->addNewPoint(newPointA);
00772
00773 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 222);
00774 setMatcheds(dimensions, newPointB, currentPackage->getMatched(2), currentPackage->getMatched(4));
00775 newPointB->setEnergyLossCorrected(Adc[2], Adc[4],CalibArray);
00776 newPointB->setFlag(100);
00777 mPoint->addNewPoint(newPointB);
00778 nSolved++;
00779 }
00780
00781 else if(!strcmp(currentKind,"1p1n2n2p1n2n"))
00782 {
00783 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 223);
00784 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
00785 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
00786
00787
00788 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 223);
00789 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
00790 newPointB->setEnergyLossCorrected(Adc[0], Adc[2],CalibArray);
00791
00792
00793 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 223);
00794 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(1));
00795 newPointC->setEnergyLossCorrected(Adc[3], Adc[1],CalibArray);
00796
00797
00798 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 223);
00799 setMatcheds(dimensions, newPointD, currentPackage->getMatched(3), currentPackage->getMatched(2));
00800 newPointD->setEnergyLossCorrected(Adc[3], Adc[2],CalibArray);
00801
00802
00803
00804 Double_t setA[2], setB[2], setC[2], setD[2];
00805 Double_t probAD, probBC;
00806
00807 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
00808 setA[1] = matchDistr(clusterControl, setA[0]);
00809 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
00810 setB[1] = matchDistr(clusterControl, setB[0]);
00811 setC[0] = (Adc[3] - Adc[1])/sqrt(2.0);
00812 setC[1] = matchDistr(clusterControl, setC[0]);
00813 setD[0] = (Adc[3] - Adc[2])/sqrt(2.0);
00814 setD[1] = matchDistr(clusterControl, setD[0]);
00815 if ((setA[1]*setD[1])||(setB[1]*setC[1]))
00816 {
00817 Double_t tmp = 3e-33+(setA[1]*setD[1]+setB[1]*setC[1]);
00818 probAD = (setA[1]*setD[1])/tmp;
00819 probBC = (setB[1]*setC[1])/tmp;
00820 if(probAD>probBC)
00821 {
00822 mPoint->addNewPoint(newPointA);
00823 mPoint->addNewPoint(newPointD);
00824 }
00825 else
00826 {
00827 mPoint->addNewPoint(newPointB);
00828 mPoint->addNewPoint(newPointC);
00829 }
00830 }
00831 else
00832 {
00833 probAD = 0.5;
00834 probBC = 0.5;
00835 mPoint->addNewPoint(newPointA);
00836 mPoint->addNewPoint(newPointD);
00837 mPoint->addNewPoint(newPointB);
00838 mPoint->addNewPoint(newPointC);
00839 }
00840 newPointA->setFlag(int(100*probAD));
00841 newPointB->setFlag(int(100*probBC));
00842 newPointC->setFlag(int(100*probBC));
00843 newPointD->setFlag(int(100*probAD));
00844 nSolved++;
00845
00846 }
00847
00848 else if(!strcmp(currentKind,"1p1n2n2p2n3n"))
00849 {
00850 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
00851 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
00852 newPointA->setFlag(100);
00853
00854
00855 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
00856 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
00857 newPointB->setEnergyLossCorrected(Adc[0]-Adc[1], Adc[2],CalibArray);
00858
00859
00860 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
00861 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(2));
00862 newPointC->setEnergyLossCorrected(Adc[3]-Adc[5], Adc[2],CalibArray);
00863
00864
00865 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
00866 setMatcheds(dimensions, newPointD, currentPackage->getMatched(3), currentPackage->getMatched(5));
00867 newPointD->setFlag(100);
00868
00869
00870
00871 Double_t setA[2], setD[2];
00872 Double_t setAB[2], setCD[2];
00873 Double_t probABD, probACD;
00874
00875 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
00876 setA[1] = matchDistr(clusterControl, setA[0]);
00877 setAB[0] = (Adc[0] - (Adc[1]+Adc[2]))/sqrt(2.0);
00878 setAB[1] = matchDistr(clusterControl, setAB[0]);
00879 setCD[0] = (Adc[3] - (Adc[2]+Adc[5]))/sqrt(2.0);
00880 setCD[1] = matchDistr(clusterControl, setCD[0]);
00881 setD[0] = (Adc[3] - Adc[5])/sqrt(2.0);
00882 setD[1] = matchDistr(clusterControl, setD[0]);
00883 Double_t tmp = 3e-33+(setAB[1]*setD[1]+setA[1]*setCD[1]+1e-10);
00884 probABD = (setAB[1]*setD[1])/tmp;
00885 probACD = (setA[1]*setCD[1])/tmp;
00886 newPointB->setFlag(int(100*probABD));
00887 newPointC->setFlag(int(100*probACD));
00888 if (probABD > probACD)
00889 {
00890 newPointA->setEnergyLossCorrected(Adc[0]-Adc[2],Adc[1],CalibArray);
00891 newPointD->setEnergyLossCorrected(Adc[3], Adc[5],CalibArray);
00892 mPoint->addNewPoint(newPointA);
00893 mPoint->addNewPoint(newPointB);
00894 mPoint->addNewPoint(newPointD);
00895 }
00896 else
00897 {
00898 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
00899 newPointD->setEnergyLossCorrected(Adc[3]-Adc[2], Adc[5],CalibArray);
00900 mPoint->addNewPoint(newPointA);
00901 mPoint->addNewPoint(newPointB);
00902 mPoint->addNewPoint(newPointC);
00903 }
00904 nSolved++;
00905 }
00906
00907 else if(!strcmp(currentKind,"1p1n2p1n2n3p2n"))
00908 {
00909 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
00910 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
00911 newPointA->setFlag(100);
00912
00913
00914 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
00915 setMatcheds(dimensions, newPointB, currentPackage->getMatched(2), currentPackage->getMatched(1));
00916 newPointB->setEnergyLossCorrected(Adc[2], Adc[1]-Adc[0],CalibArray);
00917
00918
00919 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
00920 setMatcheds(dimensions, newPointC, currentPackage->getMatched(2), currentPackage->getMatched(4));
00921 newPointC->setEnergyLossCorrected(Adc[2], Adc[4]-Adc[5],CalibArray);
00922
00923
00924 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
00925 setMatcheds(dimensions, newPointD, currentPackage->getMatched(5), currentPackage->getMatched(4));
00926 newPointD->setFlag(100);
00927
00928
00929
00930 Double_t setA[2], setD[2];
00931 Double_t setAB[2], setCD[2];
00932 Double_t probABD, probACD;
00933
00934 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
00935 setA[1] = matchDistr(clusterControl, setA[0]);
00936 setAB[0] = (Adc[0] + Adc[2] - Adc[1])/sqrt(2.0);
00937 setAB[1] = matchDistr(clusterControl, setAB[0]);
00938 setCD[0] = (Adc[2] + Adc[5] - Adc[4])/sqrt(2.0);
00939 setCD[1] = matchDistr(clusterControl, setCD[0]);
00940 setD[0] = (Adc[5] - Adc[4])/sqrt(2.0);
00941 setD[1] = matchDistr(clusterControl, setD[0]);
00942 Double_t tmp = 3e-33+(setAB[1]*setD[1]+setA[1]*setCD[1]);
00943 probABD = (setAB[1]*setD[1])/tmp;
00944 probACD = (setA[1]*setCD[1])/tmp;
00945 newPointB->setFlag(int(100*probABD));
00946 newPointC->setFlag(int(100*probACD));
00947 if (probABD > probACD)
00948 {
00949 newPointA->setEnergyLossCorrected(Adc[0], Adc[1]-Adc[2],CalibArray);
00950 newPointD->setEnergyLossCorrected(Adc[5], Adc[4],CalibArray);
00951 mPoint->addNewPoint(newPointA);
00952 mPoint->addNewPoint(newPointB);
00953 mPoint->addNewPoint(newPointD);
00954 }
00955 else
00956 {
00957 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
00958 newPointD->setEnergyLossCorrected(Adc[5], Adc[4]-Adc[2],CalibArray);
00959 mPoint->addNewPoint(newPointA);
00960 mPoint->addNewPoint(newPointB);
00961 mPoint->addNewPoint(newPointC);
00962 }
00963 nSolved++;
00964 }
00965
00966 else if(!strcmp(currentKind,"1p1n2n3n2p2n3n"))
00967 {
00968 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
00969 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
00970 newPointA->setFlag(100);
00971
00972
00973 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
00974 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
00975 newPointB->setEnergyLossCorrected(Adc[0]-Adc[1], Adc[2],CalibArray);
00976
00977
00978 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
00979 setMatcheds(dimensions, newPointC, currentPackage->getMatched(0), currentPackage->getMatched(3));
00980 newPointC->setEnergyLossCorrected(Adc[0]-Adc[1], Adc[3],CalibArray);
00981
00982
00983 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
00984 setMatcheds(dimensions, newPointD, currentPackage->getMatched(4), currentPackage->getMatched(2));
00985
00986
00987 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
00988 setMatcheds(dimensions, newPointE, currentPackage->getMatched(4), currentPackage->getMatched(3));
00989
00990
00991
00992 Double_t setA[2], setD[2], setE[2];
00993 Double_t setAB[2], setAC[2], setDE[2];
00994 Double_t probABE, probACD, probADE;
00995
00996 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
00997 setA[1] = matchDistr(clusterControl, setA[0]);
00998 setAB[0] = (Adc[0] - (Adc[1] + Adc[2]))/sqrt(2.0);
00999 setAB[1] = matchDistr(clusterControl, setAB[0]);
01000 setAC[0] = (Adc[0] - (Adc[1] + Adc[3]))/sqrt(2.0);
01001 setAC[1] = matchDistr(clusterControl, setAC[0]);
01002 setDE[0] = (Adc[4] - (Adc[2] + Adc[3]))/sqrt(2.0);
01003 setDE[1] = matchDistr(clusterControl, setDE[0]);
01004 setD[0] = (Adc[4] - Adc[2])/sqrt(2.0);
01005 setD[1] = matchDistr(clusterControl, setD[0]);
01006 setE[0] = (Adc[4] - Adc[3])/sqrt(2.0);
01007 setE[1] = matchDistr(clusterControl, setE[0]);
01008 Double_t tmp = 3e-33+(setAB[1]*setE[1]+setAC[1]*setD[1]+setA[1]*setDE[1]);
01009 probABE = (setAB[1]*setE[1])/tmp;
01010 probACD = (setAC[1]*setD[1])/tmp;
01011 probADE = (setA[1]*setDE[1])/tmp;
01012 newPointB->setFlag(int(100*probABE));
01013 newPointC->setFlag(int(100*probACD));
01014 newPointD->setFlag(int(100*(probACD+probADE)));
01015 newPointE->setFlag(int(100*(probABE+probADE)));
01016 if ((probABE > probACD)&&(probABE > probADE))
01017 {
01018 newPointA->setEnergyLossCorrected(Adc[0]-Adc[2],Adc[1],CalibArray);
01019 newPointE->setEnergyLossCorrected(Adc[4],Adc[3],CalibArray);
01020 mPoint->addNewPoint(newPointA);
01021 mPoint->addNewPoint(newPointB);
01022 mPoint->addNewPoint(newPointE);
01023
01024 }
01025 else if ((probACD > probABE)&&(probACD > probADE))
01026 {
01027 newPointA->setEnergyLossCorrected(Adc[0]-Adc[3],Adc[1],CalibArray);
01028 newPointD->setEnergyLossCorrected(Adc[4],Adc[2],CalibArray);
01029 mPoint->addNewPoint(newPointA);
01030 mPoint->addNewPoint(newPointC);
01031 mPoint->addNewPoint(newPointD);
01032 }
01033 else if ((probADE > probABE)&&(probADE > probACD))
01034 {
01035 newPointA->setEnergyLossCorrected(Adc[0],Adc[1],CalibArray);
01036 newPointD->setEnergyLossCorrected(Adc[4]-Adc[3],Adc[2],CalibArray);
01037 newPointE->setEnergyLossCorrected(Adc[4]-Adc[2],Adc[3],CalibArray);
01038 mPoint->addNewPoint(newPointA);
01039 mPoint->addNewPoint(newPointB);
01040 mPoint->addNewPoint(newPointE);
01041 }
01042 nSolved++;
01043 }
01044
01045 else if(!strcmp(currentKind,"1p1n2p1n2n3p1n2n"))
01046 {
01047 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01048 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01049 newPointA->setFlag(100);
01050
01051
01052 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01053 setMatcheds(dimensions, newPointB, currentPackage->getMatched(2), currentPackage->getMatched(1));
01054 newPointB->setEnergyLossCorrected(Adc[2], Adc[1]-Adc[0],CalibArray);
01055
01056
01057 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01058 setMatcheds(dimensions, newPointC, currentPackage->getMatched(2), currentPackage->getMatched(4));
01059
01060
01061 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01062 setMatcheds(dimensions, newPointD, currentPackage->getMatched(5), currentPackage->getMatched(1));
01063 newPointD->setEnergyLossCorrected(Adc[5], Adc[1]-Adc[0],CalibArray);
01064
01065
01066 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01067 setMatcheds(dimensions, newPointE, currentPackage->getMatched(5), currentPackage->getMatched(4));
01068
01069
01070
01071 Double_t setA[2], setC[2], setE[2];
01072 Double_t setAB[2], setAD[2], setCE[2];
01073 Double_t probABE, probACD, probACE;
01074
01075 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
01076 setA[1] = matchDistr(clusterControl, setA[0]);
01077 setAB[0] = (Adc[0] + Adc[2] - Adc[1])/sqrt(2.0);
01078 setAB[1] = matchDistr(clusterControl, setAB[0]);
01079 setAD[0] = (Adc[0] + Adc[5] - Adc[1])/sqrt(2.0);
01080 setAD[1] = matchDistr(clusterControl, setAD[0]);
01081 setCE[0] = (Adc[2] + Adc[5] + Adc[4])/sqrt(2.0);
01082 setCE[1] = matchDistr(clusterControl, setCE[0]);
01083 setC[0] = (Adc[2] - Adc[4])/sqrt(2.0);
01084 setC[1] = matchDistr(clusterControl, setC[0]);
01085 setE[0] = (Adc[5] - Adc[4])/sqrt(2.0);
01086 setE[1] = matchDistr(clusterControl, setE[0]);
01087 Double_t tmp = 3e-33+(setAB[1]*setE[1]+setAD[1]*setC[1]+setA[1]*setCE[1]);
01088 probABE = (setAB[1]*setE[1])/tmp;
01089 probACD = (setAD[1]*setC[1])/tmp;
01090 probACE = (setA[1]*setCE[1])/tmp;
01091 newPointB->setFlag(int(100*probABE));
01092 newPointC->setFlag(int(100*(probACD+probACE)));
01093 newPointD->setFlag(int(100*probACD));
01094 newPointE->setFlag(int(100*(probABE+probACE)));
01095 if ((probABE > probACD)&&(probABE > probACE))
01096 {
01097 newPointA->setEnergyLossCorrected(Adc[0],Adc[1]-Adc[2],CalibArray);
01098 newPointE->setEnergyLossCorrected(Adc[5],Adc[4],CalibArray);
01099 mPoint->addNewPoint(newPointA);
01100 mPoint->addNewPoint(newPointB);
01101 mPoint->addNewPoint(newPointE);
01102 }
01103 else if ((probACD > probABE)&&(probACD > probACE))
01104 {
01105 newPointA->setEnergyLossCorrected(Adc[0],Adc[1]-Adc[5],CalibArray);
01106 newPointC->setEnergyLossCorrected(Adc[2],Adc[4],CalibArray);
01107 mPoint->addNewPoint(newPointA);
01108 mPoint->addNewPoint(newPointC);
01109 mPoint->addNewPoint(newPointD);
01110 }
01111 else if ((probACE > probABE)&&(probACE > probACD))
01112 {
01113 newPointA->setEnergyLossCorrected(Adc[0],Adc[1],CalibArray);
01114 newPointC->setEnergyLossCorrected(Adc[2],Adc[4]-Adc[5],CalibArray);
01115 newPointE->setEnergyLossCorrected(Adc[5],Adc[4]-Adc[2],CalibArray);
01116 mPoint->addNewPoint(newPointA);
01117 mPoint->addNewPoint(newPointB);
01118 mPoint->addNewPoint(newPointE);
01119 }
01120 nSolved++;
01121 }
01122
01123 else if(!strcmp(currentKind,"1p1n2n2p1n2n3n"))
01124 {
01125 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01126 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01127
01128
01129 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01130 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
01131
01132
01133 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01134 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(1));
01135 newPointC->setEnergyLossCorrected(Adc[3]-Adc[6],Adc[1],CalibArray);
01136
01137
01138 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01139 setMatcheds(dimensions, newPointD, currentPackage->getMatched(3), currentPackage->getMatched(2));
01140 newPointD->setEnergyLossCorrected(Adc[3]-Adc[6], Adc[2],CalibArray);
01141
01142
01143 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01144 setMatcheds(dimensions, newPointE, currentPackage->getMatched(3), currentPackage->getMatched(6));
01145 newPointE->setFlag(100);
01146
01147
01148
01149 Double_t setA[2], setB[2], setE[2];
01150 Double_t setAB[2], setCE[2], setDE[2];
01151 Double_t probABE, probADE, probBCE;
01152
01153 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
01154 setA[1] = matchDistr(clusterControl, setA[0]);
01155 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
01156 setB[1] = matchDistr(clusterControl, setB[0]);
01157 setAB[0] = (Adc[0] - (Adc[1] + Adc[2]))/sqrt(2.0);
01158 setAB[1] = matchDistr(clusterControl, setAB[0]);
01159 setCE[0] = (Adc[3] - (Adc[1] - Adc[6]))/sqrt(2.0);
01160 setCE[1] = matchDistr(clusterControl, setCE[0]);
01161 setDE[0] = (Adc[3] - (Adc[2] + Adc[6]))/sqrt(2.0);
01162 setDE[1] = matchDistr(clusterControl, setDE[0]);
01163 setE[0] = (Adc[3] - Adc[6])/sqrt(2.0);
01164 setE[1] = matchDistr(clusterControl, setE[0]);
01165 Double_t tmp = 3e-33+(setAB[1]*setE[1]+setA[1]*setDE[1]+setB[1]*setCE[1]);
01166 probABE = (setAB[1]*setE[1])/tmp;
01167 probADE = (setA[1]*setDE[1])/tmp;
01168 probBCE = (setB[1]*setCE[1])/tmp;
01169 newPointA->setFlag(int(100*(probABE+probADE)));
01170 newPointB->setFlag(int(100*(probABE+probBCE)));
01171 newPointC->setFlag(int(100*probBCE));
01172 newPointD->setFlag(int(100*probADE));
01173 if ((probABE > probADE)&&(probABE > probBCE))
01174 {
01175 newPointA->setEnergyLossCorrected(Adc[0]-Adc[2],Adc[1],CalibArray);
01176 newPointB->setEnergyLossCorrected(Adc[0]-Adc[1],Adc[2],CalibArray);
01177 newPointE->setEnergyLossCorrected(Adc[3],Adc[6],CalibArray);
01178 mPoint->addNewPoint(newPointA);
01179 mPoint->addNewPoint(newPointB);
01180 mPoint->addNewPoint(newPointE);
01181 }
01182 else if ((probADE > probABE)&&(probADE > probBCE))
01183 {
01184 newPointA->setEnergyLossCorrected(Adc[0],Adc[1],CalibArray);
01185 newPointE->setEnergyLossCorrected(Adc[3]-Adc[2],Adc[6],CalibArray);
01186 mPoint->addNewPoint(newPointA);
01187 mPoint->addNewPoint(newPointD);
01188 mPoint->addNewPoint(newPointE);
01189 }
01190 else if ((probBCE > probABE)&&(probBCE > probADE))
01191 {
01192 newPointB->setEnergyLossCorrected(Adc[0],Adc[2],CalibArray);
01193 newPointE->setEnergyLossCorrected(Adc[3]-Adc[1],Adc[6],CalibArray);
01194 mPoint->addNewPoint(newPointB);
01195 mPoint->addNewPoint(newPointC);
01196 mPoint->addNewPoint(newPointE);
01197 }
01198 nSolved++;
01199 }
01200
01201 else if(!strcmp(currentKind,"1p1n2n2p1n2n3p2n"))
01202 {
01203 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01204 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01205
01206
01207 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01208 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
01209 newPointB->setEnergyLossCorrected(Adc[0]-Adc[6], Adc[2],CalibArray);
01210
01211
01212 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01213 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(1));
01214
01215
01216 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01217 setMatcheds(dimensions, newPointD, currentPackage->getMatched(3), currentPackage->getMatched(2));
01218 newPointD->setEnergyLossCorrected(Adc[3]-Adc[6], Adc[2],CalibArray);
01219
01220
01221 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01222 setMatcheds(dimensions, newPointE, currentPackage->getMatched(6), currentPackage->getMatched(2));
01223 newPointE->setFlag(100);
01224
01225
01226
01227 Double_t setA[2], setC[2], setE[2];
01228 Double_t setAC[2], setBE[2], setDE[2];
01229 Double_t probACE, probADE, probBCE;
01230
01231 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
01232 setA[1] = matchDistr(clusterControl, setA[0]);
01233 setAC[0] = (Adc[0] + Adc[3] - Adc[1])/sqrt(2.0);
01234 setAC[1] = matchDistr(clusterControl, setAC[0]);
01235 setBE[0] = (Adc[0] + Adc[6] - Adc[2])/sqrt(2.0);
01236 setBE[1] = matchDistr(clusterControl, setBE[0]);
01237 setC[0] = (Adc[3] - Adc[1])/sqrt(2.0);
01238 setC[1] = matchDistr(clusterControl, setC[0]);
01239 setDE[0] = (Adc[3] + Adc[6] - Adc[2])/sqrt(2.0);
01240 setDE[1] = matchDistr(clusterControl, setDE[0]);
01241 setE[0] = (Adc[6] - Adc[2])/sqrt(2.0);
01242 setE[1] = matchDistr(clusterControl, setE[0]);
01243 Double_t tmp = 3e-33+(setAC[1]*setE[1]+setA[1]*setDE[1]+setBE[1]*setC[1]);
01244 probACE = (setAC[1]*setE[1])/tmp;
01245 probADE = (setA[1]*setDE[1])/tmp;
01246 probBCE = (setBE[1]*setC[1])/tmp;
01247 newPointA->setFlag(int(100*(probACE+probADE)));
01248 newPointB->setFlag(int(100*probBCE));
01249 newPointC->setFlag(int(100*(probACE+probBCE)));
01250 newPointD->setFlag(int(100*probADE));
01251 if ((probACE > probADE)&&(probACE > probBCE))
01252 {
01253 newPointA->setEnergyLossCorrected(Adc[0],Adc[1]-Adc[3],CalibArray);
01254 newPointC->setEnergyLossCorrected(Adc[3],Adc[1]-Adc[0],CalibArray);
01255 newPointE->setEnergyLossCorrected(Adc[6],Adc[2],CalibArray);
01256 mPoint->addNewPoint(newPointA);
01257 mPoint->addNewPoint(newPointC);
01258 mPoint->addNewPoint(newPointE);
01259 }
01260 else if ((probADE > probACE)&&(probADE > probBCE))
01261 {
01262 newPointA->setEnergyLossCorrected(Adc[0],Adc[1],CalibArray);
01263 newPointE->setEnergyLossCorrected(Adc[6],Adc[2]-Adc[3],CalibArray);
01264 mPoint->addNewPoint(newPointA);
01265 mPoint->addNewPoint(newPointD);
01266 mPoint->addNewPoint(newPointE);
01267 }
01268 else if ((probBCE > probACE)&&(probBCE > probADE))
01269 {
01270 newPointB->setEnergyLossCorrected(Adc[3],Adc[1],CalibArray);
01271 newPointE->setEnergyLossCorrected(Adc[6],Adc[2]-Adc[0],CalibArray);
01272 mPoint->addNewPoint(newPointB);
01273 mPoint->addNewPoint(newPointC);
01274 mPoint->addNewPoint(newPointE);
01275 }
01276 nSolved++;
01277 }
01278
01279 else if(!strcmp(currentKind,"1p1n2p1n2n3n"))
01280 {
01281 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01282 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01283 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01284 newPointA->setFlag(100);
01285 mPoint->addNewPoint(newPointA);
01286
01287 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01288 setMatcheds(dimensions, newPointC, currentPackage->getMatched(2), currentPackage->getMatched(4));
01289 newPointC->setEnergyLossCorrected(Adc[2]-Adc[5], Adc[4],CalibArray);
01290 newPointC->setFlag(100);
01291 mPoint->addNewPoint(newPointC);
01292
01293 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01294 setMatcheds(dimensions, newPointD, currentPackage->getMatched(2), currentPackage->getMatched(5));
01295 newPointD->setEnergyLossCorrected(Adc[2]-Adc[4], Adc[5],CalibArray);
01296 newPointD->setFlag(100);
01297 mPoint->addNewPoint(newPointD);
01298
01299 nSolved++;
01300 }
01301
01302 else if(!strcmp(currentKind,"1p1n2n2p2n3p2n"))
01303 {
01304 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01305 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01306 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01307 newPointA->setFlag(100);
01308 mPoint->addNewPoint(newPointA);
01309
01310 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01311 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(2));
01312 newPointC->setEnergyLossCorrected(Adc[3], Adc[2]-Adc[5],CalibArray);
01313 newPointC->setFlag(100);
01314 mPoint->addNewPoint(newPointC);
01315
01316 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01317 setMatcheds(dimensions, newPointD, currentPackage->getMatched(5), currentPackage->getMatched(2));
01318 newPointD->setEnergyLossCorrected(Adc[5], Adc[2]-Adc[3],CalibArray);
01319 newPointD->setFlag(100);
01320 mPoint->addNewPoint(newPointD);
01321
01322 nSolved++;
01323 }
01324
01325 else if(!strcmp(currentKind,"1p1n2n3n2p3n"))
01326 {
01327 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01328 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01329 newPointA->setEnergyLossCorrected(Adc[0]-Adc[2], Adc[1],CalibArray);
01330 newPointA->setFlag(100);
01331 mPoint->addNewPoint(newPointA);
01332
01333 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01334 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
01335 newPointB->setEnergyLossCorrected(Adc[0]-Adc[1], Adc[2],CalibArray);
01336 newPointB->setFlag(100);
01337 mPoint->addNewPoint(newPointB);
01338
01339 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01340 setMatcheds(dimensions, newPointD, currentPackage->getMatched(4), currentPackage->getMatched(5));
01341 newPointD->setEnergyLossCorrected(Adc[4], Adc[3],CalibArray);
01342 newPointD->setFlag(100);
01343 mPoint->addNewPoint(newPointD);
01344
01345 nSolved++;
01346 }
01347
01348 else if(!strcmp(currentKind,"1p1n2p1n3p1n2n"))
01349 {
01350 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01351 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01352 newPointA->setEnergyLossCorrected(Adc[0], Adc[1]-Adc[2],CalibArray);
01353 newPointA->setFlag(100);
01354 mPoint->addNewPoint(newPointA);
01355
01356 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01357 setMatcheds(dimensions, newPointB, currentPackage->getMatched(2), currentPackage->getMatched(1));
01358 newPointB->setEnergyLossCorrected(Adc[2], Adc[1]-Adc[0],CalibArray);
01359 newPointB->setFlag(100);
01360 mPoint->addNewPoint(newPointB);
01361
01362 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 32);
01363 setMatcheds(dimensions, newPointD, currentPackage->getMatched(4), currentPackage->getMatched(6));
01364 newPointD->setEnergyLossCorrected(Adc[4], Adc[6],CalibArray);
01365 newPointD->setFlag(100);
01366 mPoint->addNewPoint(newPointD);
01367
01368 nSolved++;
01369 }
01370
01371 else if(!strcmp(currentKind,"1p1n2n3n2p1n2n3n"))
01372 {
01373 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01374 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01375 mPoint->addNewPoint(newPointA);
01376
01377 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01378 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
01379 mPoint->addNewPoint(newPointB);
01380
01381 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01382 setMatcheds(dimensions, newPointC, currentPackage->getMatched(0), currentPackage->getMatched(3));
01383 mPoint->addNewPoint(newPointC);
01384
01385 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01386 setMatcheds(dimensions, newPointD, currentPackage->getMatched(4), currentPackage->getMatched(1));
01387 mPoint->addNewPoint(newPointD);
01388
01389 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01390 setMatcheds(dimensions, newPointE, currentPackage->getMatched(4), currentPackage->getMatched(2));
01391 mPoint->addNewPoint(newPointE);
01392
01393 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01394 setMatcheds(dimensions, newPointF, currentPackage->getMatched(4), currentPackage->getMatched(3));
01395 mPoint->addNewPoint(newPointF);
01396
01397
01398 Double_t setA[2], setB[2], setC[2], setD[2], setE[2], setF[2];
01399 Double_t setAB[2], setAC[2], setBC[2], setDE[2], setDF[2], setEF[2];
01400 Double_t prob[6];
01401
01402 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
01403 setA[1] = matchDistr(clusterControl, setA[0]);
01404 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
01405 setB[1] = matchDistr(clusterControl, setB[0]);
01406 setC[0] = (Adc[0] - Adc[3])/sqrt(2.0);
01407 setC[1] = matchDistr(clusterControl, setC[0]);
01408 setD[0] = (Adc[4] - Adc[1])/sqrt(2.0);
01409 setD[1] = matchDistr(clusterControl, setD[0]);
01410 setE[0] = (Adc[4] - Adc[2])/sqrt(2.0);
01411 setE[1] = matchDistr(clusterControl, setE[0]);
01412 setF[0] = (Adc[4] - Adc[3])/sqrt(2.0);
01413 setF[1] = matchDistr(clusterControl, setF[0]);
01414 setAB[0] = (Adc[0] - Adc[1] - Adc[2])/sqrt(2.0);
01415 setAB[1] = matchDistr(clusterControl, setAB[0]);
01416 setAC[0] = (Adc[0] - Adc[1] - Adc[3])/sqrt(2.0);
01417 setAC[1] = matchDistr(clusterControl, setAC[0]);
01418 setBC[0] = (Adc[0] - Adc[2] - Adc[3])/sqrt(2.0);
01419 setBC[1] = matchDistr(clusterControl, setBC[0]);
01420 setDE[0] = (Adc[4] - Adc[1] - Adc[2])/sqrt(2.0);
01421 setDE[1] = matchDistr(clusterControl, setDE[0]);
01422 setDF[0] = (Adc[4] - Adc[1] - Adc[3])/sqrt(2.0);
01423 setDF[1] = matchDistr(clusterControl, setDF[0]);
01424 setEF[0] = (Adc[4] - Adc[2] - Adc[3])/sqrt(2.0);
01425 setEF[1] = matchDistr(clusterControl, setEF[0]);
01426 Double_t tmp = 3e-33+(setAC[1]*setE[1]+setAB[1]*setF[1]+setBC[1]*setD[1]+setDF[1]*setB[1]+setDE[1]*setC[1]+setEF[1]*setA[1]);
01427 prob[0] = (setAC[1]*setE[1]+setAB[1]*setF[1]+setEF[1]*setA[1])/tmp;
01428 prob[1] = (setAB[1]*setF[1]+setBC[1]*setD[1]+setDF[1]*setB[1])/tmp;
01429 prob[2] = (setAC[1]*setE[1]+setBC[1]*setD[1]+setDE[1]*setC[1])/tmp;
01430 prob[3] = (setBC[1]*setD[1]+setDF[1]*setB[1]+setDE[1]*setC[1])/tmp;
01431 prob[4] = (setAC[1]*setE[1]+setDE[1]*setC[1]+setEF[1]*setA[1])/tmp;
01432 prob[5] = (setAB[1]*setF[1]+setDF[1]*setB[1]+setEF[1]*setA[1])/tmp;
01433 newPointA->setFlag(int(100*prob[0]));
01434 newPointB->setFlag(int(100*prob[1]));
01435 newPointC->setFlag(int(100*prob[2]));
01436 newPointD->setFlag(int(100*prob[3]));
01437 newPointE->setFlag(int(100*prob[4]));
01438 newPointF->setFlag(int(100*prob[5]));
01439 nSolved++;
01440 }
01441
01442 else if(!strcmp(currentKind,"1p1n2n2p1n2n3p1n2n"))
01443 {
01444 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01445 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01446 mPoint->addNewPoint(newPointA);
01447
01448 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01449 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
01450 mPoint->addNewPoint(newPointB);
01451
01452 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01453 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(1));
01454 mPoint->addNewPoint(newPointC);
01455
01456 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01457 setMatcheds(dimensions, newPointD, currentPackage->getMatched(3), currentPackage->getMatched(2));
01458 mPoint->addNewPoint(newPointD);
01459
01460 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01461 setMatcheds(dimensions, newPointE, currentPackage->getMatched(6), currentPackage->getMatched(1));
01462 mPoint->addNewPoint(newPointE);
01463
01464 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 23);
01465 setMatcheds(dimensions, newPointF, currentPackage->getMatched(6), currentPackage->getMatched(2));
01466 mPoint->addNewPoint(newPointF);
01467
01468
01469 Double_t setA[2], setB[2], setC[2], setD[2], setE[2], setF[2];
01470 Double_t setAC[2], setBD[2], setAE[2], setBF[2], setCE[2], setDF[2];
01471 Double_t prob[6];
01472
01473 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
01474 setA[1] = matchDistr(clusterControl, setA[0]);
01475 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
01476 setB[1] = matchDistr(clusterControl, setB[0]);
01477 setC[0] = (Adc[3] - Adc[1])/sqrt(2.0);
01478 setC[1] = matchDistr(clusterControl, setC[0]);
01479 setD[0] = (Adc[3] - Adc[2])/sqrt(2.0);
01480 setD[1] = matchDistr(clusterControl, setD[0]);
01481 setE[0] = (Adc[6] - Adc[1])/sqrt(2.0);
01482 setE[1] = matchDistr(clusterControl, setE[0]);
01483 setF[0] = (Adc[6] - Adc[2])/sqrt(2.0);
01484 setF[1] = matchDistr(clusterControl, setF[0]);
01485 setAC[0] = (Adc[0] + Adc[3] - Adc[1])/sqrt(2.0);
01486 setAC[1] = matchDistr(clusterControl, setAC[0]);
01487 setBD[0] = (Adc[0] + Adc[3] - Adc[2])/sqrt(2.0);
01488 setBD[1] = matchDistr(clusterControl, setBD[0]);
01489 setAE[0] = (Adc[0] + Adc[6] - Adc[1])/sqrt(2.0);
01490 setAE[1] = matchDistr(clusterControl, setAE[0]);
01491 setBF[0] = (Adc[0] + Adc[6] - Adc[2])/sqrt(2.0);
01492 setBF[1] = matchDistr(clusterControl, setBF[0]);
01493 setCE[0] = (Adc[3] + Adc[6] - Adc[1])/sqrt(2.0);
01494 setCE[1] = matchDistr(clusterControl, setCE[0]);
01495 setDF[0] = (Adc[3] + Adc[6] - Adc[2])/sqrt(2.0);
01496 setDF[1] = matchDistr(clusterControl, setDF[0]);
01497 Double_t tmp = 3e-33+(setAC[1]*setF[1]+setAE[1]*setD[1]+setDF[1]*setA[1]+setCE[1]*setB[1]+setBD[1]*setE[1]+setBF[1]*setC[1]);
01498 prob[0] = (setAC[1]*setF[1]+setAE[1]*setD[1]+setDF[1]*setA[1])/tmp;
01499 prob[1] = (setCE[1]*setB[1]+setBD[1]*setE[1]+setBF[1]*setC[1])/tmp;
01500 prob[2] = (setAC[1]*setF[1]+setCE[1]*setB[1]+setBF[1]*setC[1])/tmp;
01501 prob[3] = (setAE[1]*setD[1]+setCE[1]*setB[1]+setBD[1]*setE[1])/tmp;
01502 prob[4] = (setAE[1]*setD[1]+setDF[1]*setA[1]+setBD[1]*setE[1])/tmp;
01503 prob[5] = (setAC[1]*setF[1]+setDF[1]*setA[1]+setBF[1]*setC[1])/tmp;
01504 newPointA->setFlag(int(100*prob[0]));
01505 newPointB->setFlag(int(100*prob[1]));
01506 newPointC->setFlag(int(100*prob[2]));
01507 newPointD->setFlag(int(100*prob[3]));
01508 newPointE->setFlag(int(100*prob[4]));
01509 newPointF->setFlag(int(100*prob[5]));
01510 nSolved++;
01511 }
01512
01513 else if(!strcmp(currentKind,"1p1n2n2p2n3n3p3n"))
01514 {
01515 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01516 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01517 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01518 newPointA->setFlag(100);
01519 mPoint->addNewPoint(newPointA);
01520
01521 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01522 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(2));
01523 newPointC->setEnergyLossCorrected(Adc[3], Adc[2],CalibArray);
01524 newPointC->setFlag(100);
01525 mPoint->addNewPoint(newPointC);
01526
01527 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01528 setMatcheds(dimensions, newPointE, currentPackage->getMatched(6), currentPackage->getMatched(5));
01529 newPointE->setEnergyLossCorrected(Adc[6], Adc[5],CalibArray);
01530 newPointE->setFlag(100);
01531 mPoint->addNewPoint(newPointE);
01532
01533 nSolved++;
01534 }
01535
01536 else if(!strcmp(currentKind,"1p1n2p1n2n3p2n3n"))
01537 {
01538 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01539 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01540 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01541 newPointA->setFlag(100);
01542 mPoint->addNewPoint(newPointA);
01543
01544 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01545 setMatcheds(dimensions, newPointC, currentPackage->getMatched(2), currentPackage->getMatched(4));
01546 newPointC->setEnergyLossCorrected(Adc[2], Adc[4],CalibArray);
01547 newPointC->setFlag(100);
01548 mPoint->addNewPoint(newPointC);
01549
01550 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01551 setMatcheds(dimensions, newPointE, currentPackage->getMatched(5), currentPackage->getMatched(7));
01552 newPointE->setEnergyLossCorrected(Adc[5], Adc[7],CalibArray);
01553 newPointE->setFlag(100);
01554 mPoint->addNewPoint(newPointE);
01555
01556 nSolved++;
01557 }
01558
01559 else if(!strcmp(currentKind,"1p1n2n2p2n3n3p2n3n"))
01560 {
01561 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01562 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01563 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01564 newPointA->setFlag(100);
01565
01566
01567 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01568 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(2));
01569 newPointC->setEnergyLossCorrected(Adc[3], Adc[2],CalibArray);
01570
01571
01572 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01573 setMatcheds(dimensions, newPointD, currentPackage->getMatched(3), currentPackage->getMatched(5));
01574 newPointD->setEnergyLossCorrected(Adc[3], Adc[5],CalibArray);
01575
01576
01577 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01578 setMatcheds(dimensions, newPointE, currentPackage->getMatched(6), currentPackage->getMatched(2));
01579 newPointE->setEnergyLossCorrected(Adc[6], Adc[2],CalibArray);
01580
01581
01582 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01583 setMatcheds(dimensions, newPointF, currentPackage->getMatched(6), currentPackage->getMatched(5));
01584 newPointF->setEnergyLossCorrected(Adc[6], Adc[5],CalibArray);
01585
01586
01587
01588 Double_t setC[2], setD[2], setE[2], setF[2];
01589 Double_t probACF, probADE;
01590
01591 setC[0] = (Adc[3] - Adc[2])/sqrt(2.0);
01592 setC[1] = matchDistr(clusterControl, setC[0]);
01593 setD[0] = (Adc[3] - Adc[5])/sqrt(2.0);
01594 setD[1] = matchDistr(clusterControl, setD[0]);
01595 setE[0] = (Adc[6] - Adc[2])/sqrt(2.0);
01596 setE[1] = matchDistr(clusterControl, setE[0]);
01597 setF[0] = (Adc[6] - Adc[5])/sqrt(2.0);
01598 setF[1] = matchDistr(clusterControl, setF[0]);
01599 Double_t tmp = 3e-33+ setC[1]*setF[1]+setD[1]*setE[1];
01600 probACF = (setC[1]*setF[1])/tmp;
01601 probADE = (setD[1]*setE[1])/tmp;
01602 if(probACF>probADE)
01603 {
01604 mPoint->addNewPoint(newPointA);
01605 mPoint->addNewPoint(newPointC);
01606 mPoint->addNewPoint(newPointF);
01607 }
01608 else
01609 {
01610 mPoint->addNewPoint(newPointA);
01611 mPoint->addNewPoint(newPointD);
01612 mPoint->addNewPoint(newPointE);
01613 }
01614 newPointC->setFlag(int(100*probACF));
01615 newPointD->setFlag(int(100*probADE));
01616 newPointE->setFlag(int(100*probADE));
01617 newPointF->setFlag(int(100*probACF));
01618 nSolved++;
01619 }
01620
01621 else if(!strcmp(currentKind,"1p1n2p1n2n3n3p2n3n"))
01622 {
01623 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01624 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01625 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01626 newPointA->setFlag(100);
01627
01628
01629 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01630 setMatcheds(dimensions, newPointC, currentPackage->getMatched(2), currentPackage->getMatched(4));
01631 newPointC->setEnergyLossCorrected(Adc[2], Adc[4],CalibArray);
01632
01633
01634 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01635 setMatcheds(dimensions, newPointD, currentPackage->getMatched(2), currentPackage->getMatched(5));
01636 newPointD->setEnergyLossCorrected(Adc[2], Adc[5],CalibArray);
01637
01638
01639 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01640 setMatcheds(dimensions, newPointE, currentPackage->getMatched(6), currentPackage->getMatched(4));
01641 newPointE->setEnergyLossCorrected(Adc[6], Adc[4],CalibArray);
01642
01643
01644 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01645 setMatcheds(dimensions, newPointF, currentPackage->getMatched(6), currentPackage->getMatched(5));
01646 newPointF->setEnergyLossCorrected(Adc[6], Adc[5],CalibArray);
01647
01648
01649
01650 Double_t setC[2], setD[2], setE[2], setF[2];
01651 Double_t probACF, probADE;
01652
01653 setC[0] = (Adc[2] - Adc[4])/sqrt(2.0);
01654 setC[1] = matchDistr(clusterControl, setC[0]);
01655 setD[0] = (Adc[2] - Adc[5])/sqrt(2.0);
01656 setD[1] = matchDistr(clusterControl, setD[0]);
01657 setE[0] = (Adc[6] - Adc[4])/sqrt(2.0);
01658 setE[1] = matchDistr(clusterControl, setE[0]);
01659 setF[0] = (Adc[6] - Adc[5])/sqrt(2.0);
01660 setF[1] = matchDistr(clusterControl, setF[0]);
01661 Double_t tmp = 3e-33+ setC[1]*setF[1]+setD[1]*setE[1];
01662 probACF = (setC[1]*setF[1])/tmp;
01663 probADE = (setD[1]*setE[1])/tmp;
01664 if(probACF>probADE)
01665 {
01666 mPoint->addNewPoint(newPointA);
01667 mPoint->addNewPoint(newPointC);
01668 mPoint->addNewPoint(newPointF);
01669 }
01670 else
01671 {
01672 mPoint->addNewPoint(newPointA);
01673 mPoint->addNewPoint(newPointD);
01674 mPoint->addNewPoint(newPointE);
01675 }
01676 newPointC->setFlag(int(100*probACF));
01677 newPointD->setFlag(int(100*probADE));
01678 newPointE->setFlag(int(100*probADE));
01679 newPointF->setFlag(int(100*probACF));
01680 nSolved++;
01681 }
01682
01683 else if(!strcmp(currentKind,"1p1n2n2p1n2n3p2n3n"))
01684 {
01685 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01686 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01687 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01688
01689
01690 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01691 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
01692 newPointB->setEnergyLossCorrected(Adc[0], Adc[2],CalibArray);
01693
01694
01695 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01696 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(1));
01697 newPointC->setEnergyLossCorrected(Adc[3], Adc[1],CalibArray);
01698
01699
01700 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01701 setMatcheds(dimensions, newPointD, currentPackage->getMatched(3), currentPackage->getMatched(2));
01702 newPointD->setEnergyLossCorrected(Adc[3], Adc[2],CalibArray);
01703
01704
01705 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01706 setMatcheds(dimensions, newPointF, currentPackage->getMatched(6), currentPackage->getMatched(8));
01707 newPointF->setEnergyLossCorrected(Adc[6], Adc[8],CalibArray);
01708 newPointF->setFlag(100);
01709
01710
01711
01712 Double_t setA[2], setB[2], setC[2], setD[2];
01713 Double_t probADF, probBCF;
01714
01715 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
01716 setA[1] = matchDistr(clusterControl, setA[0]);
01717 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
01718 setB[1] = matchDistr(clusterControl, setB[0]);
01719 setC[0] = (Adc[3] - Adc[1])/sqrt(2.0);
01720 setC[1] = matchDistr(clusterControl, setC[0]);
01721 setD[0] = (Adc[3] - Adc[2])/sqrt(2.0);
01722 setD[1] = matchDistr(clusterControl, setD[0]);
01723 Double_t tmp = 3e-33+(setA[1]*setD[1]+setB[1]*setC[1]);
01724 probADF = (setA[1]*setD[1])/tmp;
01725 probBCF = (setB[1]*setC[1])/tmp;
01726 if(probADF>probBCF)
01727 {
01728 mPoint->addNewPoint(newPointA);
01729 mPoint->addNewPoint(newPointD);
01730 mPoint->addNewPoint(newPointF);
01731 }
01732 else
01733 {
01734 mPoint->addNewPoint(newPointB);
01735 mPoint->addNewPoint(newPointC);
01736 mPoint->addNewPoint(newPointF);
01737 }
01738 newPointA->setFlag(int(100*probADF));
01739 newPointB->setFlag(int(100*probBCF));
01740 newPointC->setFlag(int(100*probBCF));
01741 newPointD->setFlag(int(100*probADF));
01742 nSolved++;
01743 }
01744
01745 else if(!strcmp(currentKind,"1p1n2n2p1n2n3n3p3n"))
01746 {
01747 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01748 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01749 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01750
01751
01752 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01753 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
01754 newPointB->setEnergyLossCorrected(Adc[0], Adc[2],CalibArray);
01755
01756
01757 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01758 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(1));
01759 newPointC->setEnergyLossCorrected(Adc[3], Adc[1],CalibArray);
01760
01761
01762 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01763 setMatcheds(dimensions, newPointD, currentPackage->getMatched(3), currentPackage->getMatched(2));
01764 newPointD->setEnergyLossCorrected(Adc[3], Adc[2],CalibArray);
01765
01766
01767 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01768 setMatcheds(dimensions, newPointF, currentPackage->getMatched(7), currentPackage->getMatched(6));
01769 newPointF->setEnergyLossCorrected(Adc[7], Adc[6],CalibArray);
01770 newPointF->setNMatched(33);
01771 newPointF->setFlag(100);
01772
01773
01774
01775 Double_t setA[2], setB[2], setC[2], setD[2];
01776 Double_t probADF, probBCF;
01777
01778 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
01779 setA[1] = matchDistr(clusterControl, setA[0]);
01780 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
01781 setB[1] = matchDistr(clusterControl, setB[0]);
01782 setC[0] = (Adc[3] - Adc[1])/sqrt(2.0);
01783 setC[1] = matchDistr(clusterControl, setC[0]);
01784 setD[0] = (Adc[3] - Adc[2])/sqrt(2.0);
01785 setD[1] = matchDistr(clusterControl, setD[0]);
01786 Double_t tmp = 3e-33+(setA[1]*setD[1]+setB[1]*setC[1]);
01787 probADF = (setA[1]*setD[1])/tmp;
01788 probBCF = (setB[1]*setC[1])/tmp;
01789 if(probADF>probBCF)
01790 {
01791 mPoint->addNewPoint(newPointA);
01792 mPoint->addNewPoint(newPointD);
01793 mPoint->addNewPoint(newPointF);
01794 }
01795 else
01796 {
01797 mPoint->addNewPoint(newPointB);
01798 mPoint->addNewPoint(newPointC);
01799 mPoint->addNewPoint(newPointF);
01800 }
01801 newPointA->setFlag(int(100*probADF));
01802 newPointB->setFlag(int(100*probBCF));
01803 newPointC->setFlag(int(100*probBCF));
01804 newPointD->setFlag(int(100*probADF));
01805 nSolved++;
01806 }
01807
01808 else if(!strcmp(currentKind,"1p1n2n3n2p2n3n3p3n"))
01809 {
01810 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01811 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01812 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01813 newPointA->setFlag(100);
01814 mPoint->addNewPoint(newPointA);
01815
01816 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01817 setMatcheds(dimensions, newPointD, currentPackage->getMatched(4), currentPackage->getMatched(2));
01818 newPointD->setEnergyLossCorrected(Adc[4], Adc[2],CalibArray);
01819 newPointD->setFlag(100);
01820 mPoint->addNewPoint(newPointD);
01821
01822 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01823 setMatcheds(dimensions, newPointF, currentPackage->getMatched(7), currentPackage->getMatched(3));
01824 newPointF->setEnergyLossCorrected(Adc[7], Adc[3],CalibArray);
01825 newPointF->setFlag(100);
01826 mPoint->addNewPoint(newPointF);
01827
01828 nSolved++;
01829 }
01830
01831
01832 else if(!strcmp(currentKind,"1p1n2p1n2n3p1n2n3n"))
01833 {
01834 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01835 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01836 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01837 newPointA->setFlag(100);
01838 mPoint->addNewPoint(newPointA);
01839
01840 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01841 setMatcheds(dimensions, newPointD, currentPackage->getMatched(2), currentPackage->getMatched(4));
01842 newPointD->setEnergyLossCorrected(Adc[2], Adc[4],CalibArray);
01843 newPointD->setFlag(100);
01844 mPoint->addNewPoint(newPointD);
01845
01846 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01847 setMatcheds(dimensions, newPointF, currentPackage->getMatched(5), currentPackage->getMatched(8));
01848 newPointF->setEnergyLossCorrected(Adc[5], Adc[8],CalibArray);
01849 newPointF->setFlag(100);
01850 mPoint->addNewPoint(newPointF);
01851
01852 nSolved++;
01853 }
01854
01855
01856 else if(!strcmp(currentKind,"1p1n2n3n2p2n3n3p2n3n"))
01857 {
01858 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01859 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01860 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01861 newPointA->setFlag(100);
01862
01863
01864 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01865 setMatcheds(dimensions, newPointD, currentPackage->getMatched(4), currentPackage->getMatched(2));
01866 newPointD->setEnergyLossCorrected(Adc[4], Adc[2],CalibArray);
01867
01868
01869 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01870 setMatcheds(dimensions, newPointE, currentPackage->getMatched(4), currentPackage->getMatched(3));
01871 newPointE->setEnergyLossCorrected(Adc[4], Adc[3],CalibArray);
01872
01873
01874 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01875 setMatcheds(dimensions, newPointF, currentPackage->getMatched(7), currentPackage->getMatched(2));
01876 newPointF->setEnergyLossCorrected(Adc[7], Adc[2],CalibArray);
01877
01878
01879 StSsdPoint *newPointG = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01880 setMatcheds(dimensions, newPointG, currentPackage->getMatched(7), currentPackage->getMatched(3));
01881 newPointG->setEnergyLossCorrected(Adc[7], Adc[3],CalibArray);
01882
01883
01884
01885 Double_t setD[2], setE[2], setF[2], setG[2];
01886 Double_t probADG, probAEF;
01887
01888 setD[0] = (Adc[4] - Adc[2])/sqrt(2.0);
01889 setD[1] = matchDistr(clusterControl, setD[0]);
01890 setE[0] = (Adc[4] - Adc[3])/sqrt(2.0);
01891 setE[1] = matchDistr(clusterControl, setE[0]);
01892 setF[0] = (Adc[7] - Adc[2])/sqrt(2.0);
01893 setF[1] = matchDistr(clusterControl, setF[0]);
01894 setG[0] = (Adc[7] - Adc[3])/sqrt(2.0);
01895 setG[1] = matchDistr(clusterControl, setG[0]);
01896 Double_t tmp = 3e-33+(setD[1]*setG[1]+setE[1]*setF[1]);
01897 probADG = (setD[1]*setG[1])/tmp;
01898 probAEF = (setE[1]*setF[1])/tmp;
01899 if(probADG>probAEF)
01900 {
01901 mPoint->addNewPoint(newPointA);
01902 mPoint->addNewPoint(newPointD);
01903 mPoint->addNewPoint(newPointG);
01904 }
01905 else
01906 {
01907 mPoint->addNewPoint(newPointA);
01908 mPoint->addNewPoint(newPointE);
01909 mPoint->addNewPoint(newPointF);
01910 }
01911 newPointD->setFlag(int(100*probADG));
01912 newPointE->setFlag(int(100*probAEF));
01913 newPointF->setFlag(int(100*probAEF));
01914 newPointG->setFlag(int(100*probADG));
01915
01916 nSolved++;
01917 }
01918
01919 else if(!strcmp(currentKind,"1p1n2p1n2n3n3p1n2n3n"))
01920 {
01921 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01922 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01923 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01924 newPointA->setFlag(100);
01925
01926
01927 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01928 setMatcheds(dimensions, newPointC, currentPackage->getMatched(2), currentPackage->getMatched(4));
01929 newPointC->setEnergyLossCorrected(Adc[2], Adc[4],CalibArray);
01930
01931
01932 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01933 setMatcheds(dimensions, newPointD, currentPackage->getMatched(2), currentPackage->getMatched(5));
01934 newPointD->setEnergyLossCorrected(Adc[2], Adc[5],CalibArray);
01935
01936
01937 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01938 setMatcheds(dimensions, newPointF, currentPackage->getMatched(6), currentPackage->getMatched(4));
01939 newPointF->setEnergyLossCorrected(Adc[6], Adc[4],CalibArray);
01940
01941
01942 StSsdPoint *newPointG = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01943 setMatcheds(dimensions, newPointG, currentPackage->getMatched(6), currentPackage->getMatched(5));
01944 newPointG->setEnergyLossCorrected(Adc[6], Adc[5],CalibArray);
01945
01946
01947
01948 Double_t setC[2], setD[2], setF[2], setG[2];
01949 Double_t probACG, probADF;
01950
01951 setC[0] = (Adc[2] - Adc[4])/sqrt(2.0);
01952 setC[1] = matchDistr(clusterControl, setC[0]);
01953 setD[0] = (Adc[2] - Adc[5])/sqrt(2.0);
01954 setD[1] = matchDistr(clusterControl, setD[0]);
01955 setF[0] = (Adc[6] - Adc[4])/sqrt(2.0);
01956 setF[1] = matchDistr(clusterControl, setF[0]);
01957 setG[0] = (Adc[6] - Adc[5])/sqrt(2.0);
01958 setG[1] = matchDistr(clusterControl, setG[0]);
01959 Double_t tmp = 3e-33+(setC[1]*setG[1]+setD[1]*setF[1]);
01960 probACG = (setC[1]*setG[1])/tmp;
01961 probADF = (setD[1]*setF[1])/tmp;
01962 if(probACG>probADF)
01963 {
01964 mPoint->addNewPoint(newPointA);
01965 mPoint->addNewPoint(newPointC);
01966 mPoint->addNewPoint(newPointG);
01967 }
01968 else
01969 {
01970 mPoint->addNewPoint(newPointA);
01971 mPoint->addNewPoint(newPointD);
01972 mPoint->addNewPoint(newPointF);
01973 }
01974 newPointC->setFlag(int(100*probACG));
01975 newPointD->setFlag(int(100*probADF));
01976 newPointF->setFlag(int(100*probADF));
01977 newPointG->setFlag(int(100*probACG));
01978
01979 nSolved++;
01980 }
01981
01982 else if(!strcmp(currentKind,"1p1n2n2p1n2n3p1n2n3n"))
01983 {
01984 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01985 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
01986 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
01987
01988
01989 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01990 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
01991 newPointB->setEnergyLossCorrected(Adc[0], Adc[2],CalibArray);
01992
01993
01994 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
01995 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(1));
01996 newPointC->setEnergyLossCorrected(Adc[3], Adc[1],CalibArray);
01997
01998
01999 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02000 setMatcheds(dimensions, newPointD, currentPackage->getMatched(3), currentPackage->getMatched(2));
02001 newPointD->setEnergyLossCorrected(Adc[3], Adc[2],CalibArray);
02002
02003
02004 StSsdPoint *newPointG = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02005 setMatcheds(dimensions, newPointG, currentPackage->getMatched(6), currentPackage->getMatched(9));
02006 newPointG->setEnergyLossCorrected(Adc[6], Adc[9],CalibArray);
02007 newPointG->setFlag(100);
02008
02009
02010
02011 Double_t setA[2], setB[2], setC[2], setD[2];
02012 Double_t probADG, probBCG;
02013
02014 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
02015 setA[1] = matchDistr(clusterControl, setA[0]);
02016 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
02017 setB[1] = matchDistr(clusterControl, setB[0]);
02018 setC[0] = (Adc[3] - Adc[1])/sqrt(2.0);
02019 setC[1] = matchDistr(clusterControl, setC[0]);
02020 setD[0] = (Adc[3] - Adc[2])/sqrt(2.0);
02021 setD[1] = matchDistr(clusterControl, setD[0]);
02022 Double_t tmp = 3e-33+(setA[1]*setD[1]+setB[1]*setC[1]);
02023 probADG = (setA[1]*setD[1])/tmp;
02024 probBCG = (setB[1]*setC[1])/tmp;
02025 if(probADG>probBCG)
02026 {
02027 mPoint->addNewPoint(newPointA);
02028 mPoint->addNewPoint(newPointD);
02029 mPoint->addNewPoint(newPointG);
02030 }
02031 else
02032 {
02033 mPoint->addNewPoint(newPointB);
02034 mPoint->addNewPoint(newPointC);
02035 mPoint->addNewPoint(newPointG);
02036 }
02037 newPointA->setFlag(int(100*probADG));
02038 newPointB->setFlag(int(100*probBCG));
02039 newPointC->setFlag(int(100*probBCG));
02040 newPointD->setFlag(int(100*probADG));
02041
02042 nSolved++;
02043 }
02044
02045 else if(!strcmp(currentKind,"1p1n2n3n2p1n2n3n3p3n"))
02046 {
02047 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02048 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
02049 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
02050
02051
02052 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02053 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
02054 newPointB->setEnergyLossCorrected(Adc[0], Adc[2],CalibArray);
02055
02056
02057 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02058 setMatcheds(dimensions, newPointD, currentPackage->getMatched(4), currentPackage->getMatched(1));
02059 newPointD->setEnergyLossCorrected(Adc[4], Adc[1],CalibArray);
02060
02061
02062 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02063 setMatcheds(dimensions, newPointE, currentPackage->getMatched(4), currentPackage->getMatched(2));
02064 newPointE->setEnergyLossCorrected(Adc[4], Adc[2],CalibArray);
02065
02066
02067 StSsdPoint *newPointG = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02068 setMatcheds(dimensions, newPointG, currentPackage->getMatched(8), currentPackage->getMatched(3));
02069 newPointG->setEnergyLossCorrected(Adc[8], Adc[3],CalibArray);
02070 newPointG->setFlag(100);
02071
02072
02073
02074 Double_t setA[2], setB[2], setD[2], setE[2];
02075 Double_t probAEG, probBDG;
02076
02077 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
02078 setA[1] = matchDistr(clusterControl, setA[0]);
02079 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
02080 setB[1] = matchDistr(clusterControl, setB[0]);
02081 setD[0] = (Adc[4] - Adc[2])/sqrt(2.0);
02082 setD[1] = matchDistr(clusterControl, setD[0]);
02083 setE[0] = (Adc[4] - Adc[1])/sqrt(2.0);
02084 setE[1] = matchDistr(clusterControl, setE[0]);
02085 Double_t tmp = 3e-33+(setA[1]*setE[1]+setB[1]*setD[1]);
02086 probAEG = (setA[1]*setE[1])/tmp;
02087 probBDG = (setB[1]*setD[1])/tmp;
02088 if(probAEG>probBDG)
02089 {
02090 mPoint->addNewPoint(newPointA);
02091 mPoint->addNewPoint(newPointE);
02092 mPoint->addNewPoint(newPointG);
02093 }
02094 else
02095 {
02096 mPoint->addNewPoint(newPointB);
02097 mPoint->addNewPoint(newPointD);
02098 mPoint->addNewPoint(newPointG);
02099 }
02100 newPointA->setFlag(int(100*probAEG));
02101 newPointB->setFlag(int(100*probBDG));
02102 newPointD->setFlag(int(100*probBDG));
02103 newPointE->setFlag(int(100*probAEG));
02104
02105 nSolved++;
02106 }
02107
02108 else if(!strcmp(currentKind,"1p1n2p1n2n3n3p3n"))
02109 {
02110 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02111 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
02112 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
02113 newPointA->setFlag(100);
02114 mPoint->addNewPoint(newPointA);
02115
02116 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02117 setMatcheds(dimensions, newPointC, currentPackage->getMatched(2), currentPackage->getMatched(4));
02118 newPointC->setEnergyLossCorrected(Adc[2], Adc[4],CalibArray);
02119 newPointC->setFlag(100);
02120 mPoint->addNewPoint(newPointC);
02121
02122 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02123 setMatcheds(dimensions, newPointE, currentPackage->getMatched(6), currentPackage->getMatched(5));
02124 newPointE->setEnergyLossCorrected(Adc[6], Adc[5],CalibArray);
02125 newPointE->setFlag(100);
02126 mPoint->addNewPoint(newPointE);
02127
02128 nSolved++;
02129 }
02130
02131 else if(!strcmp(currentKind,"1p1n2n2p2n3p2n3n"))
02132 {
02133 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02134 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
02135 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
02136 newPointA->setFlag(100);
02137 mPoint->addNewPoint(newPointA);
02138
02139 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02140 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(2));
02141 newPointC->setEnergyLossCorrected(Adc[3], Adc[2],CalibArray);
02142 newPointC->setFlag(100);
02143 mPoint->addNewPoint(newPointC);
02144
02145 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02146 setMatcheds(dimensions, newPointE, currentPackage->getMatched(5), currentPackage->getMatched(7));
02147 newPointE->setEnergyLossCorrected(Adc[5], Adc[7],CalibArray);
02148 newPointE->setFlag(100);
02149 mPoint->addNewPoint(newPointE);
02150
02151 nSolved++;
02152 }
02153
02154 else if(!strcmp(currentKind,"1p1n2n2p1n2n3n3p2n3n"))
02155 {
02156 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02157 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
02158 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
02159
02160
02161 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02162 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
02163 newPointB->setEnergyLossCorrected(Adc[0], Adc[2],CalibArray);
02164
02165
02166 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02167 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(1));
02168 newPointC->setEnergyLossCorrected(Adc[3], Adc[1],CalibArray);
02169
02170
02171 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02172 setMatcheds(dimensions, newPointD, currentPackage->getMatched(3), currentPackage->getMatched(2));
02173 newPointD->setEnergyLossCorrected(Adc[3], Adc[2],CalibArray);
02174
02175
02176 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02177 setMatcheds(dimensions, newPointE, currentPackage->getMatched(3), currentPackage->getMatched(6));
02178 newPointE->setEnergyLossCorrected(Adc[3], Adc[6],CalibArray);
02179
02180
02181 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02182 setMatcheds(dimensions, newPointF, currentPackage->getMatched(7), currentPackage->getMatched(2));
02183 newPointF->setEnergyLossCorrected(Adc[7], Adc[2],CalibArray);
02184
02185
02186 StSsdPoint *newPointG = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02187 setMatcheds(dimensions, newPointG, currentPackage->getMatched(7), currentPackage->getMatched(6));
02188 newPointG->setEnergyLossCorrected(Adc[7], Adc[6],CalibArray);
02189
02190
02191
02192 Double_t setA[2], setB[2], setC[2], setD[2], setE[2], setF[2], setG[2];
02193 Double_t probADG, probAEF, probBCG;
02194
02195 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
02196 setA[1] = matchDistr(clusterControl, setA[0]);
02197 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
02198 setB[1] = matchDistr(clusterControl, setB[0]);
02199 setC[0] = (Adc[3] - Adc[1])/sqrt(2.0);
02200 setC[1] = matchDistr(clusterControl, setC[0]);
02201 setD[0] = (Adc[3] - Adc[2])/sqrt(2.0);
02202 setD[1] = matchDistr(clusterControl, setD[0]);
02203 setE[0] = (Adc[3] - Adc[6])/sqrt(2.0);
02204 setE[1] = matchDistr(clusterControl, setE[0]);
02205 setF[0] = (Adc[7] - Adc[2])/sqrt(2.0);
02206 setF[1] = matchDistr(clusterControl, setF[0]);
02207 setG[0] = (Adc[7] - Adc[6])/sqrt(2.0);
02208 setG[1] = matchDistr(clusterControl, setG[0]);
02209 Double_t tmp = 3e-33+(setA[1]*setD[1]*setG[1]+setA[1]*setE[1]*setF[1]+setB[1]*setC[1]*setG[1]);
02210 probADG = (setA[1]*setD[1]*setG[1])/tmp;
02211 probAEF = (setA[1]*setE[1]*setF[1])/tmp;
02212 probBCG = (setB[1]*setC[1]*setG[1])/tmp;
02213 if ((probADG > probAEF)&&(probADG > probBCG))
02214 {
02215
02216 mPoint->addNewPoint(newPointA);
02217 mPoint->addNewPoint(newPointD);
02218 mPoint->addNewPoint(newPointG);
02219 }
02220 else if ((probAEF > probADG)&&(probAEF > probBCG))
02221 {
02222 mPoint->addNewPoint(newPointA);
02223 mPoint->addNewPoint(newPointE);
02224 mPoint->addNewPoint(newPointF);
02225 }
02226 else if ((probBCG > probADG)&&(probBCG > probAEF))
02227 {
02228 mPoint->addNewPoint(newPointB);
02229 mPoint->addNewPoint(newPointC);
02230 mPoint->addNewPoint(newPointG);
02231 }
02232 newPointA->setFlag(int(100*(probADG+probAEF)));
02233 newPointB->setFlag(int(100*probBCG));
02234 newPointC->setFlag(int(100*probBCG));
02235 newPointD->setFlag(int(100*probADG));
02236 newPointE->setFlag(int(100*probAEF));
02237 newPointF->setFlag(int(100*probAEF));
02238 newPointG->setFlag(int(100*(probADG+probBCG)));
02239
02240 nSolved++;
02241 }
02242
02243 else if(!strcmp(currentKind,"1p1n2n3n2p1n2n3n3p2n3n"))
02244 {
02245 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02246 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
02247 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
02248 mPoint->addNewPoint(newPointA);
02249
02250 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02251 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
02252 newPointB->setEnergyLossCorrected(Adc[0], Adc[2],CalibArray);
02253 mPoint->addNewPoint(newPointB);
02254
02255 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02256 setMatcheds(dimensions, newPointC, currentPackage->getMatched(0), currentPackage->getMatched(3));
02257 newPointC->setEnergyLossCorrected(Adc[0], Adc[3],CalibArray);
02258 mPoint->addNewPoint(newPointC);
02259
02260 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02261 setMatcheds(dimensions, newPointD, currentPackage->getMatched(4), currentPackage->getMatched(1));
02262 newPointD->setEnergyLossCorrected(Adc[4], Adc[1],CalibArray);
02263 mPoint->addNewPoint(newPointD);
02264
02265 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02266 setMatcheds(dimensions, newPointE, currentPackage->getMatched(4), currentPackage->getMatched(2));
02267 newPointE->setEnergyLossCorrected(Adc[4], Adc[2],CalibArray);
02268 mPoint->addNewPoint(newPointE);
02269
02270 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02271 setMatcheds(dimensions, newPointF, currentPackage->getMatched(4), currentPackage->getMatched(3));
02272 newPointF->setEnergyLossCorrected(Adc[4], Adc[3],CalibArray);
02273 mPoint->addNewPoint(newPointF);
02274
02275 StSsdPoint *newPointG = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02276 setMatcheds(dimensions, newPointG, currentPackage->getMatched(8), currentPackage->getMatched(2));
02277 newPointG->setEnergyLossCorrected(Adc[8], Adc[2],CalibArray);
02278 mPoint->addNewPoint(newPointG);
02279
02280 StSsdPoint *newPointH = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02281 setMatcheds(dimensions, newPointH, currentPackage->getMatched(8), currentPackage->getMatched(3));
02282 newPointH->setEnergyLossCorrected(Adc[8], Adc[3],CalibArray);
02283 mPoint->addNewPoint(newPointH);
02284
02285
02286 Double_t setA[2], setB[2], setC[2], setD[2], setE[2], setF[2], setG[2], setH[2];
02287 Double_t probAEH, probAFG, probBDH, probCDG;
02288
02289 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
02290 setA[1] = matchDistr(clusterControl, setA[0]);
02291 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
02292 setB[1] = matchDistr(clusterControl, setB[0]);
02293 setC[0] = (Adc[0] - Adc[3])/sqrt(2.0);
02294 setC[1] = matchDistr(clusterControl, setC[0]);
02295 setD[0] = (Adc[4] - Adc[1])/sqrt(2.0);
02296 setD[1] = matchDistr(clusterControl, setD[0]);
02297 setE[0] = (Adc[4] - Adc[2])/sqrt(2.0);
02298 setE[1] = matchDistr(clusterControl, setE[0]);
02299 setF[0] = (Adc[4] - Adc[3])/sqrt(2.0);
02300 setF[1] = matchDistr(clusterControl, setF[0]);
02301 setG[0] = (Adc[8] - Adc[2])/sqrt(2.0);
02302 setG[1] = matchDistr(clusterControl, setG[0]);
02303 setH[0] = (Adc[8] - Adc[3])/sqrt(2.0);
02304 setH[1] = matchDistr(clusterControl, setH[0]);
02305 Double_t tmp = 3e-33+(setA[1]*setE[1]*setH[1]+setA[1]*setF[1]*setG[1]+setB[1]*setD[1]*setH[1]+setC[1]*setD[1]*setG[1]);
02306 probAEH = (setA[1]*setE[1]*setH[1])/tmp;
02307 probAFG = (setA[1]*setF[1]*setG[1])/tmp;
02308 probBDH = (setB[1]*setD[1]*setH[1])/tmp;
02309 probCDG = (setC[1]*setD[1]*setG[1])/tmp;
02310 newPointA->setFlag(int(100*(probAEH+probAFG)));
02311 newPointB->setFlag(int(100*probBDH));
02312 newPointC->setFlag(int(100*probCDG));
02313 newPointD->setFlag(int(100*(probBDH+probCDG)));
02314 newPointE->setFlag(int(100*probAEH));
02315 newPointF->setFlag(int(100*probAFG));
02316 newPointG->setFlag(int(100*(probAFG+probCDG)));
02317 newPointH->setFlag(int(100*(probAEH+probBDH)));
02318
02319 nSolved++;
02320 }
02321
02322 else if(!strcmp(currentKind,"1p1n2n2p1n2n3n3p1n2n3n"))
02323 {
02324 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02325 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
02326 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
02327 mPoint->addNewPoint(newPointA);
02328
02329 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02330 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
02331 newPointB->setEnergyLossCorrected(Adc[0], Adc[2],CalibArray);
02332 mPoint->addNewPoint(newPointB);
02333
02334 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02335 setMatcheds(dimensions, newPointC, currentPackage->getMatched(3), currentPackage->getMatched(1));
02336 newPointC->setEnergyLossCorrected(Adc[3], Adc[1],CalibArray);
02337 mPoint->addNewPoint(newPointC);
02338
02339 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02340 setMatcheds(dimensions, newPointD, currentPackage->getMatched(3), currentPackage->getMatched(2));
02341 newPointD->setEnergyLossCorrected(Adc[3], Adc[2],CalibArray);
02342 mPoint->addNewPoint(newPointD);
02343
02344 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02345 setMatcheds(dimensions, newPointE, currentPackage->getMatched(3), currentPackage->getMatched(6));
02346 newPointE->setEnergyLossCorrected(Adc[3], Adc[6],CalibArray);
02347 mPoint->addNewPoint(newPointE);
02348
02349 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02350 setMatcheds(dimensions, newPointF, currentPackage->getMatched(7), currentPackage->getMatched(1));
02351 newPointF->setEnergyLossCorrected(Adc[7], Adc[1],CalibArray);
02352 mPoint->addNewPoint(newPointF);
02353
02354 StSsdPoint *newPointG = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02355 setMatcheds(dimensions, newPointG, currentPackage->getMatched(7), currentPackage->getMatched(2));
02356 newPointG->setEnergyLossCorrected(Adc[7], Adc[2],CalibArray);
02357 mPoint->addNewPoint(newPointG);
02358
02359 StSsdPoint *newPointH = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02360 setMatcheds(dimensions, newPointH, currentPackage->getMatched(7), currentPackage->getMatched(6));
02361 newPointH->setEnergyLossCorrected(Adc[7], Adc[6],CalibArray);
02362 mPoint->addNewPoint(newPointH);
02363
02364
02365 Double_t setA[2], setB[2], setC[2], setD[2], setE[2], setF[2], setG[2], setH[2];
02366 Double_t probADH, probAEG, probBCH, probBEF;
02367
02368 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
02369 setA[1] = matchDistr(clusterControl, setA[0]);
02370 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
02371 setB[1] = matchDistr(clusterControl, setB[0]);
02372 setC[0] = (Adc[3] - Adc[1])/sqrt(2.0);
02373 setC[1] = matchDistr(clusterControl, setC[0]);
02374 setD[0] = (Adc[3] - Adc[2])/sqrt(2.0);
02375 setD[1] = matchDistr(clusterControl, setD[0]);
02376 setE[0] = (Adc[3] - Adc[6])/sqrt(2.0);
02377 setE[1] = matchDistr(clusterControl, setE[0]);
02378 setF[0] = (Adc[7] - Adc[1])/sqrt(2.0);
02379 setF[1] = matchDistr(clusterControl, setF[0]);
02380 setG[0] = (Adc[7] - Adc[2])/sqrt(2.0);
02381 setG[1] = matchDistr(clusterControl, setG[0]);
02382 setH[0] = (Adc[7] - Adc[6])/sqrt(2.0);
02383 setH[1] = matchDistr(clusterControl, setH[0]);
02384 Double_t tmp = 3e-33+(setA[1]*setD[1]*setH[1]+setA[1]*setE[1]*setG[1]+setB[1]*setC[1]*setH[1]+setB[1]*setE[1]*setF[1]);
02385 probADH = (setA[1]*setD[1]*setH[1])/tmp;
02386 probAEG = (setA[1]*setE[1]*setG[1])/tmp;
02387 probBCH = (setB[1]*setC[1]*setH[1])/tmp;
02388 probBEF = (setB[1]*setE[1]*setF[1])/tmp;
02389 newPointA->setFlag(int(100*(probADH+probAEG)));
02390 newPointB->setFlag(int(100*(probBCH+probBEF)));
02391 newPointC->setFlag(int(100*probBCH));
02392 newPointD->setFlag(int(100*probADH));
02393 newPointE->setFlag(int(100*(probAEG+probBEF)));
02394 newPointF->setFlag(int(100*probBEF));
02395 newPointG->setFlag(int(100*probAEG));
02396 newPointH->setFlag(int(100*(probADH+probBCH)));
02397
02398 nSolved++;
02399 }
02400
02401 else if(!strcmp(currentKind,"1p1n2n3n2p1n2n3n3p1n2n3n"))
02402 {
02403 StSsdPoint *newPointA = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02404 setMatcheds(dimensions, newPointA, currentPackage->getMatched(0), currentPackage->getMatched(1));
02405 newPointA->setEnergyLossCorrected(Adc[0], Adc[1],CalibArray);
02406 mPoint->addNewPoint(newPointA);
02407
02408 StSsdPoint *newPointB = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02409 setMatcheds(dimensions, newPointB, currentPackage->getMatched(0), currentPackage->getMatched(2));
02410 newPointB->setEnergyLossCorrected(Adc[0], Adc[2],CalibArray);
02411 mPoint->addNewPoint(newPointB);
02412
02413 StSsdPoint *newPointC = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02414 setMatcheds(dimensions, newPointC, currentPackage->getMatched(0), currentPackage->getMatched(3));
02415 newPointC->setEnergyLossCorrected(Adc[0], Adc[3],CalibArray);
02416 mPoint->addNewPoint(newPointC);
02417
02418 StSsdPoint *newPointD = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02419 setMatcheds(dimensions, newPointD, currentPackage->getMatched(4), currentPackage->getMatched(1));
02420 newPointD->setEnergyLossCorrected(Adc[4], Adc[1],CalibArray);
02421 mPoint->addNewPoint(newPointD);
02422
02423 StSsdPoint *newPointE = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02424 setMatcheds(dimensions, newPointE, currentPackage->getMatched(4), currentPackage->getMatched(2));
02425 newPointE->setEnergyLossCorrected(Adc[4], Adc[2],CalibArray);
02426 mPoint->addNewPoint(newPointE);
02427
02428 StSsdPoint *newPointF = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02429 setMatcheds(dimensions, newPointF, currentPackage->getMatched(4), currentPackage->getMatched(3));
02430 newPointF->setEnergyLossCorrected(Adc[4], Adc[3],CalibArray);
02431 mPoint->addNewPoint(newPointF);
02432
02433 StSsdPoint *newPointG = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02434 setMatcheds(dimensions, newPointG, currentPackage->getMatched(8), currentPackage->getMatched(1));
02435 newPointG->setEnergyLossCorrected(Adc[8], Adc[1],CalibArray);
02436 mPoint->addNewPoint(newPointG);
02437
02438 StSsdPoint *newPointH = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02439 setMatcheds(dimensions, newPointH, currentPackage->getMatched(8), currentPackage->getMatched(2));
02440 newPointH->setEnergyLossCorrected(Adc[8], Adc[2],CalibArray);
02441 mPoint->addNewPoint(newPointH);
02442
02443 StSsdPoint *newPointI = new StSsdPoint(mPoint->getSize(), mId, currentPackage->getNPackage(), 33);
02444 setMatcheds(dimensions, newPointI, currentPackage->getMatched(8), currentPackage->getMatched(3));
02445 newPointI->setEnergyLossCorrected(Adc[8], Adc[3],CalibArray);
02446 mPoint->addNewPoint(newPointI);
02447
02448
02449 Double_t setA[2], setB[2], setC[2], setD[2], setE[2], setF[2], setG[2], setH[2], setI[2];
02450 Double_t probAEI, probCEG, probAFH, probBDI, probCDH, probBFG;
02451
02452 setA[0] = (Adc[0] - Adc[1])/sqrt(2.0);
02453 setA[1] = matchDistr(clusterControl, setA[0]);
02454 setB[0] = (Adc[0] - Adc[2])/sqrt(2.0);
02455 setB[1] = matchDistr(clusterControl, setB[0]);
02456 setC[0] = (Adc[0] - Adc[3])/sqrt(2.0);
02457 setC[1] = matchDistr(clusterControl, setC[0]);
02458 setD[0] = (Adc[4] - Adc[1])/sqrt(2.0);
02459 setD[1] = matchDistr(clusterControl, setD[0]);
02460 setE[0] = (Adc[4] - Adc[2])/sqrt(2.0);
02461 setE[1] = matchDistr(clusterControl, setE[0]);
02462 setF[0] = (Adc[4] - Adc[3])/sqrt(2.0);
02463 setF[1] = matchDistr(clusterControl, setF[0]);
02464 setG[0] = (Adc[8] - Adc[1])/sqrt(2.0);
02465 setG[1] = matchDistr(clusterControl, setG[0]);
02466 setH[0] = (Adc[8] - Adc[2])/sqrt(2.0);
02467 setH[1] = matchDistr(clusterControl, setH[0]);
02468 setI[0] = (Adc[8] - Adc[3])/sqrt(2.0);
02469 setI[1] = matchDistr(clusterControl, setI[0]);
02470 Double_t tmp = (3e-33+setA[1]*setE[1]*setI[1]+setC[1]*setE[1]*setG[1]+setA[1]*setF[1]*setH[1]+setB[1]*setD[1]*setI[1]+setC[1]*setD[1]*setH[1]+setB[1]*setF[1]*setG[1]);
02471 probAEI = (setA[1]*setE[1]*setI[1])/(tmp);
02472 probCEG = (setC[1]*setE[1]*setG[1])/(tmp);
02473 probAFH = (setA[1]*setF[1]*setH[1])/(tmp);
02474 probBDI = (setB[1]*setD[1]*setI[1])/(tmp);
02475 probCDH = (setC[1]*setD[1]*setH[1])/(tmp);
02476 probBFG = (setB[1]*setF[1]*setG[1])/(tmp);
02477 newPointA->setFlag(int(100*(probAEI+probAFH)));
02478 newPointB->setFlag(int(100*(probBDI+probBFG)));
02479 newPointC->setFlag(int(100*(probCEG+probCDH)));
02480 newPointD->setFlag(int(100*(probBDI+probCDH)));
02481 newPointE->setFlag(int(100*(probAEI+probCEG)));
02482 newPointF->setFlag(int(100*(probAFH+probBFG)));
02483 newPointG->setFlag(int(100*(probCEG+probBFG)));
02484 newPointH->setFlag(int(100*(probAFH+probCDH)));
02485 newPointI->setFlag(int(100*(probAEI+probBDI)));
02486
02487 nSolved++;
02488 }
02489 else cout<<" Warning unsolved case ("<<currentKind<<")\n";
02490 delete [] Adc;
02491 currentPackage=mPackage->next(currentPackage);
02492 }
02493 return nSolved;
02494 }
02495
02496 Int_t StSsdWafer::convertDigitToAnalog(Double_t pairCreationEnergy)
02497 {
02498 StSsdPoint *currentPoint = mPoint->first();
02499 while(currentPoint)
02500 {
02501 currentPoint->setDe(currentPoint->getDe(0)*pairCreationEnergy,0);
02502 currentPoint->setDe(currentPoint->getDe(1)*pairCreationEnergy,1);
02503 currentPoint = mPoint->next(currentPoint);
02504 }
02505 return 1;
02506 }
02507
02508 Int_t StSsdWafer::convertUFrameToLocal(ssdDimensions_st *dimensions)
02509 {
02510 StSsdPoint *currentPoint = mPoint->first();
02511 while(currentPoint)
02512 {
02513
02514 currentPoint->setXl(currentPoint->getPositionU(0)/2.+currentPoint->getPositionU(1)/2.-dimensions[0].waferHalfActLength+dimensions[0].waferHalfActWidth*tan(dimensions[0].stereoAngle),0);
02515 currentPoint->setXl((currentPoint->getPositionU(1)-currentPoint->getPositionU(0))/(2*tan(dimensions[0].stereoAngle)),1);
02516 currentPoint = mPoint->next(currentPoint);
02517 }
02518 return 1;
02519 }
02520
02521 Int_t StSsdWafer::convertLocalToGlobal() {
02522 StSsdPoint *currentPoint = mPoint->first();
02523 Double_t xg[3];
02524 while(currentPoint) {
02525
02526 Double_t xl[3] = {-currentPoint->getXl(0), currentPoint->getXl(1), currentPoint->getXl(2)};
02527 LocalToMaster(xl,xg);
02528 currentPoint->setXg(xg[0],0);
02529 currentPoint->setXg(xg[1],1);
02530 currentPoint->setXg(xg[2],2);
02531 currentPoint = mPoint->next(currentPoint);
02532 }
02533 return 1;
02534 }
02535
02536 Int_t StSsdWafer::convertGlobalToLocal() {
02537 Int_t localSize = (this->mPoint)->getSize();
02538 if (!localSize) return 0;
02539 StSsdPoint *temp = mPoint->first();
02540 for (Int_t i = 0; i < localSize; i++) {
02541 Double_t xg[3] = {temp->getXg(0), temp->getXg(1), temp->getXg(2)};
02542 Double_t xl[3];
02543 MasterToLocal(xg,xl);
02544 temp->setXl(-xl[0], 0);
02545 temp->setXl( xl[1], 1);
02546 temp->setXl( xl[2], 2);
02547 temp = mPoint->next(temp);
02548 }
02549 return 1;
02550 }
02551
02552 Int_t StSsdWafer::convertLocalToUFrame(Float_t ActiveLargeEdge, Float_t ActiveSmallEdge, Float_t Theta)
02553 {
02554 Int_t localSize = (mPoint)->getSize();
02555 if (!localSize) return 0;
02556
02557 StSsdPoint *temp = (mPoint)->first();
02558 for (Int_t i = 0; i < localSize; i++)
02559
02560 {
02561 temp->setUpos((temp->getXl(0)+(ActiveLargeEdge/2.))-(temp->getXl(1)+(ActiveSmallEdge/2.))*tan(Theta), 0);
02562 temp->setUpos((temp->getXl(0)+(ActiveLargeEdge/2.))+(temp->getXl(1)-(ActiveSmallEdge/2.))*tan(Theta), 1);
02563 temp = mPoint->next(temp);
02564 }
02565
02566 return localSize;
02567 }
02568
02569 StSsdPointList* StSsdWafer::getDeadHits(Float_t ActiveLargeEdge, Float_t ActiveSmallEdge,Float_t Test)
02570 {
02571 StSsdPointList *listDeadBorder = getNonActivePointBorder(ActiveLargeEdge,ActiveSmallEdge);
02572 StSsdPointList *listDeadTriangle = getNonActivePointTriangle(Test);
02573 StSsdPointList *listDeadTotal = new StSsdPointList();
02574 listDeadTotal = listDeadTotal->addPointList(listDeadBorder);
02575 listDeadTotal = listDeadTotal->addPointList(listDeadTriangle);
02576 listDeadTotal = listDeadTotal->removeMultipleCount();
02577 (mPoint)->substractPointList(listDeadTotal);
02578 delete listDeadBorder;
02579 delete listDeadTriangle;
02580 return listDeadTotal;
02581 }
02582
02583 void StSsdWafer::convertToStrip(Float_t Pitch,
02584 Int_t nStripPerSide,
02585 Double_t pairCreationEnergy,
02586 Int_t nstripInACluster,
02587 Double_t parDiffP,
02588 Double_t parDiffN,
02589 Double_t parIndRightP,
02590 Double_t parIndRightN,
02591 Double_t parIndLeftP,
02592 Double_t parIndLeftN,
02593 Float_t mShift_hole,
02594 Float_t mShift_elec)
02595 {
02596 convertHitToStrip(Pitch,
02597 nStripPerSide,
02598 nstripInACluster,
02599 parDiffP,
02600 parDiffN,
02601 parIndRightP,
02602 parIndRightN,
02603 parIndLeftP,
02604 parIndLeftN,
02605 mShift_hole,
02606 mShift_elec);
02607 convertAnalogToDigit(pairCreationEnergy);
02608 mStripP->sortStrip();
02609 mStripN->sortStrip();
02610 }
02611
02612 Int_t StSsdWafer::printborder()
02613 {
02614 if (mId==7101){
02615 printf("Wafer = %d \n",mId);
02616 Double_t actives[4][3],templs[4][3];
02617 Double_t activee[4][3],temple[4][3];
02618
02619 actives[0][0]=-3.65,actives[1][0]= 3.65,actives[2][0]= 3.65,actives[3][0]=-3.65;
02620 actives[0][1]= 2.00,actives[1][1]= 2.00,actives[2][1]=-2.00,actives[3][1]=-2.00;
02621 actives[0][2]= 0.00,actives[1][2]= 0.00,actives[2][2]= 0.00,actives[3][2]= 0.00;
02622
02623 activee[0][0]= 3.65,activee[1][0]= 3.65,activee[2][0]=-3.65,activee[3][0]=-3.65;
02624 activee[0][1]= 2.00,activee[1][1]=-2.00,activee[2][1]=-2.00,activee[3][1]= 2.00;
02625 activee[0][2]= 0.00,activee[1][2]= 0.00,activee[2][2]= 0.00,activee[3][2]= 0.00;
02626 for (Int_t j = 0; j < 4; j++) {
02627 LocalToMaster(actives[j], templs[j]);
02628 LocalToMaster(activee[j], temple[j]);
02629 }
02630 const Char_t *xyz[3] = {"x","y","z"};
02631 for (Int_t i = 0; i < 3; i++) {
02632 printf("%ssSsdLadder%d set {",xyz[i],mId-7100);
02633 for (Int_t j = 0; j < 4; j++) printf("%.2f ",templs[j][i]);
02634 printf("}\n");
02635 printf("%seSsdLadder%d set {",xyz[i],mId-7100);
02636 for (Int_t j = 0; j < 4; j++) printf("%.2f ",temple[j][i]);
02637 printf("}\n");
02638 }
02639 }
02640 return 1;
02641 }
02642
02643 StSsdWafer::StSsdWafer(const StSsdWafer & originalWafer)
02644 {
02645 memcpy (first, originalWafer.first, last-first);
02646 mStripP = new StSsdStripList();
02647 mStripN = new StSsdStripList();
02648 mNoiseP = new StSpaListNoise();
02649 mNoiseN = new StSpaListNoise();
02650 mClusterP = new StSsdClusterList();
02651 mClusterN = new StSsdClusterList();
02652 mPackage = new StSsdPackageList();
02653 mPoint = new StSsdPointList();
02654 }
02655
02656 StSsdWafer& StSsdWafer::operator=(const StSsdWafer originalWafer) {
02657 memset(first, 0, last-first);
02658 mId = originalWafer.mId;
02659 SetName(originalWafer.GetName());
02660 SetRotation(originalWafer.GetRotationMatrix());
02661 SetTranslation(originalWafer.GetTranslation());
02662 return *this;
02663 }
02664
02668 Int_t StSsdWafer::geoMatched(ssdDimensions_st *dimensions, StSsdCluster *ptr1, StSsdCluster *ptr2)
02669 {
02670 Int_t geomatched = 0;
02671 Int_t numStrip = int((2*dimensions[0].waferHalfActWidth*tan(dimensions[0].stereoAngle)/dimensions[0].stripPitch)+1);
02672 if ( (!ptr1) || (!ptr2) )
02673 geomatched = 0;
02674 else if((ptr2->getStripMean() > ( ptr1->getStripMean() - numStrip))
02675 && (ptr2->getStripMean() < (ptr1->getStripMean() + numStrip)))
02676 geomatched = 1;
02677 return geomatched;
02678 }
02679
02683 Int_t StSsdWafer::setMatcheds(ssdDimensions_st *dimensions, StSsdPoint *Point, StSsdCluster *pMatched, StSsdCluster *nMatched)
02684 {
02685 Point->setPositionU((pMatched->getStripMean()-1)*dimensions[0].stripPitch,0);
02686 Point->setPositionU((nMatched->getStripMean()-1)*dimensions[0].stripPitch,1);
02687 Point->setIdClusterP(pMatched->getNCluster());
02688 Point->setIdClusterN(nMatched->getNCluster());
02689
02690
02691 Int_t pHitIndex = 0;
02692 Int_t nHitIndex = 0;
02693 Int_t sptHitIndex = 0;
02694 for (pHitIndex = 0; pHitIndex < SSD_MAXIDMCHIT; pHitIndex++)
02695 {
02696 for (nHitIndex = 0; nHitIndex < SSD_MAXIDMCHIT; nHitIndex++)
02697 {
02698 if ((pMatched->getIdMcHit(pHitIndex))
02699 &&(nMatched->getIdMcHit(nHitIndex))
02700 &&(pMatched->getIdMcHit(pHitIndex) == nMatched->getIdMcHit(nHitIndex))
02701 &&(sptHitIndex < SSD_MAXIDMCHIT))
02702 Point->setNMchit(pMatched->getIdMcHit(pHitIndex),sptHitIndex++);
02703 }
02704 }
02705 return 1;
02706 }
02707
02708 Double_t StSsdWafer::matchDistr(StSsdClusterControl *clusterControl, Double_t x)
02709 {
02710 Double_t mean = clusterControl->getMatchMean();
02711 Double_t sigm = clusterControl->getMatchSigma();
02712 return TMath::Gaus(x, mean, sigm, 1);
02713 }
02714
02715 void StSsdWafer::addHit(Int_t rNId , Int_t rMcHit, Int_t rMcTrack, Float_t *rXg , Float_t rDe, Float_t *p)
02716 {
02717 Float_t *alpha = new float[2];
02718 alpha[0] = 0.;
02719 alpha[1] = 0.;
02720 StSsdPoint *tmpPoint = new StSsdPoint(rNId, rMcHit, rMcTrack, rXg, rDe, findAngle(p,alpha));
02721 (mPoint)->addNewPoint(tmpPoint);
02722 delete [] alpha;
02723 }
02724
02725 StSsdPointList* StSsdWafer::getNonActivePointBorder(Float_t ActiveLargeEdge, Float_t ActiveSmallEdge)
02726 {
02727 Int_t localSize = (mPoint)->getSize();
02728
02729 StSsdPointList *deadPoints = new StSsdPointList();
02730 if (!localSize) return deadPoints;
02731
02732 StSsdPoint *temp = (mPoint)->first();
02733 for (Int_t i = 0; i < localSize; i++)
02734 {
02735 if((temp->getXl(0) >(ActiveLargeEdge/2.)) || (temp->getXl(0) < (-ActiveLargeEdge/2.)) ||
02736 (temp->getXl(1) >(ActiveSmallEdge/2.)) || (temp->getXl(1) < (-ActiveSmallEdge/2.)))
02737 {
02738
02739 StSsdPoint *badPoint = temp->giveCopy();
02740 deadPoints->addNewPoint(badPoint);
02741 }
02742 temp = (mPoint)->next(temp);
02743 }
02744 return deadPoints;
02745 }
02746
02747 StSsdPointList* StSsdWafer::getNonActivePointTriangle(Float_t Test)
02748
02749 {
02750 Int_t localSize = (mPoint)->getSize();
02751 StSsdPointList *deadPoints = new StSsdPointList();
02752
02753 if (!localSize) return deadPoints;
02754
02755 StSsdPoint *temp = (mPoint)->first();
02756 for (Int_t i = 0; i < localSize; i++)
02757 {
02758 if (temp->getPositionU(0) < -1.*Test && temp->getPositionU(1) < -1.*Test)
02759 {
02760
02761 StSsdPoint *badPoint = temp->giveCopy();
02762 deadPoints->addNewPoint(badPoint);
02763 }
02764 temp = (mPoint)->next(temp);
02765 }
02766 return deadPoints;
02767 }
02768
02769
02770 Double_t StSsdWafer::myErf(Double_t x)
02771 {
02772 const Double_t a1 = -1.26551223, a2 = 1.00002368,
02773 a3 = 0.37409196, a4 = 0.09678418,
02774 a5 = -0.18628806, a6 = 0.27886807,
02775 a7 = -1.13520398, a8 = 1.48851587,
02776 a9 = -0.82215223, a10 = 0.17087277;
02777
02778 Double_t v = 1.;
02779 Double_t z = ((x) < 0. ? -(x) : (x));
02780
02781 if (z <= 0) return (1.-v);
02782 Double_t t = 1./(1.+0.5*z);
02783 v = t*exp((-z*z) +a1+t*(a2+t*(a3+t*(a4+t*(a5+t*(a6+t*(a7+t*(a8+t*(a9+t*a10)))))))));
02784
02785 if (x < 0) v = 2.-v;
02786 return (1.-v);
02787 }
02788
02789 void StSsdWafer::convertHitToStrip(Float_t Pitch,
02790 Int_t nStripPerSide,
02791 Int_t nstripInACluster,
02792 Double_t parDiffP,
02793 Double_t parDiffN,
02794 Double_t parIndRightP,
02795 Double_t parIndRightN,
02796 Double_t parIndLeftP,
02797 Double_t parIndLeftN,
02798 Float_t mShift_hole,
02799 Float_t mShift_elec)
02800 {
02801 const Double_t parDiff[2]={parDiffP/Pitch,parDiffN/Pitch};
02802 const Double_t parIndRight[2]={parIndRightP,parIndRightN};
02803 const Double_t parIndLeft[2]={parIndLeftP,parIndLeftN};
02804
02805 Int_t *tabInd = new Int_t[nstripInACluster];
02806 Float_t *tabDe = new Float_t[nstripInACluster];
02807
02808 StSsdPoint *ptr = (mPoint)->first();
02809 Int_t localSize = (mPoint)->getSize();
02810 for (Int_t iPoint = 0; iPoint < localSize; iPoint++)
02811 {
02812 for (Int_t iSide = 0; iSide < 2; iSide++)
02813 {
02814 for (Int_t v = 0 ; v < nstripInACluster; v++)
02815 {
02816 tabInd[v] = 0 ;
02817 tabDe[v] = 0.;
02818 }
02819 if (Debug()) LOG_DEBUG<<Form("Before Lorentz Shift")<<endm;
02820 if (Debug()) LOG_DEBUG<<Form("position of the hit : strip P=%f stripN=%f Pitch=%f",ptr->getPositionU(0),ptr->getPositionU(1),Pitch)<<endm;
02821 UndoLorentzShift(ptr,iSide,mShift_hole,mShift_elec,Pitch);
02822 if (Debug()) LOG_DEBUG<<Form("After Lorentz Shift\n");
02823 if (Debug()) LOG_DEBUG<<Form("position of the hit : strip P=%f stripN=%f Pitch=%f",ptr->getPositionU(0),ptr->getPositionU(1),Pitch)<<endm;
02824 tabInd[0] = (int)(ptr->getPositionU(iSide)/Pitch + 1.);
02825 tabInd[1] = tabInd[0]+1;
02826 tabInd[2] = tabInd[0]-1;
02827 tabInd[3] = tabInd[0]+2;
02828 if (Debug()) LOG_DEBUG<<Form("Mean strip=%d strip1=%d strip2=%d strip3=%d",tabInd[0],tabInd[1],tabInd[2],tabInd[3])<<endm;
02829 Double_t rest = (double)(ptr->getPositionU(iSide)/Pitch) - (double)(tabInd[0]-1);
02830 Double_t Result=0.5*(1.+myErf((rest-0.5)/sqrt(2.)/parDiff[iSide]) );
02831 Float_t TmpDe0 = 0.;
02832 Float_t TmpDe1 = 0.;
02833 tabDe[0] = (1.-Result)*ptr->getDe();
02834 tabDe[1] = Result*ptr->getDe();
02835 tabDe[2] = tabDe[0]*parIndLeft[iSide];
02836 tabDe[3] = tabDe[1]*parIndRight[iSide];
02837 TmpDe0 = tabDe[1]*parIndLeft[iSide];
02838 TmpDe1 = tabDe[0]*parIndRight[iSide];
02839 tabDe[0] += TmpDe0;
02840 tabDe[1] += TmpDe1;
02841 for (Int_t st = 0; st < nstripInACluster; st++)
02842 {
02843 if ( tabInd[st] > 0 && tabInd[st] < nStripPerSide+1 )
02844 {
02845 if (Debug())printf("st =%d id =%d tabDe(%d)=%f charge=%f NId=%d McHit=%d MvTrack=%d\n",st,tabInd[st],st,tabDe[st],ptr->getDe(),ptr->getNId(),ptr->getMcHit(),ptr->getMcTrack());
02846 StSsdStrip *newStrip = new StSsdStrip(tabInd[st], ptr->getNId(), ptr->getMcHit(), ptr->getMcTrack(), tabDe[st]);
02847 switch (iSide)
02848 {
02849 case 0:
02850 mStripP->updateStrip(newStrip);
02851 break;
02852 case 1:
02853 mStripN->updateStrip(newStrip);
02854 break;
02855 }
02856 }
02857 }
02858 }
02859 ptr = (mPoint)->next(ptr);
02860 }
02861 delete [] tabInd;
02862 delete [] tabDe;
02863 }
02864
02865 void StSsdWafer::convertAnalogToDigit(Double_t pairCreationEnergy)
02866 {
02867 const Double_t ConversionFactor = 1./pairCreationEnergy;
02868
02869 Int_t localSize = mStripP->getSize();
02870 StSsdStrip *curr = mStripP->first();
02871 Int_t i = 0;
02872 for (i = 0; i < localSize; i++)
02873 {
02874 curr->setDigitSig((int)(curr->getAnalogSig()*ConversionFactor));
02875 curr = mStripP->next(curr);
02876 }
02877 localSize = mStripN->getSize();
02878 curr = mStripN->first();
02879 for (i = 0; i < localSize; i++)
02880 {
02881 curr->setDigitSig((int)(curr->getAnalogSig()*ConversionFactor));
02882 curr = mStripN->next(curr);
02883 }
02884 }
02885
02886 float* StSsdWafer::findAngle(Float_t *p, Float_t *alpha)
02887 {
02888 Int_t i = 0;
02889 Float_t pT[3],pN[3],pD[3];
02890
02891 Float_t spT = 0.;
02892 Float_t spN = 0.;
02893 Float_t spD = 0.;
02894
02895 Float_t npT = 0.;
02896 Float_t npN = 0.;
02897 Float_t npD = 0.;
02898
02899 for (i = 0; i < 3; i++)
02900 {
02901 spN += n(i)*p[i] ;
02902 spT += t(i)*p[i] ;
02903 spD += d(i)*p[i] ;
02904 }
02905 for (i = 0; i < 3; i++)
02906 {
02907 pN[i] = n(i)*spN ;
02908 pT[i] = t(i)*spT ;
02909 pD[i] = d(i)*spD ;
02910 }
02911
02912 npT = sqrt(pT[0]*pT[0]+pT[1]*pT[1]+pT[2]*pT[2]);
02913 npD = sqrt(pD[0]*pD[0]+pD[1]*pD[1]+pD[2]*pD[2]);
02914 npN = sqrt(pN[0]*pN[0]+pN[1]*pN[1]+pN[2]*pN[2]);
02915
02916
02917 Float_t npDN = sqrt((pN[0]+pD[0])*(pN[0]+pD[0])+(pN[1]+pD[1])*(pN[1]+pD[1])+(pN[2]+pD[2])*(pN[2]+pD[2]));
02918 Float_t npTD = sqrt((pT[0]+pD[0])*(pT[0]+pD[0])+(pT[1]+pD[1])*(pT[1]+pD[1])+(pT[2]+pD[2])*(pT[2]+pD[2]));
02919
02920 alpha[0] = acos(npN/npDN);
02921 Float_t sSign = 0.;
02922 sSign = pD[0]*pN[0]+pD[1]*pN[1]+pD[2]*pN[2]+npN*npN;
02923 if (sSign<0.) alpha[0] = -1.*alpha[0];
02924
02925 alpha[1] = acos(npD/npTD);
02926 sSign = pD[0]*pT[0]+pD[1]*pT[1]+pD[2]*pT[2]+npD*npD;
02927 if (sSign<0.) alpha[1] = -1.*alpha[1];
02928
02929 return alpha;
02930 }
02931
02932 void StSsdWafer::addNoiseToStripSignal(StSpaNoise *ptr, Int_t iSide)
02933 {
02934 if (iSide)
02935 { mNoiseN->addNewNoise(ptr); }
02936 else
02937 { mNoiseP->addNewNoise(ptr); }
02938 }
02939
02940 void StSsdWafer::setIsActive(Int_t rIsActive, Int_t iSide, Int_t rNStrip)
02941 {
02942 if (iSide)
02943 { mNoiseN->setIsActive(rIsActive, rNStrip); }
02944 else
02945 { mNoiseP->setIsActive(rIsActive, rNStrip); }
02946 }
02947
02948 void StSsdWafer::sortNoise()
02949 {
02950 mNoiseP->sortStrip();
02951 mNoiseN->sortStrip();
02952 }
02953
02954 void StSsdWafer::addNoiseToStripSignal(long nElectronInAMip,long adcDynamic)
02955 {
02956 mNoiseP->addSignal(mStripP, nElectronInAMip, adcDynamic);
02957 mNoiseN->addSignal(mStripN, nElectronInAMip, adcDynamic);
02958 }
02959
02960 void StSsdWafer::pedestalSubstraction()
02961 {
02962 mNoiseP->substractPedestal();
02963 mNoiseN->substractPedestal();
02964 }
02965
02966 void StSsdWafer::zeroSubstraction()
02967 {
02968 mNoiseP->zeroSubstraction();
02969 mNoiseN->zeroSubstraction();
02970 }
02971
02972 void StSsdWafer::convertAnalogToDigit(Long_t nElectronInAMip,Long_t adcDynamic,
02973 Long_t nbitEncoding, Float_t daqCutValue)
02974 {
02975 mNoiseP->convertAnalogToDigit(nElectronInAMip, adcDynamic,
02976 nbitEncoding,daqCutValue);
02977 mNoiseN->convertAnalogToDigit(nElectronInAMip, adcDynamic,
02978 nbitEncoding,daqCutValue);
02979 }
02980
02981 void StSsdWafer::updateStripList()
02982 {
02983 mStripP->updateStripList(mNoiseP);
02984 mStripN->updateStripList(mNoiseN);
02985 }
02986
02987 void StSsdWafer::UndoLorentzShift(StSsdPoint *ptr,Int_t iSide,Float_t mShift_hole,Float_t mShift_elec,Float_t pitch)
02988 {
02989 Float_t tempPosition = ptr->getPositionU(iSide);
02990 if(iSide==0){
02991 ptr->setPositionU(tempPosition+mShift_hole,iSide);
02992 }
02993 else
02994 if(iSide==1){
02995 ptr->setPositionU(tempPosition+mShift_elec,iSide);
02996 }
02997 }
02998
