[u/mrichter/AliRoot.git] / HLT / MUON / OnlineAnalysis / AliHLTMUONTriggerReconstructor.cxx

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Authors:                                                       *
 *   Indranil Das <indra.das@saha.ac.in>                                  *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          * 
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

/**********************************************************************
 Created on : 16/05/2007
 Purpose    : This class is supposed to read the tracker DDL files and 
              give the output AliMUONCoreTriggerRecord
 Author     : Indranil Das, HEP Division, SINP
 Email      : indra.das@saha.ac.in | indra.ehep@gmail.com
**********************************************************************/

///*
//
//  The trigger reconstructor class is designed to deal the rawdata inputfiles
//  to findout the the reconstructed hits at the trigger DDL. The output is send
//  to the output block for further processing.
//
//  Author : Indranil Das ( indra.das@saha.ac.in || indra.ehep@gmail.com )
// 
//*/

#include "AliHLTMUONTriggerReconstructor.h"

const int AliHLTMUONTriggerReconstructor::fgkDetectorId = 0xB00;
const int AliHLTMUONTriggerReconstructor::fgkDDLOffSet = 20 ;
const int AliHLTMUONTriggerReconstructor::fgkNofDDL = 2 ;

const int AliHLTMUONTriggerReconstructor::fgkDDLHeaderSize = 8;
const int AliHLTMUONTriggerReconstructor::fgkEvenLutSize = 2602351 + 1; 
const int AliHLTMUONTriggerReconstructor::fgkOddLutSize = 2528735 + 1;

const int AliHLTMUONTriggerReconstructor::fgkLutLine = 10496;

const int AliHLTMUONTriggerReconstructor::fgkMinIdManuChannel[2] = {819616, 862288};
const int AliHLTMUONTriggerReconstructor::fgkMaxIdManuChannel[2] = {3421966, 3391022};

const float AliHLTMUONTriggerReconstructor::fgkHalfPadSizeXB[3] = {8.5, 17.0, 25.5};
const float AliHLTMUONTriggerReconstructor::fgkHalfPadSizeYNB[2] = {25.5, 34.0};

const int AliHLTMUONTriggerReconstructor::fgkDetElem = 9*4 ; // 9 detele per half chamber


AliHLTMUONTriggerReconstructor::AliHLTMUONTriggerReconstructor()
  :
  fPadData(NULL),
  fLookUpTableData(NULL),
  fRecPoints(NULL),
  fRecPointsCount(NULL),
  fMaxRecPointsCount(0),
  fMaxFiredPerDetElem(),
  fDetElemToDataId(),
  fDDLId(0),
  fIdOffSet(0)
{
  // ctor 
  
  if(AliHLTMUONTriggerReconstructor::fgkEvenLutSize > AliHLTMUONTriggerReconstructor::fgkOddLutSize){
    fPadData = new AliHLTMUONHitReconstructor::DHLTPad[AliHLTMUONTriggerReconstructor::fgkEvenLutSize];
  }
  else{
    fPadData = new AliHLTMUONHitReconstructor::DHLTPad[AliHLTMUONTriggerReconstructor::fgkOddLutSize];
  }

  bzero(fGetIdTotalData,104*64*2*sizeof(int));
}


AliHLTMUONTriggerReconstructor::~AliHLTMUONTriggerReconstructor()
{
  // dtor
  delete []fPadData;
  delete []fLookUpTableData;
}

bool AliHLTMUONTriggerReconstructor::SetRegToLocCardMap(RegToLoc* regToLoc)
{
  if(!memcpy(fRegToLocCard,regToLoc,128*sizeof(RegToLoc)))
    return false;

  for(int i=0;i<128;i++){
    HLTDebug("DDL : %d, reg : %d, loc : %d",fRegToLocCard[i].fTrigDDL,
	    fRegToLocCard[i].fRegId,fRegToLocCard[i].fLocId);
  }

  return true;
}

bool AliHLTMUONTriggerReconstructor::LoadLookUpTable(AliHLTMUONHitReconstructor::DHLTLut* lookUpTableData, int lookUpTableId)
{
  if(lookUpTableId<fgkDDLOffSet || lookUpTableId>= fgkDDLOffSet + fgkNofDDL){
    HLTError("DDL number is out of range (must be %d<=iDDL<%d)",fgkDDLOffSet,fgkDDLOffSet+fgkNofDDL);
    return false;
  }
  
  fDDLId = lookUpTableId;

  int lutSize = ((lookUpTableId%2)==0) ? fgkEvenLutSize : fgkOddLutSize ;
  int nofLutLine = fgkLutLine ;
  fIdOffSet = fgkMinIdManuChannel[lookUpTableId%2];

  int detManuChannelId;

  fLookUpTableData = new AliHLTMUONHitReconstructor::DHLTLut[lutSize];

  memset(fLookUpTableData,-1,lutSize*sizeof(AliHLTMUONHitReconstructor::DHLTLut));

  for(int i=0; i<nofLutLine; i++){

    detManuChannelId = lookUpTableData[i].fIdManuChannel - fIdOffSet + 1;
    fLookUpTableData[detManuChannelId].fIdManuChannel = lookUpTableData[i].fIdManuChannel - fIdOffSet;
    fLookUpTableData[detManuChannelId].fIX = lookUpTableData[i].fIX ;
    fLookUpTableData[detManuChannelId].fIY = lookUpTableData[i].fIY ;
    fLookUpTableData[detManuChannelId].fRealX = lookUpTableData[i].fRealX ;
    fLookUpTableData[detManuChannelId].fRealY = lookUpTableData[i].fRealY ;
    fLookUpTableData[detManuChannelId].fRealZ = lookUpTableData[i].fRealZ ;
    fLookUpTableData[detManuChannelId].fPcbZone = lookUpTableData[i].fPcbZone ;
    fLookUpTableData[detManuChannelId].fPlane = lookUpTableData[i].fPlane ;
  }
  return true;

  return true;
}

