[u/mrichter/AliRoot.git] / VZERO / AliVZERO.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$ */

///////////////////////////////////////////////////////////////////////////
//                                                                       //
//                          V-Zero   Detector                            //
//  This class contains the base procedures for the VZERO  detector      //
//  Default geometry of November 2003 :   V0R box is 4.4 cm thick        //
//                                  scintillators are 2 cm thick         //
//  All comments should be sent to Brigitte CHEYNIS :                    //
//                                 b.cheynis@ipnl.in2p3.fr               //
//                                                                       //
//                                                                       //
///////////////////////////////////////////////////////////////////////////


// --- Standard libraries ---
#include <Riostream.h>
#include <stdlib.h>

// --- ROOT libraries ---
#include <TNamed.h>
#include "TROOT.h"
#include "TFile.h"
#include "TNetFile.h"
#include "TRandom.h"
#include "TTree.h"
#include "TBranch.h"
#include "TClonesArray.h"
#include "TStopwatch.h"
#include "TParameter.h"
#include "TF1.h"

// --- AliRoot header files ---
#include "AliRun.h"
#include "AliMC.h"
#include "AliVZERO.h"
#include "AliVZEROLoader.h"
#include "AliVZERODigitizer.h"
#include "AliVZEROBuffer.h"
#include "AliRunDigitizer.h"
#include "AliVZEROdigit.h"
#include "AliVZEROSDigit.h"
#include "AliDAQ.h"
#include "AliRawReader.h"
#include "AliCDBManager.h"
#include "AliCDBEntry.h"
#include "AliVZERORawStream.h"
#include "AliVZEROCalibData.h"
#include "AliVZERORecoParam.h"
#include "AliVZEROReconstructor.h"

ClassImp(AliVZERO)
 //__________________________________________________________________
AliVZERO::AliVZERO(): AliDetector(),
          fIdSens1(0),
          fThickness(0.),
	  fThickness1(0.),
	  fMaxStepQua(0.),
	  fMaxStepAlu(0.),
	  fMaxDestepQua(0.),
          fMaxDestepAlu(0.),
          fCalibData(NULL),
          fTimeSlewing(NULL),
          fSignalShape(NULL),
          fRecoParam(NULL)
{
/// Default Constructor
    
    AliDebug(1,Form("default (empty) ctor this=%p",this));
    fIshunt          = 0;

    for(Int_t i = 0 ; i < 64; ++i) {
      fNBins[i] = 0;
      fBinSize[i] = 0;
    }
}

//_____________________________________________________________________________
AliVZERO::AliVZERO(const char *name, const char *title)
       : AliDetector(name,title),
         fIdSens1(0),
         fThickness(4.4),
	 fThickness1(2.0),
	 fMaxStepQua(0.05),
	 fMaxStepAlu(0.01),
	 fMaxDestepQua(-1.0),
	 fMaxDestepAlu(-1.0),
	 fCalibData(NULL),
	 fTimeSlewing(NULL),
         fSignalShape(NULL),
	 fRecoParam(NULL)
{
  
  // Standard constructor for VZERO Detector
  
  AliDebug(1,Form("ctor this=%p",this));
  
  //  fIshunt       =  1;  // All hits are associated with primary particles  
   
  fHits         =  new TClonesArray("AliVZEROhit", 400);
  fDigits       =  new TClonesArray("AliVZEROdigit",400); 
   
  gAlice->GetMCApp()->AddHitList(fHits);

//   fThickness    =  4.4;   // total thickness of the V0R box in cm
//   fThickness1   =  2.0;   // thickness of scintillating cells in cm
//   
//   fMaxStepQua   =  0.05; 
//   fMaxStepAlu   =  0.01; 
//   
//   fMaxDestepQua =  -1.0;
//   fMaxDestepAlu =  -1.0;
  
  for(Int_t i = 0 ; i < 64; ++i) {
    fNBins[i] = 0;
    fBinSize[i] = 0;
  }
}

//_____________________________________________________________________________
AliVZERO::~AliVZERO()
{
  //
  // Default destructor for VZERO Detector
  //
  
    if (fHits) {
        fHits->Delete();
        delete fHits;
	fHits=0; }
    
    if (fDigits) {
        fDigits->Delete();
        delete fDigits;
        fDigits=0; }
    if (fSignalShape) {
      delete fSignalShape;
      fSignalShape = NULL;
    }
    if (fRecoParam) {
      delete fRecoParam;
      fRecoParam = NULL;
    }
}

//_____________________________________________________________________________
void AliVZERO::CreateGeometry()
{
  //
  // Builds simple Geant3 geometry 
  //
}
//_____________________________________________________________________________
void AliVZERO::CreateMaterials()
{
  //
  // Creates materials used for Geant3 geometry 
  //
}

//_____________________________________________________________________________
void AliVZERO::Init()
{
  //
  // Initialises the VZERO  class after it has been built
  //
}


//_____________________________________________________________________________
void AliVZERO::SetMaxStepQua(Float_t p1)
{
  //
  // Possible parametrisation of steps in active materials
  //
     fMaxStepQua = p1;
}

//_____________________________________________________________________________
void AliVZERO::SetMaxStepAlu(Float_t p1)
{
  //
  // Possible parametrisation of steps in Aluminum foils (not used in 
  // version v2)
  //
    fMaxStepAlu = p1;
}

//_____________________________________________________________________________
void AliVZERO::SetMaxDestepQua(Float_t p1)
{
  //
  // Possible parametrisation of steps in active materials (quartz)
  //
    fMaxDestepQua = p1;
}

//_____________________________________________________________________________
void AliVZERO::SetMaxDestepAlu(Float_t p1)
{
  //
  // Possible parametrisation of steps in Aluminum (not used in 
  // version v2)
  //
    fMaxDestepAlu = p1;
}

//_____________________________________________________________________________
AliLoader* AliVZERO::MakeLoader(const char* topfoldername)
{ 
  //
  // Builds VZEROgetter (AliLoader type)
  // if detector wants to use customized getter, it must overload this method
  //
//  Info("MakeLoader","Creating AliVZEROLoader. Top folder is %s.",topfoldername); 
 
  AliDebug(1,Form("Creating AliVZEROLoader, Top folder is %s ",topfoldername));
  fLoader = new AliVZEROLoader(GetName(),topfoldername);
  return fLoader;
}

