TrackerLevel2/src/TrkLevel1.cpp

/**
 * \file TrkLevel1.cpp
 * \author Elena Vannuccini
 */
#include <TrkLevel1.h>
#include <iostream>
using namespace std;
//......................................
// F77 routines
//......................................
extern "C" {
        
//      int readetaparam_(); 
    float cog_(int*,int*);
    float pfaeta_(int*,float*);
    float pfaeta2_(int*,float*);
    float pfaeta3_(int*,float*);
    float pfaeta4_(int*,float*);
        
}
//--------------------------------------
//
//
//--------------------------------------
TrkCluster::TrkCluster(){
        
//    cout << "TrkCluster::TrkCluster()"<<endl;
    view     = -1;
    maxs     = -1;
    indmax   = -1;
        
    CLlength = 0;
    clsignal = 0; 
    clsigma  = 0; 
    cladc    = 0; 
    clbad    = 0; 

};
//--------------------------------------
//
//
//--------------------------------------
TrkCluster::TrkCluster(const TrkCluster& t){
        
    view     = t.view;
    maxs     = t.maxs;
    indmax   = t.indmax;
        
    CLlength = t.CLlength;      
    if(CLlength){
        clsignal = new Float_t[CLlength];
        clsigma  = new Float_t[CLlength];
        cladc    = new Int_t[CLlength];
        clbad    = new Bool_t[CLlength];
        for(Int_t i=0; i<CLlength;i++){
            clsignal[i] = t.clsignal[i]; 
            clsigma[i]  = t.clsigma[i]; 
            cladc[i]    = t.cladc[i]; 
            clbad[i]    = t.clbad[i]; 
        };
    };
};
//--------------------------------------
//
//
//--------------------------------------
void TrkCluster::Clear(){
    
//    cout << "void TrkCluster::Clear()"<<endl;
    if(CLlength){
        delete [] clsignal; 
        delete [] clsigma; 
        delete [] cladc; 
        delete [] clbad; 
    }

    view     = 0;
    maxs     = 0;
    indmax   = 0;
        
    CLlength = 0;
    clsignal = 0; 
    clsigma  = 0; 
    cladc    = 0; 
    clbad    = 0; 

};
//--------------------------------------
//
//
//--------------------------------------
/**
 * Evaluate the cluster signal including a maximum number of adjacent 
 * strips, around maxs, having a significant signal. 
 * @param nstrip   Maximum number of strips.
 * @param cut      Inclusion cut ( s > cut*sigma ).
 * If nstrip<=0 only the inclusion cut is used to determine the cluster size.
 */
Float_t TrkCluster::GetSignal(Int_t nstrip, Float_t cut){
    
    if(CLlength<=0)return 0;

    Float_t s = 0;
    
    if( nstrip<=0 ){
//          for(Int_t is = 0; is < CLlength; is++){
//              Float_t scut = cut*clsigma[is];
//              if(clsignal[is] > scut) s += clsignal[is];
//          };
        for(Int_t is = indmax+1; is < CLlength; is++){
            Float_t scut = cut*clsigma[is];
            if(clsignal[is] > scut) s += clsignal[is];
            else break;
        };
        for(Int_t is = indmax; is >=0; is--){
            Float_t scut = cut*clsigma[is];
            if(clsignal[is] > scut) s += clsignal[is];
            else break;
        };
        return s;
    };
    
    
    Int_t il = indmax;
    Int_t ir = indmax;
    Int_t inc = 0;

    if( clsignal[indmax] < cut*clsigma[indmax] ) return 0;

    while ( inc < nstrip ){
        Float_t sl = -100000;
        Float_t sr = -100000;
        if( il >= 0       ) sl = clsignal[il];
        if( ir < CLlength ) sr = clsignal[ir];
        if( sl == sr && inc == 0 ){
            s += clsignal[il]; //cout << inc<<" - "<< clsignal[il]<<" "<<s<<endl;
            il--; 
            ir++;
        }else if ( sl >= sr && sl > cut*clsigma[il] && inc !=0 ){
            s += sl;//cout << inc<<" - "<< clsignal[il]<<" "<<s<<endl;
            il--; 
        }else if ( sl < sr && sr > cut*clsigma[ir] ){
            s += sr;//cout << inc<<" - " << clsignal[ir]<<" "<<s<<endl;
            ir++;
        }else break;
        
        inc++;
    }
    return s;
};


/**
 * Evaluate the cluster signal-to-noise, as defined by Turchetta, including a 
 * maximum number of adjacent strips, around maxs, having a significant signal. 
 * @param nstrip   Maximum number of strips.
 * @param cut      Inclusion cut ( s > cut*sigma ).
 * If nstrip<=0 only the inclusion cut is used to determine the cluster size.
 */
Float_t TrkCluster::GetSignalToNoise(Int_t nstrip, Float_t cut){
        
    if(CLlength<=0)return 0;

    Float_t sn = 0;
    
    if( nstrip<=0 ){
        for(Int_t is = indmax+1; is < CLlength; is++){
            Float_t scut = cut*clsigma[is];
            if(clsignal[is] > scut) sn += clsignal[is]/clsigma[is];
            else break;
        };
        for(Int_t is = indmax; is >=0; is--){
            Float_t scut = cut*clsigma[is];
            if(clsignal[is] > scut) sn += clsignal[is]/clsigma[is];
            else break;
        };
        return sn;
    };
    
    
    Int_t il = indmax;
    Int_t ir = indmax;
    Int_t inc = 0;

    if( clsignal[indmax] < cut*clsigma[indmax] ) return 0;

    while ( inc < nstrip ){
        Float_t sl = -100000;
        Float_t sr = -100000;
        if( il >= 0       ) sl = clsignal[il];
        if( ir < CLlength ) sr = clsignal[ir];
        if( sl == sr && inc == 0 ){
            sn += clsignal[il]/clsigma[il]; 
            il--; 
            ir++;
        }else if ( sl >= sr && sl > cut*clsigma[il] && inc !=0 ){
            sn += sl/clsigma[il];
            il--; 
        }else if ( sl < sr && sr > cut*clsigma[ir] ){
            sn += sr/clsigma[ir];
            ir++;
        }else break;
        
        inc++;
    }
    return sn;
};
/**
 * Evaluate the cluster multiplicity.
 * @param cut Inclusion cut.
 */