bool AliHLTMUONTriggerReconstructor::Run(
		const AliHLTUInt32_t* rawData,
		AliHLTUInt32_t rawDataSize,
		AliHLTMUONTriggerRecordStruct* trigRecord,
		AliHLTUInt32_t& nofTrigRec
	)
{

  fRecPoints = trigRecord;
  fMaxRecPointsCount = nofTrigRec;
  fRecPointsCount = &nofTrigRec;
  *fRecPointsCount = 0;
  fMaxFiredPerDetElem.clear();
  fDetElemToDataId.clear();

  fPadData[0].fDetElemId = 0;
  fPadData[0].fBuspatchId = 0;
  fPadData[0].fIdManuChannel = 0;
  fPadData[0].fIX = 0 ;
  fPadData[0].fIY = 0 ;
  fPadData[0].fRealX = 0.0 ;
  fPadData[0].fRealY = 0.0 ;
  fPadData[0].fRealZ = 0.0 ;
  fPadData[0].fPlane = -1 ;
  fPadData[0].fPcbZone = -1 ;
  fPadData[0].fCharge = 0 ;
  
  if(!ReadDDL(rawData, rawDataSize)){
    HLTError("Failed to read the complete DDL file\n");
    return false;
  }

  if(!FindTrigHits()){
    HLTError("Failed to generate RecHits\n");
    return false;
  }
    
  return true;
}


bool AliHLTMUONTriggerReconstructor::ReadDDL(
		const AliHLTUInt32_t* rawData,
		AliHLTUInt32_t rawDataSize
	)
{

  int idManuChannel ;
  
  int index = 0;
  int dataCount = 0;
  int detElemId = 0 ;
  int reg_output,reg_phys_trig_occur ;
  int iLocIndex,loc,locDec,triggY,sign,loDev,triggX;
  int iRegLoc, locId ;
  short pattern[2][4]; // 2 stands for two cathode planes and 4 stands for 4 chambers

  Int_t offset,ithSwitch,secondLocation,idetElemId;

  int shiftIndex = 10 - 6 - 1; // the one comes due to indexing from zero

  DataIdIndex dataIndex;
#ifdef DEBUG
  int globalcard_data_occurance = (rawData[index]>>10)&0x1; //Set to 1 if global info present in DDL else set to 0 
  int version = (rawData[index]>>12)&0xFF; // software version
  int serial_number =  (rawData[index]>>20)&0xF; // serial number set to 0xF 
#endif
  int phys_trig_occur = (rawData[index]>>30)&0x1; // 1 for physics trigger, 0 for software trigger
  
  HLTDebug("globalcard_data_occurance  %d, version  %d, serial_number  %d, phys_trig_occur  %d",
	 globalcard_data_occurance,version,serial_number,phys_trig_occur);

  if(!phys_trig_occur) // for software trigger
    index += 8 ;// corresponding to scalar words
  
  index += 1 ; // To skip the separator 0xDEADFACE
  
  index += 4 ; // corresponding to global input
  
  index += 1 ; // reaches to global output
  
  if((fDDLId - AliHLTMUONTriggerReconstructor::fgkDDLOffSet) == 0){ //if globalData is present in DDL 0 (presummed may be changed)
#ifdef DEBUG
    int singleLpt = rawData[index] & 0x1;
    int singleHpt = (rawData[index] >> 1) & 0x1;
    
    int pairUnlikeLpt = (rawData[index] >> 4)  & 0x1;
    int pairUnlikeHpt = (rawData[index] >> 5)  & 0x1;
    
    int pairLikeLpt = (rawData[index] >> 2)  & 0x1;
    int pairLikeHpt = (rawData[index] >> 3)  & 0x1;
#endif
    HLTDebug("singleLpt : %x, singleHpt : %x, pairUnlikeLpt : %x, pairUnlikeHpt : %x, pairLikeLpt : %x, pairLikeHpt : %x",
	     singleLpt,singleHpt,pairUnlikeLpt,pairUnlikeHpt,pairLikeLpt,pairLikeHpt);
  }

  if(!phys_trig_occur)
    index += 10 ;// corresponds to scalar words

  index += 1; // separator 0xDEADBEEF 

  for (int iReg = 0; iReg < 8; iReg++) {
    index += 1; // DARC Status Word
    index += 1; // Regeional Word
    reg_output = rawData[index] & 0xFF;
    reg_phys_trig_occur = ( rawData[index] >> 31) & 0x1;
    
    index += 2; // 2 words for regional input
    
    index += 1; // L0 counter
    
    if(!reg_phys_trig_occur)
      index += 10;
    
    index += 1 ; // end of Regeonal header 0xBEEFFACE

    for(int iLoc = 0; iLoc < 16 ; iLoc++){

      iLocIndex = index ;      

      loc = (rawData[index+5] >> 19) &  0xF ;
      
      locDec = (rawData[index+5] >> 15) & 0xF;
      triggY = (rawData[index+5] >> 14) & 0x1 ;
      sign = (rawData[index+5] >> 9) & 0x1;
      loDev = (rawData[index+5] >> 5) & 0xF ;
      triggX = (loDev >> 4 & 0x1 ) && !(loDev & 0xF) ;

      if( locDec != 0x9 ){ // check for Dec
	
	iRegLoc = iReg*16 + iLoc;
	locId = fRegToLocCard[iRegLoc].fLocId ; 
	
	if(locId<=234){ // to avoid the copy locCards
	  
	  index += 1;
	  pattern[0][0] = rawData[index] & 0xFFFF; // x-strip pattern for chaber 0 
	  pattern[0][1] = (rawData[index] >> 16) & 0xFFFF; // x-strip pattern for chaber 1
 	  index += 1; 
	  pattern[0][2] = rawData[index] & 0xFFFF; 
	  pattern[0][3] = (rawData[index] >> 16) & 0xFFFF; 
	  
 	  index += 1;
	  pattern[1][0] = rawData[index] & 0xFFFF; // y-strip pattern for chaber 0
	  pattern[1][1] = (rawData[index] >> 16) & 0xFFFF; // y-strip pattern for chaber 0 
 	  index += 1; 
	  pattern[1][2] = rawData[index] & 0xFFFF; 
	  pattern[1][3] = (rawData[index] >> 16) & 0xFFFF; 
	  
	  if(pattern[0][0] || pattern[0][1] || pattern[0][2] || pattern[0][3]
	     || pattern[1][0] || pattern[1][1] || pattern[1][2] || pattern[1][3]
	     ){

	    HLTDebug("iReg: %d, iLoc :%d, locId : %d,X : %x, %x, %x, %x ...Y : %x, %x, %x, %x",
		    iReg,iLoc,locId,pattern[0][0],pattern[0][1],pattern[0][2],pattern[0][3],
		    pattern[1][0],pattern[1][1],pattern[1][2],pattern[1][3]);

	    for(int iChamber = 0; iChamber < 4 ; iChamber++){ //4 chambers per DDL 
	      for(int iPlane = 0; iPlane < 2 ; iPlane++){// 2 cathode plane
		if(pattern[iPlane][iChamber]){
		  detElemId = fRegToLocCard[iRegLoc].fDetElemId[iChamber];
		  HLTDebug("\tdetElemId : %d\n",detElemId);
		  for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy) {
		    if ((pattern[iPlane][iChamber] >> ibitxy) & 0x1) {
	  
		      // not quite sure about this
		      offset = 0;
		      ithSwitch = (fRegToLocCard[iRegLoc].fSwitch >> shiftIndex) & 0x1;
		      if (iPlane && ithSwitch) offset = -8;
		      
		      secondLocation = ibitxy + offset;
		      
		      idetElemId = detElemId%1000;

		      idetElemId &= 0x1FF ;
		      iPlane &= 0x1 ;
		      locId &= 0xFF ;
		      secondLocation &= 0xF ;
		      
		      idManuChannel &= 0x0;
		      idManuChannel = (idManuChannel|idetElemId)<<1;  
		      idManuChannel = (idManuChannel|iPlane)<<8;  
		      idManuChannel = (idManuChannel|locId)<<4 ;
		      idManuChannel |= secondLocation  ;

		      idManuChannel -= fIdOffSet ;
		      
		      if(fLookUpTableData[idManuChannel+1].fIdManuChannel == -1) //skip uninitialized values
			continue;

	   	      fPadData[idManuChannel].fDetElemId = detElemId;
	   	      fPadData[idManuChannel].fIdManuChannel = idManuChannel;
	   	      fPadData[idManuChannel].fIX = fLookUpTableData[idManuChannel+1].fIX;
	   	      fPadData[idManuChannel].fIY = fLookUpTableData[idManuChannel+1].fIY;
	   	      fPadData[idManuChannel].fRealX = fLookUpTableData[idManuChannel+1].fRealX;
	   	      fPadData[idManuChannel].fRealY = fLookUpTableData[idManuChannel+1].fRealY;
	   	      fPadData[idManuChannel].fRealZ = fLookUpTableData[idManuChannel+1].fRealZ;
	   	      fPadData[idManuChannel].fPcbZone = fLookUpTableData[idManuChannel+1].fPcbZone;
	   	      fPadData[idManuChannel].fPlane = fLookUpTableData[idManuChannel+1].fPlane;
		      HLTDebug("\t Hit Found fo ich : %d, iPlane : %d, detelem %d, id : %d, at (%lf, %lf, %lf) cm"
			      ,iChamber,fLookUpTableData[idManuChannel+1].fPlane,detElemId,fLookUpTableData[idManuChannel+1].fIdManuChannel,
			      fPadData[idManuChannel].fRealX,
			      fPadData[idManuChannel].fRealY,fPadData[idManuChannel].fRealZ);
			      
		      if(fMaxFiredPerDetElem[detElemId] == 0){
			DataIdIndex first;
			first.push_back(idManuChannel);
			fDetElemToDataId[detElemId] = first;
		      }else{
			dataIndex =  fDetElemToDataId[detElemId];
			dataIndex.push_back(idManuChannel);
			fDetElemToDataId[detElemId] = dataIndex;
		      }

		      fMaxFiredPerDetElem[detElemId] = fMaxFiredPerDetElem[detElemId] + 1;

	   	      dataCount ++;
		      
		    }//pattern maching is found 
		  }// loop of ibitxy
		}// if pattern
	      }// iplane
	    }// ichamber
	    
	  }// if any non zero pattern found


	  index += 1 ; // skipping the last word though it is important
	  
	}// if locId <=234
      }// Dec Condn
	
      
      if(!reg_phys_trig_occur)
	 index += 45;
	
      index += 1; // end of local Data 0xCAFEFADE

      HLTDebug("iReg %d, iLoc %d, locId : %d, trigY %x, triggX %x, loDev %x, dec %x, sign %x,rawData : %x",
	       iReg,iLoc,locId,triggY,triggX,loDev,dec,sign, rawData[index]);

      index = iLocIndex + 6 ; //important to reset the index counter for fake locids like 235 
      
     }// iLoc loop
     
  }// iReg Loop

  return true;
}

