[u/mrichter/AliRoot.git] / VZERO / AliVZEROTriggerMask.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */
//-------------------------------------------
// Class : AliVZEROTriggerMask
//
// Fill up the trigger mask word.
//

#include <Riostream.h>
#include <TGeoManager.h>
#include <TGeoMatrix.h>
#include <TGeoPhysicalNode.h>
#include <TF1.h>
#include <TMath.h>

#include <AliGeomManager.h>
#include "AliLog.h"
#include "AliVZEROTriggerMask.h"
#include "AliVZEROConst.h"
#include "AliVZEROCalibData.h"
#include "AliESDVZERO.h"
#include "AliVZEROReconstructor.h"

//______________________________________________________________________
ClassImp(AliVZEROTriggerMask)

//______________________________________________________________________

AliVZEROTriggerMask::AliVZEROTriggerMask()
  :TObject(),
   fAdcThresHold(0.0),
   fTimeWindowBBALow(-9.5),
   fTimeWindowBBAUp(22.5),
   fTimeWindowBGALow(-2.5),
   fTimeWindowBGAUp(5.0),
   fTimeWindowFakeALow(-17.5),
   fTimeWindowFakeAUp(-9.5),
   fTimeWindowBBCLow(-2.5),
   fTimeWindowBBCUp(22.5),
   fTimeWindowBGCLow(-2.5),
   fTimeWindowBGCUp(2.5),
   fTimeWindowFakeCLow(-22.5),
   fTimeWindowFakeCUp(-8.5),
   fV0ADist(0),
   fV0CDist(0)
{
  // Default constructor
  //
  Float_t zV0A = TMath::Abs(GetZPosition("VZERO/V0A"));
  Float_t zV0C = TMath::Abs(GetZPosition("VZERO/V0C"));

  // distance in time units from nominal vertex to V0
  fV0ADist = zV0A/TMath::Ccgs()*1e9;
  fV0CDist = zV0C/TMath::Ccgs()*1e9;
}

//________________________________________________________________________________
Double_t AliVZEROTriggerMask::GetZPosition(const char* symname){
// Get the global z coordinate of the given V0 alignable volume
//
  Double_t *tr;
  TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
  if (!pne) {
    AliFatalClass(Form("TGeoPNEntry with symbolic name %s does not exist!",symname));
    return 0;
  }

  TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
  if(pnode){
          TGeoHMatrix* hm = pnode->GetMatrix();
           tr = hm->GetTranslation();
  }else{
          const char* path = pne->GetTitle();
          if(!gGeoManager->cd(path)){
                  AliFatalClass(Form("Volume path %s not valid!",path));
                  return 0;
          }
         tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
  }
  return tr[2];

}

//________________________________________________________________________________