Int_t TrkCluster::GetMultiplicity(Float_t cut){

    if(CLlength<=0)return 0;

    Int_t m = 0;

    for(Int_t is = indmax+1; is < CLlength; is++){
        Float_t scut = cut*clsigma[is];
        if(clsignal[is] > scut) m++;
        else break;
    };
    for(Int_t is = indmax; is >=0; is--){
        Float_t scut = cut*clsigma[is];
        if(clsignal[is] > scut) m++;
        else break;
    };
    return m;
};
/**
 * True if the cluster contains bad strips.
 * @param nbad Number of strips around the maximum.
 */
Bool_t TrkCluster::IsBad(Int_t nbad){
                
    if(CLlength<=0)return 0;

    Int_t il,ir;
    il = indmax;
    ir = indmax;
    for(Int_t i=1; i<nbad; i++){
        if (ir == CLlength && il == 0)break;
        else if (ir == CLlength && il != 0)il--;
        else if (ir != CLlength && il == 0)ir++;
        else{
            if(clsignal[il-1] > clsignal[ir+1])il--;
            else ir++;
        }
    }
    Int_t isbad = 0;
    for(Int_t i=il; i<=ir; i++)isbad += clbad[i];
    
    return ( isbad != nbad );
};
/**
 * True if the cluster contains saturated strips.
 * @param nbad Number of strips around the maximum.
 */
Bool_t TrkCluster::IsSaturated(Int_t nbad){

    if(CLlength<=0)return 0;

    Int_t il,ir;
    il = indmax;
    ir = indmax;
    for(Int_t i=1; i<nbad; i++){
        if (ir == CLlength && il == 0)break;
        else if (ir == CLlength && il != 0)il--;
        else if (ir != CLlength && il == 0)ir++;
        else{
            if(clsignal[il-1] > clsignal[ir+1])il--;
            else ir++;
        }
    }
    Int_t isbad = 0;
    for(Int_t i=il; i<=ir; i++){
        if( IsX() && cladc[i] > 2980 )isbad++;
        if( IsY() && cladc[i] <   80 )isbad++;
    }
    return ( isbad != 0 );
    
}
//--------------------------------------
//
//
//--------------------------------------
void TrkCluster::Dump(){

    cout << "----- Cluster" << endl;
    cout << "View "<<view << " - Ladder "<<GetLadder()<<endl;
    cout << "Position of maximun "<< maxs <<endl;
    cout << "Multiplicity        "<< GetMultiplicity() <<endl;
    cout << "Tot signal          "<< GetSignal() << " (ADC channels)"<<endl ;
    cout << "Signal/Noise        "<< GetSignalToNoise();
    cout <<endl<< "Strip signals       ";
    for(Int_t i =0; i<CLlength; i++)cout << " " <<clsignal[i];
    cout <<endl<< "Strip sigmas        ";
    for(Int_t i =0; i<CLlength; i++)cout << " " <<clsigma[i];
    cout <<endl<< "Strip ADC           ";
    for(Int_t i =0; i<CLlength; i++)cout << " " <<cladc[i];
    cout <<endl<< "Strip BAD           ";
    for(Int_t i =0; i<CLlength; i++){
        if(i==indmax)cout << "  *" <<clbad[i]<<"*";
        else cout << " " <<clbad[i];
    }
    cout << endl;
        
}
//--------------------------------------
//
//
//--------------------------------------
/**
 * Method to fill a level1 struct with only one cluster (done to use F77 p.f.a. routines on a cluster basis). 
 */
cTrkLevel1* TrkCluster::GetLevel1Struct(){
                
//    cTrkLevel1* l1 = new cTrkLevel1;

    cTrkLevel1* l1 = &level1event_ ;
        
    l1->nclstr1 = 1;
    l1->view[0] = view;
    l1->ladder[0] = GetLadder();
    l1->maxs[0] = maxs;
    l1->mult[0] = GetMultiplicity();
    l1->dedx[0] = GetSignal();
    l1->indstart[0] = 1;
    l1->indmax[0]   = indmax+1;
    l1->totCLlength = CLlength;
    for(Int_t i=0; i<CLlength; i++){
        l1->clsignal[i] = clsignal[i];
        l1->clsigma[i] = clsigma[i];
        l1->cladc[i] = cladc[i];
        l1->clbad[i] = clbad[i];
    };
    
    return l1;
};
//--------------------------------------
//
//
//--------------------------------------
/**
 * Evaluates the Center-Of-Gravity (COG) of the cluster, in strips, relative to the strip with the maximum signal (TrkCluster::maxs).
 *      @param ncog Number of strips to evaluate COG.   
 * If ncog=0, the COG of the cluster is evaluated according to the cluster multiplicity (defined by the inclusion cut). 
 * If ncog>0, the COG is evaluated using ncog strips, even if they have a negative signal (according to G.Landi)
 */