//_____________________________________________________________________________
void AliVZERO::SetTreeAddress()
{
  //
  // Sets tree address for hits.
  //
  if (fLoader->TreeH() && (fHits == 0x0))
    fHits = new  TClonesArray("AliVZEROhit", 400);

  AliDetector::SetTreeAddress();
}

//_____________________________________________________________________________
AliDigitizer* AliVZERO::CreateDigitizer(AliRunDigitizer* manager) const
{
  //
  // Creates a digitizer for VZERO
  //
  return new AliVZERODigitizer(manager);
}

//_____________________________________________________________________________
void AliVZERO::Hits2Digits(){
  //
  // Converts hits to digits
  //
  // Creates the VZERO digitizer 
  AliVZERODigitizer* dig = new AliVZERODigitizer(this,AliVZERODigitizer::kHits2Digits);

  // Creates the digits
  dig->Exec("");

  // deletes the digitizer
  delete dig;
}

//_____________________________________________________________________________
void AliVZERO::Hits2SDigits(){
  //
  // Converts hits to summable digits
  //
  // Creates the VZERO digitizer 
  AliVZERODigitizer* dig = new AliVZERODigitizer(this,AliVZERODigitizer::kHits2SDigits);

  // Creates the sdigits
  dig->Exec("");

  // deletes the digitizer
  delete dig;
}

//_____________________________________________________________________________
void AliVZERO::Digits2Raw()
{
   //
   //  Converts digits of the current event to raw data
   //
  
   AliVZERO *fVZERO = (AliVZERO*)gAlice->GetDetector("VZERO");
   fLoader->LoadDigits();
   TTree* digits = fLoader->TreeD();
   if (!digits) {
      Error("Digits2Raw", "no digits tree");
      return;
   }
   TClonesArray * VZEROdigits = new TClonesArray("AliVZEROdigit",1000);
   fVZERO->SetTreeAddress();  		
   digits->GetBranch("VZERODigit")->SetAddress(&VZEROdigits); 
  
   const char *fileName    = AliDAQ::DdlFileName("VZERO",0);
   AliVZEROBuffer* buffer  = new AliVZEROBuffer(fileName);
  
   // Get Trigger information first
   // Read trigger inputs from trigger-detector object
   AliDataLoader * dataLoader = fLoader->GetDigitsDataLoader();
   if( !dataLoader->IsFileOpen() ) 
        dataLoader->OpenFile( "READ" );
   AliTriggerDetector* trgdet = (AliTriggerDetector*)dataLoader->GetDirectory()->Get( "Trigger" );
   UInt_t triggerInfo = 0;
   if(trgdet) {
      triggerInfo = trgdet->GetMask() & 0xffff;
   }
   else {
      AliError(Form("There is no trigger object for %s",fLoader->GetName()));
   }

   buffer->WriteTriggerInfo((UInt_t)triggerInfo); 
   buffer->WriteTriggerScalers(); 
   buffer->WriteBunchNumbers(); 
  
   Int_t aBBflagsV0A = 0;
   Int_t aBBflagsV0C = 0;
   Int_t aBGflagsV0A = 0;
   Int_t aBGflagsV0C = 0;

   if (digits->GetUserInfo()->FindObject("BBflagsV0A")) {
     aBBflagsV0A = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BBflagsV0A"))->GetVal();
   }
   else
     AliWarning("V0A beam-beam flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");

   if (digits->GetUserInfo()->FindObject("BBflagsV0C")) {
     aBBflagsV0C = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BBflagsV0C"))->GetVal();
   }
   else
     AliWarning("V0C beam-beam flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");

   if (digits->GetUserInfo()->FindObject("BGflagsV0A")) {
     aBGflagsV0A = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BGflagsV0A"))->GetVal();
   }
   else
     AliWarning("V0A beam-gas flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");

   if (digits->GetUserInfo()->FindObject("BGflagsV0C")) {
     aBGflagsV0C = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BGflagsV0C"))->GetVal();
   }
   else
     AliWarning("V0C beam-gas flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");

   // Now retrieve the channel information: charge smaples + time and 
   // dump it into ADC and Time arrays
   Int_t nEntries = Int_t(digits->GetEntries());
   Short_t aADC[64][AliVZEROdigit::kNClocks];
   Float_t aTime[64];
   Float_t aWidth[64];
   Bool_t  aIntegrator[64];
   Bool_t  aBBflag[64];
   Bool_t  aBGflag[64];
  
   for (Int_t i = 0; i < nEntries; i++) {
     fVZERO->ResetDigits();
     digits->GetEvent(i);
     Int_t ndig = VZEROdigits->GetEntriesFast(); 
   
     if(ndig == 0) continue;
     for(Int_t k=0; k<ndig; k++){
         AliVZEROdigit* fVZERODigit = (AliVZEROdigit*) VZEROdigits->At(k);
         // Convert aliroot channel k into FEE channel iChannel before writing data
	 Int_t iChannel       = AliVZEROCalibData::GetBoardNumber(fVZERODigit->PMNumber()) * 8 +
	   AliVZEROCalibData::GetFEEChannelNumber(fVZERODigit->PMNumber());
	 for(Int_t iClock = 0; iClock < AliVZEROdigit::kNClocks; ++iClock) aADC[iChannel][iClock] = fVZERODigit->ChargeADC(iClock);
	 aTime[iChannel]      = fVZERODigit->Time();
	 aWidth[iChannel]     = fVZERODigit->Width();
	 aIntegrator[iChannel]= fVZERODigit->Integrator();
	 if(fVZERODigit->PMNumber() < 32) {
	   aBBflag[iChannel] = (aBBflagsV0C >> fVZERODigit->PMNumber()) & 0x1;
	   aBGflag[iChannel] = (aBGflagsV0C >> fVZERODigit->PMNumber()) & 0x1;
	 }
	 else {
	   aBBflag[iChannel] = (aBBflagsV0A >> (fVZERODigit->PMNumber()-32)) & 0x1;
	   aBGflag[iChannel] = (aBGflagsV0A >> (fVZERODigit->PMNumber()-32)) & 0x1;
	 }
         AliDebug(1,Form("DDL: %s\tdigit number: %d\tPM number: %d\tADC: %d\tTime: %f",
			 fileName,k,fVZERODigit->PMNumber(),aADC[iChannel][AliVZEROdigit::kNClocks/2],aTime[iChannel])); 
     }        
   }

   // Now fill raw data
          
   for (Int_t  iCIU = 0; iCIU < 8; iCIU++) { 
 
   // decoding of one Channel Interface Unit numbered iCIU - there are 8 channels per CIU (and 8 CIUs) :
  
      for(Int_t iChannel_Offset = iCIU*8; iChannel_Offset < (iCIU*8)+8; iChannel_Offset=iChannel_Offset+4) { 
         for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
             buffer->WriteChannel(iChannel, aADC[iChannel], aIntegrator[iChannel]);       
         }
         buffer->WriteBeamFlags(&aBBflag[iChannel_Offset],&aBGflag[iChannel_Offset]); 
         buffer->WriteMBInfo(); 
         buffer->WriteMBFlags();   
         buffer->WriteBeamScalers(); 
      } 

      for(Int_t iChannel = iCIU*8 + 7; iChannel >= iCIU*8; iChannel--) {
          buffer->WriteTiming(aTime[iChannel], aWidth[iChannel]); 
      }

    // End of decoding of one CIU card
    
  } // end of decoding the eight CIUs
     
  delete buffer;
  fLoader->UnloadDigits();  
}

