[u/mrichter/AliRoot.git] / TPC / AliTPCDigitizer.cxx

/**************************************************************************
 * Copyright(c) 1998-2000, 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$ */

#include <stdlib.h>
#include <TTree.h> 
#include <TObjArray.h>
#include <TFile.h>
#include <TDirectory.h>
#include <Riostream.h>

#include "AliTPCDigitizer.h"

#include "AliTPC.h"
#include "AliTPCParam.h"
#include "AliTPCParamSR.h" 
#include "AliRun.h"
#include "AliPDG.h"
#include "AliRunDigitizer.h"
#include "AliSimDigits.h"


ClassImp(AliTPCDigitizer)

//___________________________________________
AliTPCDigitizer::AliTPCDigitizer() :AliDigitizer()
{
// Default ctor - don't use it
  fDebug =0;
}

//___________________________________________
AliTPCDigitizer::AliTPCDigitizer(AliRunDigitizer* manager) 
    :AliDigitizer(manager)
{
// ctor which should be used
  fDebug =0;
  if (GetDebug()>2) 
    cerr<<"AliTPCDigitizer::AliTPCDigitizer"
       <<"(AliRunDigitizer* manager) was processed"<<endl;
}

//------------------------------------------------------------------------
AliTPCDigitizer::~AliTPCDigitizer()
{
// Destructor
}


//------------------------------------------------------------------------
Bool_t AliTPCDigitizer::Init()
{
// Initialization 
    
 return kTRUE;
}