Float_t TrkCluster::GetCOG(Int_t ncog){
        
    int ic = 1;
    GetLevel1Struct();
    return cog_(&ncog,&ic);
        
};
/**
 * Evaluates the Center-Of-Gravity (COG) of the cluster, in strips, relative to the strip with the maximum signal (TrkCluster::maxs), 
 * choosing the number of strips according to the angle, as implemented for the eta-algorythm .
 *      @param angle Projected angle in degree.         
 */
Float_t TrkCluster::GetCOG(Float_t angle){
            
    Int_t neta  = 0;

//     Float_t eta = GetETA(0,angle);
//     for(neta=2; neta<10; neta++) if( eta == GetETA(neta,angle) ) break;
//    if(eta != GetETA(neta,angle) )cout << "Attenzione!! pasticcio "<<endl;

    if( view%2 ){   //Y
        neta=2;
    }else{          //X
        if( fabs(angle) <= 10. ){
            neta = 2;
        }else if( fabs(angle) > 10. && fabs(angle) <= 15. ){
            neta = 3;
        }else{
            neta = 4;
        };
    };

    return GetCOG(neta);
        
};
//--------------------------------------
//
//
//--------------------------------------
/**
 * Evaluates the cluster position, in strips, relative to the strip with the maximum signal (TrkCluster::maxs), by applying the non-linear ETA-algorythm. 
 *  @param neta  Number of strips to evaluate ETA.
 *  @param angle Projected angle between particle track and detector plane.
 * Implemented values of neta are 2,3,4. If neta=0, ETA2, ETA3 and ETA4 are applied according to the angle.
 */
Float_t TrkCluster::GetETA(Int_t neta, float angle){
        
//    cout << "GetETA(neta,angle) "<< neta << " "<< angle;
//      LoadPfaParam();

    float ax = angle;
    int ic = 1;
    GetLevel1Struct();
    if(neta == 0)      return pfaeta_(&ic,&ax);
    else if(neta == 2) return pfaeta2_(&ic,&ax);
    else if(neta == 3) return pfaeta3_(&ic,&ax);
    else if(neta == 4) return pfaeta4_(&ic,&ax);
    else cout << "ETA"<<neta<<" not implemented\n";
    return 0;
    
};
 
//--------------------------------------
//
//
//--------------------------------------
TrkLevel1::TrkLevel1(){
        
//    cout << "TrkLevel1::TrkLevel1()"<<endl;
//    Cluster = new TClonesArray("TrkCluster");
    Cluster = 0;
    for(Int_t i=0; i<12 ; i++){
        good[i] = -1;
        for(Int_t j=0; j<24 ; j++){
            cn[j][i]=0;
            cnn[j][i]=0;
        };
    };
}
//--------------------------------------
//
//
//--------------------------------------
void TrkLevel1::Dump(){
    
    cout<<"DSP status: ";
    for(Int_t i=0; i<12 ; i++)cout<<good[i]<<" ";
    cout<<endl;
    cout<<"VA1 mask : "<<endl;
    for(Int_t i=0; i<12 ; i++){
        for(Int_t ii=0; ii<24 ; ii++){
            Int_t mask = cnn[ii][i];
            if(mask>0)mask=1;
            cout<<mask<<" ";
        }
        cout <<endl;
    }
    
    if(!Cluster)return;
    TClonesArray &t  = *Cluster;
    for(int i=0; i<this->nclstr(); i++)     ((TrkCluster *)t[i])->Dump();
    
}
//--------------------------------------
//
//
//--------------------------------------
/**
 * Fills a TrkLevel1 object with values from a struct cTrkLevel1 (to get data from F77 common).
 */
void TrkLevel1::SetFromLevel1Struct(cTrkLevel1 *l1, Bool_t full){

    //  ---------------
    //  *** CLUSTER ***
    //  ---------------
    TrkCluster* t_cl = new TrkCluster();
    if(!Cluster)Cluster = new TClonesArray("TrkCluster");
    TClonesArray &t = *Cluster;
    for(int i=0; i<l1->nclstr1; i++){

        t_cl->Clear();
//      if( full || (!full && l1->whichtrack[i]) ){
        
        t_cl->view     = l1->view[i];
        t_cl->maxs     = l1->maxs[i];

        if( full || (!full && l1->whichtrack[i]) ){
            t_cl->indmax   = l1->indmax[i] - l1->indstart[i];       
            Int_t from = l1->indstart[i] -1;
            Int_t to   = l1->totCLlength ;
            if(i != l1->nclstr1-1)to   = l1->indstart[i+1] -1 ;
            t_cl->CLlength = to - from ;
            
            t_cl->clsignal = new Float_t[t_cl->CLlength];
            t_cl->clsigma  = new Float_t[t_cl->CLlength];
            t_cl->cladc    = new Int_t[t_cl->CLlength];
            t_cl->clbad    = new Bool_t[t_cl->CLlength];
            Int_t index = 0;
            for(Int_t is = from; is < to; is++ ){
                t_cl->clsignal[index] = (Float_t) l1->clsignal[is];
                t_cl->clsigma[index]  = (Float_t) l1->clsigma[is];
                t_cl->cladc[index]    = (Int_t)   l1->cladc[is];
                t_cl->clbad[index]    = (Bool_t)  l1->clbad[is];
                index++;
            };
        }
        new(t[i]) TrkCluster(*t_cl); // <<< store cluster
    };
    
    delete t_cl;
    
    //  -------------------------
    //  ****general variables****
    //  -------------------------    
    for(Int_t i=0; i<12 ; i++){
        good[i] = l1->good[i];
        for(Int_t j=0; j<24 ; j++){
            cn[j][i]     = l1->cnev[j][i];
//          cnrms[j][i]  = l1->cnrmsev[j][i];
            cnn[j][i]    = l1->cnnev[j][i];
        };
    };
    
}
/**
 * Fills a struct cTrkLevel1 with values from a TrkLevel1 object (to put data into a F77 common).
 */