//_____________________________________________________________________________
Bool_t AliVZERO::Raw2SDigits(AliRawReader* rawReader){
  // Converts the VZERO raw data into digits
  // The method is used for merging simulated and
  // real data events
  TStopwatch timer;
  timer.Start();

  if(!fLoader) {
    AliError("no VZERO loader found");
    return kFALSE;
  }
  fLoader->LoadSDigits("UPDATE");

  if (!fLoader->TreeS()) fLoader->MakeTree("S");
  fLoader->MakeSDigitsContainer();
  TTree* treeS  = fLoader->TreeS();

  TClonesArray *sdigits = new TClonesArray("AliVZEROSDigit", 64);
  treeS->Branch("VZEROSDigit", &sdigits); 

  {
    rawReader->Reset();
    AliVZERORawStream rawStream(rawReader);    
     
    if (!rawStream.Next()) return kFALSE; // No VZERO data found

    GetCalibData();

    Int_t nSDigits = 0;
    Float_t *charges = NULL;
    Int_t nbins = 0;
    for(Int_t iChannel=0; iChannel < 64; ++iChannel) {
      Int_t offlineCh = rawStream.GetOfflineChannel(iChannel);
      Short_t chargeADC[AliVZEROdigit::kNClocks];
      for(Int_t iClock=0; iClock < AliVZEROdigit::kNClocks; ++iClock) {
	chargeADC[iClock] = rawStream.GetPedestal(iChannel,iClock);
      }
      // Integrator flag
      Bool_t integrator = rawStream.GetIntegratorFlag(iChannel,AliVZEROdigit::kNClocks/2);
      // HPTDC data (leading time and width)
      Int_t board = AliVZEROCalibData::GetBoardNumber(offlineCh);
      Float_t time = rawStream.GetTime(iChannel)*fCalibData->GetTimeResolution(board);
      //      Float_t width = rawStream.GetWidth(iChannel)*fCalibData->GetWidthResolution(board);
      Float_t adc = 0;

      // Pedestal retrieval and suppression
      Float_t maxadc = 0;
      Int_t imax = -1;
      Float_t adcPedSub[AliVZEROdigit::kNClocks];
      Float_t integral = fSignalShape->Integral(0,200);
      for(Int_t iClock=0; iClock < AliVZEROdigit::kNClocks; ++iClock) {
	Bool_t iIntegrator = (iClock%2 == 0) ? integrator : !integrator;
	Int_t k = offlineCh + 64*iIntegrator;
	adcPedSub[iClock] = (Float_t)chargeADC[iClock] - fCalibData->GetPedestal(k);
	if(adcPedSub[iClock] <= fRecoParam->GetNSigmaPed()*fCalibData->GetSigma(k)) {
	  adcPedSub[iClock] = 0;
	  continue;
	}
	if(iClock < fRecoParam->GetStartClock() || iClock > fRecoParam->GetEndClock()) continue;
	if(adcPedSub[iClock] > maxadc) {
	  maxadc = adcPedSub[iClock];
	  imax   = iClock;
	}
      }
      if (imax != -1) {
	Int_t start = imax - fRecoParam->GetNPreClocks();
	if (start < 0) start = 0;
	Int_t end = imax + fRecoParam->GetNPostClocks();
	if (end > 20) end = 20;
	for(Int_t iClock = start; iClock <= end; iClock++) {
	  adc += adcPedSub[iClock];
	}
      }
      Float_t correctedTime = CorrectLeadingTime(offlineCh,time,adc);

      if (!charges) {
	nbins = fNBins[offlineCh];
	charges = new Float_t[nbins];
      }
      else if (nbins != fNBins[offlineCh]) {
	delete [] charges;
	nbins = fNBins[offlineCh];
	charges = new Float_t[nbins];
      }
      memset(charges,0,nbins*sizeof(Float_t));

      // Now lets produce SDigit
      if ((correctedTime > (AliVZEROReconstructor::kInvalidTime + 1e-6)) &&
	  (adc > 1e-6)) {
	for(Int_t iBin = 0; iBin < nbins; ++iBin) {
	  Float_t t = fBinSize[offlineCh]*Float_t(iBin);
	  if ((t < correctedTime) ||
	      (t > (correctedTime+200.))) continue;
	  charges[iBin] = kChargePerADC*adc*(fSignalShape->Eval(t-correctedTime)*fBinSize[offlineCh]/integral);
	}
      }

      TClonesArray &sdigitsref = *sdigits;  
      new (sdigitsref[nSDigits++]) AliVZEROSDigit(offlineCh,fNBins[offlineCh],charges);
    }
    if (charges) delete [] charges;
  }
  
  treeS->Fill();
  fLoader->WriteSDigits("OVERWRITE");
  fLoader->UnloadSDigits();	
	
  timer.Stop();
  timer.Print();
  return kTRUE;
}