bool AliHLTMUONTriggerReconstructor::FindTrigHits() 
{

  map<int,DataIdIndex>::iterator it;

  for(it = fDetElemToDataId.begin(); it != fDetElemToDataId.end(); it++){
    HLTDebug("Nof data found in Detelem : %d = %d",it->first,(it->second).size());
    if(!MergeTrigHits(it->second))
      return false;
  }// loop over detection element

  DataIdIndex dataIndex;
  for(it = fDetElemToDataId.begin(); it != fDetElemToDataId.end(); it++){
    dataIndex = it->second;
    for(size_t i=0;i<dataIndex.size();i++){
      fPadData[dataIndex.at(i)].fDetElemId = 0;
      fPadData[dataIndex.at(i)].fBuspatchId = 0;
      fPadData[dataIndex.at(i)].fIdManuChannel = 0;
      fPadData[dataIndex.at(i)].fIX = 0 ;
      fPadData[dataIndex.at(i)].fIY = 0 ;
      fPadData[dataIndex.at(i)].fRealX = 0.0 ;
      fPadData[dataIndex.at(i)].fRealY = 0.0 ;
      fPadData[dataIndex.at(i)].fRealZ = 0.0 ;
      fPadData[dataIndex.at(i)].fPlane = -1 ;
      fPadData[dataIndex.at(i)].fPcbZone = -1 ;
      fPadData[dataIndex.at(i)].fCharge = 0 ;
    }// data per detelem loop  
  }//detelem loop
  
  return true;
}