cTrkLevel1* TrkLevel1::GetLevel1Struct() {
        
    cTrkLevel1 *l1=0;
    //
    for(Int_t i=0; i<12 ; i++){
        l1->good[i] = good[i];
        for(Int_t j=0; j<24 ; j++){
            l1->cnev[j][i]    = cn[j][i];
//          l1->cnrmsev[j][i] = cnrms[j][i];
            l1->cnnev[j][i]   = cnn[j][i];
        };
    };
    
//  *** CLUSTERS ***
    if(Cluster){
        l1->nclstr1 =  Cluster->GetEntries();
        for(Int_t i=0;i<l1->nclstr1;i++){
        
            l1->view[i]     = ((TrkCluster *)Cluster->At(i))->view;
            l1->maxs[i]     = ((TrkCluster *)Cluster->At(i))->maxs;
            // COMPLETARE //
            // COMPLETARE //
            // COMPLETARE //
            // COMPLETARE //
            // COMPLETARE //
            // COMPLETARE //
        
        }
        // COMPLETARE //
        // COMPLETARE //
        // COMPLETARE //
        // COMPLETARE //
        // COMPLETARE //
        // COMPLETARE //
    }
    return l1;
}
//--------------------------------------
//
//
//--------------------------------------
void TrkLevel1::Clear(){
    
    for(Int_t i=0; i<12 ; i++){
        good[i] = -1;
        for(Int_t j=0; j<24 ; j++){
            cn[j][i]    = 0;
            cnn[j][i]   = 0;
        };
    };
//    if(Cluster)Cluster->Clear("C");
    if(Cluster)Cluster->Delete();
    
}
//--------------------------------------
//
//
//--------------------------------------
void TrkLevel1::Delete(){
    
//    Clear();
    if(Cluster)Cluster->Delete();
    if(Cluster)delete Cluster;
    
}
//--------------------------------------
//
//
//--------------------------------------
TrkCluster *TrkLevel1::GetCluster(int is){

    if(!Cluster)return 0;
    if(is >= nclstr()){
        cout << "** TrkLevel1::GetCluster(int) ** Cluster "<< is << " does not exits! " << endl; 
        cout << "( Stored clusters nclstr() = "<< this->nclstr()<<" )" << endl;
        return 0;
    }
    
    TClonesArray &t = *(Cluster);
    TrkCluster *cluster = (TrkCluster*)t[is];
    return cluster;
}
//--------------------------------------
//
//
//--------------------------------------
/**
 * Load Position-Finding-Algorythm parameters (call the F77 routine).
 * 
 */
int TrkLevel1::LoadPfaParam(TString path){
        
    if( strcmp(path_.path,path.Data()) ){
        cout <<"Loading p.f.a. param::eters\n";
        strcpy(path_.path,path.Data());
        path_.pathlen = path.Length();
        path_.error   = 0;
        return readetaparam_();
    }   
    return 0;
}