void AliVZEROTriggerMask::FillMasks(AliESDVZERO *esdV0,
				    AliVZEROCalibData *cal,
				    TF1 *slewing)
{
  // Fill up the trigger mask word
  // using the TDC data (already corrected for
  // slewing and misalignment between channels)

  esdV0->SetBit(AliESDVZERO::kTriggerBitsFilled,kTRUE);
  esdV0->SetBit(AliESDVZERO::kDecisionFilled,kTRUE);

  UInt_t aBBtriggerV0A = 0; // bit mask for Beam-Beam trigger in V0A
  UInt_t aBGtriggerV0A = 0; // bit mask for Beam-Gas trigger in V0A
  UInt_t aBBtriggerV0C = 0; // bit mask for Beam-Beam trigger in V0C
  UInt_t aBGtriggerV0C = 0; // bit mask for Beam-Gas trigger in V0C

  const Float_t p1 = 2.19; // photostatistics term in the time resolution
  const Float_t p2 = 1.31; // slewing related term in the time resolution

  // loop over vzero channels
  Float_t timeAW = 0,timeCW = 0;
  Float_t weightA = 0,weightC = 0;
  Int_t ntimeA = 0, ntimeC = 0;
  for (Int_t i = 0; i < 64; ++i) {
    Float_t adc = esdV0->GetAdc(i);
    if (adc > fAdcThresHold) {
      Float_t tdc = esdV0->GetTime(i);
      if (tdc > (AliVZEROReconstructor::kInvalidTime + 1e-6)) {
	Float_t nphe = adc*kChargePerADC/(cal->GetGain(i)*TMath::Qe());
	Float_t timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+
				      p1*p1/nphe+
				      p2*p2*(slewing->GetParameter(0)*slewing->GetParameter(1))*(slewing->GetParameter(0)*slewing->GetParameter(1))*
				      TMath::Power(adc/cal->GetDiscriThr(i),2.*(slewing->GetParameter(1)-1.)));

	if (i < 32) { // in V0C
	  ntimeC++;
	  timeCW += tdc/(timeErr*timeErr);
	  weightC += 1.0/(timeErr*timeErr);

	  if (tdc > (fV0CDist + fTimeWindowBBCLow) &&
	      tdc < (fV0CDist + fTimeWindowBBCUp))
	    aBBtriggerV0C |= (1 << i);
	  if (tdc > (-fV0CDist + fTimeWindowBGCLow) &&
	      tdc < (-fV0CDist + fTimeWindowBGCUp))
	    aBGtriggerV0C |= (1 << i); 
	}
	else { // in V0A
	  ntimeA++;
	  timeAW += tdc/(timeErr*timeErr);
	  weightA += 1.0/(timeErr*timeErr);

	  Int_t shift = i - 32;
	  if (tdc > (fV0ADist + fTimeWindowBBALow) &&
	      tdc < (fV0ADist + fTimeWindowBBAUp)) 
	    aBBtriggerV0A |= (1 << shift);
	  if (tdc > (-fV0ADist + fTimeWindowBGALow) &&
	      tdc < (-fV0ADist + fTimeWindowBGAUp))
	    aBGtriggerV0A |= (1 << shift); 
	}
      }
    }
  } // end of loop over channels

  esdV0->SetBBtriggerV0A(aBBtriggerV0A);
  esdV0->SetBGtriggerV0A(aBGtriggerV0A);
  esdV0->SetBBtriggerV0C(aBBtriggerV0C);
  esdV0->SetBGtriggerV0C(aBGtriggerV0C);

  if (weightA > 0) timeAW = timeAW/weightA;
  else timeAW = AliVZEROReconstructor::kInvalidTime;

  if (weightC > 0) timeCW = timeCW/weightC;
  else timeCW = AliVZEROReconstructor::kInvalidTime;

  esdV0->SetV0ATime(timeAW);
  esdV0->SetV0CTime(timeCW);
  esdV0->SetV0ATimeError((weightA > 0) ? (1./TMath::Sqrt(weightA)) : 0);
  esdV0->SetV0ATimeError((weightC > 0) ? (1./TMath::Sqrt(weightC)) : 0);

  esdV0->SetV0ADecision(AliESDVZERO::kV0Empty);
  esdV0->SetV0CDecision(AliESDVZERO::kV0Empty);

  if (timeAW > (fV0ADist + fTimeWindowBBALow) &&
      timeAW < (fV0ADist + fTimeWindowBBAUp)) 
    esdV0->SetV0ADecision(AliESDVZERO::kV0BB);
  else if (timeAW > (-fV0ADist + fTimeWindowBGALow) &&
	   timeAW < (-fV0ADist + fTimeWindowBGAUp))
    esdV0->SetV0ADecision(AliESDVZERO::kV0BG);
  else if (timeAW > (fV0ADist + fTimeWindowFakeALow) &&
	   timeAW < (fV0ADist + fTimeWindowFakeAUp))
    esdV0->SetV0ADecision(AliESDVZERO::kV0Fake);

  if (timeCW > (fV0CDist + fTimeWindowBBCLow) &&
      timeCW < (fV0CDist + fTimeWindowBBCUp)) 
    esdV0->SetV0CDecision(AliESDVZERO::kV0BB);
  else if (timeCW > (-fV0CDist + fTimeWindowBGCLow) &&
	   timeCW < (-fV0CDist + fTimeWindowBGCUp))
    esdV0->SetV0CDecision(AliESDVZERO::kV0BG);
  else if (timeCW > (fV0CDist + fTimeWindowFakeCLow) &&
	   timeCW < (fV0CDist + fTimeWindowFakeCUp))
    esdV0->SetV0CDecision(AliESDVZERO::kV0Fake);

}
Commit	Line	Data
a055ee24	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
2647fc37	17	//-------------------------------------------
	18	// Class : AliVZEROTriggerMask
	19	//
	20	// Fill up the trigger mask word.
	21	//
	22
a055ee24	23	#include <Riostream.h>
	24	#include <TGeoManager.h>
	25	#include <TGeoMatrix.h>
	26	#include <TGeoPhysicalNode.h>