bool AliHLTMUONTriggerReconstructor::MergeTrigHits(DataIdIndex& dataIndex)
{
  int idManuChannelB, idManuChannelNB;
  float halfPadLengthX,halfPadLengthY;
  float diffX,diffY;

  HLTDebug("\tThe bending plane hits are :");
  for(size_t iPad=0;iPad<dataIndex.size();iPad++){
    idManuChannelB   = dataIndex.at(iPad);
    if(fPadData[idManuChannelB].fPlane == 0){
      HLTDebug("\t detelem :%d, pcbzone : %d, (%f, %f, %f) cm",fPadData[idManuChannelB].fDetElemId,fPadData[idManuChannelB].fPcbZone,fPadData[idManuChannelB].fRealX,
	      fPadData[idManuChannelB].fRealY,fPadData[idManuChannelB].fRealZ);
    }
  }

  HLTDebug("\tThe non-bending plane hits are :");
  for(size_t jPad=0;jPad<dataIndex.size();jPad++){
    idManuChannelNB   = dataIndex.at(jPad);
    if(fPadData[idManuChannelNB].fPlane == 1){
      HLTDebug("\t detelem :%d, pcbzone : %d,(%f, %f, %f) cm",fPadData[idManuChannelNB].fDetElemId,fPadData[idManuChannelNB].fPcbZone,fPadData[idManuChannelNB].fRealX,
	      fPadData[idManuChannelNB].fRealY,fPadData[idManuChannelNB].fRealZ);
    }
  }


  for(size_t iPad=0;iPad<dataIndex.size();iPad++){
    idManuChannelB   = dataIndex.at(iPad);
    if(fPadData[idManuChannelB].fPlane == 0){
      
      halfPadLengthX = AliHLTMUONTriggerReconstructor::fgkHalfPadSizeXB[fPadData[idManuChannelB].fPcbZone] ;

      for(size_t jPad=0;jPad<dataIndex.size();jPad++){
	idManuChannelNB   = dataIndex.at(jPad);;
	if(fPadData[idManuChannelNB].fPlane == 1){
	  
	  halfPadLengthY = AliHLTMUONTriggerReconstructor::fgkHalfPadSizeYNB[fPadData[idManuChannelNB].fPcbZone] ;
	  
	  if(fabsf(fPadData[idManuChannelNB].fRealX) > fabsf(fPadData[idManuChannelB].fRealX))
	    diffX = fabsf(fPadData[idManuChannelNB].fRealX) - fabsf(fPadData[idManuChannelB].fRealX);
	  else
	    diffX = fabsf(fPadData[idManuChannelB].fRealX) - fabsf(fPadData[idManuChannelNB].fRealX) ;

	  
	  if(fabsf(fPadData[idManuChannelNB].fRealY) > fabsf(fPadData[idManuChannelB].fRealY))
	    diffY = fabsf(fPadData[idManuChannelNB].fRealY) - fabsf(fPadData[idManuChannelB].fRealY);
	  else
	    diffY = fabsf(fPadData[idManuChannelB].fRealY) - fabsf(fPadData[idManuChannelNB].fRealY) ;
 	  HLTDebug("\tdiffX %f,  halfPadLengthX %f,  diffY  %f, halfPadLengthY  %f\n",diffX,halfPadLengthX,diffY,halfPadLengthY);

 	  if(diffX < halfPadLengthX + 1.0 && diffY < halfPadLengthY + 1.0 ){// added redundancy of 1.0 cm due to the pb of geometrical segmentation 

	    AliHLTMUONRecHitStruct hit;
	    hit.fX = fPadData[idManuChannelNB].fRealX;
	    hit.fY = fPadData[idManuChannelB].fRealY;
	    hit.fZ = fPadData[idManuChannelNB].fRealZ;

	    fRecPoints[(*fRecPointsCount)].fHit[0] = hit;
	    fRecPoints[(*fRecPointsCount)].fId = fPadData[idManuChannelB].fDetElemId ;
	    
	    (*fRecPointsCount)++;
	    if((*fRecPointsCount) == fMaxRecPointsCount){
	      HLTFatal("Nof RecHit (i.e. %d) exceeds the max nof RecHit limit %d\n",(*fRecPointsCount),fMaxRecPointsCount);
	      return false;
	    }

	    HLTDebug("\t\t\tdetelem : %d, x %f, y %f, z %f\n",fPadData[idManuChannelB].fDetElemId,fPadData[idManuChannelNB].fRealX,
		   fPadData[idManuChannelB].fRealY,fPadData[idManuChannelB].fRealZ);
	  }
	  
	}//condn for non-bending plane
      }//for loop for non-bending plane

    }// condn for bending plane
  }// for loop for bending plane

  return true;
}
Commit	Line	Data
6efe69e7	1	/**************************************************************************
	2	* This file is property of and copyright by the ALICE HLT Project *
	3	* All rights reserved. *
	4	* *
	5	* Primary Authors: *
	6	* Indranil Das <indra.das@saha.ac.in> *
	7	* *
	8	* Permission to use, copy, modify and distribute this software and its *
	9	* documentation strictly for non-commercial purposes is hereby granted *
	10	* without fee, provided that the above copyright notice appears in all *
	11	* copies and that both the copyright notice and this permission notice *
	12	* appear in the supporting documentation. The authors make no claims *
	13	* about the suitability of this software for any purpose. It is *
	14	* provided "as is" without express or implied warranty. *
	15	**************************************************************************/
	16
	17	/* $Id$ */
	18
	19	/**********************************************************************
	20	Created on : 16/05/2007
	21	Purpose : This class is supposed to read the tracker DDL files and
960d54ad	22	give the output AliMUONCoreTriggerRecord
6efe69e7	23	Author : Indranil Das, HEP Division, SINP
	24	Email : indra.das@saha.ac.in \| indra.ehep@gmail.com
	25	**********************************************************************/
	26
	27	///*
	28	//
960d54ad	29	// The trigger reconstructor class is designed to deal the rawdata inputfiles
	30	// to findout the the reconstructed hits at the trigger DDL. The output is send
	31	// to the output block for further processing.
6efe69e7	32	//
	33	// Author : Indranil Das ( indra.das@saha.ac.in \|\| indra.ehep@gmail.com )
	34	//
	35	//*/
	36
6efe69e7	37	#include "AliHLTMUONTriggerReconstructor.h"
6efe69e7	38
6efe69e7	39	const int AliHLTMUONTriggerReconstructor::fgkDetectorId = 0xB00;
	40	const int AliHLTMUONTriggerReconstructor::fgkDDLOffSet = 20 ;
	41	const int AliHLTMUONTriggerReconstructor::fgkNofDDL = 2 ;
	42
	43	const int AliHLTMUONTriggerReconstructor::fgkDDLHeaderSize = 8;