//_____________________________________________________________________________
void AliVZERO::GetCalibData()
{
  // Gets calibration object for VZERO set
  // Do nothing in case it is already loaded
  if (fCalibData) return;

  AliCDBEntry *entry = AliCDBManager::Instance()->Get("VZERO/Calib/Data");
  if (entry) fCalibData = (AliVZEROCalibData*) entry->GetObject();
  if (!fCalibData)  AliFatal("No calibration data from calibration database !");

  AliCDBEntry *entry2 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeSlewing");
  if (!entry2) AliFatal("VZERO time slewing function is not found in OCDB !");
  fTimeSlewing = (TF1*)entry2->GetObject();

  for(Int_t i = 0 ; i < 64; ++i) {
    Int_t board = AliVZEROCalibData::GetBoardNumber(i);
    fNBins[i] = TMath::Nint(((Float_t)(fCalibData->GetMatchWindow(board)+1)*25.0+
			     (Float_t)kMaxTDCWidth*fCalibData->GetWidthResolution(board))/
			    fCalibData->GetTimeResolution(board));
    fBinSize[i] = fCalibData->GetTimeResolution(board);
  }

  fSignalShape = new TF1("VZEROSDigitSignalShape",this,&AliVZERO::SignalShape,0,200,6,"AliVZERO","SignalShape");
  fSignalShape->SetParameters(0,1.57345e1,-4.25603e-1,
			      2.9,6.40982,3.69339e-01);

  fRecoParam = new AliVZERORecoParam;

  return;
}

Float_t AliVZERO::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const
{
  // Correct the leading time
  // for slewing effect and
  // misalignment of the channels
  if (time < 1e-6) return -1024;

  // In case of pathological signals
  if (adc < 1e-6) return time;

  // Slewing correction
  Float_t thr = fCalibData->GetCalibDiscriThr(i,kTRUE);
  time -= fTimeSlewing->Eval(adc/thr);

  return time;
}

double AliVZERO::SignalShape(double *x, double *par)
{
  // this function simulates the signal
  // shape used in Raw->SDigits method

  Double_t xx = x[0];
  if (xx <= par[0]) return 0;
  Double_t a = 1./TMath::Power((xx-par[0])/par[1],1./par[2]);
  if (xx <= par[3]) return a;
  Double_t b = 1./TMath::Power((xx-par[3])/par[4],1./par[5]);
  Double_t f = a*b/(a+b);
  AliDebug(100,Form("x=%f func=%f",xx,f));
  return f;
}
Commit	Line	Data
47890cd3	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
88cb7938	16	/* $Id$ */
47890cd3	17
	18	///////////////////////////////////////////////////////////////////////////
	19	// //
	20	// V-Zero Detector //
	21	// This class contains the base procedures for the VZERO detector //
b0d2c2d3	22	// Default geometry of November 2003 : V0R box is 4.4 cm thick //
b0d2c2d3	23	// scintillators are 2 cm thick //
47890cd3	24	// All comments should be sent to Brigitte CHEYNIS : //
61874e87	25	// b.cheynis@ipnl.in2p3.fr //
61874e87	26	// //
47890cd3	27	// //
	28	///////////////////////////////////////////////////////////////////////////
	29
88cb7938	30
b2501ea3	31	// --- Standard libraries ---
3af027ba	32	#include <Riostream.h>
b0d2c2d3	33	#include <stdlib.h>
47890cd3	34
b2501ea3	35	// --- ROOT libraries ---
b2501ea3	36	#include <TNamed.h>
b0d2c2d3	37	#include "TROOT.h"
	38	#include "TFile.h"
	39	#include "TNetFile.h"
	40	#include "TRandom.h"
	41	#include "TTree.h"
	42	#include "TBranch.h"
	43	#include "TClonesArray.h"
	44	#include "TStopwatch.h"
b6fd9c4a	45	#include "TParameter.h"
0984ee9d	46	#include "TF1.h"
b2501ea3	47
	48	// --- AliRoot header files ---
	49	#include "AliRun.h"
	50	#include "AliMC.h"
47890cd3	51	#include "AliVZERO.h"
b2501ea3	52	#include "AliVZEROLoader.h"
b0d2c2d3	53	#include "AliVZERODigitizer.h"
	54	#include "AliVZEROBuffer.h"
	55	#include "AliRunDigitizer.h"
	56	#include "AliVZEROdigit.h"
0984ee9d	57	#include "AliVZEROSDigit.h"
362c9d61	58	#include "AliDAQ.h"
20a489c2	59	#include "AliRawReader.h"
0984ee9d	60	#include "AliCDBManager.h"
0984ee9d	61	#include "AliCDBEntry.h"
20a489c2	62	#include "AliVZERORawStream.h"
b6fd9c4a	63	#include "AliVZEROCalibData.h"
0984ee9d	64	#include "AliVZERORecoParam.h"
0984ee9d	65	#include "AliVZEROReconstructor.h"
47890cd3	66
47890cd3	67	ClassImp(AliVZERO)
0b2bea8b	68	//__________________________________________________________________
	69	AliVZERO::AliVZERO(): AliDetector(),
	70	fIdSens1(0),
	71	fThickness(0.),
	72	fThickness1(0.),
	73	fMaxStepQua(0.),
	74	fMaxStepAlu(0.),
	75	fMaxDestepQua(0.),
0984ee9d	76	fMaxDestepAlu(0.),
	77	fCalibData(NULL),
	78	fTimeSlewing(NULL),
	79	fSignalShape(NULL),
	80	fRecoParam(NULL)