b44c933e	27	#include <TF1.h>
b44c933e	28	#include <TMath.h>
2647fc37	29
a055ee24	30	#include <AliGeomManager.h>
a055ee24	31	#include "AliLog.h"
a055ee24	32	#include "AliVZEROTriggerMask.h"
b44c933e	33	#include "AliVZEROConst.h"
	34	#include "AliVZEROCalibData.h"
	35	#include "AliESDVZERO.h"
	36	#include "AliVZEROReconstructor.h"
a055ee24	37
	38	//______________________________________________________________________
	39	ClassImp(AliVZEROTriggerMask)
	40
	41	//______________________________________________________________________
	42
	43	AliVZEROTriggerMask::AliVZEROTriggerMask()
	44	:TObject(),
	45	fAdcThresHold(0.0),
b44c933e	46	fTimeWindowBBALow(-9.5),
	47	fTimeWindowBBAUp(22.5),
	48	fTimeWindowBGALow(-2.5),
	49	fTimeWindowBGAUp(5.0),
	50	fTimeWindowFakeALow(-17.5),
	51	fTimeWindowFakeAUp(-9.5),
	52	fTimeWindowBBCLow(-2.5),
	53	fTimeWindowBBCUp(22.5),
	54	fTimeWindowBGCLow(-2.5),
	55	fTimeWindowBGCUp(2.5),
	56	fTimeWindowFakeCLow(-22.5),
	57	fTimeWindowFakeCUp(-8.5),
	58	fV0ADist(0),
	59	fV0CDist(0)
a055ee24	60	{
b44c933e	61	// Default constructor
	62	//
	63	Float_t zV0A = TMath::Abs(GetZPosition("VZERO/V0A"));
	64	Float_t zV0C = TMath::Abs(GetZPosition("VZERO/V0C"));
	65
	66	// distance in time units from nominal vertex to V0
	67	fV0ADist = zV0A/TMath::Ccgs()*1e9;
	68	fV0CDist = zV0C/TMath::Ccgs()*1e9;
a055ee24	69	}
	70
	71	//________________________________________________________________________________
	72	Double_t AliVZEROTriggerMask::GetZPosition(const char* symname){
	73	// Get the global z coordinate of the given V0 alignable volume
	74	//
	75	Double_t *tr;
	76	TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
b44c933e	77	if (!pne) {
	78	AliFatalClass(Form("TGeoPNEntry with symbolic name %s does not exist!",symname));
	79	return 0;
	80	}
a055ee24	81
	82	TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
	83	if(pnode){
	84	TGeoHMatrix* hm = pnode->GetMatrix();
	85	tr = hm->GetTranslation();
	86	}else{
	87	const char* path = pne->GetTitle();
	88	if(!gGeoManager->cd(path)){
b44c933e	89	AliFatalClass(Form("Volume path %s not valid!",path));
a055ee24	90	return 0;
	91	}
	92	tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
	93	}
	94	return tr[2];
	95
	96	}
	97
	98	//________________________________________________________________________________
	99
	100
b44c933e	101	void AliVZEROTriggerMask::FillMasks(AliESDVZERO *esdV0,
	102	AliVZEROCalibData *cal,
	103	TF1 *slewing)