960d54ad	44	const int AliHLTMUONTriggerReconstructor::fgkEvenLutSize = 2602351 + 1;
960d54ad	45	const int AliHLTMUONTriggerReconstructor::fgkOddLutSize = 2528735 + 1;
6efe69e7	46
	47	const int AliHLTMUONTriggerReconstructor::fgkLutLine = 10496;
	48
960d54ad	49	const int AliHLTMUONTriggerReconstructor::fgkMinIdManuChannel[2] = {819616, 862288};
960d54ad	50	const int AliHLTMUONTriggerReconstructor::fgkMaxIdManuChannel[2] = {3421966, 3391022};
6efe69e7	51
	52	const float AliHLTMUONTriggerReconstructor::fgkHalfPadSizeXB[3] = {8.5, 17.0, 25.5};
	53	const float AliHLTMUONTriggerReconstructor::fgkHalfPadSizeYNB[2] = {25.5, 34.0};
	54
	55	const int AliHLTMUONTriggerReconstructor::fgkDetElem = 9*4 ; // 9 detele per half chamber
	56
960d54ad	57
	58	AliHLTMUONTriggerReconstructor::AliHLTMUONTriggerReconstructor()
	59	:
6efe69e7	60	fPadData(NULL),
	61	fLookUpTableData(NULL),
	62	fRecPoints(NULL),
	63	fRecPointsCount(NULL),
	64	fMaxRecPointsCount(0),
960d54ad	65	fMaxFiredPerDetElem(),
960d54ad	66	fDetElemToDataId(),
6efe69e7	67	fDDLId(0),
960d54ad	68	fIdOffSet(0)
6efe69e7	69	{
	70	// ctor
	71
	72	if(AliHLTMUONTriggerReconstructor::fgkEvenLutSize > AliHLTMUONTriggerReconstructor::fgkOddLutSize){
	73	fPadData = new AliHLTMUONHitReconstructor::DHLTPad[AliHLTMUONTriggerReconstructor::fgkEvenLutSize];
	74	}
	75	else{
	76	fPadData = new AliHLTMUONHitReconstructor::DHLTPad[AliHLTMUONTriggerReconstructor::fgkOddLutSize];
	77	}
	78
6efe69e7	79	bzero(fGetIdTotalData,104642*sizeof(int));
	80	}
	81
	82
	83	AliHLTMUONTriggerReconstructor::~AliHLTMUONTriggerReconstructor()
	84	{
	85	// dtor
6efe69e7	86	delete []fPadData;
6efe69e7	87	delete []fLookUpTableData;
960d54ad	88	}
	89
	90	bool AliHLTMUONTriggerReconstructor::SetRegToLocCardMap(RegToLoc* regToLoc)
	91	{
	92	if(!memcpy(fRegToLocCard,regToLoc,128*sizeof(RegToLoc)))
	93	return false;
	94
	95	for(int i=0;i<128;i++){
	96	HLTDebug("DDL : %d, reg : %d, loc : %d",fRegToLocCard[i].fTrigDDL,
	97	fRegToLocCard[i].fRegId,fRegToLocCard[i].fLocId);
	98	}
	99
	100	return true;
6efe69e7	101	}
	102
	103	bool AliHLTMUONTriggerReconstructor::LoadLookUpTable(AliHLTMUONHitReconstructor::DHLTLut* lookUpTableData, int lookUpTableId)
	104	{
	105	if(lookUpTableId<fgkDDLOffSet \|\| lookUpTableId>= fgkDDLOffSet + fgkNofDDL){
	106	HLTError("DDL number is out of range (must be %d<=iDDL<%d)",fgkDDLOffSet,fgkDDLOffSet+fgkNofDDL);
	107	return false;
	108	}
	109
	110	fDDLId = lookUpTableId;
	111
	112	int lutSize = ((lookUpTableId%2)==0) ? fgkEvenLutSize : fgkOddLutSize ;
	113	int nofLutLine = fgkLutLine ;
	114	fIdOffSet = fgkMinIdManuChannel[lookUpTableId%2];
	115
	116	int detManuChannelId;
	117
	118	fLookUpTableData = new AliHLTMUONHitReconstructor::DHLTLut[lutSize];
	119
960d54ad	120	memset(fLookUpTableData,-1,lutSize*sizeof(AliHLTMUONHitReconstructor::DHLTLut));
6efe69e7	121
	122	for(int i=0; i<nofLutLine; i++){
	123
	124	detManuChannelId = lookUpTableData[i].fIdManuChannel - fIdOffSet + 1;
	125	fLookUpTableData[detManuChannelId].fIdManuChannel = lookUpTableData[i].fIdManuChannel - fIdOffSet;
	126	fLookUpTableData[detManuChannelId].fIX = lookUpTableData[i].fIX ;
	127	fLookUpTableData[detManuChannelId].fIY = lookUpTableData[i].fIY ;
	128	fLookUpTableData[detManuChannelId].fRealX = lookUpTableData[i].fRealX ;
	129	fLookUpTableData[detManuChannelId].fRealY = lookUpTableData[i].fRealY ;
	130	fLookUpTableData[detManuChannelId].fRealZ = lookUpTableData[i].fRealZ ;
	131	fLookUpTableData[detManuChannelId].fPcbZone = lookUpTableData[i].fPcbZone ;
	132	fLookUpTableData[detManuChannelId].fPlane = lookUpTableData[i].fPlane ;
	133	}
	134	return true;
	135
	136	return true;
	137	}
	138
227e7192	139	bool AliHLTMUONTriggerReconstructor::Run(
	140	const AliHLTUInt32_t* rawData,
	141	AliHLTUInt32_t rawDataSize,
	142	AliHLTMUONTriggerRecordStruct* trigRecord,
	143	AliHLTUInt32_t& nofTrigRec
	144	)