ClassImp(TrkLevel1);
ClassImp(TrkCluster);
1	pam-fi	1.1	/**
2			* \file TrkLevel1.cpp
3			* \author Elena Vannuccini
4			*/
5			#include <TrkLevel1.h>
6			#include <iostream>
7			using namespace std;
8	pam-fi	1.3	//......................................
9			// F77 routines
10			//......................................
11			extern "C" {
12
13			// int readetaparam_();
14	pam-fi	1.11	float cog_(int,int);
15			float pfaeta_(int,float);
16			float pfaeta2_(int,float);
17			float pfaeta3_(int,float);
18			float pfaeta4_(int,float);
19	pam-fi	1.3
20			}
21	pam-fi	1.1	//--------------------------------------
22			//
23			//
24			//--------------------------------------
25			TrkCluster::TrkCluster(){
26
27	pam-fi	1.11	// cout << "TrkCluster::TrkCluster()"<<endl;
28			view = -1;
29			maxs = -1;
30			indmax = -1;
31
32			CLlength = 0;
33			clsignal = 0;
34			clsigma = 0;
35			cladc = 0;
36			clbad = 0;
37	pam-fi	1.1
38			};
39			//--------------------------------------
40			//
41			//
42			//--------------------------------------
43			TrkCluster::TrkCluster(const TrkCluster& t){
44
45	pam-fi	1.11	view = t.view;
46			maxs = t.maxs;
47			indmax = t.indmax;
48
49			CLlength = t.CLlength;
50			if(CLlength){
51			clsignal = new Float_t[CLlength];
52			clsigma = new Float_t[CLlength];
53			cladc = new Int_t[CLlength];
54			clbad = new Bool_t[CLlength];
55			for(Int_t i=0; i<CLlength;i++){
56			clsignal[i] = t.clsignal[i];
57			clsigma[i] = t.clsigma[i];
58			cladc[i] = t.cladc[i];
59			clbad[i] = t.clbad[i];
60	pam-fi	1.1	};
61	pam-fi	1.11	};
62	pam-fi	1.10	};
63			//--------------------------------------
64			//
65			//
66			//--------------------------------------
67			void TrkCluster::Clear(){
68	pam-fi	1.11
69			// cout << "void TrkCluster::Clear()"<<endl;
70			if(CLlength){
71			delete [] clsignal;
72			delete [] clsigma;
73			delete [] cladc;
74			delete [] clbad;
75			}
76
77			view = 0;
78			maxs = 0;
79			indmax = 0;
80
81			CLlength = 0;
82			clsignal = 0;
83			clsigma = 0;
84			cladc = 0;
85			clbad = 0;
86	pam-fi	1.1
87			};
88			//--------------------------------------
89			//
90			//
91			//--------------------------------------
92	pam-fi	1.2	/**
93	pam-fi	1.5	* Evaluate the cluster signal including a maximum number of adjacent
94			* strips, around maxs, having a significant signal.
95			* @param nstrip Maximum number of strips.
96			* @param cut Inclusion cut ( s > cut*sigma ).
97			* If nstrip<=0 only the inclusion cut is used to determine the cluster size.
98	pam-fi	1.2	*/
99	pam-fi	1.5	Float_t TrkCluster::GetSignal(Int_t nstrip, Float_t cut){
100	pam-fi	1.11
101			if(CLlength<=0)return 0;
102
103	pam-fi	1.5	Float_t s = 0;
104
105			if( nstrip<=0 ){
106			// for(Int_t is = 0; is < CLlength; is++){
107			// Float_t scut = cut*clsigma[is];
108			// if(clsignal[is] > scut) s += clsignal[is];
109			// };
110			for(Int_t is = indmax+1; is < CLlength; is++){
111			Float_t scut = cut*clsigma[is];
112			if(clsignal[is] > scut) s += clsignal[is];
113			else break;
114			};
115			for(Int_t is = indmax; is >=0; is--){
116			Float_t scut = cut*clsigma[is];
117			if(clsignal[is] > scut) s += clsignal[is];
118			else break;
119	pam-fi	1.2	};
120			return s;
121	pam-fi	1.5	};
122
123
124			Int_t il = indmax;
125			Int_t ir = indmax;
126			Int_t inc = 0;
127
128			if( clsignal[indmax] < cut*clsigma[indmax] ) return 0;
129
130			while ( inc < nstrip ){
131			Float_t sl = -100000;
132			Float_t sr = -100000;
133			if( il >= 0 ) sl = clsignal[il];
134			if( ir < CLlength ) sr = clsignal[ir];
135			if( sl == sr && inc == 0 ){
136			s += clsignal[il]; //cout << inc<<" - "<< clsignal[il]<<" "<<s<<endl;
137			il--;
138			ir++;
139			}else if ( sl >= sr && sl > cut*clsigma[il] && inc !=0 ){
140			s += sl;//cout << inc<<" - "<< clsignal[il]<<" "<<s<<endl;
141			il--;
142			}else if ( sl < sr && sr > cut*clsigma[ir] ){
143			s += sr;//cout << inc<<" - " << clsignal[ir]<<" "<<s<<endl;
144			ir++;
145			}else break;
146
147			inc++;
148			}
149			return s;
150	pam-fi	1.2	};
151	pam-fi	1.5
152	pam-fi	1.11
153	pam-fi	1.2	/**
154	pam-fi	1.11	* Evaluate the cluster signal-to-noise, as defined by Turchetta, including a
155			* maximum number of adjacent strips, around maxs, having a significant signal.
156	pam-fi	1.5	* @param nstrip Maximum number of strips.
157			* @param cut Inclusion cut ( s > cut*sigma ).
158			* If nstrip<=0 only the inclusion cut is used to determine the cluster size.
159	pam-fi	1.3	*/
160	pam-fi	1.5	Float_t TrkCluster::GetSignalToNoise(Int_t nstrip, Float_t cut){
161	pam-fi	1.3
162	pam-fi	1.11	if(CLlength<=0)return 0;
163
164	pam-fi	1.5	Float_t sn = 0;
165
166			if( nstrip<=0 ){
167			for(Int_t is = indmax+1; is < CLlength; is++){
168			Float_t scut = cut*clsigma[is];
169			if(clsignal[is] > scut) sn += clsignal[is]/clsigma[is];
170			else break;
171			};
172			for(Int_t is = indmax; is >=0; is--){
173			Float_t scut = cut*clsigma[is];
174			if(clsignal[is] > scut) sn += clsignal[is]/clsigma[is];
175			else break;
176			};
177	pam-fi	1.3	return sn;
178	pam-fi	1.5	};
179
180
181			Int_t il = indmax;
182			Int_t ir = indmax;
183			Int_t inc = 0;
184
185			if( clsignal[indmax] < cut*clsigma[indmax] ) return 0;
186
187			while ( inc < nstrip ){
188			Float_t sl = -100000;
189			Float_t sr = -100000;
190			if( il >= 0 ) sl = clsignal[il];
191			if( ir < CLlength ) sr = clsignal[ir];
192			if( sl == sr && inc == 0 ){
193			sn += clsignal[il]/clsigma[il];
194			il--;
195			ir++;
196			}else if ( sl >= sr && sl > cut*clsigma[il] && inc !=0 ){
197			sn += sl/clsigma[il];
198			il--;
199			}else if ( sl < sr && sr > cut*clsigma[ir] ){
200			sn += sr/clsigma[ir];
201			ir++;
202			}else break;
203
204			inc++;
205			}
206			return sn;
207	pam-fi	1.3	};
208			/**
209	pam-fi	1.2	* Evaluate the cluster multiplicity.
210			* @param cut Inclusion cut.
211			*/
212			Int_t TrkCluster::GetMultiplicity(Float_t cut){
213	pam-fi	1.11
214			if(CLlength<=0)return 0;
215
216			Int_t m = 0;
217
218			for(Int_t is = indmax+1; is < CLlength; is++){
219			Float_t scut = cut*clsigma[is];
220			if(clsignal[is] > scut) m++;
221			else break;
222			};
223			for(Int_t is = indmax; is >=0; is--){
224			Float_t scut = cut*clsigma[is];
225			if(clsignal[is] > scut) m++;
226			else break;
227			};
228			return m;
229	pam-fi	1.2	};
230			/**
231			* True if the cluster contains bad strips.
232			* @param nbad Number of strips around the maximum.
233			*/
234			Bool_t TrkCluster::IsBad(Int_t nbad){
235	pam-fi	1.11
236			if(CLlength<=0)return 0;
237
238			Int_t il,ir;
239			il = indmax;
240			ir = indmax;
241			for(Int_t i=1; i<nbad; i++){
242			if (ir == CLlength && il == 0)break;
243			else if (ir == CLlength && il != 0)il--;
244			else if (ir != CLlength && il == 0)ir++;
245			else{
246			if(clsignal[il-1] > clsignal[ir+1])il--;
247			else ir++;
248	pam-fi	1.2	}
249	pam-fi	1.11	}
250			Int_t isbad = 0;
251			for(Int_t i=il; i<=ir; i++)isbad += clbad[i];
252
253			return ( isbad != nbad );
254	pam-fi	1.2	};
255	pam-fi	1.11	/**
256			* True if the cluster contains saturated strips.
257			* @param nbad Number of strips around the maximum.
258			*/
259			Bool_t TrkCluster::IsSaturated(Int_t nbad){
260
261			if(CLlength<=0)return 0;
262
263			Int_t il,ir;
264			il = indmax;
265			ir = indmax;
266			for(Int_t i=1; i<nbad; i++){
267			if (ir == CLlength && il == 0)break;
268			else if (ir == CLlength && il != 0)il--;
269			else if (ir != CLlength && il == 0)ir++;
270			else{
271			if(clsignal[il-1] > clsignal[ir+1])il--;
272			else ir++;
273			}
274			}
275			Int_t isbad = 0;
276			for(Int_t i=il; i<=ir; i++){
277			if( IsX() && cladc[i] > 2980 )isbad++;
278			if( IsY() && cladc[i] < 80 )isbad++;
279			}
280			return ( isbad != 0 );
281
282			}
283	pam-fi	1.2	//--------------------------------------
284			//
285			//
286			//--------------------------------------
287	pam-fi	1.1	void TrkCluster::Dump(){
288
289	pam-fi	1.11	cout << "----- Cluster" << endl;
290			cout << "View "<<view << " - Ladder "<<GetLadder()<<endl;
291			cout << "Position of maximun "<< maxs <<endl;
292			cout << "Multiplicity "<< GetMultiplicity() <<endl;
293			cout << "Tot signal "<< GetSignal() << " (ADC channels)"<<endl ;
294			cout << "Signal/Noise "<< GetSignalToNoise();
295			cout <<endl<< "Strip signals ";
296			for(Int_t i =0; i<CLlength; i++)cout << " " <<clsignal[i];
297			cout <<endl<< "Strip sigmas ";
298			for(Int_t i =0; i<CLlength; i++)cout << " " <<clsigma[i];
299			cout <<endl<< "Strip ADC ";
300			for(Int_t i =0; i<CLlength; i++)cout << " " <<cladc[i];
301			cout <<endl<< "Strip BAD ";
302			for(Int_t i =0; i<CLlength; i++){
303			if(i==indmax)cout << " " <<clbad[i]<<"";
304			else cout << " " <<clbad[i];
305			}
306			cout << endl;
307	pam-fi	1.1
308			}
309			//--------------------------------------
310			//
311			//
312			//--------------------------------------
313	pam-fi	1.3	/**
314			* Method to fill a level1 struct with only one cluster (done to use F77 p.f.a. routines on a cluster basis).
315			*/
316			cTrkLevel1* TrkCluster::GetLevel1Struct(){
317
318	pam-fi	1.6	// cTrkLevel1* l1 = new cTrkLevel1;
319
320			cTrkLevel1* l1 = &level1event_ ;
321	pam-fi	1.3
322	pam-fi	1.6	l1->nclstr1 = 1;
323			l1->view[0] = view;
324			l1->ladder[0] = GetLadder();
325			l1->maxs[0] = maxs;
326			l1->mult[0] = GetMultiplicity();
327			l1->dedx[0] = GetSignal();
328			l1->indstart[0] = 1;
329			l1->indmax[0] = indmax+1;
330			l1->totCLlength = CLlength;
331			for(Int_t i=0; i<CLlength; i++){
332			l1->clsignal[i] = clsignal[i];
333			l1->clsigma[i] = clsigma[i];
334			l1->cladc[i] = cladc[i];
335			l1->clbad[i] = clbad[i];
336			};
337
338			return l1;
339	pam-fi	1.3	};
340			//--------------------------------------
341			//
342			//
343			//--------------------------------------
344			/**
345			* Evaluates the Center-Of-Gravity (COG) of the cluster, in strips, relative to the strip with the maximum signal (TrkCluster::maxs).
346			* @param ncog Number of strips to evaluate COG.
347			* If ncog=0, the COG of the cluster is evaluated according to the cluster multiplicity (defined by the inclusion cut).
348			* If ncog>0, the COG is evaluated using ncog strips, even if they have a negative signal (according to G.Landi)
349			*/
350			Float_t TrkCluster::GetCOG(Int_t ncog){
351
352	pam-fi	1.6	int ic = 1;
353			GetLevel1Struct();
354			return cog_(&ncog,&ic);
355
356			};
357			/**
358			* Evaluates the Center-Of-Gravity (COG) of the cluster, in strips, relative to the strip with the maximum signal (TrkCluster::maxs),
359			* choosing the number of strips according to the angle, as implemented for the eta-algorythm .
360			* @param angle Projected angle in degree.
361			*/
362			Float_t TrkCluster::GetCOG(Float_t angle){
363
364			Int_t neta = 0;
365
366			// Float_t eta = GetETA(0,angle);
367			// for(neta=2; neta<10; neta++) if( eta == GetETA(neta,angle) ) break;
368			// if(eta != GetETA(neta,angle) )cout << "Attenzione!! pasticcio "<<endl;
369
370			if( view%2 ){ //Y
371			neta=2;
372			}else{ //X
373	pam-fi	1.7	if( fabs(angle) <= 10. ){
374	pam-fi	1.6	neta = 2;
375	pam-fi	1.7	}else if( fabs(angle) > 10. && fabs(angle) <= 15. ){
376	pam-fi	1.6	neta = 3;
377			}else{
378			neta = 4;
379			};
380			};
381
382			return GetCOG(neta);
383	pam-fi	1.3
384			};
385			//--------------------------------------
386			//
387			//
388			//--------------------------------------
389			/**
390			* Evaluates the cluster position, in strips, relative to the strip with the maximum signal (TrkCluster::maxs), by applying the non-linear ETA-algorythm.
391			* @param neta Number of strips to evaluate ETA.
392			* @param angle Projected angle between particle track and detector plane.
393			* Implemented values of neta are 2,3,4. If neta=0, ETA2, ETA3 and ETA4 are applied according to the angle.
394			*/
395			Float_t TrkCluster::GetETA(Int_t neta, float angle){
396
397	pam-fi	1.6	// cout << "GetETA(neta,angle) "<< neta << " "<< angle;
398	pam-fi	1.3	// LoadPfaParam();
399	pam-fi	1.6
400			float ax = angle;
401			int ic = 1;
402			GetLevel1Struct();
403			if(neta == 0) return pfaeta_(&ic,&ax);
404			else if(neta == 2) return pfaeta2_(&ic,&ax);
405			else if(neta == 3) return pfaeta3_(&ic,&ax);
406			else if(neta == 4) return pfaeta4_(&ic,&ax);
407			else cout << "ETA"<<neta<<" not implemented\n";
408			return 0;
409
410	pam-fi	1.3	};
411
412			//--------------------------------------
413			//
414			//
415			//--------------------------------------
416	pam-fi	1.1	TrkLevel1::TrkLevel1(){
417	pam-fi	1.6
418	pam-fi	1.11	// cout << "TrkLevel1::TrkLevel1()"<<endl;
419			// Cluster = new TClonesArray("TrkCluster");
420			Cluster = 0;
421	pam-fi	1.6	for(Int_t i=0; i<12 ; i++){
422			good[i] = -1;
423			for(Int_t j=0; j<24 ; j++){
424			cn[j][i]=0;
425			cnn[j][i]=0;
426	pam-fi	1.1	};
427	pam-fi	1.6	};
428	pam-fi	1.1	}
429			//--------------------------------------
430			//
431			//
432			//--------------------------------------
433			void TrkLevel1::Dump(){
434
435	pam-fi	1.6	cout<<"DSP status: ";
436			for(Int_t i=0; i<12 ; i++)cout<<good[i]<<" ";
437			cout<<endl;
438	pam-fi	1.9	cout<<"VA1 mask : "<<endl;
439			for(Int_t i=0; i<12 ; i++){
440			for(Int_t ii=0; ii<24 ; ii++){
441			Int_t mask = cnn[ii][i];
442			if(mask>0)mask=1;
443			cout<<mask<<" ";
444			}
445			cout <<endl;
446			}
447	pam-fi	1.6
448	pam-fi	1.11	if(!Cluster)return;
449	pam-fi	1.6	TClonesArray &t = *Cluster;
450			for(int i=0; i<this->nclstr(); i++) ((TrkCluster *)t[i])->Dump();
451
452	pam-fi	1.1	}
453			//--------------------------------------
454			//
455			//
456			//--------------------------------------
457			/**
458			* Fills a TrkLevel1 object with values from a struct cTrkLevel1 (to get data from F77 common).
459			*/
460	pam-fi	1.10	void TrkLevel1::SetFromLevel1Struct(cTrkLevel1 *l1, Bool_t full){
461	pam-fi	1.1
462	pam-fi	1.10	// ---------------
463	pam-fi	1.6	// * CLUSTER *
464	pam-fi	1.10	// ---------------
465	pam-fi	1.6	TrkCluster* t_cl = new TrkCluster();
466	pam-fi	1.11	if(!Cluster)Cluster = new TClonesArray("TrkCluster");
467	pam-fi	1.6	TClonesArray &t = *Cluster;
468			for(int i=0; i<l1->nclstr1; i++){
469	pam-fi	1.10
470			t_cl->Clear();
471	pam-fi	1.11	// if( full \|\| (!full && l1->whichtrack[i]) ){
472
473			t_cl->view = l1->view[i];
474			t_cl->maxs = l1->maxs[i];
475
476	pam-fi	1.10	if( full \|\| (!full && l1->whichtrack[i]) ){
477	pam-fi	1.11	t_cl->indmax = l1->indmax[i] - l1->indstart[i];
478	pam-fi	1.10	Int_t from = l1->indstart[i] -1;
479			Int_t to = l1->totCLlength ;
480			if(i != l1->nclstr1-1)to = l1->indstart[i+1] -1 ;
481			t_cl->CLlength = to - from ;
482
483			t_cl->clsignal = new Float_t[t_cl->CLlength];
484			t_cl->clsigma = new Float_t[t_cl->CLlength];
485			t_cl->cladc = new Int_t[t_cl->CLlength];
486			t_cl->clbad = new Bool_t[t_cl->CLlength];
487			Int_t index = 0;
488			for(Int_t is = from; is < to; is++ ){
489			t_cl->clsignal[index] = (Float_t) l1->clsignal[is];
490			t_cl->clsigma[index] = (Float_t) l1->clsigma[is];
491			t_cl->cladc[index] = (Int_t) l1->cladc[is];
492			t_cl->clbad[index] = (Bool_t) l1->clbad[is];
493			index++;
494			};
495			}
496			new(t[i]) TrkCluster(*t_cl); // <<< store cluster
497	pam-fi	1.6	};
498
499			delete t_cl;
500
501	pam-fi	1.10	// -------------------------
502	pam-fi	1.6	// **general variables**
503	pam-fi	1.10	// -------------------------
504	pam-fi	1.6	for(Int_t i=0; i<12 ; i++){
505			good[i] = l1->good[i];
506			for(Int_t j=0; j<24 ; j++){
507			cn[j][i] = l1->cnev[j][i];
508			// cnrms[j][i] = l1->cnrmsev[j][i];
509			cnn[j][i] = l1->cnnev[j][i];
510	pam-fi	1.1	};
511	pam-fi	1.6	};
512
513	pam-fi	1.1	}
514			/**
515			* Fills a struct cTrkLevel1 with values from a TrkLevel1 object (to put data into a F77 common).
516			*/
517
518	pam-fi	1.3	cTrkLevel1* TrkLevel1::GetLevel1Struct() {
519
520	pam-fi	1.6	cTrkLevel1 *l1=0;
521	pam-fi	1.11	//
522	pam-fi	1.6	for(Int_t i=0; i<12 ; i++){
523			l1->good[i] = good[i];
524			for(Int_t j=0; j<24 ; j++){
525			l1->cnev[j][i] = cn[j][i];
526			// l1->cnrmsev[j][i] = cnrms[j][i];
527			l1->cnnev[j][i] = cnn[j][i];
528	pam-fi	1.1	};
529	pam-fi	1.6	};
530
531	pam-fi	1.1	// * CLUSTERS *
532	pam-fi	1.11	if(Cluster){
533			l1->nclstr1 = Cluster->GetEntries();
534			for(Int_t i=0;i<l1->nclstr1;i++){
535
536			l1->view[i] = ((TrkCluster *)Cluster->At(i))->view;
537			l1->maxs[i] = ((TrkCluster *)Cluster->At(i))->maxs;
538			// COMPLETARE //
539			// COMPLETARE //
540			// COMPLETARE //
541			// COMPLETARE //
542			// COMPLETARE //
543			// COMPLETARE //
544	pam-fi	1.6
545	pam-fi	1.11	}
546	pam-fi	1.3	// COMPLETARE //
547			// COMPLETARE //
548			// COMPLETARE //
549			// COMPLETARE //
550			// COMPLETARE //
551			// COMPLETARE //
552	pam-fi	1.6	}
553			return l1;
554	pam-fi	1.3	}
555			//--------------------------------------
556			//
557			//
558			//--------------------------------------
559			void TrkLevel1::Clear(){
560	pam-fi	1.6
561			for(Int_t i=0; i<12 ; i++){
562			good[i] = -1;
563			for(Int_t j=0; j<24 ; j++){
564			cn[j][i] = 0;
565			cnn[j][i] = 0;
566	pam-fi	1.3	};
567	pam-fi	1.6	};
568	pam-fi	1.11	// if(Cluster)Cluster->Clear("C");
569			if(Cluster)Cluster->Delete();
570	pam-fi	1.6
571	pam-fi	1.1	}
572			//--------------------------------------
573			//
574			//
575			//--------------------------------------
576	pam-fi	1.3	void TrkLevel1::Delete(){
577	pam-fi	1.11
578			// Clear();
579			if(Cluster)Cluster->Delete();
580			if(Cluster)delete Cluster;
581	pam-fi	1.6
582	pam-fi	1.1	}
583			//--------------------------------------
584			//
585			//
586			//--------------------------------------
587			TrkCluster *TrkLevel1::GetCluster(int is){
588
589	pam-fi	1.11	if(!Cluster)return 0;
590			if(is >= nclstr()){
591			cout << " TrkLevel1::GetCluster(int) Cluster "<< is << " does not exits! " << endl;
592			cout << "( Stored clusters nclstr() = "<< this->nclstr()<<" )" << endl;
593			return 0;
594			}
595
596			TClonesArray &t = *(Cluster);
597			TrkCluster cluster = (TrkCluster)t[is];
598			return cluster;
599	pam-fi	1.1	}
600	pam-fi	1.3	//--------------------------------------
601			//
602			//
603			//--------------------------------------
604			/**
605			* Load Position-Finding-Algorythm parameters (call the F77 routine).
606			*
607			*/
608			int TrkLevel1::LoadPfaParam(TString path){
609
610	pam-fi	1.11	if( strcmp(path_.path,path.Data()) ){
611			cout <<"Loading p.f.a. param::eters\n";
612			strcpy(path_.path,path.Data());
613			path_.pathlen = path.Length();
614			path_.error = 0;
615			return readetaparam_();
616			}
617			return 0;
618	pam-fi	1.3	}
619	pam-fi	1.1
620
621			ClassImp(TrkLevel1);
622			ClassImp(TrkCluster);