//------------------------------------------------------------------------
void AliTPCDigitizer::Exec(Option_t* option)
{
  ExecFast(option);  
}
//------------------------------------------------------------------------
void AliTPCDigitizer::ExecFast(Option_t* option)
{
  
  // merge input tree's with summable digits
  //output stored in TreeTPCD
  char s[100]; 
  char ss[100];
  TString optionString = option;
  if (optionString.Data() == "deb") {
    cout<<"AliTPCDigitizer::Exec: called with option deb "<<endl;
    fDebug = 3;
  }
  //get detector and geometry


  AliRunLoader *rl, *orl;
  AliLoader *gime, *ogime;
  
  if (gAlice == 0x0)
   {
     Warning("ExecFast","gAlice is NULL. Loading from input 0");
     rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
     if (rl == 0x0)
      {
        Error("ExecFast","Can not find Run Loader for input 0. Can not proceed.");
        return;
      }
     rl->LoadgAlice();
     rl->GetAliRun();
   }
  AliTPC *pTPC  = (AliTPC *) gAlice->GetModule("TPC");
  AliTPCParam * param = pTPC->GetParam();
  
  sprintf(s,param->GetTitle());
  sprintf(ss,"75x40_100x60");
  if(strcmp(s,ss)==0){
    printf("2 pad-length geom hits with 3 pad-lenght geom digits...\n");
    delete param;
    param=new AliTPCParamSR();
  }
  else{
   sprintf(ss,"75x40_100x60_150x60");
   if(strcmp(s,ss)!=0) {
     printf("No TPC parameters found...\n");
     exit(2); 
   }
  }
  
  pTPC->GenerNoise(500000); //create teble with noise
  //
  Int_t nInputs = fManager->GetNinputs();
  Int_t * masks = new Int_t[nInputs];
  for (Int_t i=0; i<nInputs;i++)
    masks[i]= fManager->GetMask(i);
  Short_t **pdig= new Short_t*[nInputs];   //pointers to the expanded digits array
  Int_t **ptr=  new Int_t*[nInputs];       //pointers to teh expanded tracks array
  Bool_t *active=  new Bool_t[nInputs];    //flag for active input segments

  
  //create digits array for given sectors
  // make indexes
  
  AliSimDigits ** digarr = new AliSimDigits*[nInputs]; 
  for (Int_t i1=0;i1<nInputs; i1++)
    {
      digarr[i1]=0;
     //    intree[i1]
      rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i1));
      gime = rl->GetLoader("TPCLoader");
      gime->LoadSDigits("read");
      TTree * treear =  gime->TreeS();
     
      if (!treear) 
       {
        cerr<<"AliTPCDigitizer: Input tree with SDigits not found in"
            <<" input "<< i1<<endl;
        return;
       }
    
      if (treear->GetIndex()==0)  
	treear->BuildIndex("fSegmentID","fSegmentID");
      treear->GetBranch("Segment")->SetAddress(&digarr[i1]);
    }


  //create branch's in TPC treeD
  AliSimDigits * digrow = new AliSimDigits;

  orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
  ogime = orl->GetLoader("TPCLoader");
  
  TTree * tree  = ogime->TreeD();
  if (tree == 0x0)
   {
     ogime->MakeTree("D");
     tree  = ogime->TreeD();
   }
  tree->Branch("Segment","AliSimDigits",&digrow);
  //

  param->SetZeroSup(2);

  Int_t zerosup = param->GetZeroSup(); 
  //
  //Loop over segments of the TPC
    
  for (Int_t segmentID=0; segmentID<param->GetNRowsTotal(); segmentID++) 
   {
    Int_t sec, row;
    if (!param->AdjustSectorRow(segmentID,sec,row)) 
     {
      cerr<<"AliTPC warning: invalid segment ID ! "<<segmentID<<endl;
      continue;
     }

    digrow->SetID(segmentID);

    Int_t nrows = 0;
    Int_t ncols = 0;

    Bool_t digitize = kFALSE;
    for (Int_t i=0;i<nInputs; i++) 
     { 

      rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i));
      gime = rl->GetLoader("TPCLoader");
      
      if (gime->TreeS()->GetEntryWithIndex(segmentID,segmentID) >= 0) {
	digarr[i]->ExpandBuffer();
	digarr[i]->ExpandTrackBuffer();
        nrows = digarr[i]->GetNRows();
        ncols = digarr[i]->GetNCols();
	active[i] = kTRUE;
	if (!fRegionOfInterest || (i == 0)) digitize = kTRUE;
      } else {
	active[i] = kFALSE;
      }
      if (fRegionOfInterest && !digitize) break;
     }   
    if (!digitize) continue;

    digrow->Allocate(nrows,ncols);
    digrow->AllocateTrack(3);

    Float_t q=0;
    Int_t label[1000]; //stack for 300 events 
    Int_t labptr = 0;

    Int_t nElems = nrows*ncols;     
 
    for (Int_t i=0;i<nInputs; i++)
     if (active[i]) { 
       pdig[i] = digarr[i]->GetDigits();
       ptr[i]  = digarr[i]->GetTracks();
      }
     
    Short_t *pdig1= digrow->GetDigits();
    Int_t   *ptr1= digrow->GetTracks() ;

    
    for (Int_t elem=0;elem<nElems; elem++)
     {    

       q=0;
       labptr=0;
       // looop over digits 
        for (Int_t i=0;i<nInputs; i++) if (active[i]) 
         { 
          //          q  += digarr[i]->GetDigitFast(rows,col);
            q  += *(pdig[i]);
         
           for (Int_t tr=0;tr<3;tr++) 
            {
             //             Int_t lab = digarr[i]->GetTrackIDFast(rows,col,tr);
             Int_t lab = ptr[i][tr*nElems];
             if ( (lab > 1) && *(pdig[i])>zerosup) 
              {
                label[labptr]=lab+masks[i];
                labptr++;
              }          
            }
           pdig[i]++;
           ptr[i]++;
         }
        q/=16.;  //conversion factor
        //       Float_t noise  = gRandom->Gaus(0,param->GetNoise()*param->GetNoiseNormFac());  
        Float_t noise  = pTPC->GetNoise();
        q+=noise;
        q=TMath::Nint(q);
        if (q > zerosup)
         { 
          if(q > param->GetADCSat()) q = (Short_t)(param->GetADCSat());
          //digrow->SetDigitFast((Short_t)q,rows,col);  
          *pdig1 =Short_t(q);
          for (Int_t tr=0;tr<3;tr++)
           {
            if (tr<labptr) 
             ptr1[tr*nElems] = label[tr];
           }
          }
        pdig1++;
        ptr1++;
     }
    
    digrow->CompresBuffer(1,zerosup);
    digrow->CompresTrackBuffer(1);
    tree->Fill();
    if (fDebug>0) cerr<<sec<<"\t"<<row<<"\n";  
   } //for (Int_t n=0; n<param->GetNRowsTotal(); n++) 
  

  orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
  ogime = orl->GetLoader("TPCLoader");
  ogime->WriteDigits("OVERWRITE");
  
  //fManager->GetTreeDTPC()->Write(0,TObject::kOverwrite);
  
  delete digrow;     
  for (Int_t i1=0;i1<nInputs; i1++) delete digarr[i1];
  delete []masks;
  delete []pdig;
  delete []ptr;
  delete []active;
  delete []digarr;  
}