6efe69e7	145	{
6efe69e7	146
227e7192	147	fRecPoints = trigRecord;
	148	fMaxRecPointsCount = nofTrigRec;
	149	fRecPointsCount = &nofTrigRec;
6efe69e7	150	*fRecPointsCount = 0;
960d54ad	151	fMaxFiredPerDetElem.clear();
960d54ad	152	fDetElemToDataId.clear();
6efe69e7	153
	154	fPadData[0].fDetElemId = 0;
	155	fPadData[0].fBuspatchId = 0;
	156	fPadData[0].fIdManuChannel = 0;
	157	fPadData[0].fIX = 0 ;
	158	fPadData[0].fIY = 0 ;
	159	fPadData[0].fRealX = 0.0 ;
	160	fPadData[0].fRealY = 0.0 ;
	161	fPadData[0].fRealZ = 0.0 ;
	162	fPadData[0].fPlane = -1 ;
	163	fPadData[0].fPcbZone = -1 ;
	164	fPadData[0].fCharge = 0 ;
	165
227e7192	166	if(!ReadDDL(rawData, rawDataSize)){
6efe69e7	167	HLTError("Failed to read the complete DDL file\n");
	168	return false;
	169	}
	170
	171	if(!FindTrigHits()){
	172	HLTError("Failed to generate RecHits\n");
	173	return false;
	174	}
	175
	176	return true;
	177	}
	178
	179
227e7192	180	bool AliHLTMUONTriggerReconstructor::ReadDDL(
	181	const AliHLTUInt32_t* rawData,
	182	AliHLTUInt32_t rawDataSize
	183	)