0b2bea8b	81	{
	82	/// Default Constructor
	83
	84	AliDebug(1,Form("default (empty) ctor this=%p",this));
0984ee9d	85	fIshunt = 0;
	86
	87	for(Int_t i = 0 ; i < 64; ++i) {
	88	fNBins[i] = 0;
	89	fBinSize[i] = 0;
	90	}
0b2bea8b	91	}
0984ee9d	92
47890cd3	93	//_____________________________________________________________________________
47890cd3	94	AliVZERO::AliVZERO(const char name, const char title)
0b2bea8b	95	: AliDetector(name,title),
	96	fIdSens1(0),
	97	fThickness(4.4),
	98	fThickness1(2.0),
	99	fMaxStepQua(0.05),
	100	fMaxStepAlu(0.01),
	101	fMaxDestepQua(-1.0),
0984ee9d	102	fMaxDestepAlu(-1.0),
	103	fCalibData(NULL),
	104	fTimeSlewing(NULL),
	105	fSignalShape(NULL),
	106	fRecoParam(NULL)
47890cd3	107	{
0b2bea8b	108
47890cd3	109	// Standard constructor for VZERO Detector
0b2bea8b	110
0b2bea8b	111	AliDebug(1,Form("ctor this=%p",this));
47890cd3	112
b0d2c2d3	113	// fIshunt = 1; // All hits are associated with primary particles
47890cd3	114
61874e87	115	fHits = new TClonesArray("AliVZEROhit", 400);
	116	fDigits = new TClonesArray("AliVZEROdigit",400);
	117
5d12ce38	118	gAlice->GetMCApp()->AddHitList(fHits);
61874e87	119
0b2bea8b	120	// fThickness = 4.4; // total thickness of the V0R box in cm
	121	// fThickness1 = 2.0; // thickness of scintillating cells in cm
	122	//
	123	// fMaxStepQua = 0.05;
	124	// fMaxStepAlu = 0.01;
	125	//
	126	// fMaxDestepQua = -1.0;
	127	// fMaxDestepAlu = -1.0;
47890cd3	128
0984ee9d	129	for(Int_t i = 0 ; i < 64; ++i) {
	130	fNBins[i] = 0;
	131	fBinSize[i] = 0;
	132	}
61874e87	133	}
	134
	135	//_____________________________________________________________________________
	136	AliVZERO::~AliVZERO()
	137	{
b2501ea3	138	//
	139	// Default destructor for VZERO Detector
	140	//
	141
61874e87	142	if (fHits) {
	143	fHits->Delete();
	144	delete fHits;
b0d2c2d3	145	fHits=0; }
b2501ea3	146
	147	if (fDigits) {
	148	fDigits->Delete();
	149	delete fDigits;
b0d2c2d3	150	fDigits=0; }
0984ee9d	151	if (fSignalShape) {
	152	delete fSignalShape;
	153	fSignalShape = NULL;
	154	}
	155	if (fRecoParam) {
	156	delete fRecoParam;
	157	fRecoParam = NULL;
	158	}
61874e87	159	}
47890cd3	160
47890cd3	161	//_____________________________________________________________________________
	162	void AliVZERO::CreateGeometry()
	163	{
	164	//
b2501ea3	165	// Builds simple Geant3 geometry
47890cd3	166	//
	167	}
	168	//_____________________________________________________________________________
	169	void AliVZERO::CreateMaterials()
	170	{
	171	//
b2501ea3	172	// Creates materials used for Geant3 geometry
47890cd3	173	//
47890cd3	174	}
61874e87	175
47890cd3	176	//_____________________________________________________________________________
47890cd3	177	void AliVZERO::Init()
	178	{
	179	//
b2501ea3	180	// Initialises the VZERO class after it has been built
47890cd3	181	//
	182	}
	183
61874e87	184
b2501ea3	185	//_____________________________________________________________________________
47890cd3	186	void AliVZERO::SetMaxStepQua(Float_t p1)
47890cd3	187	{
b2501ea3	188	//
	189	// Possible parametrisation of steps in active materials
	190	//
47890cd3	191	fMaxStepQua = p1;
	192	}
	193
b2501ea3	194	//_____________________________________________________________________________
47890cd3	195	void AliVZERO::SetMaxStepAlu(Float_t p1)
47890cd3	196	{
b2501ea3	197	//
	198	// Possible parametrisation of steps in Aluminum foils (not used in
	199	// version v2)
	200	//
47890cd3	201	fMaxStepAlu = p1;
	202	}
	203
b2501ea3	204	//_____________________________________________________________________________
47890cd3	205	void AliVZERO::SetMaxDestepQua(Float_t p1)
47890cd3	206	{
b2501ea3	207	//
	208	// Possible parametrisation of steps in active materials (quartz)
	209	//
47890cd3	210	fMaxDestepQua = p1;
	211	}
	212
b2501ea3	213	//_____________________________________________________________________________
47890cd3	214	void AliVZERO::SetMaxDestepAlu(Float_t p1)
47890cd3	215	{
b2501ea3	216	//
	217	// Possible parametrisation of steps in Aluminum (not used in
	218	// version v2)
	219	//
47890cd3	220	fMaxDestepAlu = p1;
47890cd3	221	}
4dbb3fd3	222
b2501ea3	223	//_____________________________________________________________________________
4dbb3fd3	224	AliLoader* AliVZERO::MakeLoader(const char* topfoldername)
4dbb3fd3	225	{
b2501ea3	226	//
b2501ea3	227	// Builds VZEROgetter (AliLoader type)
4dbb3fd3	228	// if detector wants to use customized getter, it must overload this method
b2501ea3	229	//
3e87825e	230	// Info("MakeLoader","Creating AliVZEROLoader. Top folder is %s.",topfoldername);
	231
	232	AliDebug(1,Form("Creating AliVZEROLoader, Top folder is %s ",topfoldername));
4dbb3fd3	233	fLoader = new AliVZEROLoader(GetName(),topfoldername);
	234	return fLoader;
	235	}
	236