//------------------------------------------------------------------------
void AliTPCDigitizer::ExecSave(Option_t* option)
{
  
  // merge input tree's with summable digits
  //output stored in TreeTPCD

  TString optionString = option;
  if (optionString.Data() == "deb") {
    cout<<"AliTPCDigitizer::Exec: called with option deb "<<endl;
    fDebug = 3;
  }
  //get detector and geometry 
  AliRunLoader *rl, *orl;
  AliLoader *gime, *ogime;

  
  orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
  ogime = orl->GetLoader("TPCLoader");
  
  rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
  gime = rl->GetLoader("TPCLoader");
  
  rl->LoadgAlice();
  AliRun* alirun = rl->GetAliRun();
  
  AliTPC *pTPC  = (AliTPC *) alirun->GetModule("TPC");
  AliTPCParam * param = pTPC->GetParam();
  pTPC->GenerNoise(500000); //create teble with noise
  printf("noise %f \n",  param->GetNoise()*param->GetNoiseNormFac());
  //
  Int_t nInputs = fManager->GetNinputs();
  Int_t * masks = new Int_t[nInputs];
  for (Int_t i=0; i<nInputs;i++)
    masks[i]= fManager->GetMask(i);

  AliSimDigits ** digarr = new AliSimDigits*[nInputs]; 
  for (Int_t i1=0;i1<nInputs; i1++)
   {
    digarr[i1]=0;
    //    intree[i1]
    rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i1));
    gime = rl->GetLoader("TPCLoader");

    TTree * treear =  gime->TreeS();
    TBranch * br = treear->GetBranch("fSegmentID");
    if (br) br->GetFile()->cd();
    if (!treear) {      
      cerr<<" TPC -  not existing input = \n"<<i1<<" ";      
    } 
    treear->GetBranch("Segment")->SetAddress(&digarr[i1]);
  }
  
  rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
  gime = rl->GetLoader("TPCLoader");
  Stat_t nentries = gime->TreeS()->GetEntries();
  

  //create branch's in TPC treeD
  AliSimDigits * digrow = new AliSimDigits;
  TTree * tree  = ogime->TreeD();

  tree->Branch("Segment","AliSimDigits",&digrow);
  param->SetZeroSup(2);

  Int_t zerosup = param->GetZeroSup();
  //Loop over segments of the TPC
    
  for (Int_t n=0; n<nentries; n++) {
    rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
    gime = rl->GetLoader("TPCLoader");
    gime->TreeS()->GetEvent(n);

    digarr[0]->ExpandBuffer();
    digarr[0]->ExpandTrackBuffer();
           
    for (Int_t i=1;i<nInputs; i++){ 
//      fManager->GetInputTreeTPCS(i)->GetEntryWithIndex(digarr[0]->GetID(),digarr[0]->GetID());      
      rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i));
      gime = rl->GetLoader("TPCLoader");
      gime->TreeS()->GetEntryWithIndex(digarr[0]->GetID(),digarr[0]->GetID());  
      digarr[i]->ExpandBuffer();
      digarr[i]->ExpandTrackBuffer();
      if ((digarr[0]->GetID()-digarr[i]->GetID())>0) 
       printf("problem\n");
    
    }   
    
    Int_t sec, row;
    if (!param->AdjustSectorRow(digarr[0]->GetID(),sec,row)) {
      cerr<<"AliTPC warning: invalid segment ID ! "<<digarr[0]->GetID()<<endl;
      continue;
    }

    digrow->SetID(digarr[0]->GetID());

    Int_t nrows = digarr[0]->GetNRows();
    Int_t ncols = digarr[0]->GetNCols();
    digrow->Allocate(nrows,ncols);
    digrow->AllocateTrack(3);

    Float_t q=0;
    Int_t label[1000]; //stack for 300 events 
    Int_t labptr = 0;

    
    for (Int_t rows=0;rows<nrows; rows++){
      for (Int_t col=0;col<ncols; col++){
    
       q=0;
       labptr=0;
       // looop over digits 
        for (Int_t i=0;i<nInputs; i++){ 
         q  += digarr[i]->GetDigitFast(rows,col);
          //q  += *(pdig[i]);
         
          for (Int_t tr=0;tr<3;tr++) {
           Int_t lab = digarr[i]->GetTrackIDFast(rows,col,tr);
           //Int_t lab = ptr[i][tr*nElems];
            if ( (lab > 1) ) {
              label[labptr]=lab+masks[i];
              labptr++;
            }          
          }
         // pdig[i]++;
         //ptr[i]++;
         
        }
       q/=16.;  //conversion factor
       //       Float_t noise  = gRandom->Gaus(0,param->GetNoise()*param->GetNoiseNormFac());  
       Float_t noise  = pTPC->GetNoise();
       q+=noise;
        q=TMath::Nint(q);
        if (q > zerosup){ 
         
         if(q > param->GetADCSat()) q = (Short_t)(param->GetADCSat());
         digrow->SetDigitFast((Short_t)q,rows,col);  
         // *pdig1 =Short_t(q);
         for (Int_t tr=0;tr<3;tr++){
           if (tr<labptr) 
             ((AliSimDigits*)digrow)->SetTrackIDFast(label[tr],rows,col,tr);
           //ptr1[tr*nElems] = label[tr];
           //else
             //           ((AliSimDigits*)digrow)->SetTrackIDFast(-1,rows,col,tr);          
           //  ptr1[tr*nElems] = 1;
         }
       }
       //pdig1++;
       //ptr1++;
    }
    }
    
    digrow->CompresBuffer(1,zerosup);
    digrow->CompresTrackBuffer(1);
    tree->Fill();
    if (fDebug>0) cerr<<sec<<"\t"<<row<<"\n";  
  } 