6efe69e7	184	{
6efe69e7	185
6efe69e7	186	int idManuChannel ;
	187
	188	int index = 0;
	189	int dataCount = 0;
6efe69e7	190	int detElemId = 0 ;
960d54ad	191	int reg_output,reg_phys_trig_occur ;
	192	int iLocIndex,loc,locDec,triggY,sign,loDev,triggX;
	193	int iRegLoc, locId ;
	194	short pattern[2][4]; // 2 stands for two cathode planes and 4 stands for 4 chambers
	195
	196	Int_t offset,ithSwitch,secondLocation,idetElemId;
6efe69e7	197
960d54ad	198	int shiftIndex = 10 - 6 - 1; // the one comes due to indexing from zero
6efe69e7	199
960d54ad	200	DataIdIndex dataIndex;
6efe69e7	201	#ifdef DEBUG
	202	int globalcard_data_occurance = (rawData[index]>>10)&0x1; //Set to 1 if global info present in DDL else set to 0
	203	int version = (rawData[index]>>12)&0xFF; // software version
	204	int serial_number = (rawData[index]>>20)&0xF; // serial number set to 0xF
	205	#endif
	206	int phys_trig_occur = (rawData[index]>>30)&0x1; // 1 for physics trigger, 0 for software trigger
	207
6efe69e7	208	HLTDebug("globalcard_data_occurance %d, version %d, serial_number %d, phys_trig_occur %d",
	209	globalcard_data_occurance,version,serial_number,phys_trig_occur);
	210
	211	if(!phys_trig_occur) // for software trigger
	212	index += 8 ;// corresponding to scalar words
	213
	214	index += 1 ; // To skip the separator 0xDEADFACE
	215
	216	index += 4 ; // corresponding to global input
	217
	218	index += 1 ; // reaches to global output
	219
	220	if((fDDLId - AliHLTMUONTriggerReconstructor::fgkDDLOffSet) == 0){ //if globalData is present in DDL 0 (presummed may be changed)
	221	#ifdef DEBUG
	222	int singleLpt = rawData[index] & 0x1;
	223	int singleHpt = (rawData[index] >> 1) & 0x1;
	224
	225	int pairUnlikeLpt = (rawData[index] >> 4) & 0x1;
	226	int pairUnlikeHpt = (rawData[index] >> 5) & 0x1;
	227
	228	int pairLikeLpt = (rawData[index] >> 2) & 0x1;
	229	int pairLikeHpt = (rawData[index] >> 3) & 0x1;
960d54ad	230	#endif
6efe69e7	231	HLTDebug("singleLpt : %x, singleHpt : %x, pairUnlikeLpt : %x, pairUnlikeHpt : %x, pairLikeLpt : %x, pairLikeHpt : %x",
	232	singleLpt,singleHpt,pairUnlikeLpt,pairUnlikeHpt,pairLikeLpt,pairLikeHpt);
	233	}
	234
	235	if(!phys_trig_occur)
	236	index += 10 ;// corresponds to scalar words
960d54ad	237
6efe69e7	238	index += 1; // separator 0xDEADBEEF
	239
	240	for (int iReg = 0; iReg < 8; iReg++) {
	241	index += 1; // DARC Status Word
	242	index += 1; // Regeional Word
960d54ad	243	reg_output = rawData[index] & 0xFF;
960d54ad	244	reg_phys_trig_occur = ( rawData[index] >> 31) & 0x1;
6efe69e7	245
	246	index += 2; // 2 words for regional input
	247
	248	index += 1; // L0 counter
	249
	250	if(!reg_phys_trig_occur)
	251	index += 10;
	252
960d54ad	253	index += 1 ; // end of Regeonal header 0xBEEFFACE
6efe69e7	254
	255	for(int iLoc = 0; iLoc < 16 ; iLoc++){
	256
960d54ad	257	iLocIndex = index ;
6efe69e7	258
960d54ad	259	loc = (rawData[index+5] >> 19) & 0xF ;
6efe69e7	260
960d54ad	261	locDec = (rawData[index+5] >> 15) & 0xF;
	262	triggY = (rawData[index+5] >> 14) & 0x1 ;
	263	sign = (rawData[index+5] >> 9) & 0x1;
	264	loDev = (rawData[index+5] >> 5) & 0xF ;
	265	triggX = (loDev >> 4 & 0x1 ) && !(loDev & 0xF) ;
6efe69e7	266
960d54ad	267	if( locDec != 0x9 ){ // check for Dec
	268
	269	iRegLoc = iReg*16 + iLoc;
	270	locId = fRegToLocCard[iRegLoc].fLocId ;
	271
	272	if(locId<=234){ // to avoid the copy locCards
6efe69e7	273
6efe69e7	274	index += 1;
960d54ad	275	pattern[0][0] = rawData[index] & 0xFFFF; // x-strip pattern for chaber 0
	276	pattern[0][1] = (rawData[index] >> 16) & 0xFFFF; // x-strip pattern for chaber 1
	277	index += 1;
	278	pattern[0][2] = rawData[index] & 0xFFFF;
	279	pattern[0][3] = (rawData[index] >> 16) & 0xFFFF;
6efe69e7	280
960d54ad	281	index += 1;
	282	pattern[1][0] = rawData[index] & 0xFFFF; // y-strip pattern for chaber 0
	283	pattern[1][1] = (rawData[index] >> 16) & 0xFFFF; // y-strip pattern for chaber 0
	284	index += 1;
	285	pattern[1][2] = rawData[index] & 0xFFFF;
	286	pattern[1][3] = (rawData[index] >> 16) & 0xFFFF;
6efe69e7	287
960d54ad	288	if(pattern[0][0] \|\| pattern[0][1] \|\| pattern[0][2] \|\| pattern[0][3]
	289	\|\| pattern[1][0] \|\| pattern[1][1] \|\| pattern[1][2] \|\| pattern[1][3]
	290	){
	291
	292	HLTDebug("iReg: %d, iLoc :%d, locId : %d,X : %x, %x, %x, %x ...Y : %x, %x, %x, %x",
	293	iReg,iLoc,locId,pattern[0][0],pattern[0][1],pattern[0][2],pattern[0][3],
	294	pattern[1][0],pattern[1][1],pattern[1][2],pattern[1][3]);
	295
	296	for(int iChamber = 0; iChamber < 4 ; iChamber++){ //4 chambers per DDL
	297	for(int iPlane = 0; iPlane < 2 ; iPlane++){// 2 cathode plane
	298	if(pattern[iPlane][iChamber]){
	299	detElemId = fRegToLocCard[iRegLoc].fDetElemId[iChamber];
	300	HLTDebug("\tdetElemId : %d\n",detElemId);
	301	for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy) {
	302	if ((pattern[iPlane][iChamber] >> ibitxy) & 0x1) {
6efe69e7	303
960d54ad	304	// not quite sure about this
	305	offset = 0;
	306	ithSwitch = (fRegToLocCard[iRegLoc].fSwitch >> shiftIndex) & 0x1;
	307	if (iPlane && ithSwitch) offset = -8;
	308
	309	secondLocation = ibitxy + offset;
	310
	311	idetElemId = detElemId%1000;
	312
	313	idetElemId &= 0x1FF ;
	314	iPlane &= 0x1 ;
	315	locId &= 0xFF ;
	316	secondLocation &= 0xF ;
	317
	318	idManuChannel &= 0x0;
	319	idManuChannel = (idManuChannel\|idetElemId)<<1;
	320	idManuChannel = (idManuChannel\|iPlane)<<8;
	321	idManuChannel = (idManuChannel\|locId)<<4 ;
	322	idManuChannel \|= secondLocation ;
	323
	324	idManuChannel -= fIdOffSet ;
	325
	326	if(fLookUpTableData[idManuChannel+1].fIdManuChannel == -1) //skip uninitialized values
	327	continue;
	328
	329	fPadData[idManuChannel].fDetElemId = detElemId;
	330	fPadData[idManuChannel].fIdManuChannel = idManuChannel;
	331	fPadData[idManuChannel].fIX = fLookUpTableData[idManuChannel+1].fIX;
	332	fPadData[idManuChannel].fIY = fLookUpTableData[idManuChannel+1].fIY;
	333	fPadData[idManuChannel].fRealX = fLookUpTableData[idManuChannel+1].fRealX;
	334	fPadData[idManuChannel].fRealY = fLookUpTableData[idManuChannel+1].fRealY;
	335	fPadData[idManuChannel].fRealZ = fLookUpTableData[idManuChannel+1].fRealZ;
	336	fPadData[idManuChannel].fPcbZone = fLookUpTableData[idManuChannel+1].fPcbZone;
	337	fPadData[idManuChannel].fPlane = fLookUpTableData[idManuChannel+1].fPlane;
	338	HLTDebug("\t Hit Found fo ich : %d, iPlane : %d, detelem %d, id : %d, at (%lf, %lf, %lf) cm"
	339	,iChamber,fLookUpTableData[idManuChannel+1].fPlane,detElemId,fLookUpTableData[idManuChannel+1].fIdManuChannel,
	340	fPadData[idManuChannel].fRealX,
	341	fPadData[idManuChannel].fRealY,fPadData[idManuChannel].fRealZ);
	342
	343	if(fMaxFiredPerDetElem[detElemId] == 0){
	344	DataIdIndex first;
	345	first.push_back(idManuChannel);
	346	fDetElemToDataId[detElemId] = first;
	347	}else{
	348	dataIndex = fDetElemToDataId[detElemId];
	349	dataIndex.push_back(idManuChannel);
	350	fDetElemToDataId[detElemId] = dataIndex;
	351	}
	352
	353	fMaxFiredPerDetElem[detElemId] = fMaxFiredPerDetElem[detElemId] + 1;
	354
	355	dataCount ++;
	356
	357	}//pattern maching is found
	358	}// loop of ibitxy
	359	}// if pattern
	360	}// iplane
	361	}// ichamber
	362
	363	}// if any non zero pattern found
	364
	365
6efe69e7	366	index += 1 ; // skipping the last word though it is important
6efe69e7	367
960d54ad	368	}// if locId <=234
6efe69e7	369	}// Dec Condn
6efe69e7	370
6efe69e7	371
960d54ad	372	if(!reg_phys_trig_occur)
	373	index += 45;
	374
	375	index += 1; // end of local Data 0xCAFEFADE
6efe69e7	376
960d54ad	377	HLTDebug("iReg %d, iLoc %d, locId : %d, trigY %x, triggX %x, loDev %x, dec %x, sign %x,rawData : %x",
960d54ad	378	iReg,iLoc,locId,triggY,triggX,loDev,dec,sign, rawData[index]);
6efe69e7	379
960d54ad	380	index = iLocIndex + 6 ; //important to reset the index counter for fake locids like 235
6efe69e7	381
960d54ad	382	}// iLoc loop
	383
	384	}// iReg Loop