a055ee24	104	{
b44c933e	105	// Fill up the trigger mask word
	106	// using the TDC data (already corrected for
	107	// slewing and misalignment between channels)
	108
	109	esdV0->SetBit(AliESDVZERO::kTriggerBitsFilled,kTRUE);
	110	esdV0->SetBit(AliESDVZERO::kDecisionFilled,kTRUE);
	111
	112	UInt_t aBBtriggerV0A = 0; // bit mask for Beam-Beam trigger in V0A
	113	UInt_t aBGtriggerV0A = 0; // bit mask for Beam-Gas trigger in V0A
	114	UInt_t aBBtriggerV0C = 0; // bit mask for Beam-Beam trigger in V0C
	115	UInt_t aBGtriggerV0C = 0; // bit mask for Beam-Gas trigger in V0C
	116
	117	const Float_t p1 = 2.19; // photostatistics term in the time resolution
	118	const Float_t p2 = 1.31; // slewing related term in the time resolution
	119
	120	// loop over vzero channels
	121	Float_t timeAW = 0,timeCW = 0;
	122	Float_t weightA = 0,weightC = 0;
	123	Int_t ntimeA = 0, ntimeC = 0;
	124	for (Int_t i = 0; i < 64; ++i) {
	125	Float_t adc = esdV0->GetAdc(i);
	126	if (adc > fAdcThresHold) {
	127	Float_t tdc = esdV0->GetTime(i);
	128	if (tdc > (AliVZEROReconstructor::kInvalidTime + 1e-6)) {
	129	Float_t nphe = adckChargePerADC/(cal->GetGain(i)TMath::Qe());
	130	Float_t timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+
	131	p1*p1/nphe+
	132	p2p2(slewing->GetParameter(0)slewing->GetParameter(1))(slewing->GetParameter(0)slewing->GetParameter(1))
	133	TMath::Power(adc/cal->GetDiscriThr(i),2.*(slewing->GetParameter(1)-1.)));
	134
	135	if (i < 32) { // in V0C
	136	ntimeC++;
	137	timeCW += tdc/(timeErr*timeErr);
	138	weightC += 1.0/(timeErr*timeErr);
	139
	140	if (tdc > (fV0CDist + fTimeWindowBBCLow) &&
	141	tdc < (fV0CDist + fTimeWindowBBCUp))
	142	aBBtriggerV0C \|= (1 << i);
	143	if (tdc > (-fV0CDist + fTimeWindowBGCLow) &&
	144	tdc < (-fV0CDist + fTimeWindowBGCUp))
	145	aBGtriggerV0C \|= (1 << i);
a055ee24	146	}
b44c933e	147	else { // in V0A
	148	ntimeA++;
	149	timeAW += tdc/(timeErr*timeErr);
	150	weightA += 1.0/(timeErr*timeErr);
	151
	152	Int_t shift = i - 32;
	153	if (tdc > (fV0ADist + fTimeWindowBBALow) &&
	154	tdc < (fV0ADist + fTimeWindowBBAUp))
	155	aBBtriggerV0A \|= (1 << shift);
	156	if (tdc > (-fV0ADist + fTimeWindowBGALow) &&
	157	tdc < (-fV0ADist + fTimeWindowBGAUp))
	158	aBGtriggerV0A \|= (1 << shift);
a055ee24	159	}
a055ee24	160	}
b44c933e	161	}
	162	} // end of loop over channels
	163
	164	esdV0->SetBBtriggerV0A(aBBtriggerV0A);
	165	esdV0->SetBGtriggerV0A(aBGtriggerV0A);
	166	esdV0->SetBBtriggerV0C(aBBtriggerV0C);
	167	esdV0->SetBGtriggerV0C(aBGtriggerV0C);
	168
	169	if (weightA > 0) timeAW = timeAW/weightA;
	170	else timeAW = AliVZEROReconstructor::kInvalidTime;
	171
	172	if (weightC > 0) timeCW = timeCW/weightC;
	173	else timeCW = AliVZEROReconstructor::kInvalidTime;
	174
	175	esdV0->SetV0ATime(timeAW);
	176	esdV0->SetV0CTime(timeCW);
	177	esdV0->SetV0ATimeError((weightA > 0) ? (1./TMath::Sqrt(weightA)) : 0);
	178	esdV0->SetV0ATimeError((weightC > 0) ? (1./TMath::Sqrt(weightC)) : 0);
	179
	180	esdV0->SetV0ADecision(AliESDVZERO::kV0Empty);
	181	esdV0->SetV0CDecision(AliESDVZERO::kV0Empty);
	182
	183	if (timeAW > (fV0ADist + fTimeWindowBBALow) &&
	184	timeAW < (fV0ADist + fTimeWindowBBAUp))
	185	esdV0->SetV0ADecision(AliESDVZERO::kV0BB);
	186	else if (timeAW > (-fV0ADist + fTimeWindowBGALow) &&
	187	timeAW < (-fV0ADist + fTimeWindowBGAUp))
	188	esdV0->SetV0ADecision(AliESDVZERO::kV0BG);
	189	else if (timeAW > (fV0ADist + fTimeWindowFakeALow) &&
	190	timeAW < (fV0ADist + fTimeWindowFakeAUp))
	191	esdV0->SetV0ADecision(AliESDVZERO::kV0Fake);
	192
	193	if (timeCW > (fV0CDist + fTimeWindowBBCLow) &&
	194	timeCW < (fV0CDist + fTimeWindowBBCUp))
	195	esdV0->SetV0CDecision(AliESDVZERO::kV0BB);
	196	else if (timeCW > (-fV0CDist + fTimeWindowBGCLow) &&
	197	timeCW < (-fV0CDist + fTimeWindowBGCUp))
	198	esdV0->SetV0CDecision(AliESDVZERO::kV0BG);
	199	else if (timeCW > (fV0CDist + fTimeWindowFakeCLow) &&
	200	timeCW < (fV0CDist + fTimeWindowFakeCUp))
	201	esdV0->SetV0CDecision(AliESDVZERO::kV0Fake);
	202
a055ee24	203	}