//  printf("end TPC merging - end -Tree %s\t%p\n",fManager->GetInputTreeH(0)->GetName(),fManager->GetInputTreeH(0)->GetListOfBranches()->At(3));
  //fManager->GetTreeDTPC()->Write(0,TObject::kOverwrite);
    ogime->WriteDigits("OVERWRITE");

    for (Int_t i=1;i<nInputs; i++) 
     { 
      rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i));
      gime = rl->GetLoader("TPCLoader");
      gime->UnloadSDigits();
     }
    ogime->UnloadDigits();
    
  delete digrow;     
  for (Int_t i1=0;i1<nInputs; i1++) delete digarr[i1];
  delete []masks;
  delete digarr;  
}
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 1998-2000, 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$ */
	17
	18	#include <stdlib.h>
	19	#include <TTree.h>
	20	#include <TObjArray.h>
	21	#include <TFile.h>
	22	#include <TDirectory.h>
	23	#include <Riostream.h>
	24
	25	#include "AliTPCDigitizer.h"
	26
	27	#include "AliTPC.h"
	28	#include "AliTPCParam.h"
	29	#include "AliTPCParamSR.h"
	30	#include "AliRun.h"
	31	#include "AliPDG.h"
	32	#include "AliRunDigitizer.h"
	33	#include "AliSimDigits.h"
	34
	35
	36	ClassImp(AliTPCDigitizer)
	37
	38	//___________________________________________
	39	AliTPCDigitizer::AliTPCDigitizer() :AliDigitizer()
	40	{
	41	// Default ctor - don't use it
	42	fDebug =0;
	43	}
	44
	45	//___________________________________________
	46	AliTPCDigitizer::AliTPCDigitizer(AliRunDigitizer* manager)
	47	:AliDigitizer(manager)
	48	{
	49	// ctor which should be used
	50	fDebug =0;
	51	if (GetDebug()>2)
	52	cerr<<"AliTPCDigitizer::AliTPCDigitizer"
	53	<<"(AliRunDigitizer* manager) was processed"<<endl;
	54	}
	55
	56	//------------------------------------------------------------------------
	57	AliTPCDigitizer::~AliTPCDigitizer()
	58	{
	59	// Destructor
	60	}
	61
	62
	63
	64	//------------------------------------------------------------------------
	65	Bool_t AliTPCDigitizer::Init()
	66	{
	67	// Initialization
	68
	69	return kTRUE;
	70	}
	71
	72
	73	//------------------------------------------------------------------------
	74	void AliTPCDigitizer::Exec(Option_t* option)
	75	{
	76	ExecFast(option);
	77	}
	78	//------------------------------------------------------------------------
	79	void AliTPCDigitizer::ExecFast(Option_t* option)
	80	{
	81
	82	// merge input tree's with summable digits
	83	//output stored in TreeTPCD
	84	char s[100];
	85	char ss[100];
	86	TString optionString = option;
	87	if (optionString.Data() == "deb") {
	88	cout<<"AliTPCDigitizer::Exec: called with option deb "<<endl;
	89	fDebug = 3;
	90	}
	91	//get detector and geometry
	92
	93
	94	AliRunLoader rl, orl;
	95	AliLoader gime, ogime;
	96
	97	if (gAlice == 0x0)
	98	{
	99	Warning("ExecFast","gAlice is NULL. Loading from input 0");
	100	rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
	101	if (rl == 0x0)
	102	{
	103	Error("ExecFast","Can not find Run Loader for input 0. Can not proceed.");
	104	return;
	105	}
	106	rl->LoadgAlice();
	107	rl->GetAliRun();
	108	}
	109	AliTPC pTPC = (AliTPC ) gAlice->GetModule("TPC");
	110	AliTPCParam * param = pTPC->GetParam();
	111
	112	sprintf(s,param->GetTitle());
	113	sprintf(ss,"75x40_100x60");
	114	if(strcmp(s,ss)==0){
	115	printf("2 pad-length geom hits with 3 pad-lenght geom digits...\n");
	116	delete param;
	117	param=new AliTPCParamSR();
	118	}
	119	else{
	120	sprintf(ss,"75x40_100x60_150x60");
	121	if(strcmp(s,ss)!=0) {
	122	printf("No TPC parameters found...\n");
	123	exit(2);
	124	}
	125	}
	126
	127	pTPC->GenerNoise(500000); //create teble with noise
	128	//
	129	Int_t nInputs = fManager->GetNinputs();
	130	Int_t * masks = new Int_t[nInputs];
	131	for (Int_t i=0; i<nInputs;i++)
	132	masks[i]= fManager->GetMask(i);
	133	Short_t *pdig= new Short_t[nInputs]; //pointers to the expanded digits array
	134	Int_t *ptr= new Int_t[nInputs]; //pointers to teh expanded tracks array
	135	Bool_t *active= new Bool_t[nInputs]; //flag for active input segments
	136
	137
	138	//create digits array for given sectors
	139	// make indexes
	140
	141	AliSimDigits ** digarr = new AliSimDigits*[nInputs];
	142	for (Int_t i1=0;i1<nInputs; i1++)
	143	{
	144	digarr[i1]=0;
	145	// intree[i1]
	146	rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i1));
	147	gime = rl->GetLoader("TPCLoader");
	148	gime->LoadSDigits("read");
	149	TTree * treear = gime->TreeS();
	150
	151	if (!treear)
	152	{
	153	cerr<<"AliTPCDigitizer: Input tree with SDigits not found in"
	154	<<" input "<< i1<<endl;
	155	return;
	156	}
	157
	158	if (treear->GetIndex()==0)
	159	treear->BuildIndex("fSegmentID","fSegmentID");
	160	treear->GetBranch("Segment")->SetAddress(&digarr[i1]);
	161	}
	162
	163
	164	//create branch's in TPC treeD
	165	AliSimDigits * digrow = new AliSimDigits;
	166
	167	orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
	168	ogime = orl->GetLoader("TPCLoader");
	169
	170	TTree * tree = ogime->TreeD();
	171	if (tree == 0x0)
	172	{
	173	ogime->MakeTree("D");
	174	tree = ogime->TreeD();
	175	}
	176	tree->Branch("Segment","AliSimDigits",&digrow);
	177	//
	178
	179	param->SetZeroSup(2);
	180
	181	Int_t zerosup = param->GetZeroSup();
	182	//
	183	//Loop over segments of the TPC
	184
	185	for (Int_t segmentID=0; segmentID<param->GetNRowsTotal(); segmentID++)
	186	{
	187	Int_t sec, row;
	188	if (!param->AdjustSectorRow(segmentID,sec,row))
	189	{
	190	cerr<<"AliTPC warning: invalid segment ID ! "<<segmentID<<endl;
	191	continue;
	192	}
	193
	194	digrow->SetID(segmentID);
	195
	196	Int_t nrows = 0;
	197	Int_t ncols = 0;
	198
	199	Bool_t digitize = kFALSE;
	200	for (Int_t i=0;i<nInputs; i++)
	201	{
	202
	203	rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i));
	204	gime = rl->GetLoader("TPCLoader");
	205
	206	if (gime->TreeS()->GetEntryWithIndex(segmentID,segmentID) >= 0) {
	207	digarr[i]->ExpandBuffer();
	208	digarr[i]->ExpandTrackBuffer();
	209	nrows = digarr[i]->GetNRows();
	210	ncols = digarr[i]->GetNCols();
	211	active[i] = kTRUE;
	212	if (!fRegionOfInterest \|\| (i == 0)) digitize = kTRUE;
	213	} else {
	214	active[i] = kFALSE;
	215	}
	216	if (fRegionOfInterest && !digitize) break;
	217	}
	218	if (!digitize) continue;
	219
	220	digrow->Allocate(nrows,ncols);
	221	digrow->AllocateTrack(3);
	222
	223	Float_t q=0;
	224	Int_t label[1000]; //stack for 300 events
	225	Int_t labptr = 0;
	226
	227	Int_t nElems = nrows*ncols;
	228
	229	for (Int_t i=0;i<nInputs; i++)
	230	if (active[i]) {
	231	pdig[i] = digarr[i]->GetDigits();
	232	ptr[i] = digarr[i]->GetTracks();
	233	}
	234
	235	Short_t *pdig1= digrow->GetDigits();
	236	Int_t *ptr1= digrow->GetTracks() ;
	237
	238
	239
	240	for (Int_t elem=0;elem<nElems; elem++)
	241	{
	242
	243	q=0;
	244	labptr=0;
	245	// looop over digits
	246	for (Int_t i=0;i<nInputs; i++) if (active[i])
	247	{
	248	// q += digarr[i]->GetDigitFast(rows,col);
	249	q += *(pdig[i]);
	250
	251	for (Int_t tr=0;tr<3;tr++)
	252	{
	253	// Int_t lab = digarr[i]->GetTrackIDFast(rows,col,tr);
	254	Int_t lab = ptr[i][tr*nElems];
	255	if ( (lab > 1) && *(pdig[i])>zerosup)
	256	{
	257	label[labptr]=lab+masks[i];
	258	labptr++;
	259	}
	260	}
	261	pdig[i]++;
	262	ptr[i]++;
	263	}
	264	q/=16.; //conversion factor
	265	// Float_t noise = gRandom->Gaus(0,param->GetNoise()*param->GetNoiseNormFac());
	266	Float_t noise = pTPC->GetNoise();
	267	q+=noise;
	268	q=TMath::Nint(q);
	269	if (q > zerosup)
	270	{
	271	if(q > param->GetADCSat()) q = (Short_t)(param->GetADCSat());
	272	//digrow->SetDigitFast((Short_t)q,rows,col);
	273	*pdig1 =Short_t(q);
	274	for (Int_t tr=0;tr<3;tr++)
	275	{
	276	if (tr<labptr)
	277	ptr1[tr*nElems] = label[tr];
	278	}
	279	}
	280	pdig1++;
	281	ptr1++;
	282	}
	283
	284	digrow->CompresBuffer(1,zerosup);
	285	digrow->CompresTrackBuffer(1);
	286	tree->Fill();
	287	if (fDebug>0) cerr<<sec<<"\t"<<row<<"\n";
	288	} //for (Int_t n=0; n<param->GetNRowsTotal(); n++)
	289
	290
	291	orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
	292	ogime = orl->GetLoader("TPCLoader");
	293	ogime->WriteDigits("OVERWRITE");
	294
	295	//fManager->GetTreeDTPC()->Write(0,TObject::kOverwrite);
	296
	297	delete digrow;
	298	for (Int_t i1=0;i1<nInputs; i1++) delete digarr[i1];
	299	delete []masks;
	300	delete []pdig;
	301	delete []ptr;
	302	delete []active;
	303	delete []digarr;
	304	}
	305
	306
	307
	308	//------------------------------------------------------------------------
	309	void AliTPCDigitizer::ExecSave(Option_t* option)
	310	{
	311
	312	// merge input tree's with summable digits
	313	//output stored in TreeTPCD
	314
	315	TString optionString = option;
	316	if (optionString.Data() == "deb") {
	317	cout<<"AliTPCDigitizer::Exec: called with option deb "<<endl;
	318	fDebug = 3;
	319	}
	320	//get detector and geometry
	321	AliRunLoader rl, orl;
	322	AliLoader gime, ogime;
	323
	324
	325	orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
	326	ogime = orl->GetLoader("TPCLoader");
	327
	328	rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
	329	gime = rl->GetLoader("TPCLoader");
	330
	331	rl->LoadgAlice();
	332	AliRun* alirun = rl->GetAliRun();
	333
	334	AliTPC pTPC = (AliTPC ) alirun->GetModule("TPC");
	335	AliTPCParam * param = pTPC->GetParam();
	336	pTPC->GenerNoise(500000); //create teble with noise
	337	printf("noise %f \n", param->GetNoise()*param->GetNoiseNormFac());
	338	//
	339	Int_t nInputs = fManager->GetNinputs();
	340	Int_t * masks = new Int_t[nInputs];
	341	for (Int_t i=0; i<nInputs;i++)
	342	masks[i]= fManager->GetMask(i);
	343
	344	AliSimDigits ** digarr = new AliSimDigits*[nInputs];
	345	for (Int_t i1=0;i1<nInputs; i1++)
	346	{
	347	digarr[i1]=0;
	348	// intree[i1]
	349	rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i1));
	350	gime = rl->GetLoader("TPCLoader");
	351
	352	TTree * treear = gime->TreeS();
	353	TBranch * br = treear->GetBranch("fSegmentID");
	354	if (br) br->GetFile()->cd();
	355	if (!treear) {
	356	cerr<<" TPC - not existing input = \n"<<i1<<" ";
	357	}
	358	treear->GetBranch("Segment")->SetAddress(&digarr[i1]);
	359	}
	360
	361	rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
	362	gime = rl->GetLoader("TPCLoader");
	363	Stat_t nentries = gime->TreeS()->GetEntries();
	364
	365
	366	//create branch's in TPC treeD
	367	AliSimDigits * digrow = new AliSimDigits;
	368	TTree * tree = ogime->TreeD();
	369
	370	tree->Branch("Segment","AliSimDigits",&digrow);
	371	param->SetZeroSup(2);
	372
	373	Int_t zerosup = param->GetZeroSup();
	374	//Loop over segments of the TPC
	375
	376	for (Int_t n=0; n<nentries; n++) {
	377	rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
	378	gime = rl->GetLoader("TPCLoader");
	379	gime->TreeS()->GetEvent(n);
	380
	381	digarr[0]->ExpandBuffer();
	382	digarr[0]->ExpandTrackBuffer();
	383
	384	for (Int_t i=1;i<nInputs; i++){
	385	// fManager->GetInputTreeTPCS(i)->GetEntryWithIndex(digarr[0]->GetID(),digarr[0]->GetID());
	386	rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i));
	387	gime = rl->GetLoader("TPCLoader");
	388	gime->TreeS()->GetEntryWithIndex(digarr[0]->GetID(),digarr[0]->GetID());
	389	digarr[i]->ExpandBuffer();
	390	digarr[i]->ExpandTrackBuffer();
	391	if ((digarr[0]->GetID()-digarr[i]->GetID())>0)
	392	printf("problem\n");
	393
	394	}
	395
	396	Int_t sec, row;
	397	if (!param->AdjustSectorRow(digarr[0]->GetID(),sec,row)) {
	398	cerr<<"AliTPC warning: invalid segment ID ! "<<digarr[0]->GetID()<<endl;
	399	continue;
	400	}
	401
	402	digrow->SetID(digarr[0]->GetID());
	403
	404	Int_t nrows = digarr[0]->GetNRows();
	405	Int_t ncols = digarr[0]->GetNCols();
	406	digrow->Allocate(nrows,ncols);
	407	digrow->AllocateTrack(3);
	408
	409	Float_t q=0;
	410	Int_t label[1000]; //stack for 300 events
	411	Int_t labptr = 0;
	412
	413
	414
	415	for (Int_t rows=0;rows<nrows; rows++){
	416	for (Int_t col=0;col<ncols; col++){
	417
	418	q=0;
	419	labptr=0;
	420	// looop over digits
	421	for (Int_t i=0;i<nInputs; i++){
	422	q += digarr[i]->GetDigitFast(rows,col);
	423	//q += *(pdig[i]);
	424
	425	for (Int_t tr=0;tr<3;tr++) {
	426	Int_t lab = digarr[i]->GetTrackIDFast(rows,col,tr);
	427	//Int_t lab = ptr[i][tr*nElems];
	428	if ( (lab > 1) ) {
	429	label[labptr]=lab+masks[i];
	430	labptr++;
	431	}
	432	}
	433	// pdig[i]++;
	434	//ptr[i]++;
	435
	436	}
	437	q/=16.; //conversion factor
	438	// Float_t noise = gRandom->Gaus(0,param->GetNoise()*param->GetNoiseNormFac());
	439	Float_t noise = pTPC->GetNoise();
	440	q+=noise;
	441	q=TMath::Nint(q);
	442	if (q > zerosup){
	443
	444	if(q > param->GetADCSat()) q = (Short_t)(param->GetADCSat());
	445	digrow->SetDigitFast((Short_t)q,rows,col);
	446	// *pdig1 =Short_t(q);
	447	for (Int_t tr=0;tr<3;tr++){
	448	if (tr<labptr)
	449	((AliSimDigits*)digrow)->SetTrackIDFast(label[tr],rows,col,tr);
	450	//ptr1[tr*nElems] = label[tr];
	451	//else
	452	// ((AliSimDigits*)digrow)->SetTrackIDFast(-1,rows,col,tr);
	453	// ptr1[tr*nElems] = 1;
	454	}
	455	}
	456	//pdig1++;
	457	//ptr1++;
	458	}
	459	}
	460
	461	digrow->CompresBuffer(1,zerosup);
	462	digrow->CompresTrackBuffer(1);
	463	tree->Fill();
	464	if (fDebug>0) cerr<<sec<<"\t"<<row<<"\n";
	465	}
	466	// printf("end TPC merging - end -Tree %s\t%p\n",fManager->GetInputTreeH(0)->GetName(),fManager->GetInputTreeH(0)->GetListOfBranches()->At(3));
	467	//fManager->GetTreeDTPC()->Write(0,TObject::kOverwrite);
	468	ogime->WriteDigits("OVERWRITE");
	469
	470	for (Int_t i=1;i<nInputs; i++)
	471	{
	472	rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(i));
	473	gime = rl->GetLoader("TPCLoader");
	474	gime->UnloadSDigits();
	475	}
	476	ogime->UnloadDigits();
	477
	478	delete digrow;
	479	for (Int_t i1=0;i1<nInputs; i1++) delete digarr[i1];
	480	delete []masks;
	481	delete digarr;
	482	}