6efe69e7	385
	386	return true;
	387	}
	388
	389	bool AliHLTMUONTriggerReconstructor::FindTrigHits()
	390	{
6efe69e7	391
960d54ad	392	map<int,DataIdIndex>::iterator it;
6efe69e7	393
960d54ad	394	for(it = fDetElemToDataId.begin(); it != fDetElemToDataId.end(); it++){
	395	HLTDebug("Nof data found in Detelem : %d = %d",it->first,(it->second).size());
	396	if(!MergeTrigHits(it->second))
	397	return false;
6efe69e7	398	}// loop over detection element
6efe69e7	399
960d54ad	400	DataIdIndex dataIndex;
	401	for(it = fDetElemToDataId.begin(); it != fDetElemToDataId.end(); it++){
	402	dataIndex = it->second;
	403	for(size_t i=0;i<dataIndex.size();i++){
	404	fPadData[dataIndex.at(i)].fDetElemId = 0;
	405	fPadData[dataIndex.at(i)].fBuspatchId = 0;
	406	fPadData[dataIndex.at(i)].fIdManuChannel = 0;
	407	fPadData[dataIndex.at(i)].fIX = 0 ;
	408	fPadData[dataIndex.at(i)].fIY = 0 ;
	409	fPadData[dataIndex.at(i)].fRealX = 0.0 ;
	410	fPadData[dataIndex.at(i)].fRealY = 0.0 ;
	411	fPadData[dataIndex.at(i)].fRealZ = 0.0 ;
	412	fPadData[dataIndex.at(i)].fPlane = -1 ;
	413	fPadData[dataIndex.at(i)].fPcbZone = -1 ;
	414	fPadData[dataIndex.at(i)].fCharge = 0 ;
	415	}// data per detelem loop
	416	}//detelem loop
	417
6efe69e7	418	return true;
	419	}
	420
960d54ad	421	bool AliHLTMUONTriggerReconstructor::MergeTrigHits(DataIdIndex& dataIndex)
6efe69e7	422	{
	423	int idManuChannelB, idManuChannelNB;
	424	float halfPadLengthX,halfPadLengthY;
	425	float diffX,diffY;
	426
960d54ad	427	HLTDebug("\tThe bending plane hits are :");
	428	for(size_t iPad=0;iPad<dataIndex.size();iPad++){
	429	idManuChannelB = dataIndex.at(iPad);
	430	if(fPadData[idManuChannelB].fPlane == 0){
	431	HLTDebug("\t detelem :%d, pcbzone : %d, (%f, %f, %f) cm",fPadData[idManuChannelB].fDetElemId,fPadData[idManuChannelB].fPcbZone,fPadData[idManuChannelB].fRealX,
	432	fPadData[idManuChannelB].fRealY,fPadData[idManuChannelB].fRealZ);
	433	}
	434	}
	435
	436	HLTDebug("\tThe non-bending plane hits are :");
	437	for(size_t jPad=0;jPad<dataIndex.size();jPad++){
	438	idManuChannelNB = dataIndex.at(jPad);
	439	if(fPadData[idManuChannelNB].fPlane == 1){
	440	HLTDebug("\t detelem :%d, pcbzone : %d,(%f, %f, %f) cm",fPadData[idManuChannelNB].fDetElemId,fPadData[idManuChannelNB].fPcbZone,fPadData[idManuChannelNB].fRealX,
	441	fPadData[idManuChannelNB].fRealY,fPadData[idManuChannelNB].fRealZ);
	442	}
	443	}
	444
	445
	446	for(size_t iPad=0;iPad<dataIndex.size();iPad++){
	447	idManuChannelB = dataIndex.at(iPad);
6efe69e7	448	if(fPadData[idManuChannelB].fPlane == 0){
	449
	450	halfPadLengthX = AliHLTMUONTriggerReconstructor::fgkHalfPadSizeXB[fPadData[idManuChannelB].fPcbZone] ;
	451
960d54ad	452	for(size_t jPad=0;jPad<dataIndex.size();jPad++){
960d54ad	453	idManuChannelNB = dataIndex.at(jPad);;
6efe69e7	454	if(fPadData[idManuChannelNB].fPlane == 1){
	455
	456	halfPadLengthY = AliHLTMUONTriggerReconstructor::fgkHalfPadSizeYNB[fPadData[idManuChannelNB].fPcbZone] ;
	457
	458	if(fabsf(fPadData[idManuChannelNB].fRealX) > fabsf(fPadData[idManuChannelB].fRealX))
	459	diffX = fabsf(fPadData[idManuChannelNB].fRealX) - fabsf(fPadData[idManuChannelB].fRealX);
	460	else
	461	diffX = fabsf(fPadData[idManuChannelB].fRealX) - fabsf(fPadData[idManuChannelNB].fRealX) ;
	462
	463
	464	if(fabsf(fPadData[idManuChannelNB].fRealY) > fabsf(fPadData[idManuChannelB].fRealY))
	465	diffY = fabsf(fPadData[idManuChannelNB].fRealY) - fabsf(fPadData[idManuChannelB].fRealY);
	466	else
	467	diffY = fabsf(fPadData[idManuChannelB].fRealY) - fabsf(fPadData[idManuChannelNB].fRealY) ;
960d54ad	468	HLTDebug("\tdiffX %f, halfPadLengthX %f, diffY %f, halfPadLengthY %f\n",diffX,halfPadLengthX,diffY,halfPadLengthY);
6efe69e7	469
960d54ad	470	if(diffX < halfPadLengthX + 1.0 && diffY < halfPadLengthY + 1.0 ){// added redundancy of 1.0 cm due to the pb of geometrical segmentation
6efe69e7	471
	472	AliHLTMUONRecHitStruct hit;
	473	hit.fX = fPadData[idManuChannelNB].fRealX;
960d54ad	474	hit.fY = fPadData[idManuChannelB].fRealY;
6efe69e7	475	hit.fZ = fPadData[idManuChannelNB].fRealZ;
6efe69e7	476
960d54ad	477	fRecPoints[(*fRecPointsCount)].fHit[0] = hit;
960d54ad	478	fRecPoints[(*fRecPointsCount)].fId = fPadData[idManuChannelB].fDetElemId ;
6efe69e7	479
	480	(*fRecPointsCount)++;
	481	if((*fRecPointsCount) == fMaxRecPointsCount){
960d54ad	482	HLTFatal("Nof RecHit (i.e. %d) exceeds the max nof RecHit limit %d\n",(*fRecPointsCount),fMaxRecPointsCount);
6efe69e7	483	return false;
	484	}
	485
960d54ad	486	HLTDebug("\t\t\tdetelem : %d, x %f, y %f, z %f\n",fPadData[idManuChannelB].fDetElemId,fPadData[idManuChannelNB].fRealX,
6efe69e7	487	fPadData[idManuChannelB].fRealY,fPadData[idManuChannelB].fRealZ);
	488	}
	489
6efe69e7	490	}//condn for non-bending plane
	491	}//for loop for non-bending plane
	492
	493	}// condn for bending plane
	494	}// for loop for bending plane
	495
	496	return true;
	497	}
	498