b2501ea3	237	//_____________________________________________________________________________
	238	void AliVZERO::SetTreeAddress()
	239	{
b0d2c2d3	240	//
0e305a84	241	// Sets tree address for hits.
b2501ea3	242	//
0e305a84	243	if (fLoader->TreeH() && (fHits == 0x0))
	244	fHits = new TClonesArray("AliVZEROhit", 400);
	245
	246	AliDetector::SetTreeAddress();
	247	}
4dbb3fd3	248
b0d2c2d3	249	//_____________________________________________________________________________
	250	AliDigitizer* AliVZERO::CreateDigitizer(AliRunDigitizer* manager) const
	251	{
	252	//
	253	// Creates a digitizer for VZERO
	254	//
	255	return new AliVZERODigitizer(manager);
	256	}
	257
	258	//_____________________________________________________________________________
	259	void AliVZERO::Hits2Digits(){
	260	//
72da5ce8	261	// Converts hits to digits
b0d2c2d3	262	//
72da5ce8	263	// Creates the VZERO digitizer
72da5ce8	264	AliVZERODigitizer* dig = new AliVZERODigitizer(this,AliVZERODigitizer::kHits2Digits);
b0d2c2d3	265
72da5ce8	266	// Creates the digits
	267	dig->Exec("");
	268
3bc365d5	269	// deletes the digitizer
3bc365d5	270	delete dig;
72da5ce8	271	}
b0d2c2d3	272
72da5ce8	273	//_____________________________________________________________________________
	274	void AliVZERO::Hits2SDigits(){
	275	//
	276	// Converts hits to summable digits
	277	//
b0d2c2d3	278	// Creates the VZERO digitizer
72da5ce8	279	AliVZERODigitizer* dig = new AliVZERODigitizer(this,AliVZERODigitizer::kHits2SDigits);
b0d2c2d3	280
72da5ce8	281	// Creates the sdigits
b0d2c2d3	282	dig->Exec("");
b0d2c2d3	283
3bc365d5	284	// deletes the digitizer
3bc365d5	285	delete dig;
b0d2c2d3	286	}
72da5ce8	287
b0d2c2d3	288	//_____________________________________________________________________________
	289	void AliVZERO::Digits2Raw()
	290	{
c4f89fd4	291	//
	292	// Converts digits of the current event to raw data
	293	//
b0d2c2d3	294
c4f89fd4	295	AliVZERO fVZERO = (AliVZERO)gAlice->GetDetector("VZERO");
	296	fLoader->LoadDigits();
	297	TTree* digits = fLoader->TreeD();
	298	if (!digits) {
	299	Error("Digits2Raw", "no digits tree");
	300	return;
	301	}
	302	TClonesArray * VZEROdigits = new TClonesArray("AliVZEROdigit",1000);
	303	fVZERO->SetTreeAddress();
	304	digits->GetBranch("VZERODigit")->SetAddress(&VZEROdigits);
b0d2c2d3	305
c4f89fd4	306	const char *fileName = AliDAQ::DdlFileName("VZERO",0);
c4f89fd4	307	AliVZEROBuffer* buffer = new AliVZEROBuffer(fileName);
b0d2c2d3	308
c4f89fd4	309	// Get Trigger information first
	310	// Read trigger inputs from trigger-detector object
	311	AliDataLoader * dataLoader = fLoader->GetDigitsDataLoader();
	312	if( !dataLoader->IsFileOpen() )
	313	dataLoader->OpenFile( "READ" );
	314	AliTriggerDetector* trgdet = (AliTriggerDetector*)dataLoader->GetDirectory()->Get( "Trigger" );
	315	UInt_t triggerInfo = 0;
	316	if(trgdet) {
	317	triggerInfo = trgdet->GetMask() & 0xffff;
	318	}
	319	else {
	320	AliError(Form("There is no trigger object for %s",fLoader->GetName()));
	321	}
b0d2c2d3	322
c4f89fd4	323	buffer->WriteTriggerInfo((UInt_t)triggerInfo);
	324	buffer->WriteTriggerScalers();
	325	buffer->WriteBunchNumbers();
	326
b6fd9c4a	327	Int_t aBBflagsV0A = 0;
	328	Int_t aBBflagsV0C = 0;
	329	Int_t aBGflagsV0A = 0;
	330	Int_t aBGflagsV0C = 0;
	331
	332	if (digits->GetUserInfo()->FindObject("BBflagsV0A")) {
	333	aBBflagsV0A = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BBflagsV0A"))->GetVal();
	334	}
	335	else
	336	AliWarning("V0A beam-beam flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
	337
	338	if (digits->GetUserInfo()->FindObject("BBflagsV0C")) {
	339	aBBflagsV0C = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BBflagsV0C"))->GetVal();
	340	}
	341	else
	342	AliWarning("V0C beam-beam flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
726d762c	343
b6fd9c4a	344	if (digits->GetUserInfo()->FindObject("BGflagsV0A")) {
	345	aBGflagsV0A = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BGflagsV0A"))->GetVal();
	346	}
	347	else
	348	AliWarning("V0A beam-gas flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
	349
	350	if (digits->GetUserInfo()->FindObject("BGflagsV0C")) {
	351	aBGflagsV0C = ((TParameter<int>*)digits->GetUserInfo()->FindObject("BGflagsV0C"))->GetVal();
	352	}
	353	else
	354	AliWarning("V0C beam-gas flags not found in digits tree UserInfo! The flags will not be written to the raw-data stream!");
	355
	356	// Now retrieve the channel information: charge smaples + time and
	357	// dump it into ADC and Time arrays
c4f89fd4	358	Int_t nEntries = Int_t(digits->GetEntries());
b6fd9c4a	359	Short_t aADC[64][AliVZEROdigit::kNClocks];
	360	Float_t aTime[64];
	361	Float_t aWidth[64];
	362	Bool_t aIntegrator[64];
	363	Bool_t aBBflag[64];
	364	Bool_t aBGflag[64];
b0d2c2d3	365
c4f89fd4	366	for (Int_t i = 0; i < nEntries; i++) {
	367	fVZERO->ResetDigits();
	368	digits->GetEvent(i);
	369	Int_t ndig = VZEROdigits->GetEntriesFast();
b0d2c2d3	370
c4f89fd4	371	if(ndig == 0) continue;
c4f89fd4	372	for(Int_t k=0; k<ndig; k++){
7c786908	373	AliVZEROdigit* fVZERODigit = (AliVZEROdigit*) VZEROdigits->At(k);
7c786908	374	// Convert aliroot channel k into FEE channel iChannel before writing data
b6fd9c4a	375	Int_t iChannel = AliVZEROCalibData::GetBoardNumber(fVZERODigit->PMNumber()) * 8 +
	376	AliVZEROCalibData::GetFEEChannelNumber(fVZERODigit->PMNumber());
	377	for(Int_t iClock = 0; iClock < AliVZEROdigit::kNClocks; ++iClock) aADC[iChannel][iClock] = fVZERODigit->ChargeADC(iClock);
	378	aTime[iChannel] = fVZERODigit->Time();
	379	aWidth[iChannel] = fVZERODigit->Width();
	380	aIntegrator[iChannel]= fVZERODigit->Integrator();
	381	if(fVZERODigit->PMNumber() < 32) {
	382	aBBflag[iChannel] = (aBBflagsV0C >> fVZERODigit->PMNumber()) & 0x1;
	383	aBGflag[iChannel] = (aBGflagsV0C >> fVZERODigit->PMNumber()) & 0x1;
	384	}
	385	else {
	386	aBBflag[iChannel] = (aBBflagsV0A >> (fVZERODigit->PMNumber()-32)) & 0x1;
	387	aBGflag[iChannel] = (aBGflagsV0A >> (fVZERODigit->PMNumber()-32)) & 0x1;
	388	}
55a7359d	389	AliDebug(1,Form("DDL: %s\tdigit number: %d\tPM number: %d\tADC: %d\tTime: %f",
58d2283f	390	fileName,k,fVZERODigit->PMNumber(),aADC[iChannel][AliVZEROdigit::kNClocks/2],aTime[iChannel]));
c4f89fd4	391	}
c4f89fd4	392	}
b0d2c2d3	393
c4f89fd4	394	// Now fill raw data
	395
	396	for (Int_t iCIU = 0; iCIU < 8; iCIU++) {
	397
	398	// decoding of one Channel Interface Unit numbered iCIU - there are 8 channels per CIU (and 8 CIUs) :
	399
	400	for(Int_t iChannel_Offset = iCIU8; iChannel_Offset < (iCIU8)+8; iChannel_Offset=iChannel_Offset+4) {
	401	for(Int_t iChannel = iChannel_Offset; iChannel < iChannel_Offset+4; iChannel++) {
b6fd9c4a	402	buffer->WriteChannel(iChannel, aADC[iChannel], aIntegrator[iChannel]);
c4f89fd4	403	}
b6fd9c4a	404	buffer->WriteBeamFlags(&aBBflag[iChannel_Offset],&aBGflag[iChannel_Offset]);
c4f89fd4	405	buffer->WriteMBInfo();
	406	buffer->WriteMBFlags();
	407	buffer->WriteBeamScalers();
	408	}
b6fd9c4a	409
	410	for(Int_t iChannel = iCIU8 + 7; iChannel >= iCIU8; iChannel--) {
	411	buffer->WriteTiming(aTime[iChannel], aWidth[iChannel]);
c4f89fd4	412	}
726d762c	413
c4f89fd4	414	// End of decoding of one CIU card
	415
	416	} // end of decoding the eight CIUs
	417
b0d2c2d3	418	delete buffer;
c4f89fd4	419	fLoader->UnloadDigits();
b0d2c2d3	420	}
b0d2c2d3	421
20a489c2	422	//_____________________________________________________________________________
	423	Bool_t AliVZERO::Raw2SDigits(AliRawReader* rawReader){
	424	// Converts the VZERO raw data into digits
	425	// The method is used for merging simulated and
	426	// real data events
	427	TStopwatch timer;
	428	timer.Start();
	429
	430	if(!fLoader) {
	431	AliError("no VZERO loader found");
0984ee9d	432	return kFALSE;
	433	}
	434	fLoader->LoadSDigits("UPDATE");
20a489c2	435
0984ee9d	436	if (!fLoader->TreeS()) fLoader->MakeTree("S");
	437	fLoader->MakeSDigitsContainer();
	438	TTree* treeS = fLoader->TreeS();
	439
	440	TClonesArray *sdigits = new TClonesArray("AliVZEROSDigit", 64);
	441	treeS->Branch("VZEROSDigit", &sdigits);
	442
	443	{
	444	rawReader->Reset();
	445	AliVZERORawStream rawStream(rawReader);
20a489c2	446
0984ee9d	447	if (!rawStream.Next()) return kFALSE; // No VZERO data found
	448
	449	GetCalibData();
	450
	451	Int_t nSDigits = 0;
	452	Float_t *charges = NULL;
	453	Int_t nbins = 0;
	454	for(Int_t iChannel=0; iChannel < 64; ++iChannel) {
	455	Int_t offlineCh = rawStream.GetOfflineChannel(iChannel);
	456	Short_t chargeADC[AliVZEROdigit::kNClocks];
	457	for(Int_t iClock=0; iClock < AliVZEROdigit::kNClocks; ++iClock) {
	458	chargeADC[iClock] = rawStream.GetPedestal(iChannel,iClock);
	459	}
	460	// Integrator flag
	461	Bool_t integrator = rawStream.GetIntegratorFlag(iChannel,AliVZEROdigit::kNClocks/2);
	462	// HPTDC data (leading time and width)
	463	Int_t board = AliVZEROCalibData::GetBoardNumber(offlineCh);
	464	Float_t time = rawStream.GetTime(iChannel)*fCalibData->GetTimeResolution(board);
	465	// Float_t width = rawStream.GetWidth(iChannel)*fCalibData->GetWidthResolution(board);
	466	Float_t adc = 0;
	467
	468	// Pedestal retrieval and suppression
	469	Float_t maxadc = 0;
	470	Int_t imax = -1;
	471	Float_t adcPedSub[AliVZEROdigit::kNClocks];
	472	Float_t integral = fSignalShape->Integral(0,200);
	473	for(Int_t iClock=0; iClock < AliVZEROdigit::kNClocks; ++iClock) {
	474	Bool_t iIntegrator = (iClock%2 == 0) ? integrator : !integrator;
	475	Int_t k = offlineCh + 64*iIntegrator;
	476	adcPedSub[iClock] = (Float_t)chargeADC[iClock] - fCalibData->GetPedestal(k);
	477	if(adcPedSub[iClock] <= fRecoParam->GetNSigmaPed()*fCalibData->GetSigma(k)) {
	478	adcPedSub[iClock] = 0;
	479	continue;
	480	}
	481	if(iClock < fRecoParam->GetStartClock() \|\| iClock > fRecoParam->GetEndClock()) continue;
	482	if(adcPedSub[iClock] > maxadc) {
	483	maxadc = adcPedSub[iClock];
	484	imax = iClock;
	485	}
	486	}
	487	if (imax != -1) {
	488	Int_t start = imax - fRecoParam->GetNPreClocks();
	489	if (start < 0) start = 0;
	490	Int_t end = imax + fRecoParam->GetNPostClocks();
	491	if (end > 20) end = 20;
	492	for(Int_t iClock = start; iClock <= end; iClock++) {
	493	adc += adcPedSub[iClock];
	494	}
	495	}
	496	Float_t correctedTime = CorrectLeadingTime(offlineCh,time,adc);
	497
	498	if (!charges) {
	499	nbins = fNBins[offlineCh];
	500	charges = new Float_t[nbins];
	501	}
	502	else if (nbins != fNBins[offlineCh]) {
	503	delete [] charges;
	504	nbins = fNBins[offlineCh];
	505	charges = new Float_t[nbins];
	506	}
	507	memset(charges,0,nbins*sizeof(Float_t));
	508
	509	// Now lets produce SDigit
	510	if ((correctedTime > (AliVZEROReconstructor::kInvalidTime + 1e-6)) &&
511	(adc > 1e-6)) {
512	for(Int_t iBin = 0; iBin < nbins; ++iBin) {
513	Float_t t = fBinSize[offlineCh]*Float_t(iBin);
514	if ((t < correctedTime) \|\|
515	(t > (correctedTime+200.))) continue;
516	charges[iBin] = kChargePerADCadc(fSignalShape->Eval(t-correctedTime)*fBinSize[offlineCh]/integral);
517	}
518	}
519
520	TClonesArray &sdigitsref = *sdigits;
521	new (sdigitsref[nSDigits++]) AliVZEROSDigit(offlineCh,fNBins[offlineCh],charges);
522	}
523	if (charges) delete [] charges;
524	}
20a489c2	525
0984ee9d	526	treeS->Fill();
	527	fLoader->WriteSDigits("OVERWRITE");
	528	fLoader->UnloadSDigits();
20a489c2	529
20a489c2	530	timer.Stop();
20a489c2	531	timer.Print();
c61a7285	532	return kTRUE;
20a489c2	533	}
20a489c2	534
0984ee9d	535	//_____________________________________________________________________________
	536	void AliVZERO::GetCalibData()
	537	{
	538	// Gets calibration object for VZERO set
	539	// Do nothing in case it is already loaded
	540	if (fCalibData) return;
	541
	542	AliCDBEntry *entry = AliCDBManager::Instance()->Get("VZERO/Calib/Data");
	543	if (entry) fCalibData = (AliVZEROCalibData*) entry->GetObject();
	544	if (!fCalibData) AliFatal("No calibration data from calibration database !");
	545
	546	AliCDBEntry *entry2 = AliCDBManager::Instance()->Get("VZERO/Calib/TimeSlewing");
	547	if (!entry2) AliFatal("VZERO time slewing function is not found in OCDB !");
	548	fTimeSlewing = (TF1*)entry2->GetObject();
	549
	550	for(Int_t i = 0 ; i < 64; ++i) {
	551	Int_t board = AliVZEROCalibData::GetBoardNumber(i);
	552	fNBins[i] = TMath::Nint(((Float_t)(fCalibData->GetMatchWindow(board)+1)*25.0+
	553	(Float_t)kMaxTDCWidth*fCalibData->GetWidthResolution(board))/
	554	fCalibData->GetTimeResolution(board));
	555	fBinSize[i] = fCalibData->GetTimeResolution(board);
	556	}
	557
	558	fSignalShape = new TF1("VZEROSDigitSignalShape",this,&AliVZERO::SignalShape,0,200,6,"AliVZERO","SignalShape");
	559	fSignalShape->SetParameters(0,1.57345e1,-4.25603e-1,
	560	2.9,6.40982,3.69339e-01);
	561
	562	fRecoParam = new AliVZERORecoParam;
	563
	564	return;
	565	}
	566
	567	Float_t AliVZERO::CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const
	568	{
	569	// Correct the leading time
	570	// for slewing effect and
	571	// misalignment of the channels
	572	if (time < 1e-6) return -1024;
	573
	574	// In case of pathological signals
	575	if (adc < 1e-6) return time;
	576
	577	// Slewing correction
b0eaf826	578	Float_t thr = fCalibData->GetCalibDiscriThr(i,kTRUE);
0984ee9d	579	time -= fTimeSlewing->Eval(adc/thr);
4dbb3fd3	580
0984ee9d	581	return time;
	582	}
	583
	584	double AliVZERO::SignalShape(double x, double par)
	585	{
	586	// this function simulates the signal
	587	// shape used in Raw->SDigits method
	588
	589	Double_t xx = x[0];
	590	if (xx <= par[0]) return 0;
	591	Double_t a = 1./TMath::Power((xx-par[0])/par[1],1./par[2]);
	592	if (xx <= par[3]) return a;
	593	Double_t b = 1./TMath::Power((xx-par[3])/par[4],1./par[5]);
	594	Double_t f = a*b/(a+b);
	595	AliDebug(100,Form("x=%f func=%f",xx,f));
	596	return f;
	597	}