// -------------------------------------------------------------------------
// -----                PndSttTrackFinderReal source file             -----
// -----                  Created 28/03/06  by V. Friese               -----
// -------------------------------------------------------------------------
#include "glpk.h"

// Pnd includes
#include "PndSttTrackFinderReal.h"

#include "PndSttHit.h"
#include "PndSttPoint.h"
#include "PndSttHelixHit.h"
#include "PndTrackCand.h"
#include "PndDetectorList.h"
#include "PndSttTube.h"
#include  <cmath>
#include "FairMCPoint.h"
#include "FairRootManager.h"
//#include "GFKalman.h"

// ROOT includes
#include "TClonesArray.h"
#include "TDatabasePDG.h"
#include "TRandom.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"

// C++ includes
#include <iostream>
#include <map>

using std::cout;
using std::cin;
using std::endl;
using std::map;

// -----   Default constructor   -------------------------------------------
PndSttTrackFinderReal::PndSttTrackFinderReal()
{ 
  fVerbose      = 1;
  MINIMUMOUTERHITSPERTRACK=5;
                 Fimin=0.;     Fimax=2.*PI;
                 FI0min = 0.; FI0max = 2.*PI;
               stepD=(Dmax-Dmin)/nbinD;
               stepFi=(Fimax-Fimin)/nbinFi;
               stepR=(Rmax-Rmin)/nbinR;
               stepKAPPA=(KAPPAmax-KAPPAmin)/nbinKAPPA;
               stepFI0=(FI0max-FI0min)/nbinFI0;
               stepfineKAPPA=2.*DELTA_KAPPA/nbinKAPPA;
               stepfineFI0=2.*DELTA_FI0/nbinFI0;
               RminStrawSkewArea = RStrawDetectorMin*2./1.732051 + 18.*StrawRadius ; // delimitation of the skew area
               RmaxStrawSkewArea = RminStrawSkewArea + 8.*1.732051 *StrawRadius ;

}
// -------------------------------------------------------------------------



// -----   Standard constructor   ------------------------------------------
PndSttTrackFinderReal::PndSttTrackFinderReal(Int_t verbose) 
{ 
  fVerbose      = verbose;
  MINIMUMOUTERHITSPERTRACK=5;
                 Fimin=0.;     Fimax=2.*PI;
                 FI0min = 0.; FI0max = 2.*PI;
               stepD=(Dmax-Dmin)/nbinD;
               stepFi=(Fimax-Fimin)/nbinFi;
               stepR=(Rmax-Rmin)/nbinR;
               stepKAPPA=(KAPPAmax-KAPPAmin)/nbinKAPPA;
               stepFI0=(FI0max-FI0min)/nbinFI0;
               stepfineKAPPA=2.*DELTA_KAPPA/nbinKAPPA;
               stepfineFI0=2.*DELTA_FI0/nbinFI0;
               RminStrawSkewArea = RStrawDetectorMin*2./1.732051 + 18.*StrawRadius ; // delimitation of the skew area
               RmaxStrawSkewArea = RminStrawSkewArea + 8.*1.732051 *StrawRadius ;

}
// -------------------------------------------------------------------------



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



// -----   Public method Init   --------------------------------------------
void PndSttTrackFinderReal::Init() 
{

   UShort_t i, j, k;
   Double_t    r1, r2, A , rConfMin, rConfMax,
              tempRadiaConf[nRdivConformal];


//  --------------------------- opening files for special purposes
/*
if(istampa >=2 ){
//---- fetch the n. of tracks MC that were intended to be generated
   HANDLE = fopen("n_intended_tracks.txt","r");
   fscanf(HANDLE,"%d",&N_INTENDED);
   fclose(HANDLE);
//---- apertura file con info su Found tracce su cui si fa Helix fit dopo
   HANDLE2 = fopen("info_da_PndTrackFinderReal.txt","w");

//  ---- open filehandle per statistica sugli hits etc.
   HANDLE = fopen("statistiche.txt","w");

//  ---------------  open file delle info su deltaX, Y, Z  degli hits in comune tra tracce trovate e MC
   PHANDLEX = fopen("deltaParXmio.txt","w");
   PHANDLEY = fopen("deltaParYmio.txt","w");
   PHANDLEZ = fopen("deltaParZmio.txt","w");
   SHANDLEX = fopen("deltaSkewXmio.txt","w");
   SHANDLEY = fopen("deltaSkewYmio.txt","w");
   SHANDLEZ = fopen("deltaSkewZmio.txt","w");

}  //  end of if(istampa >=2)

*/

// -------------------------





   IVOLTE=0; ntimes = 0;


  // Get and check FairRootManager
  FairRootManager* ioman = FairRootManager::Instance();

//    get   the MCTrack  array

  fMCTrackArray = (TClonesArray*) ioman->ActivateBranch("MCTrack");

//   -------------------------------------------------------------------


//   --------------------   initializations for the Kalman with Genfit later

/*
   fSttHitArray=(TClonesArray*) ioman->GetObject("STTHit");
   if(fSttHitArray==0){
     Error("PndSttKalmanTask2::Init","stt pattern recognition; hit-array not found!");
     return ;
   }

  // Build hit factory -----------------------------

  _theRecoHitFactory = new GFRecoHitFactory();
  _theRecoHitFactory->addProducer(3, new GFRecoHitProducer<PndSttHit,PndSttRecoHit>(fSttHitArray));   //
*/
// -------------------- end initializations for the Kalman with Genfit later





//  hx = new TH1F("hx", "Associated Z", 400, -200., 200.);

  if (!ioman) 
    {
      cout << "-E- PndSttTrackFinderReal::Init: "
	   << "RootManager not instantised!" << endl;
      return;
    }
 
//   calculate the boundaries of the Box in Conformal Space, see Gianluigi logbook on pag. 210-211


    radiaConf[0] = 1./RStrawDetectorMax; 
    r1 = RStrawDetectorMin;
//    A = (RStrawDetectorMax*RStrawDetectorMax - r1)/nRdivConformal;
    A = (RStrawDetectorMax - r1)/nRdivConformal;
    if ( nRdivConformal > 1 ) {
      for(i = 1; i< nRdivConformal ; i++){
        r2 = r1 + A;
//        tempRadiaConf[nRdivConformal-i] = 1./sqrt(r2);
        tempRadiaConf[nRdivConformal-i] = 1./r2;
        r1=r2;

      }
    }


/*
  for(i = 1; i< nRdivConformal ; i++){
      cout<<"from Init :  temporary CONFORMAL radius n. "<<i<<"  "<< tempRadiaConf[i]<<endl;
        r1=r2;
      }
*/



      rConfMin = 1./RmaxStrawSkewArea;
      rConfMax = 1./RminStrawSkewArea;

//  now take into account the zone of the skew straws, which is 'empty' as far as the parallel straws is concerned

//      for(i = 1; i< nRdivConformal && tempRadiaConf[i] < rConfMin ; i++){
      for(i = 1; i< nRdivConformal  ; i++){

        radiaConf[i] = tempRadiaConf[i];
      }
      nRdivConformalEffective = nRdivConformal;

/*
      if( i == nRdivConformal ) {
       nRdivConformalEffective = nRdivConformal;
       goto fine ;
      }

      radiaConf[i] = tempRadiaConf[i];

      if( i == nRdivConformal-1 ){
          nRdivConformalEffective = nRdivConformal;
          goto fine ;
      }

      for(j=i+1; j< nRdivConformal && tempRadiaConf[j] < rConfMax ; j++){
      }
      radiaConf[i+1] = tempRadiaConf[j];
      nRdivConformalEffective = i+1;
      if( i+1 == nRdivConformal-1 ) {
       nRdivConformalEffective = nRdivConformal;
       goto fine ;
      }

      for( k= j+1; k<nRdivConformal; k++){
       nRdivConformalEffective ++;
       radiaConf[nRdivConformalEffective] = tempRadiaConf[k];
      }
      nRdivConformalEffective ++;

fine: ;

*/
//--------------------  end of method Init   --------------------------------------------



}
// -------------------- starting PndSttTrackFinderReal::GetHitFromCollections

PndSttHit* PndSttTrackFinderReal::GetHitFromCollections(Int_t hitCounter)
{
    PndSttHit
	*retval = NULL;
 
    Int_t
	relativeCounter = hitCounter;

    for (Int_t collectionCounter = 0; collectionCounter < fHitCollectionList.GetEntries(); collectionCounter++)
    {
	Int_t
	    size = ((TClonesArray *)fHitCollectionList.At(collectionCounter))->GetEntriesFast();

	if (relativeCounter < size)
	{
	    retval = (PndSttHit*) ((TClonesArray *)fHitCollectionList.At(collectionCounter))->At(relativeCounter);
	    break;
	}
	else
	{
	    relativeCounter -= size;
	}
    }
    return retval;
}

// -------------------- end of PndSttTrackFinderReal::GetHitFromCollections



// -------------------- starting PndSttTrackFinderReal::GetPointFromCollections

FairMCPoint* PndSttTrackFinderReal::GetPointFromCollections(Int_t hitCounter)
{
    FairMCPoint
	*retval = NULL;
 
    Int_t
	relativeCounter = hitCounter;

    for (Int_t collectionCounter = 0; collectionCounter < fHitCollectionList.GetEntries(); collectionCounter++)
    {
	Int_t
	    size = ((TClonesArray *)fHitCollectionList.At(collectionCounter))->GetEntriesFast();

	if (relativeCounter < size)
	{
	    Int_t
		tmpHit = ((PndSttHit*) ((TClonesArray *)fHitCollectionList.At(collectionCounter))->At(relativeCounter))->GetRefIndex();
	    
	    retval = (FairMCPoint*) ((TClonesArray *)fPointCollectionList.At(collectionCounter))->At(tmpHit);
	    
	    break;
	}
	else
	{
	    relativeCounter -= size;
	}
    }
    return retval;
}


// -------------------- end of PndSttTrackFinderReal::GetPointFromCollections




// -----------------   start of method DoFind
Int_t PndSttTrackFinderReal::DoFind(TClonesArray* trackArray, TClonesArray* helixHitArray) 
{


    UShort_t auxIndex[nmaxHits],
             OLDinfoparal[nmaxHits];
    UShort_t istep,inclination_type;

    Double_t aaa, ddd, delta, deltabis, deltaZ, mindis, distanza, fi_hit,
              ap1, ap2, ap3, cross1, cross2, cross3,
             lowlimit[MAXMCTRACKS],
             uplimit[MAXMCTRACKS],
             info[nmaxHits][7],
             WDX, WDY, WDZ,
             auxRvalues[nmaxHits],
             inclination[nmaxinclinationversors][3];

    PndSttHit*  ListPointer_to_Hit[nmaxHits];


    inclination[0][0]=inclination[0][1]=0.,    inclination[0][2]=1.;
    Int_t Nincl = 1, Ninclinate, iHit;
    Int_t Minclinations[nmaxinclinationversors];

//------------------------------------ modifiche Gianluigi, 9-7-08


     IVOLTE++;

     if(istampa>=2 && IVOLTE<20)     cout<<"da PndSttTrackFinderReal : evento n. "<<IVOLTE<<endl;

//------------------------------------ fine modifiche Gianluigi, 9-7-08


  // Check pointers
  if (fHitCollectionList.GetEntries() == 0)
  {
      cout << "-E- PndSttTrackFinderReal::DoFind: "
	   << "No hit arrays present, call AddHitCollection() first (at least once)! " << endl;
      return -1;
  }

  if (fPointCollectionList.GetEntries() == 0)
  {
      cout << "-E- PndSttTrackFinderReal::DoFind: "
	   << "No point arrays present, call AddHitCollection() first (at least once)! " << endl;
      return -1;
  }

  if ( !trackArray ) 
    {
      cout << "-E- PndSttTrackFinderReal::DoFind: "
	   << "Track array missing! " << endl;
      return -1;
    }

   PndMCTrack*      pMCtr = NULL;
   nMCTracks = fMCTrackArray->GetEntriesFast(); // num. tracce/evento


   if(istampa>=2 && (nMCTracks  != N_INTENDED)  ){
    cout<<"Gianluigi : n. MC tracks = "<<nMCTracks<<" and it is different from n. intended tracks (= "<<
        N_INTENDED<<"),  return!\n";
    return  -20;
  }

   if(nMCTracks>MAXMCTRACKS){
    return  -10;
  }

   for (Int_t iMCTrack = 0; iMCTrack < nMCTracks; iMCTrack++) 
   { 
         nHitsInMCTrack[iMCTrack]  = 0;          //   initialization
         nSkewHitsInMCTrack[iMCTrack]  = 0;      //   initialization

       pMCtr = (PndMCTrack*) fMCTrackArray->At(iMCTrack);
       if ( ! pMCtr ) continue;



         Double_t R, D, Fi, Ox, Oy, Cx, Cy, Px, Py  ;
         Int_t icode;
         icode  = pMCtr->GetPdgCode() ;    //   PDG code of track
         Ox = pMCtr->GetStartVertex().X();    //   X of starting point track
         Oy = pMCtr->GetStartVertex().Y();    //   Y of starting point track
         Px = pMCtr->GetMomentum().X();
         Py = pMCtr->GetMomentum().Y();
         aaa = sqrt( Px*Px + Py*Py);
         R =   aaa*1000./(BFIELD*CVEL);    //   R (cm) of Helix of track projected in XY plane; B = 2 Tesla

         if( icode > 0 ) {
           Cx = Ox  -Py*1000./(BFIELD*CVEL);    // MC truth X of center of circle of Helix trajectory
           Cy = Oy + Px*1000./(BFIELD*CVEL);    // MC truth Y of center of circle of Helix trajectory
         }  else {
           Cx = Ox + Py*1000./(BFIELD*CVEL);    // MC truth X of center of circle of Helix trajectory
           Cy = Oy - Px*1000./(BFIELD*CVEL);    // MC truth Y of center of circle of Helix trajectory

         }




         Fi = atan2(Cy, Cx);       // MC truth Fi angle of circle of Helix trajectory
         if(Fi<0.)  Fi += 2.*PI;
         D = sqrt( Cx*Cx+Cy*Cy) - R;

if(istampa>=3){
Double_t  gomma = Cx*Cx+Cy*Cy -R*R;
cout<<"verita MC,  traccia n. "<<iMCTrack<<", Ox, Oy,  Cx, Cy, D ,  R  ,  gamma = "<<Ox<<",  "<<Oy<<",  "<<
    Cx<<",  "<<Cy<<",  "<<D<<",  "<<R<<",  "<<gomma<<endl;
}





         CxMC[iMCTrack]= Cx;
         CyMC[iMCTrack]= Cy;
         R_MC[iMCTrack]= R;



         MCtruthTrkInfo[0][iMCTrack] = Ox;    //   X of starting point track
         MCtruthTrkInfo[1][iMCTrack] = Oy;    //   Y of starting point track
         MCtruthTrkInfo[2][iMCTrack] = pMCtr->GetStartVertex().Z();    //   Z of starting point track

         MCtruthTrkInfo[3][iMCTrack] = Px;    //   Px at starting point of track
         MCtruthTrkInfo[4][iMCTrack] = Py;    //   Py at starting point of track
         MCtruthTrkInfo[5][iMCTrack] = pMCtr->GetMomentum().Z();    //   Pz at starting point of track

         MCtruthTrkInfo[6][iMCTrack] = D;     //   D of Helix of track projected in XY plane
         MCtruthTrkInfo[7][iMCTrack] = Fi;    //   Fi of Helix of track projected in XY plane
         MCtruthTrkInfo[8][iMCTrack] = R;    //   R  of Helix of track projected in XY plane

         MCtruthTrkInfo[9][iMCTrack] = Cx;     //   Cx of Helix of track projected in XY plane
         MCtruthTrkInfo[10][iMCTrack] = Cy;    //   Cy of Helix of track projected in XY plane
         MCtruthTrkInfo[11][iMCTrack] = icode ;    //   PDG code of track

         TDatabasePDG *fdbPDG= TDatabasePDG::Instance();
         TParticlePDG *fParticle= fdbPDG->GetParticle(icode);
         MCtruthTrkInfo[14][iMCTrack] = fParticle->Charge()/3. ;    //   charge of track

         MCtruthTrkInfo[12][iMCTrack] = -MCtruthTrkInfo[14][iMCTrack]*0.001*BFIELD*CVEL/
                                         MCtruthTrkInfo[5][iMCTrack] ;    //   KAPPA of Helix of track in cm*-1
//                                         fabs(MCtruthTrkInfo[5][iMCTrack]) ;    //   KAPPA of Helix of track in cm*-1

//        double tempoang = atan2(-MCtruthTrkInfo[10][iMCTrack]+MCtruthTrkInfo[1][iMCTrack],
//                                 -MCtruthTrkInfo[9][iMCTrack]+MCtruthTrkInfo[0][iMCTrack]);
//        if(tempoang<0.) tempoang+= 2.*PI;
         MCtruthTrkInfo[13][iMCTrack] = fmod(Fi+ PI, 2.*PI) ;    //   FI0 of Helix of track


   }   //  end of   for (Int_t iMCTrack = 0; iMCTrack < nMCTracks; iMCTrack++) 






    
  // Initialise control counters
  Int_t nNoTrack     = 0;
  Int_t nNoSttPoint  = 0;
  Int_t nNoSttHit    = 0;

  // Create pointers to hit and SttPoint
  PndSttHit*       pMhit = NULL;
  FairMCPoint*      pMCpt = NULL;
//   PndSttTrack*     pTrck[MAXTRACKSPEREVENT] ; // this is for the hits found by pattern recognition

  // Number of STT hits
  Int_t Nhits = 0;
  
  for (Int_t hitListCounter = 0; hitListCounter < fHitCollectionList.GetEntries(); hitListCounter++)
  {
      Nhits += ((TClonesArray *)fHitCollectionList.At(hitListCounter))->GetEntriesFast();
  }

  if(Nhits > nmaxHits ) {
    return  -10;
  }


  // Declare some variables outside the loops
  Int_t trackIndex   = 0;     // STTTrack index

  // Create STL map from MCtrack index to number of valid SttHits
  map<Int_t, map<Double_t, Int_t> >
    hitMap;



    for(Int_t j=0; j<nmaxinclinationversors;j++){
     Minclinations[j]=0;
    }

    NSkewhits=Ninclinate=0;


//  if (istampa >= 1 ) cout<<"Gianluigi : da PndSttTrackFinderReal::DoFind : Nhits="<<Nhits<<endl;

  //   generated momenta and starting position of each track




  // Loop over hits
  for (iHit = 0; iHit < Nhits; iHit++) 
    {
      // hit point
      pMhit = GetHitFromCollections(iHit);   // <== PndSttHit
      ListPointer_to_Hit[iHit]=pMhit;
      if (!pMhit) continue;
      
      // MC point
      Int_t ptIndex = pMhit->GetRefIndex();
      if (ptIndex < 0) continue;           // fake or background hit
      pMCpt = GetPointFromCollections(iHit); // <== FairMCPoint
      if (!pMCpt) continue;
      
      // tubeID  CHECK added
      Int_t tubeID = pMhit->GetTubeID();
      PndSttTube *tube = (PndSttTube*) fTubeArray->At(tubeID);
      // real hit center of tube coordinates
      TVector3 center = tube->GetPosition();

      // drift radius
      Double_t dradius = pMhit->GetIsochrone();

      // wire direction
      TVector3 wiredirection = tube->GetWireDirection();

      // "real" MC coordinates (in + out)/2.
      TVector3 mcpoint;
      pMCpt->Position(mcpoint);

      if(wiredirection.Z() >=0.) {
       WDX = wiredirection.X();     WDY = wiredirection.Y(); WDZ = wiredirection.Z();
      }  else {
       WDX = -wiredirection.X();     WDY = -wiredirection.Y(); WDZ = -wiredirection.Z();
      }


      // stampe di controllo


      info[iHit][0]= tube->GetPosition().X();
      info[iHit][1]= tube->GetPosition().Y();
      info[iHit][2]= tube->GetPosition().Z();
      info[iHit][3]= dradius;
      info[iHit][4]= tube->GetHalfLength();
      info[iHit][6]=pMCpt->GetTrackID();

      if( fabs( WDX )< 0.00001 && fabs( WDY )< 0.00001 ){
          info[iHit][5]= 1.;
          infoparal[Minclinations[0]]= iHit ;
          Minclinations[0]++;
          ZCENTER_STRAIGHT = info[iHit][2];      //    this works because just few lines below there is the
          SEMILENGTH_STRAIGHT = info[iHit][4];   //    requirement that Minclinations[0] > 2 (= at least 3 parallel straws)
      } else {
       for (Int_t i=2; i<=Nincl;i++) {
        if (fabs( WDX-inclination[i-1][0] )< 0.00001
                                &&
            fabs( WDY -inclination[i-1][1])< 0.00001
                                &&
            fabs( WDZ -inclination[i-1][2])< 0.00001
                                           ){
          info[iHit][5]= i;
          infoskew[Ninclinate]= iHit;
          Ninclinate++;
          Minclinations[i-1]++;
          goto jumpout;
        }
       }
       Nincl++;
       inclination[Nincl-1][0]=(Double_t) WDX;
       inclination[Nincl-1][1]=(Double_t) WDY;
       inclination[Nincl-1][2]=(Double_t) WDZ;
       info[iHit][5]= Nincl;
          infoskew[Ninclinate]= iHit;
          Ninclinate++;
       Minclinations[Nincl-1]++;
jumpout: ;
      }        

      NSkewhits = Ninclinate;


//   calcoli validi solo per il MC   -----------------------------

      veritaMC[iHit][0]= pMCpt->GetX();
      veritaMC[iHit][1]= pMCpt->GetY();
      veritaMC[iHit][2]= pMCpt->GetZ();

      FromHitToMCTrack[iHit] = (UShort_t) ( info[iHit][6] + 0.001 );

    if(info[iHit][5]==1. ){
      //  associazione hits paralleli
      FromMCTrackToHit[ FromHitToMCTrack[iHit] ][ nHitsInMCTrack[ FromHitToMCTrack[iHit] ] ] = iHit;
      nHitsInMCTrack[  FromHitToMCTrack[iHit]  ]++ ;

   } else {
      //  associazione hits skew
      FromMCTrackToSkewHit[ FromHitToMCTrack[iHit] ][ nSkewHitsInMCTrack[ FromHitToMCTrack[iHit] ] ] = iHit;
      nSkewHitsInMCTrack[  FromHitToMCTrack[iHit]  ]++ ;

   }




   // end of if(info[iHit][5]==1. )

//--------------- inizio stampaggi,  stampe di controllo
  if (istampa >= 2  && IVOLTE<20) {
     cout <<"iHit "<< iHit << endl;
      cout <<"             hit X, Y, Z space position "   << veritaMC[iHit][0] << " " <<
                       veritaMC[iHit][1] << " " << veritaMC[iHit][2]<<endl; 
      cout <<"             hit wire pos. in middle "   << tube->GetPosition().X() << " " << tube->GetPosition().Y() << " " << tube->GetPosition().Z() 
           << "; R = "<<sqrt(tube->GetPosition().X()*tube->GetPosition().X()+tube->GetPosition().Y()*tube->GetPosition().Y())<< endl;
      cout <<"             wire direction, X, Y, Z (Z direction set always positive)"<< WDX<<"  "<<WDY<<"  "<<WDZ <<endl
           <<"             this hit belongs to MC track n. "<<pMCpt->GetTrackID()<<endl;
  }  //  end of   if(istampa >= 

//--------  fine stampaggi





    }   //   end  of  for (Int_t iHit = 0;




//--------------- inizio stampaggi
//  if (istampa >= 2  && IVOLTE<20) {
  if (istampa >= 2  ) {
      cout<<"Gianluigi : da PndSttTrackFinderReal::DoFind : Nhits totali ="<<Nhits<<",  n Hits ||  = "<<Minclinations[0]<<
          ",  n Hits  skew = "<<NSkewhits<<endl;
  }  //  end of   if(istampa >=
//--------  fine stampaggi








//   ordering the hits by INCREASING CONFORMAL RADIUS or equivalently, decreasing spatial radius.

    for (int j = 0; j< Minclinations[0]; j++){
      auxIndex[j]=j;
      auxRvalues[j]=
                    info[ infoparal[ j ]  ][0]*
                    info[ infoparal[ j ]  ][0]+
                    info[ infoparal[ j ]  ][1]*
                    info[ infoparal[ j ]  ][1];
      OLDinfoparal[j]=infoparal[j];
    }


    PndStt_Merge_Sort( Minclinations[0], auxRvalues, auxIndex);
    for (int j = 0; j< Minclinations[0]; j++){
      infoparal[ Minclinations[0]-1-j]  =  OLDinfoparal[ auxIndex[ j ]   ];
    }

//----------------------------







   if( !( Nhits >0 &&  Minclinations[0] > 2 ) ) return 0;
   if(! ianalizza ) return 0;





  bool    ExclusionList[nmaxHits],      //  list of || hits  already assigned to a found track or with multiple hits
           ExclusionListSkew[nmaxHits],      //  list of skew hits with multiple hits
          TypeConf[MAXTRACKSPEREVENT],   //  if TypeConf[]=false --> the track is a line in the Conformal space,
                                         //   if TypeConf[]=true it is a crf;
          TypeConfSkew[MAXTRACKSPEREVENT],
          GoodTrack[MAXTRACKSPEREVENT];    //  yes = track found passes minimal requirements


  UShort_t iExclude,
           imc,jexp,mchit,exphit,
           nTracksFoundSoFar,
           NN,
           NNN,
           Nouter,
           Naux,
           Nbaux,
           nTotalHits[MAXTRACKSPEREVENT],
           iParHit,
           SeedParallelNumber,
           OLDnHitsinTrack,
           TemporarynSkewHitsinTrack,
           BigList[MAXTRACKSPEREVENT][nmaxHits],
           TemporarySkewList[nmaxHits][2],
           nHitsinTrack[MAXTRACKSPEREVENT],
           nSkewHitsinTrack[MAXTRACKSPEREVENT],
           tempore[nmaxHits],
           auxListHitsinTrack[nmaxHits],
           ListHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
           ListHitsinTrackinWhichToSearch[nmaxHits],
           OLDListHitsinTrack[nmaxHits],
           OutputListHitsinTrack[nmaxHits],
           OutputList2HitsinTrack[nmaxHits],
           ListSkewHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
           nMCParalAlone[MAXMCTRACKS],
           nMCSkewAlone[MAXMCTRACKS],
           MCParalAloneList[MAXMCTRACKS][nmaxHits],
           MCSkewAloneList[MAXMCTRACKS][nmaxHits],
           nParalCommon[MAXTRACKSPEREVENT],
           ParalCommonList[MAXMCTRACKS][nmaxHits],
           nSpuriParinTrack[MAXTRACKSPEREVENT],
           ParSpuriList[MAXTRACKSPEREVENT][nmaxHits],
           nSkewCommon[MAXTRACKSPEREVENT],
           SkewCommonList[MAXMCTRACKS][nmaxHits],
           nSpuriSkewinTrack[MAXTRACKSPEREVENT],
           SkewSpuriList[MAXTRACKSPEREVENT][nmaxHits],
           RConformalIndex[nmaxHits],  //  given a Hit number it gives its radial box number
           FiConformalIndex[nmaxHits],  //  given a Hit number it gives its azimuthal box number
           nBoxConformal[nRdivConformal][nFidivConformal],  //  first index -> radial divisions, 2nd index -> azimuthal divisions; n. of
                                                            //  hits falling in this cell
           HitsinBoxConformal[nRdivConformal][nFidivConformal][nmaxHits];  //  first index -> radial divisions, 2nd index -> azimuthal divisions;
                                                //  list of hit numbers of those falling in this cell
   Short_t Charge[MAXTRACKSPEREVENT],
           Status[MAXTRACKSPEREVENT],
           daTrackFoundaTrackMC[MAXTRACKSPEREVENT],
           daMCTrackaTrackFound[MAXMCTRACKS];

   Int_t status;



   Int_t  i, j,ii,jj,k,kk,n1,n2,n3,
          i1,j1,k1,imaxima, jmaxima,
          iofmax, jofmax, kofmax,
          index[nmaxHits], integer,
          Ncirc, nSkew1, nSkew2,
          n_K, n_FI0, n_R, n_D, n_Fi,STATUS,
          Nremaining, Nremaining2,
          NumberofMaximaDFiR,
          NumberofMaximaKFI0,
          nAssociatedParallelHits ;

   int   iimax,jjmax,  ncount,
         ipinco=0;


   Double_t angle, max1, HoughR, HoughD, HoughFi, HoughKAPPA, HoughFI0,
              tempR, tempD,tempFi,tempKAPPA,tempFI0,
              Rlow, Rup, Dlow, Dup,Filow,Fiup, KAPPAlow, KAPPAup, FI0low, FI0up,
              gamma;

   Double_t    D,Fi, rotationangle, rotationsin, rotationcos,ptotal,
               Fi_low_limit[MAXTRACKSPEREVENT],
               Fi_up_limit[MAXTRACKSPEREVENT],
               Fi_initial_helix_referenceframe[MAXTRACKSPEREVENT],
               Fi_final_helix_referenceframe[MAXTRACKSPEREVENT],
               Fi_allowedforskew_low[MAXTRACKSPEREVENT],
               Fi_allowedforskew_up[MAXTRACKSPEREVENT],
               m[MAXTRACKSPEREVENT],
               q[MAXTRACKSPEREVENT],
               ALFA[MAXTRACKSPEREVENT],
               BETA[MAXTRACKSPEREVENT],
               GAMMA[MAXTRACKSPEREVENT],
               R[MAXTRACKSPEREVENT],
               Ox[MAXTRACKSPEREVENT],
               Oy[MAXTRACKSPEREVENT],
               KAPPA[MAXTRACKSPEREVENT],
               FI0[MAXTRACKSPEREVENT],
               trajectory_vertex[3],
               infoparalConformal[nmaxHits][5],
               auxinfoparalConformal[nmaxHits][5],
               S[nmaxHits],
               Z[nmaxHits],
               temporeS[nmaxHits],
               temporeZ[nmaxHits],
               ZDrift[nmaxHits],
               ZErrorafterTilt[nmaxHits],
               temporeZDrift[nmaxHits],
               temporeZErrorafterTilt[nmaxHits],
               Posiz[3],
               Xpos_for_LHeTrack[nmaxHits],
               Ypos_for_LHeTrack[nmaxHits],
               Zpos_for_LHeTrack[nmaxHits],
               Sfinal[MAXTRACKSPEREVENT][nmaxHits],
               Zfinal[MAXTRACKSPEREVENT][nmaxHits],
               ZDriftfinal[MAXTRACKSPEREVENT][nmaxHits],
               ZErrorafterTiltfinal[MAXTRACKSPEREVENT][nmaxHits];



    Float_t RemainingR[nmaxHits],
            RemainingFi[nmaxHits],
            RemainingD[nmaxHits],
            RemainingCX[nmaxHits],
            RemainingCY[nmaxHits],
            RemainingKAPPA[nmaxHits],
            RemainingFI0[nmaxHits];
    bool    GoodSkewFit[nmaxHits];


    bool            temporflag[8],
            IFLAG;


   CalculatedCircles Result;
   CalculatedHelix   HelixResult;
   AssociatedHitsToHelix ResultAssociatedHits ;

   char nomef[100], nome[30],titolo[100];







       for(i=0; i< Minclinations[0]; i++){
         ExclusionList[   infoparal[i]   ]= true ;
      }
      for(i=0; i< NSkewhits; i++){
         ExclusionListSkew[   infoskew[i]   ]= true ;
      }








//-----------------------------------   exclusion of straws with multiple hits

      //   first the parallel straws
      for(i=0; i< Minclinations[0]-1; i++){
       if( ExclusionList[ infoparal[i] ] ){
         for(j=i+1; j< Minclinations[0]; j++){
           if(
             fabs(info[ infoparal[i] ][0] - info[ infoparal[j] ][0])<1.e-20
                             &&
             fabs(info[ infoparal[i] ][1] - info[ infoparal[j] ][1])<1.e-20  ) {

               ExclusionList[   infoparal[i]   ]= false ;
               ExclusionList[   infoparal[j]   ]= false ;

           }
         } //  end of  for(j=i+1; j< Minclinations[0]; j++)
       }  //   end of if( ExclusionList[   infoparal[i]   ] )
      }   //   end of for(i=0; i< Minclinations[0]-1; i++)


      //   then the skew straws


      for(i=0; i< NSkewhits-1; i++){
       if( ExclusionList[ infoskew[i] ] ){
         for(j=i+1; j< NSkewhits; j++){
           if(
             fabs(info[ infoskew[i] ][0] - info[ infoskew[j] ][0])<1.e-20
                             &&
             fabs(info[ infoskew[i] ][1] - info[ infoskew[j] ][1])<1.e-20  ) {

               ExclusionListSkew[   infoskew[i]   ]= false ;
               ExclusionListSkew[   infoskew[j]   ]= false ;

           }
         } //  end of  for(j=1; j< NSkewhits; j++)
       }  //   end of if( ExclusionList[ infoskew[i] ] )
      }   //   end of for(i=0; i< Minclinations[0]-1; i++)



//-----------------------------------  end of exclusion of straws with multiple hits








      trajectory_vertex[0]=trajectory_vertex[1]=trajectory_vertex[2]=0.;

      PndSttFromXYtoConformal(trajectory_vertex,info, Minclinations[0],infoparalConformal, &status);



      PndSttBoxConformalFilling(infoparalConformal, Minclinations[0], nBoxConformal, HitsinBoxConformal,
                                RConformalIndex, FiConformalIndex);



//     start the track finding procedure


//----- loop over the parallel hits

  nTracksFoundSoFar=0;    // # tracks found

//   begins the first iteration with more severe cuts on the # hits in track candidate

  MINIMUMHITSPERTRACK=4;
  for(iParHit=0; iParHit<Minclinations[0] + 1 -  MINIMUMHITSPERTRACK ; iParHit++) {

      if( ! ExclusionList[    infoparal[iParHit]  ] )  continue;
      nHitsinTrack[nTracksFoundSoFar] = PndSttFindTrackPatterninBoxConformal(
                           1,   //  distance in R cells allowed
                           2,   //  distance in Fi cells allowed
                           Minclinations[0],
                           iParHit,
                           info,
                           ExclusionList,
                           RConformalIndex,
                           FiConformalIndex,
                           nBoxConformal,
                           HitsinBoxConformal,
                           &ListHitsinTrack[nTracksFoundSoFar][0]
                                                    );

      if( nHitsinTrack[nTracksFoundSoFar] < MINIMUMHITSPERTRACK) {
//        cout<<"      nHitsinTrack = "<<nHitsinTrack[nTracksFoundSoFar]<<
//  "  is < the MINIMUMHIITSPERTRACK ("<< MINIMUMHITSPERTRACK<<
//  ");  skip this candidate track\n";
        continue;
      }



//-----------------------

//   find among the ListHitsinTrack  if there are at least a minimum # of hits belonging to the outer part
//   of the STT  system

      for(j=0, Nouter =0; j<nHitsinTrack[nTracksFoundSoFar]; j++){
         if(info[infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ]][0]* info[infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ]][0]+
            info[infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ]][1]* info[infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ]][1]
            < RmaxStrawSkewArea*RmaxStrawSkewArea  )   break;
         Nouter++;
      }


     if( Nouter >= MINIMUMOUTERHITSPERTRACK) {

      for(i=0; i< Nouter;i++){
          ListHitsinTrackinWhichToSearch[i]=ListHitsinTrack[nTracksFoundSoFar][i];
      }





      for(i=0; i< Nouter;i++){
        SeedParallelNumber = ListHitsinTrackinWhichToSearch[i];
        Naux =  PndSttFindTrackPatterninBoxConformalSpecial(
                           3,    // NRCELLDISTANCE
                           1,    // NFiCELLDISTANCE
                           Minclinations[0],
                           Nouter,
                           SeedParallelNumber,
                           ListHitsinTrackinWhichToSearch,
                           info,
                           ExclusionList,
                           RConformalIndex,
                           FiConformalIndex,
                           nBoxConformal,
                           HitsinBoxConformal,
                           OutputListHitsinTrack);

      if( Naux >= MINIMUMOUTERHITSPERTRACK && Naux > 0.7 * Nouter )  break;

      if( Naux >= MINIMUMOUTERHITSPERTRACK) {
//   further collection of hits in the inner region but this time strictly connected to the outer ones

//  first the list of non outer hits
         for(j=Nouter;j<nHitsinTrack[nTracksFoundSoFar]; j++){
            ListHitsinTrackinWhichToSearch[j-Nouter] = ListHitsinTrack[nTracksFoundSoFar][j];
         }



         Nbaux =  PndSttFindTrackStrictCollection(
                           1,    // NFiCELLDISTANCE
                           SeedParallelNumber,   //  seed hit
                           nHitsinTrack[nTracksFoundSoFar]-Nouter,
                           ListHitsinTrackinWhichToSearch,
                           ExclusionList,
                           FiConformalIndex,
                           OutputList2HitsinTrack
                                                );
//   add the new hits found to the list
         nHitsinTrack[nTracksFoundSoFar]=Naux+Nbaux;
         for(j=0;j<Naux;j++){
            ListHitsinTrack[nTracksFoundSoFar][j] = OutputListHitsinTrack[j];
         }
         for(j=0;j<Nbaux;j++){
            ListHitsinTrack[nTracksFoundSoFar][Naux+j] = OutputList2HitsinTrack[j];
         }
         break;
      }

      }   // end of for(i=0; i< Nouter;i++)
     }    // end of if( Nouter >= MINIMUMOUTERHITSPERTRACK)





//---------------------------






//  finding the rotation angle for best utilization of the MILP procedure

      for(j=0, rotationcos=0., rotationsin=0.; j<nHitsinTrack[nTracksFoundSoFar]; j++){
         rotationcos += cos( (0.5+ FiConformalIndex[ infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ] ])
                                      *2.*PI/nFidivConformal) ;
         rotationsin += sin( (0.5+ FiConformalIndex[ infoparal[ ListHitsinTrack[nTracksFoundSoFar][j] ] ])
                                      *2.*PI/nFidivConformal) ;
      }
      rotationcos /=nHitsinTrack[nTracksFoundSoFar];
      rotationsin /=nHitsinTrack[nTracksFoundSoFar];
      rotationangle = atan2(rotationsin, rotationcos);



//  fitting with superfast MILP code

//  first redefine the center of the conformal plane; it will be centered in the center of the  hit in the
//  hit list with the LEAST drift radius; this hit has to be excluded from the fitting


      trajectory_vertex[0]=  0.;
      trajectory_vertex[1]=  0.;



  for(j=0; j<nHitsinTrack[nTracksFoundSoFar]; j++){
    for(i=0; i<5;i++){
      auxinfoparalConformal[j][i] = infoparalConformal[ ListHitsinTrack[nTracksFoundSoFar][j]  ][i];
    }
  }



      INTERO=1;

      Status[nTracksFoundSoFar] = PndSttFitHelixCylinder( 
                nHitsinTrack[nTracksFoundSoFar],
                auxinfoparalConformal,
                nTracksFoundSoFar,
                rotationangle,
                trajectory_vertex,
                NHITSINFIT,
                &m[nTracksFoundSoFar],
                &q[nTracksFoundSoFar],
                ALFA,
                BETA,
                GAMMA,
                TypeConf
                      );

      if(Status[nTracksFoundSoFar] < 0  ) {

        continue;
      }




//  this trasformation is valid even if the equation is a straight line from the fit

      Ox[nTracksFoundSoFar]= -0.5*ALFA[nTracksFoundSoFar];
      Oy[nTracksFoundSoFar]= -0.5*BETA[nTracksFoundSoFar];
      R[nTracksFoundSoFar]= Ox[nTracksFoundSoFar]*Ox[nTracksFoundSoFar]+Oy[nTracksFoundSoFar]*Oy[nTracksFoundSoFar]-
                            GAMMA[nTracksFoundSoFar];
      if( R[nTracksFoundSoFar] < 0. )   continue;
      R[nTracksFoundSoFar]= sqrt( R[nTracksFoundSoFar] );

//---------------------------




//---------------------  better association of the hits in the track candidate

  ITRACCIA = nTracksFoundSoFar;



  NN =  PndSttTrkAssociatedParallelHitsToHelixQuater(
                   m[nTracksFoundSoFar],
                   q[nTracksFoundSoFar],
                   Status[nTracksFoundSoFar],
                   nHitsinTrack[nTracksFoundSoFar],
                   &ListHitsinTrack[nTracksFoundSoFar][0],
                   Minclinations[0],
                   Ox[nTracksFoundSoFar],
                   Oy[nTracksFoundSoFar],
                   R[nTracksFoundSoFar],
                   info,
                   infoparalConformal,
                   RConformalIndex,
                   FiConformalIndex,
                   nBoxConformal,
                   HitsinBoxConformal,
                   auxListHitsinTrack              //  this is the output
                                                     );








   if( NN < MINIMUMHITSPERTRACK ) {
     continue;
   }
   nHitsinTrack[nTracksFoundSoFar]=NN;
   for(i=0; i<nHitsinTrack[nTracksFoundSoFar];i++){
     ListHitsinTrack[nTracksFoundSoFar][i]=auxListHitsinTrack[i];
   }
//----------------------------------------------









// --------  here the track and its hits were found, filling the exclusion list

   for(j=0; j<nHitsinTrack[nTracksFoundSoFar]; j++){
     ExclusionList[    infoparal[   ListHitsinTrack[nTracksFoundSoFar][j]  ] ] = false;
   }


//--------------------------------------------------    macro for display
if(iplotta && IVOLTE < 20){
        WriteMacroParallelHitsConformalwithMCspecial(
                   nHitsinTrack[nTracksFoundSoFar],
                   auxinfoparalConformal,
                   nTracksFoundSoFar,
                   ALFA,
                   BETA,
                   GAMMA,
                   Status[nTracksFoundSoFar], trajectory_vertex
                                                     );
}
//----------------------------------- end macro for display





   nTracksFoundSoFar++;

  }      // end  of   for(iParHit=0; iParHit<Minclinations[0] + 1 -  MINIMUMHITSPERTRACK; iParHit++)







//--------------------------------------------------    macro for display
if(iplotta && IVOLTE < 20){
  for(i=0; i<nTracksFoundSoFar;i++){
           WriteMacroParallelAssociatedHits(
                   Ox[i], Oy[i], R[i],
                   nHitsinTrack[i],ListHitsinTrack,
                   info, Nincl, Minclinations, inclination,
                   i
                                                     );
  }


        WriteMacroParallelHitsGeneral(
                   Nhits, info, Nincl, Minclinations, inclination,nTracksFoundSoFar,TypeConf,ALFA,BETA,GAMMA
                                                     );


        WriteMacroParallelHitsGeneralConformalwithMC(
                   Nhits, info, Nincl, Minclinations, inclination,nTracksFoundSoFar,TypeConf,ALFA,BETA,GAMMA
                                                     );

}   //  end if iplotta
//----------------------------------- end macro for display






//    ordering the parallel hits; determining the charge of this track;  finding the initial (at vertex 0,0)
//    and final FI of the track in the Helix reference frame.

  for(i=0; i<nTracksFoundSoFar;i++){

       PndSttOrderingParallel(
                             Ox[i],
                             Oy[i],
                             info,
                             nHitsinTrack[i],
                             &ListHitsinTrack[i][0],
                             infoparal,
                             &Charge[i],
                             &Fi_initial_helix_referenceframe[i],
                             &Fi_final_helix_referenceframe[i]
                       );

//    end of ordering the parallel  hits; determining the charge of this track

//   finding the FI angular range (in the laboratory frame) spanned by this parallel track

       PndSttFindingParallelTrackAngularRange(
                             Ox[i],
                             Oy[i],
                             R[i],
                             Charge[i],
                             &Fi_low_limit[i],
                             &Fi_up_limit[i]
                                             );

//   finding the FI angular range (in the Helix of the trajectory frame) allowed for the skew hits
/*
       PndSttFindingAllowedAngularRangeforSkew(
                             Ox[i],
                             Oy[i],
                             R[i],
                             Charge[i],
                             &Fi_allowedforskew_low[i],
                             &Fi_allowedforskew_up[i]
                                             );
*/




   }    //  end of  for(i=0; i<nTracksFoundSoFar;i++)








//--------------------------------------------------------------------------------




//-----------------------  doing the fit with the skew hits for each XY plane track found
  for(i=0; i<nTracksFoundSoFar;i++){

    GoodSkewFit[i]=false;  //  flag indicating if the skew sector info has completed the parameter info;
                            //  a priori this is set false.


//-----  finding the skew hits intersecting this XY trajectory circle



  TemporarynSkewHitsinTrack = AssociateSkewHitsToXYTrack(
                   ExclusionListSkew,
                   Ox[i],   //  input : X of center of XY plane circle
                   Oy[i],   //  input : Y of center of XY plane circle
                   R[i],   //  input : Radius of XY plane circle
                   info,
                   inclination,
                   Fi_low_limit[i],
                   Fi_up_limit[i],
                   Fi_allowedforskew_low[i],
                   Fi_allowedforskew_up[i],
                   Charge[i],
                   Fi_initial_helix_referenceframe[i],
                   Fi_final_helix_referenceframe[i],
                   TemporarySkewList, // output,  list of selected skew hits (in skew numbering)
                   S,       //  output,  S coordinate of selected Skew hit
                   Z,       //  output,  Z coordinate of selected Skew hit
                   ZDrift,   //  output,  drift distance IN Z DIRECTION only, of selected Skew hit
                   ZErrorafterTilt   //  output,  Radius taking into account the tilt, IN Z DIRECTION only, of selected Skew hit
                                                     );
    nSkewHitsinTrack[i]=TemporarynSkewHitsinTrack;



     if( nSkewHitsinTrack[i] < MINIMUMHITSPERTRACK) {
        continue;
     }



//  finding if there are discontinuity at 0 for fi value of the Skew Straws Hit.
//  In case of discontinuity at 0, add 2*PI to fi of those hits with fi in the 1st quadrant.
//  This is necessary because the discontinuities would make the fit
//  in the SZ plane fail.
//  In this discontinuity fixing, the value FI0 of the vertex (0,0) is also included.
//  If there is discontinuity fixing, the values of S[i] AND POSSIBLY Fi_initial_helix_referenceframe[i]
//  might be modified (+2.*PI) from  now on.


      FixDiscontinuitiesFiangleinSZplane(
                TemporarynSkewHitsinTrack,
                S,
                &Fi_initial_helix_referenceframe[i],
                Charge[i]
                                        );


      Status[i] = PndSttFitSZspacebis( 
                TemporarynSkewHitsinTrack,
                S,
                Z,
                ZDrift,
                Fi_initial_helix_referenceframe[i],   //   this is an input data
                NHITSINFIT,
                &KAPPA[i]
                      );

//    the Status[i] is negative (-99) only when m = 0. as result of the fit in PndSttFitSZspacebis


      if(Status[i] < 0  ) {
        continue;
      }

      FI0[i]=Fi_initial_helix_referenceframe[i];  //  therefore, FI0[i] has an extra +2*PI or -2*PI added in case of tracks
                                                  //  crossing the X axis




//-----  finding a better association  the skew hits intersecting this XY trajectory circle

//    this means discarding those skew hits that are too far away from the fitted straight line
//    found in the SZ fit.


  NNN=AssociateBetterAfterFitSkewHitsToXYTrack(
                   TemporarynSkewHitsinTrack,
                   TemporarySkewList, // input,  list of selected skew hits (in skew numbering)
                   S,       //  input,  S coordinate of selected Skew hit
                   Z,       //  input,  Z coordinate of selected Skew hit
                   ZDrift,   //  input,  drift distance IN Z DIRECTION only, of selected Skew hit
                   ZErrorafterTilt,   //  input,  Radius taking into account the tilt, IN Z DIRECTION only, of selected Skew hit
                   KAPPA[i],    // input, KAPPA result of fit
                   FI0[i],    // input, FI0 result of fit,
                   tempore,  //  output, associated skew hits
                   temporeS,  //  output, associated skew hit  S
                   temporeZ,  //  output, associated skew hits Z
                   temporeZDrift,  //  output, associated skew hit Z drift
                   temporeZErrorafterTilt,  //  output, associated skew hits Z error after tilt
                   &STATUS   // output
                                                     );
//    out of this function  STATUS  is zero signals only that KAPPA  is zero.




 if( STATUS >=0 ){

      if (NNN < MINIMUMHITSPERTRACK) {
        continue;
      }
       GoodSkewFit[i]= true;
       nSkewHitsinTrack[i] = NNN;
       for(j=0;j<nSkewHitsinTrack[i];j++){
           ListSkewHitsinTrack[i][j]=tempore[j];
             S[j]  =  temporeS[j] ;
             Z[j]  =  temporeZ[j] ;
             ZDrift[j]  =  temporeZDrift[j] ;
             ZErrorafterTilt[j]  =  temporeZErrorafterTilt[j] ;
       }

 }   else {

    nSkewHitsinTrack[i]=TemporarynSkewHitsinTrack;
    for(j=0;j<TemporarynSkewHitsinTrack;j++){ ListSkewHitsinTrack[i][j]=TemporarySkewList[j][0];}
    GoodSkewFit[i]= true;
}    //  end of     if( STATUS >=0 )


      // ---------  only for the comparison with the MC truth;  numbering according to the ORIGINAL hit number
           for(i1=0; i1< nSkewHitsinTrack[i]; i1++){
             Sfinal[i][  infoskew[ ListSkewHitsinTrack[i][i1]  ]  ]  =  S[i1] ;
             Zfinal[i][  infoskew[ ListSkewHitsinTrack[i][i1]  ]  ]  =  Z[i1] ;
             ZDriftfinal[i][  infoskew[ ListSkewHitsinTrack[i][i1]  ]  ]  =  ZDrift[i1] ;
             ZErrorafterTiltfinal[i][  infoskew[ ListSkewHitsinTrack[i][i1]  ]  ]  =  ZErrorafterTilt[i1] ;
           }
     // ---------  end of only for the comparison with the MC truth


//     -------------------------------------------------------------





//    ordering the parallel and skew hits; determining the charge of this track


       PndSttOrdering(
                             Ox[i],
                             Oy[i],
                             info,
                             nHitsinTrack[i],
                             &ListHitsinTrack[i][0],
                             nSkewHitsinTrack[i],
                             &ListSkewHitsinTrack[i][0],
                             S,
                             infoparal,
                             infoskew,
                             &nTotalHits[i],
                             &BigList[i][0],
                             &Charge[i]
                       );

//----------------------------------------------   some printouts
if(istampa>=2 && IVOLTE<20) {
   cout<<"      Evento n. "<<IVOLTE<<"; elenco finale hits per traccia n. "<<i<<"  list dei "<<nHitsinTrack[i]
               <<" hit paralleli (original notation) :\n";
   for(int ig=0;ig<nHitsinTrack[i];ig++){
        cout<<"          hit n.  "<<infoparal[ ListHitsinTrack[i][ig] ] <<endl;
   }
cout<<"     elenco dei "<<nSkewHitsinTrack[i]<<" hits skew\n";
   for(int ig=0;ig<nSkewHitsinTrack[i];ig++){
        cout<<"          hit n.  "<<infoskew[ ListSkewHitsinTrack[i][ig] ] <<endl;
   }

   cout<<"  list dei "<<nTotalHits[i]<<"   hits come stanno in BigList (original notation) :\n";

   for(int ig=0;ig<nTotalHits[i];ig++){
        cout<<"          hit n.  "<<BigList[i][ig] <<endl;
   }

   cout<<"-------------------------------------------------------------\n";



}
//----------------------------------------------   end of some printouts






   }   //  end of     for(i=0; i<nTracksFoundSoFar;i++)











//----------------------  temporarily  matching with MC tracks here --------------------------------




//    associate the tracks found with Pattern Recognition to the MC tracks

   if( nMCTracks >0 && nTracksFoundSoFar > 0 ){

         AssociateFoundTrackstoMC(
                  nTracksFoundSoFar,
                  nHitsinTrack,
                  ListHitsinTrack,
                  nSkewHitsinTrack,
                  ListSkewHitsinTrack,
                  daTrackFoundaTrackMC,
                  daMCTrackaTrackFound 
                                   );
   }

//---------------------------------------------------------------------------------------------------------




//--------------------  inizio della sezione sul confronto tra MC truth e tracce trovate

// prima  gli hits paralleli ---------------------

   for(jexp=0; jexp<nTracksFoundSoFar;jexp++){
     nParalCommon[jexp]=0;
     nSkewCommon[jexp]=0;
   }
   for(imc=0; imc<nMCTracks;imc++){
     nMCParalAlone[imc]=0;
     nMCSkewAlone[imc]=0;
   }

   for(imc=0; imc<nMCTracks;imc++){
     if( daMCTrackaTrackFound[imc]< 0 )  continue;
     jexp = daMCTrackaTrackFound[imc];

        for(mchit=0; mchit<nHitsInMCTrack[imc]; mchit++){
           for(exphit=0; exphit<nHitsinTrack[jexp]; exphit++){
               if(infoparal[   ListHitsinTrack[jexp][exphit]  ] == FromMCTrackToHit[imc][mchit] ){
                  ParalCommonList[jexp][ nParalCommon[jexp] ] = FromMCTrackToHit[imc][mchit];
                  nParalCommon[jexp]++;
                  goto  out ;
               }   //  end of   if(infoparal[ListHitsinTrack[jexp][exphit]] == FromMCTrackToHit[imc][mchit])
           }  //  end of  for(exphit=0; exphit<nHitsinTrack[jexp]; l++)
           MCParalAloneList[imc][ nMCParalAlone[imc] ] = FromMCTrackToHit[imc][mchit];
           nMCParalAlone[imc]++;
           out:   ;
        }   //  end of  for(mchit=0; mchit<nHitsInMCTrack[imc]; mchit++)


//  ora gli hits skews in comune
        for(mchit=0; mchit<nSkewHitsInMCTrack[imc]; mchit++){
           for(exphit=0; exphit<nSkewHitsinTrack[jexp]; exphit++){
               if(infoskew[   ListSkewHitsinTrack[jexp][exphit]  ] == FromMCTrackToSkewHit[imc][mchit] ){
                  SkewCommonList[jexp][ nSkewCommon[jexp] ] = FromMCTrackToSkewHit[imc][mchit];
                  nSkewCommon[jexp]++;
                  goto out2 ;
               }
           }  //  end of  for(exphit=0; exphit<nSkewHitsinTrack[jexp]; exphit++)
           MCSkewAloneList[imc][ nMCSkewAlone[imc] ] = FromMCTrackToSkewHit[imc][mchit];
           nMCSkewAlone[imc]++;
           out2:  ;
        }   //  end of  for(mchit=0; mchit<nHitsInMCTrack[imc]; mchit++)

   }  //  end of   for(imc=0: imc<nMCTracks;imc++)



//   individua gli hits spuri delle tracce trovate dal pattern recognition

   for(i=0; i<nTracksFoundSoFar;i++){
     if ( daTrackFoundaTrackMC[i] < 0 ){
        nSpuriParinTrack[i]=nHitsinTrack[i];
        nSpuriSkewinTrack[i]=nSkewHitsinTrack[i];
        continue;
     }

// spurie degli hit paralleli
     nSpuriParinTrack[i]= 0 ;
     for(exphit=0; exphit<nHitsinTrack[i]; exphit++){
       for(j=0; j<nParalCommon[i]; j++){
        if(  infoparal[ ListHitsinTrack[i][exphit] ]  == ParalCommonList[i][j] ) { goto esci ;}
       }
       ParSpuriList[i][ nSpuriParinTrack[i] ] = infoskew[ ListHitsinTrack[i][exphit] ];
       nSpuriParinTrack[i]++;
esci:  ;
     }

// spurie degli hit skew
     nSpuriSkewinTrack[i]= 0 ;
     for(exphit=0; exphit<nSkewHitsinTrack[i]; exphit++){
       for(j=0; j<nSkewCommon[i]; j++){
        if(  infoskew[ ListSkewHitsinTrack[i][exphit] ]  == SkewCommonList[i][j] ) {goto esci2 ;}
       }
       SkewSpuriList[i][ nSpuriSkewinTrack[i] ] = infoskew[ ListSkewHitsinTrack[i][exphit] ];
       nSpuriSkewinTrack[i]++;
esci2:  ;
     }

   }   //  end of  for(i=0; i<nTracksFoundSoFar;i++)



  if(istampa>=2 )  fprintf(HANDLE, "\n Evento %d  NTotaleTracceMC %d ------\n",IVOLTE, nMCTracks);

for (i=0; i<nMCTracks && istampa>=2 ;i++){
   fprintf(HANDLE,"----------------------------------------------------------\n");
   ii=daMCTrackaTrackFound[i];
   if( ii <0  ) {
    fprintf(HANDLE,"       TracciaMC %d has not a corresponding found track in pattern recognition\n",i);
            continue;
         }
   if( ! ( nHitsInMCTrack[i]>= MINIMUMHITSPERTRACK && nSkewHitsInMCTrack[i] >= MINIMUMSKEWHITSPERTRACK
                  &&  R_MC[i] > RStrawDetectorMin )
       ) {
    fprintf(HANDLE,"       TracciaMC %d NONsoddisfaRequisitiMinimi with %d Hits paral. in MC track, %d skew hits in MC track, %f Radius in MC track ",i,
                         nHitsInMCTrack[i], nSkewHitsInMCTrack[i],  R_MC[i]      );
    fprintf(HANDLE,"     (MINIMUMHITSPERTRACK = %d, MINIMUMSKEWHITSPERTRACK=%d, minRadius=%f\n",
                                 MINIMUMHITSPERTRACK, MINIMUMSKEWHITSPERTRACK,  RStrawDetectorMin );
            continue;
         }
   if( ! ( GoodSkewFit[ii] ) ) {
    fprintf(HANDLE,
"       TracciaMC %d; sua FoundTrack associata (n. %d) NONsoddisfaRequisitiMinimi perche' in Z-S KAPPA e' risultata || asse S\n",i,ii);
            continue;
         }
   if(fabs(KAPPA[ii])<1.e-20 ){
    fprintf(HANDLE,
"       TracciaMC %d; sua FoundTrack associata (n. %d) NONsoddisfaRequisitiMinimi perche' KAPPA troppo piccolo; KAPPA = %g\n",
          i,ii,KAPPA[ii]);
           continue;
   }
   Double_t dista=sqrt( Ox[ii]*Ox[ii]+Oy[ii]*Oy[ii] );
   if(fabs(dista)<1.e-20 ){
    fprintf(HANDLE,"       TracciaMC %d; sua FoundTrack associata (n. %d) NONsoddisfaRequisitiMinimi perche' centro Helix Cilinder dista solo %g da (0,0)\n",
           i,ii,dista);
           continue;
   }
    fprintf(HANDLE,
"       TracciaMC %d ParHitsMC %d ParMecc %d ParMeccSpuri %d SkewHitsMC %d  SkewMecc %d SkewMeccSpuri %d\n",
             i,
             nHitsInMCTrack[i],
             nParalCommon[daMCTrackaTrackFound[i]],
             nSpuriParinTrack[daMCTrackaTrackFound[i]],
             nSkewHitsInMCTrack[i],
             nSkewCommon[daMCTrackaTrackFound[i]],
             nSpuriSkewinTrack[daMCTrackaTrackFound[i]]

           )  ;
    fprintf(HANDLE,
"       e corrisponde a track found n. %d\n", daMCTrackaTrackFound[i]  );
    fprintf(HANDLE,
"       AVENDO %d hits paralleli e %d hits skew non mecciati dalla corrisponde track found\n", nMCParalAlone[i],nMCSkewAlone[i]  );

    HoughFi = atan2(Oy[daMCTrackaTrackFound[i]],Ox[daMCTrackaTrackFound[i]]);
    if(HoughFi<0.)  HoughFi += 2.*PI;


    fprintf(HANDLE,
"       R_MC %g R %g Fi_MC %g Fi %g KAPPA_MC %g KAPPA %g FI0_MC %g FI0 %g\n",
     MCtruthTrkInfo[8][i],
     R[ daMCTrackaTrackFound[i] ],
     MCtruthTrkInfo[7][i],
     HoughFi,
     MCtruthTrkInfo[12][i],
     KAPPA[ daMCTrackaTrackFound[i] ],
     MCtruthTrkInfo[13][i],
     FI0[ daMCTrackaTrackFound[i] ]
           );
     

  }   //   end of  for (i=0; i<nMCTracks;i++)


//--------------ghosts

if( istampa>=2){
    int NParghost=0, NParhitsghost=0,icc;
    for(icc=0; icc<nTracksFoundSoFar;icc++){
       if( daTrackFoundaTrackMC[icc] == -1){
          NParghost++;
          NParhitsghost += nHitsinTrack[icc]+nSkewHitsinTrack[icc];

          fprintf(HANDLE,"          tracce Trovata n. %d e' Ghost\n",icc);
       }
    }
    fprintf(HANDLE,
"          tracceGhostTrovate %d TotaleHitsGhost %d  ----\n",
            NParghost,
            NParhitsghost
           );

    fprintf(HANDLE,"----------------------------------------------------------\n");


}  //   end of    if( istampa>=2)

//--------------------  fine della sezione sul confronto tra MC truth e tracce trovate







//---------------------------------------------------------------------------------------------------------
//   loading the hits found and associates to a track in a  PndTrackCand  class; a class per each track

    for(i=0; i<nTracksFoundSoFar;i++){
     ii=daTrackFoundaTrackMC[i];
     if( daTrackFoundaTrackMC[i] == -1)  continue;
     if( !  GoodSkewFit[i]  )  continue;
       Double_t dista=sqrt( Ox[i]*Ox[i]+Oy[i]*Oy[i] );
       if(fabs(KAPPA[i])<1.e-20  ||  dista < 1.e-20) continue;
       Double_t Ptras = R[i]*0.003*BFIELD;
       Double_t Pzini = 0.003*BFIELD/KAPPA[i];
       Double_t Pxini = Ptras*Oy[i]/dista;
       Double_t Pyini = -Ptras*Ox[i]/dista;



         new((*trackArray)[ipinco])  PndTrackCand;
         PndTrackCand *pTrckCand = (PndTrackCand*) trackArray->At(ipinco);
//         PndTrackCand *pTrckCand = (PndTrackCand*) (*trackArray)[ipinco];
         ipinco++;
         Double_t inv=R[i]*KAPPA[i];
	  TVector3 dirSeed(Pxini,
			   Pyini,
			   Pzini); // momentum direction in starting point
          Double_t qop = Charge[i]/dirSeed.Mag();

          dirSeed.SetMag(1.);
	  TVector3 posSeed(0.,
			   0.,
			   0.);  //  direction in starting point
          pTrckCand->setTrackSeed(posSeed, dirSeed, qop);
          pTrckCand->setMcTrackId(  daTrackFoundaTrackMC[i]   );
          for(j=0; j< nTotalHits[i]; j++){
              pTrckCand->AddHit(kSttHit, (Int_t) BigList[i][j] , j);
          }


    }   //  end of     for(i=0; i<nTracksFoundSoFar;i++)





//-----------------------------------------------------------------------------------

//    this is for the hits for LHeTrack later; loading the X, Y, Z position info of the hit
//    as obtained from the found track parameters.

  for(i=0; i< Nhits; i++){
    Zpos_for_LHeTrack[i]=0.;       //  this by default excludes this hits from LHeTrack consideration
  }


  for(i=0; i<nTracksFoundSoFar;i++){

//     first the || hits
    for( j=0; j< nHitsinTrack[i]; j++){
       PndSttInfoXYZParal (
                             info,
                             infoparal[ ListHitsinTrack[i][j] ],
                             Ox[i],
                             Oy[i],
                             R[i],
                             KAPPA[i],
                             FI0[i],
                             Charge[i],
                             Posiz
                           );
       Xpos_for_LHeTrack[  infoparal[ ListHitsinTrack[i][j] ]  ]=Posiz[0];
       Ypos_for_LHeTrack[  infoparal[ ListHitsinTrack[i][j] ]  ]=Posiz[1];
       Zpos_for_LHeTrack[  infoparal[ ListHitsinTrack[i][j] ]  ]=Posiz[2];
if(istampa>=3)  cout<<"DoFind, paralleli, infoparal[ ListHitsinTrack[i][j] ] = "<<
       infoparal[ ListHitsinTrack[i][j] ]<<
       ", X = "<<
       Posiz[0]<<
       ", Y = "<<
       Posiz[1]<<
       ", Z = "<<
       Posiz[2]<<endl;

    }  //   end  of  for( j=0; j< nHitsinTrack[i]; j++)

//     then the skew hits

    if (!GoodSkewFit[i]) continue;

    for( j=0; j< nSkewHitsinTrack[i]; j++){
       PndSttInfoXYZSkew (
                             Zfinal[i][ infoskew[ ListSkewHitsinTrack[i][j] ] ],       //  Z coordinate of selected Skew hit
                             ZDriftfinal[i][ infoskew[ ListSkewHitsinTrack[i][j] ] ],   // drift distance IN Z DIRECTION only, of Skew hit
                             Sfinal[i][ infoskew[ ListSkewHitsinTrack[i][j] ] ],
                             Ox[i],
                             Oy[i],
                             R[i],
                             KAPPA[i],
                             FI0[i],
                             Charge[i],
                             Posiz
                            );
       Xpos_for_LHeTrack[  infoskew[ ListSkewHitsinTrack[i][j] ]  ]=Posiz[0];
       Ypos_for_LHeTrack[  infoskew[ ListSkewHitsinTrack[i][j] ]  ]=Posiz[1];
       Zpos_for_LHeTrack[  infoskew[ ListSkewHitsinTrack[i][j] ]  ]=Posiz[2];
if(istampa>=3)  cout<<"DoFind, skew, infoskew[ ListSkewHitsinTrack[i][j] ] = "<<
       infoskew[ ListSkewHitsinTrack[i][j] ]<<", ListSkewHitsinTrack[i][j] = "<<
       ListSkewHitsinTrack[i][j]<<
       ", X = "<<
       Posiz[0]<<
       ", Y = "<<
       Posiz[1]<<
       ", Z = "<<
       Posiz[2]<<endl;
    }    //  end of for( j=0; j< nSkewHitsinTrack[i]; j++)

  }  //   end of for(i=0; i<nTracksFoundSoFar;i++)


  // loading helix hits (e.g. for LHeTrack)
  if(fHelixHitProduction) {
    
    for(iHit=0; iHit<Nhits;iHit++){
      // HelixHit Production after PR
      TClonesArray& clref = *helixHitArray;
      Int_t size = clref.GetEntriesFast();

      TVector3 pos(0., 0., 0.);
      if( fabs( Zpos_for_LHeTrack[iHit] ) > 1.e-20 ) {
	pos.SetXYZ(Xpos_for_LHeTrack[iHit],
		   Ypos_for_LHeTrack[iHit],
		   Zpos_for_LHeTrack[iHit]);
      }

      TVector3 posErr(0, 0, 0); // CHECK put the errors
      PndSttHelixHit *  helixhit = new(clref[size]) PndSttHelixHit(ListPointer_to_Hit[iHit]->GetDetectorID(),  
								   ListPointer_to_Hit[iHit]->GetTubeID(), 
								   iHit, ListPointer_to_Hit[iHit]->GetRefIndex(), 
								   pos, posErr,
								   ListPointer_to_Hit[iHit]->GetIsochrone(), 
								   ListPointer_to_Hit[iHit]->GetIsochroneError(),
								   0.0);

   
    }  //   end of for(iHit=0; iHit<Nhits;iHit++)
  } // end of if(fHelixHitProduction) 



//---------------------  end of loading for LHeTrack later.







//---------------   printouts of comparison with MC for judging algorithm performance

  if( nMCTracks >0 ) {
    for(i=0; i<nTracksFoundSoFar;i++){
       if(!GoodSkewFit[i])   continue;

    HoughFi = atan2(Oy[i],Ox[i]);
    if(HoughFi<0.)  HoughFi += 2.*PI;
if(istampa>=2){
    fprintf(HANDLE2,"Evento n. %d Found track %d messa in PndTrackCand",IVOLTE, i);
    fprintf(HANDLE2,
"       R_MC %g R %g Fi_MC %g Fi %g KAPPA_MC %g KAPPA %g FI0_MC %g FI0 %g\n",
     MCtruthTrkInfo[8][ii],
     R[ i ],
     MCtruthTrkInfo[7][ii],
     HoughFi,
     MCtruthTrkInfo[12][ii],
     KAPPA[ i ],
     MCtruthTrkInfo[13][ii],
//     FI0[ i ]
     fmod(HoughFi+ PI, 2.*PI)
           );

}   //  end of if (istampa>=2)



    for( j=0; j<nParalCommon[i]; j++){

       PndSttInfoXYZParal (
                             info,
                             ParalCommonList[i][j],
                             Ox[i],
                             Oy[i],
                             R[i],
                             KAPPA[i],
                             FI0[i],
                             Charge[i],
                             Posiz
                                  );

if(istampa>=3)  cout<<"DoFind, paralleli, n. hits (original notation) = "<<
       ParalCommonList[i][j] <<
       ", X = "<<
       Posiz[0]<<
       ", Y = "<<
       Posiz[1]<<
       ", Z = "<<
       Posiz[2]<<endl;


if(istampa>=2){
       fprintf(PHANDLEX,"%g\n", veritaMC[ ParalCommonList[i][j] ] [0] - Posiz[0]);
       fprintf(PHANDLEY,"%g\n", veritaMC[ ParalCommonList[i][j] ] [1] - Posiz[1]);
       fprintf(PHANDLEZ,"%g\n", veritaMC[ ParalCommonList[i][j] ] [2] - Posiz[2]);
}



         }  //   end of for( j=0; j<nParalCommon[i]; j++)


    for( j=0; j<nSkewCommon[i]; j++){

       PndSttInfoXYZSkew (
                             Zfinal[i][ SkewCommonList[i][j] ],       //  Z coordinate of selected Skew hit
                             ZDriftfinal[i][ SkewCommonList[i][j] ],   // drift distance IN Z DIRECTION only, of Skew hit
                             Sfinal[i][ SkewCommonList[i][j] ],
                             Ox[i],
                             Oy[i],
                             R[i],
                             KAPPA[i],
                             FI0[i],
                             Charge[i],
                             Posiz
                            );
if(istampa>=3)  cout<<"DoFind, skew, n. hits (original notation) = "<<
       SkewCommonList[i][j] <<
       ", X = "<<
       Posiz[0]<<
       ", Y = "<<
       Posiz[1]<<
       ", Z = "<<
       Posiz[2]<<endl;


if(istampa>=2){
       fprintf(SHANDLEX,"%g\n", veritaMC[ SkewCommonList[i][j] ] [0] - Posiz[0]);
       fprintf(SHANDLEY,"%g\n", veritaMC[ SkewCommonList[i][j] ] [1] - Posiz[1]);
       fprintf(SHANDLEZ,"%g\n", veritaMC[ SkewCommonList[i][j] ] [2] - Posiz[2]);
}

         }  //   end of for( j=0; j<nSkewCommon[i]; j++)





    }   //  end of     for(i=0; i<nTracksFoundSoFar;i++)
  }  //  end of  if( nMCTracks >0 )

//---------------  end of printouts of comparison with MC for judging algorithm performance

//---------------------------------------------------------------------------------------------------------








//------------------------------------- macro di display delle skew

if(iplotta && IVOLTE < 20){

for(i=0; i<nTracksFoundSoFar;i++){
   if( iplotta) {


    HoughR = R[i];
    HoughD   = sqrt(Ox[i]*Ox[i]+
                                    Oy[i]*Oy[i]) -R[i];
    HoughFi = atan2(Oy[i],Ox[i]);
    if(HoughFi<0.)  HoughFi += 2.*PI;





             WriteMacroSkewAssociatedHits(
                   KAPPA[i],FI0[i], HoughD, HoughFi, HoughR,
                   info, Nincl,Minclinations,inclination,
                   i,0,
                   nSkewHitsinTrack[i],
                   ListSkewHitsinTrack,
                   nSkewCommon[i],
                   SkewCommonList
 
                                                     );


      if( daTrackFoundaTrackMC[i] >= 0){
             WriteMacroSkewAssociatedHitswithMC(
                   KAPPA[i],FI0[i], HoughD, HoughFi, HoughR,
                   info, Nincl,Minclinations,inclination,
                   i,0,
                   nSkewHitsinTrack[i],
                   ListSkewHitsinTrack,
                   nSkewCommon[i],
                   SkewCommonList,
                   daTrackFoundaTrackMC[i],
                   nMCSkewAlone[  daTrackFoundaTrackMC[i] ],
                   MCSkewAloneList
                                                     );
      }



/*
        plottamentiSkewconMassimo(
                             imaxima,jmaxima,
                             Nremaining2, RemainingKAPPA, RemainingFI0, KAPPAlow, KAPPAup, FI0low, FI0up,
                             ResultAssociatedHits,HoughR, HoughD, HoughFi);
       for (i=0; i< ResultAssociatedHits.NAssociatedHits ; i++){
         for(j=0; j< ResultAssociatedHits.mAmbiguities[i] ; j++){
                   hx->Fill(ResultAssociatedHits.AssociatedHitsCoordinates[2][j][i]);
         }
        }
*/




   }    //  end of   if (iplotta)






}     //   end of  for(i=0; i<nTracksFoundSoFar;i++)


}

//------------------------------------- fine macro di display delle skew













  return   nTracksFoundSoFar;


 }; //-------------------------------------------------  end of function  PndSttTrackFinderReal::DoFind








CalculatedCircles PndSttTrackFinderReal::PndSttTrkFindCircles(Double_t x1,Double_t y1,Double_t r1,
                                                 Double_t x2,Double_t y2,Double_t r2,
                                                 Double_t x3,Double_t y3,Double_t r3)
{
  Double_t a,b,c,d,ap,bp,cp,dp,radix,solution,Radius, A,B,C,D,AAA,BBB,CCC,DELTA,S,T,X;
  Int_t Nsol = 0;
  Double_t R[8],CX[8],CY[8];
  CalculatedCircles Ris ;

//cout<<"---------------------------------- inizio printout da find_circles \n";


/*
  x1 = X center crf 1;
  y1 = Y center crf 1;
  r1 = radius crf 1;
  x2 = X center crf 2;
  y2 = Y center crf 2;
  r2 = radius crf 2;
  x3 = X center crf 3;
  y3 = Y center crf 3;
  r3 = radius crf 3;
*/

  a=2.*(x1-x2);
  b=2.*(y1-y2);
  d= x1*x1+y1*y1-r1*r1-x2*x2-y2*y2+r2*r2;
  ap=2.*(x1-x3);
  bp=2.*(y1-y3);
  dp= x1*x1+y1*y1-r1*r1-x3*x3-y3*y3+r3*r3;

/*
cout<<"printout iniziale :\nx1="<<x1<<";\nx2="<<x2<<";\nx3="<<x3<<";\ny1="<<y1<<";\ny2="<<y2<<";\ny3="
       <<y3<<";\nr1="<<r1<<";\nr2="<<r2<<";\nr3="<<r3<<endl;
cout<<" a= "<<a<<";  b="<<b<<";  d="<<d<<endl;
cout<<" ap= "<<ap<<";  bp="<<bp<<";  dp="<<dp<<endl;
cout<<"fine printout iniziale\n";
*/

  Double_t aaa= a*bp-b*ap;
//cout<<"aaa  : "<<aaa<<endl;
  if ( aaa == 0.) {
   for(Int_t i1=-1;i1<=1;i1+=2){
    for(Int_t i2=-1;i2<=1;i2+=2){
      c=-2.*(i1*r1-i2*r2);
      for(Int_t i3=-1;i3<=1;i3+=2){
        cp=-2.*(i1*r1-i3*r3);
        if( bp*c-b*cp == 0. && b == 0. && bp == 0. && a != 0. && ap != 0. && a != ap && ap*c-a*cp != 0.){
           Radius = (a*dp-ap*d)/(ap*c-a*cp);
           if ( Radius >0.){
             S = d/a;
             T = -c/a;
             BBB = y1;
             CCC = (S-T*Radius)*(S-T*Radius)-Radius*Radius-2.*x1*(S-T*Radius)-2.*i1*Radius*r1+x1*x1+y1*y1-r1*r1;
             DELTA = BBB*BBB-CCC;
             if(DELTA<0.) {
              continue;
             } else if (DELTA ==0.){
              Nsol++;
              R[Nsol-1] = Radius ;
              CX[Nsol-1] = S-T*Radius;
              CY[Nsol-1] = -BBB;
             } else{
              Nsol+=2;
              R[Nsol-2] = Radius ;
              CX[Nsol-2] = S-T*Radius;
              CY[Nsol-2] = -BBB+sqrt(DELTA);
              R[Nsol-1] = Radius ;
              CX[Nsol-1] = S-T*Radius;
              CY[Nsol-1] = -BBB-sqrt(DELTA);
             }

           }  //  end  if ( Radius >0.)
        }  else if(bp*c-b*cp != 0.) {

         Radius = (-bp*d+b*dp)/(bp*c-b*cp) ;
         if( Radius > 0. && b != 0. ){
           S = (d+c*Radius)/b;
           T = a/b;
           AAA = 1+T*T;
           BBB = -(T*S+x1-T*y1);
           CCC = S*S-Radius*Radius-2.*y1*S-2.*i1*r1*Radius+x1*x1+y1*y1-r1*r1;
           DELTA= BBB*BBB-AAA*CCC;
//cout<<"AAA ="<<AAA<<",  BBB= "<<BBB<<", CCC ="<<CCC<<", DELTA= "<<DELTA<<endl;
//cout<<"S = "<<S<<", T= "<<T<<endl<<"DELTA "<<DELTA<<endl;
           if(DELTA<0.) {
            continue;
           } else if (DELTA ==0.){
             Nsol++;
             R[Nsol-1] = Radius ;
             CX[Nsol-1] = -BBB/AAA;
             CY[Nsol-1] = S-T*CX[Nsol-1];
// cout<<"CX[Nsol-1] ="<<CX[Nsol-1]<<",  CY[Nsol-1]= "<<CY[Nsol-1]<<endl;
           } else {
             Nsol+=2;
             R[Nsol-2] = Radius ;
             CX[Nsol-2] = (-BBB+sqrt(DELTA))/AAA;
             CY[Nsol-2] = S-T*CX[Nsol-2];
             R[Nsol-1] = Radius ;
             CX[Nsol-1] = (-BBB-sqrt(DELTA))/AAA;
             CY[Nsol-1] = S-T*CX[Nsol-1];
//cout<<"CX[Nsol-2] ="<<CX[Nsol-2]<<",  CY[Nsol-2]= "<<CY[Nsol-2]<<endl;
//cout<<"CX[Nsol-1] ="<<CX[Nsol-1]<<",  CY[Nsol-1]= "<<CY[Nsol-1]<<endl;
           }  // end  if(DELTA<0.)
         }   //  end  if( Radius > 0. && b != 0. )
       }    //   end if( bp*c-b*cp == 0.) 
      }    //  end for (Int_t i3
    }    //  end for(Int_t i2
   }   //  end for(Int_t i1

  } else {   // of if(aaa == 0. )

   A=(bp*d-b*dp)/aaa;
   C=(-ap*d+a*dp)/aaa;
// cout<<"aaa "<<aaa<<endl<<"A "<<A<<endl<<"C "<<C<<endl;
   for(Int_t i1=-1;i1<=1;i1+=2){
    for(Int_t i2=-1;i2<=1;i2+=2){
      c=-2.*(i1*r1-i2*r2);
      for(Int_t i3=-1;i3<=1;i3+=2){
        cp=-2.*(i1*r1-i3*r3);
// cout<<"----------------------------------------\n";
// cout<<"c="<<c<<";  cp="<<cp<<endl;

        B=(bp*c-b*cp)/aaa;
        D=(-ap*c+a*cp)/aaa;

        AAA = B*B+D*D-1.;
        BBB = A*B+C*D-B*x1-D*y1-i1*r1;
        CCC = A*A+C*C-2.*x1*A-2.*y1*C+x1*x1+y1*y1-r1*r1;
        DELTA = BBB*BBB - CCC*AAA;
//        cout<<"caso con i1= "<<i1<<", i2, i3 = "<<" "<<i2<<" "<<i3<<endl
//              <<"A "<<A<<";  B = "<<B<<"; C= "<<C<<"; D = "<<D<<endl;
//        cout<<"AAA = "<<AAA<<";  BBB = "<<BBB<<" DELTA "<<DELTA<<endl;
//        cout<<"sqrt(DELTA) = "<<sqrt(DELTA)<<endl;

        if (DELTA <0.) { continue; }
        else if (DELTA==0.){
         if( BBB==0. ){
          continue;
         } else {
           solution=-BBB/AAA;
           if(solution > 0.){
           Nsol++;
           R[Nsol-1] = solution;
             CX[Nsol-1] = A+B*R[Nsol-1];
             CY[Nsol-1] = C+D*R[Nsol-1];
           }
         continue;
        }
       }

//  this is the case when DELTA > 0.

        radix = sqrt(DELTA);

        if (AAA == 0.) {
          cout<<"AAA== 0.";
          continue;
        } else {

          solution=(-BBB+radix)/AAA;
//cout<<"-BBB[j]  radix  AAA[j] : "<<-BBB <<";  "<< radix <<"; "<< AAA<<"; solution=+ :"<<solution<<endl;
          if(solution > 0.){
           Nsol++;
           R[Nsol-1] = solution;
           CX[Nsol-1] = A+B*R[Nsol-1];
           CY[Nsol-1] = C+D*R[Nsol-1];
          }


          solution=(-BBB-radix)/AAA;
//cout<<"-BBB[j]  radix  AAA[j] : "<<-BBB <<";  "<< radix <<"; "<< AAA<<"; solution=- :"<<solution<<endl;
          if(solution > 0.){
           Nsol++;
           R[Nsol-1] = solution;
           CX[Nsol-1] = A+B*R[Nsol-1];
           CY[Nsol-1] = C+D*R[Nsol-1];
          }



        }     //  end of   if(AAA == 0.)


      }    //  end  for(i3
    }     //  end  for(i2
   }     //  end  for(i1
    


  }   // end if ( aaa == 0.)




//cout<<"----------------------------------------\n";
//  cout<<"n. soluzioni : "<<Nsol<<endl;
 Ris.Ncircles=Nsol;
 for(Int_t i=0; i<Nsol;i++){
//  cout<<"Soluzione n. "<<i+1<<"; R = "<<R[i]<<", CX = "<<CX[i]<<", CY = "<<CY[i]<<endl;
  Ris.CX[i]=CX[i];
  Ris.CY[i]=CY[i];
  Ris.R[i] =R[i];
 }



 return Ris;  

}

//----------------------------------------------------   end of function  PndSttTrackFinderReal::PndSttTrkFindCircles


//----------------------------------------------------   begin function  PndSttTrackFinderReal::PndSttTrkFindHelix

 CalculatedHelix PndSttTrackFinderReal::PndSttTrkFindHelix(
      Double_t Ox, Double_t Oy, Double_t R,
      Double_t Zcenter1,Double_t Zcenter2,Double_t Zcenter3,
      Double_t semilengthStraight1, Double_t semilengthStraight2, Double_t semilengthStraight3,
      Double_t C0x1, Double_t C0y1, Double_t C0z1, Double_t semilengthSkew1,
      Double_t r1, Double_t vx1, Double_t vy1, Double_t vz1,
      Double_t C0x2, Double_t C0y2, Double_t C0z2, Double_t semilengthSkew2,
      Double_t r2, Double_t vx2, Double_t vy2, Double_t vz2,
      Int_t *STATUS
                                                         )
{


//-------------------------------------------



/*
 INPUTS :

  Ox, Oy        = abscissa and ordinate of the center of the circular trajectory of
                  the particle;
  R             = radius of such trajectory;
  C0x, C0y, Coz = x, y, z coordinates of a point belonging to the axis of the
                  skewed straw;
  r  = radius of equidrift of such skewed straw;
  vx, vy, vz    =  versor of the direction along which the skewed straw lies.


 OUTPUTS :

  P1x, P1y, P1z  =  x, y, z coordinates of the point intersection between the
                    particle trajectory circle and the equidrift cylinder of
                    the skewed straw calculated as a function of theta (first
                    solution);
  P2x, P2y, P2z  =  x, y, z coordinates of the point intersection between the
                    particle trajectory circle and the equidrift cylinder of
                    the skewed straw calculated as a function of theta (second
                    solution);

*/

  Int_t  Nsolutions, NTOTAL,  Msol, i, j, i1, i2, k1, k2,  enne, jtemp, nfile;

  Double_t aaa, bbb, ccc, ddd, eee, fff,
           bp, cp, bs, cs,
           q1, q2pos, q2neg,
           Rx, Ry, SkewInclWithRespectToS, Aellipsis1, Bellipsis1, Aellipsis2, Bellipsis2, LL,
           alpha, beta, gamma, delta, epsilon,DELTA, A, B, C, D, cosalfa1, cosalfa2,
           alpha1, beta1, gamma1,
           x0, y0, fi1, fi2,
           SSS1, SSS2,
           xmin,xmax,ymin,ymax,
           x1,x2,y1,y2,
           POINTS1[6],POINTS2[6],distance1[2], distance2[2],
           M[4], Temp[4], Tiltdirection1[2], Tiltdirection2[2] ;

//  const Double_t PI = 3.141592654;

  bool BAD1[2], BAD2[2] ;

  char nome[300];

  CalculatedHelix  Result;

//--------------------------



//       cout<<"Entra in PndSttTrkFindHelix.........\n";



 ntimes++;


 aaa = sqrt(vx1*vx1+vy1*vy1+vz1*vz1);
 vx1 /= aaa;
 vy1 /= aaa;
 vz1 /= aaa;
 aaa = sqrt(vx2*vx2+vy2*vy2+vz2*vz2);
 vx2 /= aaa;
 vy2 /= aaa;
 vz2 /= aaa;


 NTOTAL=0;
 Result.Nhelix[0] = Result.Nhelix[1] = Result.Nhelix[2] = 0;

//  calculation of the intersection points between skew straw axis and trajectory cylinder ----------------------------

 calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,r1,vx1,vy1,vz1, STATUS,POINTS1);

 if(*STATUS < 0 ) { return Result;}

 for( i=0; i<2; i++){
  j=3*i;
  distance1[i] = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                 );
  if( distance1[i] >= semilengthSkew1 ){
     BAD1[i] = true ;
  } else {
     BAD1[i]= false ;
  }
 }

//----------------

  if ( BAD1[0]  && BAD1[1] ) {
    *STATUS = -4;
    return Result;
  }

//----------------

 calculateintersections(Ox,Oy,R,C0x2,C0y2,C0z2,r2,vx2,vy2,vz2, STATUS,POINTS2);
 if(*STATUS < 0 ) { return Result;}

//-------------------------
 for( i=0; i<2; i++){
  j=3*i;
  distance2[i] = sqrt(
                  (POINTS2[j]-C0x2)*(POINTS2[j]-C0x2) +
                  (POINTS2[1+j]-C0y2)*(POINTS2[1+j]-C0y2) + 
                  (POINTS2[2+j]-C0z2)*(POINTS2[2+j]-C0z2) 
                 );

  if( distance2[i] >= semilengthSkew2 ){
     BAD2[i] = true ;
  } else {
     BAD2[i]= false ;
  }
 }
//-------------------------

  if ( BAD2[0] && BAD2[1] ) {
    *STATUS = -5;
    return Result;
  }

//---------------------------------------------------------------------------------------------------------------------


for(k1=0; k1<2;k1++){
//              if( BAD1[k1] )  { cout<<"per k1 = "<<k1<<"  la intersezione e' BAD\n";}
 if( BAD1[k1] )  continue;
 i1 = 3*k1;

//  calculation of the approximate axis length of the ellipses projection of the skew straw on the plane tangent to the trajectory cylinder.
//  first skew straw

 Rx = POINTS1[i1]-Ox ;   //  x component Radial vector of cylinder of trajectory
 Ry = POINTS1[1+i1]-Oy ;   //  y direction Radial vector of cylinder of trajectory

 aaa = sqrt(Rx*Rx+Ry*Ry);
 SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
  SkewInclWithRespectToS /= R;
 bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
//  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
 if( bbb > 1.e-10){
   Tiltdirection1[0] = vz1/bbb;
   Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
 } else {
   Tiltdirection1[0] = 1.;
   Tiltdirection1[1] = 0.;
 }

 LL = fabs(vx1*Rx + vy1*Ry);
 if( LL < 1.e-10) continue;
 Aellipsis1 = r1*aaa/LL;

 if(istampa >= 3 && IVOLTE<20){
   cout<<"Lunghezza asse maggiore ellisse1 = "<<Aellipsis1<<";  raggio drift1 = "<<r1<<";  Tdirz = "<<Tiltdirection1[0]
       <<";  TdirFI = "<<Tiltdirection1[1]<<endl;
   cout<<"cos angolo con la normale = "<<LL/aaa<<endl;
 }

// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder
// under the safe assumption that the ellipse has the major axis in Z direction.

 if(
    Aellipsis1 > semilengthStraight1-fabs(POINTS1[i1+2]-Zcenter1)   ||
    Aellipsis1 > semilengthStraight2-fabs(POINTS1[i1+2]-Zcenter2)   ||
    Aellipsis1 > semilengthStraight3-fabs(POINTS1[i1+2]-Zcenter3)   ||
    distance1[k1] + Aellipsis1 > semilengthSkew1        //  the ellipsis goes out of the boundaries of the skew straw
   )  continue;




  fi1 = atan2(POINTS1[i1+1]-Oy, POINTS1[i1]-Ox) ;  // atan2 returns radians in (-pi and +pi]
  if( fi1 < 0.) fi1 += 2.*PI;


 for(k2=0; k2<2;k2++){
  if(  BAD2[k2] )  continue;

  i2 = 3*k2;

//  calculation of the approximate axis length of the ellipses projection of the skew straw on the plane tangent to the trajectory cylinder.
//  first skew straw

  Rx = POINTS2[i2]-Ox ;   //  x direction along R of cylinder of trajectory
  Ry = POINTS2[1+i2]-Oy ;   //  y direction along R of cylinder of trajectory

  aaa = sqrt(Rx*Rx+Ry*Ry);
  SkewInclWithRespectToS = (-Ry*vx2 + Rx*vy2)/aaa ;
  SkewInclWithRespectToS /= R;
  bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz2*vz2);
//  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
 if( bbb > 1.e-10){
   Tiltdirection2[0] = vz2/bbb;
   Tiltdirection2[1] = SkewInclWithRespectToS/bbb;
 } else {
   Tiltdirection2[0] = 1.;
   Tiltdirection2[1] = 0.;
 }
 LL = fabs(vx2*Rx + vy2*Ry);
 if(LL < 1.e-10) continue;
 Aellipsis2 = r2*aaa/LL;
// Bellipsis2 = r2;

// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

  if(
    Aellipsis2 > semilengthStraight1-fabs(POINTS2[i2+2]-Zcenter1)   ||  // the ellipsis goes out of the boundaries of the straight straws
    Aellipsis2 > semilengthStraight2-fabs(POINTS2[i2+2]-Zcenter2)   ||
    Aellipsis2 > semilengthStraight3-fabs(POINTS2[i2+2]-Zcenter3)   ||
    distance2[k2] + Aellipsis2 > semilengthSkew2        //  the ellipsis goes out of the boundaries of the skew straw
    )  continue;


//    end of boundaries checks, now find KAPPA and FI0





     fi2 = atan2(POINTS2[i2+1]-Oy, POINTS2[i2]-Ox) ;  // atan2 returns radians in (-pi and +pi]
     if ( fi2 < 0.)  fi2 += 2.*PI;





//   translation with the new variables ( those of the lateral surface of the trajectory cylinder and with the first ellipsis
//   positioned at 0,0


  for ( enne = -1; enne<2; enne++) {    //  enne  is the order of the solution


//   translation with the new variables ( those of the lateral surface of the trajectory cylinder and with the first ellipsis
//   positioned at 0,0



     Result.Nhelix[enne+1] = 4;

  for(i=0; i<2; i++){
   for(j=0; j<2; j++){

     x1 =  POINTS1[i1+2] + (1 - 2*j)*Aellipsis1*Tiltdirection1[0];
     y1 = fi1 + (1 - 2*j)*Aellipsis1*Tiltdirection1[1] ;
     x2 =  POINTS2[i2+2] + (1 - 2*i)*Aellipsis2*Tiltdirection2[0];
     y2 = fi2 + (1 - 2*i)*Aellipsis2*Tiltdirection2[1] + enne * 2. * PI  ;




     Nsolutions = j + 2*i;

     if ( x2-x1 != 0.){
       Result.KAPPA[enne+1][Nsolutions] =  (y2-y1) / (x2-x1) ;
       Result.FI0[enne+1][Nsolutions] = -Result.KAPPA[enne+1][Nsolutions] * x1 + y1;
     } else {
       Result.KAPPA[enne+1][Nsolutions] = 1.e14;
       Result.FI0[enne+1][Nsolutions] = x1;
     }

    }
   }      //  end of   for(i=0; i<2; i++)







// --------------------- inizio stampe diagnostiche e macros diagnostiche



// --------------------------------------------------------------------   stampa delle macro di controllo
if(iplotta && IVOLTE < 20){

  Bellipsis1 = r1/R;
  Bellipsis2 = r2/R;

  SSS1=atan2(POINTS1[i1+1]-Oy,POINTS1[i1]-Ox);
  if( SSS1<0.) SSS1 +=2.*PI;
  SSS2=atan2(POINTS2[i2+1]-Oy,POINTS2[i2]-Ox);
  if( SSS2<0.) SSS2 +=2.*PI;
  SSS2 += 2.*PI*enne;

for(i=0,nfile=0; i<4; i++){
 if(ntimes < 3){
  nfile++;

  aaa = fabs(POINTS1[i1+2]-POINTS2[i2+2])*0.05;
  bbb = fabs(SSS1-SSS2)*0.05;

  if(POINTS1[i1+2]-Aellipsis1<POINTS2[i2+2]-Aellipsis2){xmin=POINTS1[i1+2]-Aellipsis1-aaa;} else
{xmin=POINTS2[i2+2]-Aellipsis2-aaa;}
  if(POINTS1[i1+2]+Aellipsis1>POINTS2[i2+2]+Aellipsis2){xmax=POINTS1[i1+2]+Aellipsis1+aaa;} else
{xmax=POINTS2[i2+2]+Aellipsis2+aaa;}

  if( SSS1-Bellipsis1 < SSS2-Bellipsis2){ ymin = SSS1-Bellipsis1-bbb; } else { ymin = SSS2-Bellipsis2-bbb; }
  if( SSS1+Bellipsis1 > SSS2+Bellipsis2){ ymax = SSS1+Bellipsis1+bbb; } else { ymax = SSS2+Bellipsis2+bbb;}

  if( enne < 0) {
   sprintf(nome,"macro1_combination%d_ennemeno%d_kuno%d_kdue%dn%d.C",ntimes,-enne,k1,k2,nfile);
  } else {
   sprintf(nome,"macro1_combination%d_enne%d_kuno%d_kdue%dn%d.C",ntimes,enne,k1,k2,nfile);
  }
  FILE * MACRO = fopen(nome,"w");
  if( enne < 0) {
    fprintf(MACRO,"void macro1_combination%d_ennemeno%d_kuno%d_kdue%dn%d()\n{\n",ntimes,-enne,k1,k2,nfile);
  } else {
    fprintf(MACRO,"void macro1_combination%d_enne%d_kuno%d_kdue%dn%d()\n{\n",ntimes,enne,k1,k2,nfile);
  }

  Double_t rotation1 = 180.*atan2(Tiltdirection1[1],Tiltdirection1[0])/PI;
  Double_t rotation2 = 180.*atan2(Tiltdirection2[1],Tiltdirection2[0])/PI;
  fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);
  fprintf(MACRO,"TEllipse* E1 = new TEllipse(%f,%f,%f,%f,0.,360.,%f);\n",POINTS1[i1+2],SSS1,Aellipsis1,Bellipsis1,rotation1);
  fprintf(MACRO,"TEllipse * E2 = new TEllipse(%f,%f,%f,%f,0.,360.,%f);\n",POINTS2[i2+2],SSS2,Aellipsis2,Bellipsis2,rotation2);
  fprintf(MACRO,"TLine* L = new TLine(%f,%f,%f,%f);\n",
        xmin,
        Result.KAPPA[enne+1][i]*xmin+Result.FI0[enne+1][i],
        xmax,
        Result.KAPPA[enne+1][i]*xmax+Result.FI0[enne+1][i]
         );
  fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin+(xmax-xmin)*0.1,
                           ymin+(ymax-ymin)*0.1,xmin+(xmax-xmin)*0.1,ymax-(ymax-ymin)*0.1,
                          ymin+(ymax-ymin)*0.1,ymax-(ymax-ymin)*0.1);
  fprintf(MACRO,"Assey->Draw();\n");
  fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin+(xmax-xmin)*0.1,
                           ymin+(ymax-ymin)*0.1,xmax-(xmax-xmin)*0.1,ymin+(ymax-ymin)*0.1,
                          xmin+(xmax-xmin)*0.1,xmax-(xmax-xmin)*0.1);
  fprintf(MACRO,"Assex->Draw();\n");
  if( ymin<2.*PI && ymax > 2.*PI) {
    fprintf(MACRO,"TLine* TWOPI = new TLine(%f,%f,%f,%f);\nTWOPI->SetLineColor(2);\nTWOPI->Draw();\n",
                 xmin,2.*PI,xmax,2.*PI);
  }
  if( ymin<0. && ymax > 0.) {
    fprintf(MACRO,"TLine* BASE = new TLine(%f,%f,%f,%f);\nBASE->SetLineColor(2);\nBASE->Draw();\n",
                 xmin,0.,xmax,0.);
  }
  if( ymin<-2.*PI && ymax > -2.*PI) {
    fprintf(MACRO,"TLine* NEG = new TLine(%f,%f,%f,%f);\nNEG->SetLineColor(2);\nNEG->Draw();\n",
                 xmin,-2.*PI,xmax,-2.*PI);
  }
  fprintf(MACRO,"TLine* Teorica = new TLine(%f,%f,%f,%f);\n",
        xmin,
        xmin/R + 3.*PI/2.,
        xmax,
        xmax/R + 3.*PI/2.
         );
  fprintf(MACRO,"Teorica->SetLineColor(4);\n");
  fprintf(MACRO,"E1->Draw();\nE2->Draw();\nL->Draw();\nTeorica->Draw();\n}\n");
  fclose(MACRO);
 }  //    end of   if(ntimes < 3)

}   //    end   of   for(i=0; i<jtemp; i++)

// -----------------------------------------------------------------  fine  stampa delle macro di controllo

     }   //  end if(iplotta)
// --------------------- fine stampe diagnostiche e macros diagnostiche




   }  //   end  for(enne=0; enne<2; enne++)

  }   // end  for(k2=0;
 }   // end  for(k1=0;

  NTOTAL=4;
 *STATUS = NTOTAL;
 
//----------------------------------------------------------------------------------------------------------------------

/*
cout<<"ultima stampa, N totale soluzioni = "<<NTOTAL<<"; N a 0 giri = "<<
     Result.Nhelix[1]<<"; N a 1 giro "<<Result.Nhelix[2]<<"; N ad un giro sotto "<<Result.Nhelix[0]<<endl;

cout<<"Esce da PndSttTrkFindHelix.........\n";
*/



 return Result;

}
//--------------------------------  end of function         PndSttTrackFinderReal::PndSttTrkFindHelix







 void PndSttTrackFinderReal::calculateintersections(Double_t Ox,Double_t Oy,Double_t R,Double_t C0x,Double_t C0y,
                   Double_t C0z,Double_t r,Double_t vx,Double_t vy,Double_t vz,
                   Int_t *STATUS, Double_t* POINTS)
{


//-------------------------------------------


  Double_t P1x, P1y, P1z, P2x, P2y, P2z;

  Double_t AAA, DELTA, ax, ay, aaa;




/*
 INPUTS :

  Ox, Oy        = abscissa and ordinate of the center of the circular trajectory of
                  the particle;
  R             = radius of such trajectory;
  C0x, C0y, Coz = x, y, z coordinates of a point belonging to the axis of the
                  skewed straw;
  r  = radius of equidrift of such skewed straw;
  vx, vy, vz    =  versor of the direction along which the skewed straw lies.


 OUTPUTS :

  P1x, P1y, P1z  =  x, y, z coordinates of the point intersection between the
                    particle trajectory circle and the equidrift cylinder of
                    the skewed straw calculated as a function of theta (first
                    solution);
  P2x, P2y, P2z  =  x, y, z coordinates of the point intersection between the
                    particle trajectory circle and the equidrift cylinder of
                    the skewed straw calculated as a function of theta (second
                    solution);

 P1x, P1y, .... , P2z  are stored in the array POINTS[0-5];  the status is stored
 in *STATUS.

*/




//--------------------------------------------------------------------------


// from the resolving formula on page 23 of Gianluigi's notes, setting  r=0.


  ax = C0x - Ox;
  ay = C0y - Oy;
  DELTA = R*R*(vx*vx+vy*vy) - (vx*ay - vy*ax)*(vx*ay - vy*ax);
  AAA = vx*vx+vy*vy;


  if ( DELTA < 0. ) {
      *STATUS=-2;
  } else if (AAA == 0.){
      *STATUS=-3;
  } else if (DELTA == 0.){
      *STATUS=1;
      POINTS[0] = C0x - vx*(vx*ax + vy*ay)/AAA;
      POINTS[1] = C0y - vy*(vx*ax + vy*ay)/AAA;
      POINTS[2] = C0z - vz*(vx*ax + vy*ay)/AAA;
  }else {
      *STATUS=0;
      DELTA = sqrt(DELTA);
      POINTS[0] = C0x - vx*(vx*ax + vy*ay - DELTA)/AAA;
      POINTS[1] = C0y - vy*(vx*ax + vy*ay - DELTA)/AAA;
      POINTS[2] = C0z - vz*(vx*ax + vy*ay - DELTA)/AAA;
      POINTS[3] = C0x - vx*(vx*ax + vy*ay + DELTA)/AAA;
      POINTS[4] = C0y - vy*(vx*ax + vy*ay + DELTA)/AAA;
      POINTS[5] = C0z - vz*(vx*ax + vy*ay + DELTA)/AAA;
  }

   return;


}



//----------end of function PndSttTrackFinderReal::calculateintersections






//----------begin of function PndSttTrackFinderReal::PndSttTrkAssociatedHitsToHelix

  AssociatedHitsToHelix PndSttTrackFinderReal::PndSttTrkAssociatedHitsToHelix(
                   Double_t KAPPA,Double_t FI0,Double_t D,Double_t Fi,Double_t R,
                   Int_t Nhits, Double_t info[][7], Int_t Nincl, Int_t Minclinations[], Double_t inclination[][3],
                   Int_t imaxima, Int_t nMaxima
                                                     )
{

    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax, Ox, Oy,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];

    AssociatedHitsToHelix ResultAssociatedHits;




    Ox = (D+R)*cos(Fi);
    Oy = (D+R)*sin(Fi);









//  association of hits, ambiguities, errors.

       ResultAssociatedHits.NAssociatedHits=0;
       ResultAssociatedHits.NAssociatedParallelHits=0;
       ResultAssociatedHits.NAssociatedSkewHits=0;

//if(IVOLTE== 16) {   cout<<"evento 16, from PndSttTrkAssociatedHitsToHelix, Nhits "<<Nhits<<endl; }

       for( i=0; i< Nhits; i++) {

          if( ResultAssociatedHits.NAssociatedHits == nmaxAssociatedHits )  break;
          Kincl = (int) info[i][5] - 1;

// --------------------    association of the hits from parallel straws
         if( info[i][5] == 1. ) {     // parallel straws

          dx = -Ox+info[i][0];
          dy = -Oy+info[i][1];
          distance = sqrt(dx*dx+dy*dy);
          if( distance < 1.e-10)  continue;
          angle = atan2(dy,dx);

          if ( fabs(R - distance ) > nAdmittedRadia*StrawRadius )  continue;
          if(distance > R )  distance *= -1.;
             if( KAPPA == 0.) {
                ResultAssociatedHits.AssociatedHitsCoordinates[0][0][ResultAssociatedHits.NAssociatedHits]= info[i][0]+info[i][3]*dx/distance;  //  X of the hit
                ResultAssociatedHits.AssociatedHitsCoordinates[1][0][ResultAssociatedHits.NAssociatedHits]= info[i][1]+info[i][3]*dy/distance;  //  Y of the hit
                ResultAssociatedHits.AssociatedHitsCoordinates[2][0][ResultAssociatedHits.NAssociatedHits] = -1.e20;
                ResultAssociatedHits.mAmbiguities[ResultAssociatedHits.NAssociatedHits]=1;
                ResultAssociatedHits.AssociatedWireDirection[0][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][0];
                ResultAssociatedHits.AssociatedWireDirection[1][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][1];
                ResultAssociatedHits.AssociatedWireDirection[2][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][2];
                ResultAssociatedHits.AssociatedWireCenter[0][ResultAssociatedHits.NAssociatedHits]=info[i][0];
                ResultAssociatedHits.AssociatedWireCenter[1][ResultAssociatedHits.NAssociatedHits]=info[i][1];
                ResultAssociatedHits.AssociatedWireCenter[2][ResultAssociatedHits.NAssociatedHits]=info[i][2];
                ResultAssociatedHits.AssociatedWireDriftRadius[ResultAssociatedHits.NAssociatedHits]=info[i][3];
                ResultAssociatedHits.Hitnumber[ResultAssociatedHits.NAssociatedHits]=i;  // temporaneo!
                ResultAssociatedHits.NAssociatedHits++;
                ResultAssociatedHits.NAssociatedParallelHits++;
                continue;
             } else  {
                diff = FI0-angle;
                major = 0.5*(KAPPA*(info[i][2]+info[i][4])+diff)/PI ;
                minor = 0.5*(KAPPA*(info[i][2]-info[i][4])+diff)/PI ;
                if ( major < minor) {
                 aaa=minor;
                 minor=major;
                 major=aaa;
                }
                minor <= 0. ?  nlow = (int) minor    : nlow = ( (int) minor) + 1;
                major <  0. ?  nup = ((int) major)-1 : nup  = (int) major;

                if( nlow> nup)  continue;
                if( nup-nlow+1 > nmaxAmbiguities )  continue;

                step = fabs(2.*PI/KAPPA) ;
                aaa = -diff/KAPPA ;
                bbb = info[i][0]+info[i][3]*dx/distance;  //  X of the hit
                ccc = info[i][1]+info[i][3]*dy/distance;  //  Y of the hit

                for(ii=nlow; ii<=nup; ii++){
                  ResultAssociatedHits.AssociatedHitsCoordinates[0][ii-nlow][ResultAssociatedHits.NAssociatedHits]= bbb;  //  X of the hit
                  ResultAssociatedHits.AssociatedHitsCoordinates[1][ii-nlow][ResultAssociatedHits.NAssociatedHits]= ccc ;  //  Y of the hit
                  ResultAssociatedHits.AssociatedHitsCoordinates[2][ii-nlow][ResultAssociatedHits.NAssociatedHits] = aaa + ii*step;   //  Z of the hit
                }
                ResultAssociatedHits.mAmbiguities[ResultAssociatedHits.NAssociatedHits] = nup - nlow + 1;
                ResultAssociatedHits.AssociatedWireDirection[0][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][0];
                ResultAssociatedHits.AssociatedWireDirection[1][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][1];
                ResultAssociatedHits.AssociatedWireDirection[2][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][2];
                ResultAssociatedHits.AssociatedWireCenter[0][ResultAssociatedHits.NAssociatedHits]=info[i][0];
                ResultAssociatedHits.AssociatedWireCenter[1][ResultAssociatedHits.NAssociatedHits]=info[i][1];
                ResultAssociatedHits.AssociatedWireCenter[2][ResultAssociatedHits.NAssociatedHits]=info[i][2];
                ResultAssociatedHits.AssociatedWireDriftRadius[ResultAssociatedHits.NAssociatedHits]=info[i][3];

                ResultAssociatedHits.Hitnumber[ResultAssociatedHits.NAssociatedHits]=i;  // temporaneo!
                ResultAssociatedHits.NAssociatedHits++;
                ResultAssociatedHits.NAssociatedParallelHits++;
             }  //  end  if( KAPPA == 0.)


            }  else {

//------------------------------ starts here association of skew straw hits

       //  calculation of the intersection points between skew straw axis and trajectory cylinder


            aaa = sqrt(inclination[Kincl][0]*inclination[Kincl][0]+inclination[Kincl][1]*inclination[Kincl][1]+
                  inclination[Kincl][2]*inclination[Kincl][2]);
            vx1 = inclination[Kincl][0]/aaa;
            vy1 = inclination[Kincl][1]/aaa;
            vz1 = inclination[Kincl][2]/aaa;
            C0x1 = info[i][0];
            C0y1 = info[i][1];
            C0z1 = info[i][2];

            calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,info[i][3],
                              vx1,vy1,vz1,
                              &STATUS,POINTS1);

            if(STATUS < 0 ) continue ;


            for( ii=0; ii<2; ii++){
              j=3*ii;
              distance = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                            );
              if( distance >= info[i][4] ) continue;


              Rx = POINTS1[j]-Ox ;   //  x component Radial vector of cylinder of trajectory
              Ry = POINTS1[1+j]-Oy ;   //  y direction Radial vector of cylinder of trajectory




              aaa = sqrt(Rx*Rx+Ry*Ry);
              SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
              SkewInclWithRespectToS /= R;
              bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
        //  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
              if( bbb > 1.e-10){
                 Tiltdirection1[0] = vz1/bbb;
                 Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
              } else {
                 Tiltdirection1[0] = 1.;
                 Tiltdirection1[1] = 0.;
              }
              LL = fabs(vx1*Rx + vy1*Ry);
              if( LL < 1.e-10) continue;
              Aellipsis1 = info[i][3]*aaa/LL;
              Bellipsis1 = info[i][3]/R;


// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

             if(
                fabs(POINTS1[j+2]-ZCENTER_STRAIGHT) > SEMILENGTH_STRAIGHT- Aellipsis1 ||
                distance + bbb > info[i][4]        //  the ellipsis goes out of the boundaries of the skew straw
               )  continue;
//--------------------------

             fi1 = atan2(POINTS1[j+1]-Oy, POINTS1[j]-Ox) ;  // atan2 returns radians in (-pi and +pi]
             if( fi1 < 0.) fi1 += 2.*PI;


//   now calculate the distance (along the Z direction) from the edge of the ellipsis and the predicted Helix
//   trajectory
             if(fabs(KAPPA) > 1.e-10) {
                z1 = POINTS1[j+2] + Aellipsis1*Tiltdirection1[0];
                y1 = fi1 + Aellipsis1*Tiltdirection1[1] ;
                zpos1 = (y1 - FI0)/KAPPA;
                d1 = fabs(zpos1 - z1);
                z2 = POINTS1[j+2] - Aellipsis1*Tiltdirection1[0];
                y2 = fi1 - Aellipsis1*Tiltdirection1[1]   ;
                zpos2 = (y2 - FI0)/KAPPA;
                d2 = fabs(zpos2 - z2);
                if ( d2>d1 ) {
                    distance = d1;
                    if( distance < nAdmittedRadia * Aellipsis1 ) {
                      ResultAssociatedHits.AssociatedHitsCoordinates[0][0][ResultAssociatedHits.NAssociatedHits]= R*cos(y1) + Ox;  //  X of the hit
                      ResultAssociatedHits.AssociatedHitsCoordinates[1][0][ResultAssociatedHits.NAssociatedHits]= R*sin(y1) + Oy;  //  Y of the hit
                      ResultAssociatedHits.AssociatedHitsCoordinates[2][0][ResultAssociatedHits.NAssociatedHits] = z1;
                      ResultAssociatedHits.mAmbiguities[ResultAssociatedHits.NAssociatedHits]=1;
                      ResultAssociatedHits.AssociatedWireDirection[0][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][0];
                      ResultAssociatedHits.AssociatedWireDirection[1][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][1];
                      ResultAssociatedHits.AssociatedWireDirection[2][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][2];
                      ResultAssociatedHits.AssociatedWireCenter[0][ResultAssociatedHits.NAssociatedHits]=info[i][0];
                      ResultAssociatedHits.AssociatedWireCenter[1][ResultAssociatedHits.NAssociatedHits]=info[i][1];
                      ResultAssociatedHits.AssociatedWireCenter[2][ResultAssociatedHits.NAssociatedHits]=info[i][2];
                      ResultAssociatedHits.AssociatedWireDriftRadius[ResultAssociatedHits.NAssociatedHits]=info[i][3];
                      ResultAssociatedHits.Hitnumber[ResultAssociatedHits.NAssociatedHits]=-i;  // temporaneo!
                      ResultAssociatedHits.NAssociatedHits++;
                      ResultAssociatedHits.NAssociatedSkewHits++;
                    }

                } else {
                    distance = d2 ;
                    if( distance < nAdmittedRadia * Aellipsis1 ) {
                      ResultAssociatedHits.AssociatedHitsCoordinates[0][0][ResultAssociatedHits.NAssociatedHits]= R*cos(y2) + Ox;  //  X of the hit
                      ResultAssociatedHits.AssociatedHitsCoordinates[1][0][ResultAssociatedHits.NAssociatedHits]= R*sin(y2) + Oy;  //  Y of the hit
                      ResultAssociatedHits.AssociatedHitsCoordinates[2][0][ResultAssociatedHits.NAssociatedHits] = z2;
                      ResultAssociatedHits.mAmbiguities[ResultAssociatedHits.NAssociatedHits]=1;
                      ResultAssociatedHits.AssociatedWireDirection[0][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][0];
                      ResultAssociatedHits.AssociatedWireDirection[1][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][1];
                      ResultAssociatedHits.AssociatedWireDirection[2][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][2];
                      ResultAssociatedHits.AssociatedWireCenter[0][ResultAssociatedHits.NAssociatedHits]=info[i][0];
                      ResultAssociatedHits.AssociatedWireCenter[1][ResultAssociatedHits.NAssociatedHits]=info[i][1];
                      ResultAssociatedHits.AssociatedWireCenter[2][ResultAssociatedHits.NAssociatedHits]=info[i][2];
                      ResultAssociatedHits.AssociatedWireDriftRadius[ResultAssociatedHits.NAssociatedHits]=info[i][3];
                      ResultAssociatedHits.Hitnumber[ResultAssociatedHits.NAssociatedHits]=-i;  // temporaneo!
                      ResultAssociatedHits.NAssociatedHits++;
                      ResultAssociatedHits.NAssociatedSkewHits++;
                    }
                }

if(istampa>= 3 && IVOLTE<20) {
  double dista;
  dista = distance;
  if(z1<z2){   if( zpos1 > z1 && zpos2 > z1  && zpos1 < z2 && zpos2 < z2 ) dista = -distance; }else{ 
            if( zpos1 > z2 && zpos2 > z2  && zpos1 < z1 && zpos2 < z1 ) dista = -distance;} ;
  cout<<"distanza minima (con segno) trovata skew-Helix = "<<dista<<endl;
}

              }  else  {    //  case when fabs(KAPPA) < 1.e-10

//  pick up the hits whose ellipse is close to the staight line at constant FI0
                z1 = POINTS1[j+2] + Aellipsis1*Tiltdirection1[0];
                y1 = fi1 + Aellipsis1*Tiltdirection1[1] ;
                d1 = fabs(y1 - FI0);
                z2 = POINTS1[j+2] - Aellipsis1*Tiltdirection1[0];
                y2 = fi1 - Aellipsis1*Tiltdirection1[1]   ;
                d1 = fabs(y2 - FI0);
                if(d1<nAdmittedRadia *Bellipsis1 || d1<nAdmittedRadia *Bellipsis1) {
                 if( d1 < d2 ){
                    y1 > FI0 ? factor = -1. : factor = 1.;
                    ResultAssociatedHits.AssociatedHitsCoordinates[0][0][ResultAssociatedHits.NAssociatedHits]=
                            R*cos(y1+factor*Bellipsis1) + Ox;  //  X of the hit
                    ResultAssociatedHits.AssociatedHitsCoordinates[1][0][ResultAssociatedHits.NAssociatedHits]=
                            R*sin(y1+factor*Bellipsis1) + Oy;  //  Y of the hit
                  }  else {
                    y2 > FI0 ? factor = -1. : factor = 1.;
                    ResultAssociatedHits.AssociatedHitsCoordinates[0][0][ResultAssociatedHits.NAssociatedHits]=
                            R*cos(y2+factor*Bellipsis1) + Ox;  //  X of the hit
                    ResultAssociatedHits.AssociatedHitsCoordinates[1][0][ResultAssociatedHits.NAssociatedHits]=
                            R*sin(y2+factor*Bellipsis1) + Oy;  //  Y of the hit
                  }
                   
                  ResultAssociatedHits.AssociatedHitsCoordinates[2][0][ResultAssociatedHits.NAssociatedHits] = (z1+z2)/2.;
                  ResultAssociatedHits.mAmbiguities[ResultAssociatedHits.NAssociatedHits]=1;
                  ResultAssociatedHits.AssociatedWireDirection[0][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][0];
                  ResultAssociatedHits.AssociatedWireDirection[1][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][1];
                  ResultAssociatedHits.AssociatedWireDirection[2][ResultAssociatedHits.NAssociatedHits]=inclination[Kincl][2];
                  ResultAssociatedHits.AssociatedWireCenter[0][ResultAssociatedHits.NAssociatedHits]=info[i][0];
                  ResultAssociatedHits.AssociatedWireCenter[1][ResultAssociatedHits.NAssociatedHits]=info[i][1];
                  ResultAssociatedHits.AssociatedWireCenter[2][ResultAssociatedHits.NAssociatedHits]=info[i][2];
                  ResultAssociatedHits.AssociatedWireDriftRadius[ResultAssociatedHits.NAssociatedHits]=info[i][3];
                  ResultAssociatedHits.Hitnumber[ResultAssociatedHits.NAssociatedHits]=-i;  // temporaneo!
                  ResultAssociatedHits.NAssociatedHits++;
                  ResultAssociatedHits.NAssociatedSkewHits++;
                }

              }   //   end of  if(fabs(KAPPA) > 1.e-10)

             }    //  end of    for( ii=0; ii<2; ii++)



            }    //  end of   if( info[i][5] == 1 )  else


       }    //   end of   for( i=1; i< Nhits; i++)





    return ResultAssociatedHits;

}


//----------end of function PndSttTrackFinderReal::PndSttTrkAssociatedHitsToHelix








//----------begin function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelix

  UShort_t PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelix(
                   Double_t Ox,
                   Double_t Oy,
                   Double_t R,
                   Int_t Nhits,
                   Double_t info[][7],
                   UShort_t *auxListHitsinTrack              //  this is the output
                                                     )
{

    Int_t i;
    UShort_t Nassociatedhits;

    Double_t dx, dy,distance;


//    Ox = (D+R)*cos(Fi);
//    Oy = (D+R)*sin(Fi);



//  association of hits in the XY plane

       Nassociatedhits=0;

       for( i=0; i< Nhits; i++) {


//          Kincl = (int) info[i][5] - 1;

// --------------------    association of the hits from parallel straws
//         if( info[i][5] == 1. ) {     // parallel straws

          dx = -Ox+info[ infoparal[i] ][0];
          dy = -Oy+info[ infoparal[i] ][1];
          distance = sqrt(dx*dx+dy*dy);
//cout<<"nuov, R "<<R<<",  distance  "<<distance<<endl;
//          if( distance < 1.e-10)  continue;
//          angle = atan2(dy,dx);

          if ( fabs(R - distance ) > 2.*StrawRadius )  continue;
          auxListHitsinTrack[Nassociatedhits]=i;
          Nassociatedhits++;

//         }    //  end of   if( info[i][5] == 1 )  else


       }    //   end of   for( i=1; i< Nhits; i++)






    return Nassociatedhits;

}


//----------end of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelix





//----------start of function PndSttTrackFinderReal::plottamentiParalleleGenerali

 void  PndSttTrackFinderReal::plottamentiParalleleGenerali(
                      Int_t Nremaining, Float_t * RemainingR, Float_t * RemainingD,
                      Float_t * RemainingFi, Float_t * RemainingCX, Float_t * RemainingCY,
                      bool *Goodflag  
                       )
{


   int itemp, i, j, ii, jj;

   Double_t  D, Fi;

   char nome[300],titolo[300];



   sprintf(nome,"HoughGeneralPlotsEvent%d.root",IVOLTE);
   TFile  hfile(nome,"RECREATE", "STT pattern recognition");

//----------
       sprintf(titolo,"Cxofcircle");
       TH1F hCX(titolo,titolo,nbinCX,CXmin,CXmax);
//----------
       sprintf(titolo,"Cyofcircle");
       TH1F hCY(titolo,titolo,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"Radiusofcircle");
       TH1F hR(titolo,titolo,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCy");
       TH2F hCX_CY(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"CxabscissavsRadius");
       TH2F hCX_R(titolo,titolo,nbinCX,CXmin,CXmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CyabscissavsRadius");
       TH2F hCY_R(titolo,titolo,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCyordinatevsRadius");
       TH3F hCX_CY_R(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"Distanceofclosestapproachofcircle");
       TH1F hD(titolo,titolo,nbinD,Dmin,Dmax);
//----------
       sprintf(titolo,"Firadofcircle");
       TH1F hFi(titolo,titolo,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsFi");
       TH2F hD_Fi(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsRadius");
       TH2F hD_R(titolo,titolo,nbinD,Dmin,Dmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"FiabscissavsRadius");
       TH2F hFi_R(titolo,titolo,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"DabscissavsFiordinatevsRadius");
       TH3F hD_Fi_R(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----

//---------------------------------------------------
//   gli stessi plots ma per le soluzioni che sono le piu' vicine alla verita' MC
//----------
       sprintf(titolo,"Cxofcircle_truth");
       TH1F hCXverita(titolo,titolo,nbinCX,CXmin,CXmax);
//----------
       sprintf(titolo,"Cyofcircle_truth");
       TH1F hCYverita(titolo,titolo,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"Radiusofcircle_truth");
       TH1F hRverita(titolo,titolo,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCy_truth");
       TH2F hCX_CYverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"CxabscissavsRadius_truth");
       TH2F hCX_Rverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CyabscissavsRadius_truth");
       TH2F hCY_Rverita(titolo,titolo,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCyordinatevsRadius_truth");
       TH3F hCX_CY_Rverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"Distanceofclosestapproachofcircle_truth");
       TH1F hDverita(titolo,titolo,nbinD,Dmin,Dmax);
//----------
       sprintf(titolo,"Firadofcircle_truth");
       TH1F hFiverita(titolo,titolo,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsFi_truth");
       TH2F hD_Fiverita(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsRadius_truth");
       TH2F hD_Rverita(titolo,titolo,nbinD,Dmin,Dmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"FiabscissavsRadius_truth");
       TH2F hFi_Rverita(titolo,titolo,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"DabscissavsFiordinatevsRadius_truth");
       TH3F hD_Fi_Rverita(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----

//---------------------------------------------------
//   gli stessi plots ma per le soluzioni che NON sono le piu' vicine alla verita' MC
//----------
       sprintf(titolo,"Cxofcircle_nontruth");
       TH1F hCXnonverita(titolo,titolo,nbinCX,CXmin,CXmax);
//----------
       sprintf(titolo,"Cyofcircle_nontruth");
       TH1F hCYnonverita(titolo,titolo,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"Radiusofcircle_nontruth");
       TH1F hRnonverita(titolo,titolo,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCy_nontruth");
       TH2F hCX_CYnonverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"CxabscissavsRadius_nontruth");
       TH2F hCX_Rnonverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CyabscissavsRadius_nontruth");
       TH2F hCY_Rnonverita(titolo,titolo,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"CxabscissavsCyordinatevsRadius_nontruth");
       TH3F hCX_CY_Rnonverita(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"Distanceofclosestapproachofcircle_nontruth");
       TH1F hDnonverita(titolo,titolo,nbinD,Dmin,Dmax);
//----------
       sprintf(titolo,"Firadofcircle_nontruth");
       TH1F hFinonverita(titolo,titolo,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsFi_nontruth");
       TH2F hD_Finonverita(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax);
//-----
       sprintf(titolo,"DabscissavsRadius_nontruth");
       TH2F hD_Rnonverita(titolo,titolo,nbinD,Dmin,Dmax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"FiabscissavsRadius_nontruth");
       TH2F hFi_Rnonverita(titolo,titolo,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----
       sprintf(titolo,"DabscissavsFiordinatevsRadius_nontruth");
       TH3F hD_Fi_Rnonverita(titolo,titolo,nbinD,Dmin,Dmax,nbinFi,Fimin,Fimax,nbinR,Rmin,Rmax);
//-----

//---------------------------------------------------





  for(itemp = 0; itemp<Nremaining; itemp++){

       D = RemainingD[itemp];
       Fi = RemainingFi[itemp];


       hCX.Fill(RemainingCX[itemp]);
       hCY.Fill(RemainingCY[itemp]);
       hR.Fill(RemainingR[itemp]);
       hCX_CY.Fill(RemainingCX[itemp],RemainingCY[itemp]);
       hCX_R.Fill(RemainingCX[itemp],RemainingR[itemp]);
       hCY_R.Fill(RemainingCY[itemp],RemainingR[itemp]);
       hCX_CY_R.Fill(RemainingCX[itemp],RemainingCY[itemp],RemainingR[itemp]);

       hD.Fill(D);
       hFi.Fill(Fi);
       hD_Fi.Fill(D,Fi);
       hD_R.Fill(D,RemainingR[itemp]);
       hFi_R.Fill(Fi,RemainingR[itemp]);
       hD_Fi_R.Fill(D,Fi,RemainingR[itemp]);



        

     if (Goodflag[itemp]) {

       hCXverita.Fill(RemainingCX[itemp]);
       hCYverita.Fill(RemainingCY[itemp]);
       hRverita.Fill(RemainingR[itemp]);
       hCX_CYverita.Fill(RemainingCX[itemp],RemainingCY[itemp]);
       hCX_Rverita.Fill(RemainingCX[itemp],RemainingR[itemp]);
       hCY_Rverita.Fill(RemainingCY[itemp],RemainingR[itemp]);
       hCX_CY_Rverita.Fill(RemainingCX[itemp],RemainingCY[itemp],RemainingR[itemp]);

       hDverita.Fill(D);
       hFiverita.Fill(Fi);
       hD_Fiverita.Fill(D,Fi);
       hD_Rverita.Fill(D,RemainingR[itemp]);
       hFi_Rverita.Fill(Fi,RemainingR[itemp]);
       hD_Fi_Rverita.Fill(D,Fi,RemainingR[itemp]);

     }   else {

       hCXnonverita.Fill(RemainingCX[itemp]);
       hCYnonverita.Fill(RemainingCY[itemp]);
       hRnonverita.Fill(RemainingR[itemp]);
       hCX_CYnonverita.Fill(RemainingCX[itemp],RemainingCY[itemp]);
       hCX_Rnonverita.Fill(RemainingCX[itemp],RemainingR[itemp]);
       hCY_Rnonverita.Fill(RemainingCY[itemp],RemainingR[itemp]);
       hCX_CY_Rnonverita.Fill(RemainingCX[itemp],RemainingCY[itemp],RemainingR[itemp]);

       hDnonverita.Fill(D);
       hFinonverita.Fill(Fi);
       hD_Finonverita.Fill(D,Fi);
       hD_Rnonverita.Fill(D,RemainingR[itemp]);
       hFi_Rnonverita.Fill(Fi,RemainingR[itemp]);
       hD_Fi_Rnonverita.Fill(D,Fi,RemainingR[itemp]);

     }





   }  //  end of    for(Int_t itemp = 0; itemp<Nremaining; itemp++)





   hfile.Write(nome);
   hfile.Close();

 }

//----------end of function PndSttTrackFinderReal::plottamentiParalleleGenerali


//----------start of function PndSttTrackFinderReal::plottamentiParalleleconMassimo

 void  PndSttTrackFinderReal::plottamentiParalleleconMassimo(
                       char * tipo,
                      Int_t nMaxima,
                      Int_t Nremaining, Float_t * RemainingR, Float_t * RemainingD,
                      Float_t * RemainingFi, Float_t * RemainingCX, Float_t * RemainingCY,  
                Double_t Rup, Double_t Rlow, Double_t Dup, Double_t Dlow, Double_t Fiup, Double_t Filow
                                                            )
 {


   int itemp, i, j, ii, jj;

   Double_t  D, Fi;

   char nome[300],titolo[300];



   sprintf(nome,"HoughParallele%sMaximumN%devent%d.root",tipo,nMaxima,IVOLTE);
   TFile  hfile(nome,"RECREATE", "STT pattern recognition");


//----------
       sprintf(titolo,"CxofcircleSelected");
       TH1F hCXsel(titolo,titolo,nbinCX,CXmin,CXmax);
//-----
       sprintf(titolo,"CyofcircleSelected");
       TH1F hCYsel(titolo,titolo,nbinCY,CYmin,CYmax);
//-----
       sprintf(titolo,"RadiusofcircleSelected");
       TH1F hRsel(titolo,titolo,nbinR,Rlow,Rup);
//-----
       sprintf(titolo,"CxabscissavsCyordinatevsRadiusSelected");
       TH3F hCX_CY_Rsel(titolo,titolo,nbinCX,CXmin,CXmax,nbinCY,CYmin,CYmax,nbinR,Rlow,Rup);
//----------
       sprintf(titolo,"DistanceofclosestapproachofcircleSelected");
       TH1F hDsel(titolo,titolo,nbinD,Dlow,Dup);
//-----
       sprintf(titolo,"FiradofcircleSselected");
       TH1F hFisel(titolo,titolo,nbinFi,Filow,Fiup);
//-----
       sprintf(titolo,"DabscissavsFiSelected");
       TH2F hD_Fisel(titolo,titolo,nbinD,Dlow,Dup,nbinFi,Filow,Fiup);
//-----
       sprintf(titolo,"DabscissavsRadiusSelected");
       TH2F hD_Rsel(titolo,titolo,nbinD,Dlow,Dup,nbinR,Rlow,Rup);
//-----
       sprintf(titolo,"FiabscissavsRadiusSelected");
       TH2F hFi_Rsel(titolo,titolo,nbinFi,Filow,Fiup,nbinR,Rlow,Rup);
//-----
       sprintf(titolo,"DabscissavsFiordinatevsRadiusSelected");
       TH3F hD_Fi_Rsel(titolo,titolo,nbinD,Dlow,Dup,nbinFi,Filow,Fiup,nbinR,Rlow,Rup);




  for(itemp = 0; itemp<Nremaining; itemp++){

       D = RemainingD[itemp];
       Fi = RemainingFi[itemp];


      if( RemainingR[itemp]>Rlow && RemainingR[itemp]<Rup
                             &&
          RemainingD[itemp]>Dlow && RemainingD[itemp]<Dup
                             &&
          RemainingFi[itemp]>Filow && RemainingFi[itemp]<Fiup
        )  {
           hRsel.Fill(RemainingR[itemp]);
           hFisel.Fill(Fi);
           hDsel.Fill(D);
           hCXsel.Fill(RemainingCX[itemp]);
           hCYsel.Fill(RemainingCY[itemp]);
           hD_Fisel.Fill(D,Fi);
           hD_Rsel.Fill(D,RemainingR[itemp]);
           hFi_Rsel.Fill(Fi,RemainingR[itemp]);
           hD_Fi_Rsel.Fill(D,Fi,RemainingR[itemp]);
           hCX_CY_Rsel.Fill(RemainingCX[itemp],RemainingCY[itemp],RemainingR[itemp]);
      }

   }  //  end of    for(Int_t itemp = 0; itemp<Nremaining; itemp++)






   hfile.Write(nome);
   hfile.Close();

 }

//----------end of function PndSttTrackFinderReal::plottamentiParalleleconMassimo










//----------start of function PndSttTrackFinderReal::plottamentiSkewconMassimo

 void  PndSttTrackFinderReal::plottamentiSkewconMassimo(
                      Int_t nMaxima, Int_t jmaxima,
                      Int_t Nremaining2, Float_t * RemainingKAPPA, Float_t *RemainingFI0,
                      Double_t KAPPAlow, Double_t KAPPAup, Double_t FI0low, Double_t FI0up,
                      AssociatedHitsToHelix  ResultAssociatedHits,
                      Double_t HoughR, Double_t HoughD, Double_t HoughFi) {


   int itemp, i, j, ii, jj;

   Double_t  D, Fi;

   char nome[300],titolo[300];





   sprintf(nome,"HoughMaximumPMaxN%dSMaxN%devent%d.root",nMaxima,jmaxima,IVOLTE);
   TFile  hfile(nome,"RECREATE", "STT pattern recognition");



//----------
       sprintf(titolo,"KAPPAofHelix");
       TH1F hKAPPA(titolo,titolo,nbinKAPPA,KAPPAmin,KAPPAmax);
//----------
       sprintf(titolo,"KAPPAofHelixSelected");
       TH1F hKAPPAsel(titolo,titolo,nbinKAPPA,KAPPAlow,KAPPAup);
//----------
       sprintf(titolo,"FI0radofHelix");
       TH1F hFI0(titolo,titolo,nbinFI0,FI0min,FI0max);
//----------
       sprintf(titolo,"FI0radofHelixSelected");
       TH1F hFI0sel(titolo,titolo,nbinFI0,FI0low,FI0up);
//----------
       sprintf(titolo,"hits parallel straws : Xfound - Xtrue");
       TH1F hXdiffparallel(titolo,titolo,1000,-5.,5.);
//----------
       sprintf(titolo,"hits parallel straws : Yfound - Ytrue");
       TH1F hYdiffparallel(titolo,titolo,1000,-5.,5.);
//----------
       sprintf(titolo,"hits parallel straws : Zfound - Ztrue");
       TH1F hZdiffparallel(titolo,titolo,1000,-5.,5.);
//----------
       sprintf(titolo,"hits skew straws : Xfound - Xtrue");
       TH1F hXdiffskew(titolo,titolo,1000,-5.,5.);
//----------
       sprintf(titolo,"hits skew straws : Yfound - Ytrue");
       TH1F hYdiffskew(titolo,titolo,1000,-5.,5.);
//----------
       sprintf(titolo,"hits skew straws : Zfound - Ztrue");
       TH1F hZdiffskew(titolo,titolo,1000,-5.,5.);



//-------------
      sprintf(titolo,"FI0abscissavsKAPPA");
       TH2F hFI0_KAPPA(titolo,titolo,nbinFI0,FI0min,FI0max,nbinKAPPA,KAPPAmin,KAPPAmax);
//-------------
      sprintf(titolo,"FI0abscissavsKAPPASelected");
       TH2F hFI0_KAPPAsel(titolo,titolo,nbinFI0,FI0low,FI0up,nbinKAPPA,KAPPAlow,KAPPAup);
//-----
      sprintf(titolo,"FI0abscissavsRadius");
       TH2F hFI0_R(titolo,titolo,nbinFI0,FI0min,FI0max,nbinR,Rmin,Rmax);
//-----
      sprintf(titolo,"FI0abscissavsCX");
       TH2F hFI0_CX(titolo,titolo,nbinFI0,FI0min,FI0max,nbinCX,CXmin,CXmax);
//-----
      sprintf(titolo,"FI0abscissavsCY");
       TH2F hFI0_CY(titolo,titolo,nbinFI0,FI0min,FI0max,nbinCY,CYmin,CYmax);
//-----
      sprintf(titolo,"KAPPAHelixabscissavsRadius");
       TH2F hKAPPA_R(titolo,titolo,nbinKAPPA,KAPPAmin,KAPPAmax,nbinR,Rmin,Rmax);
//-----
      sprintf(titolo,"KAPPAHelixabscissavsCX");
       TH2F hKAPPA_CX(titolo,titolo,nbinKAPPA,KAPPAmin,KAPPAmax,nbinCX,CXmin,CXmax);
//-----
      sprintf(titolo,"KAPPAHelixabscissavsCY");
       TH2F hKAPPA_CY(titolo,titolo,nbinKAPPA,KAPPAmin,KAPPAmax,nbinCY,CYmin,CYmax);
//-----


 for(ii=0; ii<Nremaining2; ii++){


   hKAPPA.Fill(RemainingKAPPA[ii]);
   hFI0.Fill(RemainingFI0[ii]);
   hFI0_KAPPA.Fill(RemainingFI0[ii],RemainingKAPPA[ii]);
   hFI0_R.Fill(RemainingFI0[ii],HoughR);
   hFI0_CX.Fill(RemainingFI0[ii],(HoughR-HoughD)*cos(HoughFi));
   hFI0_CY.Fill(RemainingFI0[ii],(HoughR-HoughD)*sin(HoughFi));
   hKAPPA_R.Fill(RemainingKAPPA[ii],HoughR);
   hKAPPA_CX.Fill(RemainingKAPPA[ii],(HoughR-HoughD)*cos(HoughFi));
   hKAPPA_CY.Fill(RemainingKAPPA[ii],(HoughR-HoughD)*sin(HoughFi));

      if( RemainingKAPPA[ii]>KAPPAlow && RemainingKAPPA[ii]<KAPPAup
                             &&
          RemainingFI0[ii]>FI0low && RemainingFI0[ii]<FI0up
        )  {
           hKAPPAsel.Fill(RemainingKAPPA[ii]);
           hFI0sel.Fill(RemainingFI0[ii]);
           hFI0_KAPPAsel.Fill(RemainingFI0[ii],RemainingKAPPA[ii]);
      }
 }





    for (i=0; i< ResultAssociatedHits.NAssociatedHits ; i++){
       for(j=0; j< ResultAssociatedHits.mAmbiguities[i] ; j++){


         if( ResultAssociatedHits.Hitnumber[i] >= 0){
           hXdiffparallel.Fill(ResultAssociatedHits.AssociatedHitsCoordinates[0][j][i]-veritaMC[ResultAssociatedHits.Hitnumber[i]][0]);
           hYdiffparallel.Fill(ResultAssociatedHits.AssociatedHitsCoordinates[1][j][i]-veritaMC[ResultAssociatedHits.Hitnumber[i]][1]);
           hZdiffparallel.Fill(ResultAssociatedHits.AssociatedHitsCoordinates[2][j][i]-veritaMC[ResultAssociatedHits.Hitnumber[i]][2]);
         } else {
           hXdiffskew.Fill(ResultAssociatedHits.AssociatedHitsCoordinates[0][j][i]-veritaMC[-ResultAssociatedHits.Hitnumber[i]][0]);
           hYdiffskew.Fill(ResultAssociatedHits.AssociatedHitsCoordinates[1][j][i]-veritaMC[-ResultAssociatedHits.Hitnumber[i]][1]);
           hZdiffskew.Fill(ResultAssociatedHits.AssociatedHitsCoordinates[2][j][i]-veritaMC[-ResultAssociatedHits.Hitnumber[i]][2]);
         }

       }
    }





   hfile.Write(nome);
   hfile.Close();

 }

//----------end of function PndSttTrackFinderReal::plottamentiSkewconMassimo



  void PndSttTrackFinderReal::findmaximaDFiR( UShort_t BoxDFiR[nbinD][nbinFi][nbinR],
                                    Int_t MINIMUMCOUNTS,
                                    Int_t * NumberofMaximaDFiR, Int_t  MaximaIndexesDFiR[][3],
                                    Int_t * STATUS)
{


     Int_t      i, j, iD, iFi, iR, icount,
                ntotClusters,
                NinCluster,
                nClusterElementsFound,
                nRemai,
                nRemainingElements,
                max,
                nElementsinCluster[MAXElementsOverThresholdinHough];

     UShort_t   found[MAXElementsOverThresholdinHough][MAXElementsOverThresholdinHough][3],
                auxDFiRIndex[MAXElementsOverThresholdinHough][3],
                Remai[MAXElementsOverThresholdinHough][3],
                RemainingElements[MAXElementsOverThresholdinHough][3],
                Cluster[MAXElementsOverThresholdinHough][3],
                ClusterElementsFound[MAXElementsOverThresholdinHough][3];

   if(istampa >= 3 && IVOLTE<20) {
cout<<"da   findmaximaDFiR  :   MINIMUMCOUNTS = "<<MINIMUMCOUNTS<<",nbinD = "<<nbinD <<
     ",  nbinFi = "<<nbinFi <<", nbinR = "<<nbinR
    <<endl;
    }
     icount=0;
     for(iD=0; iD<nbinD; iD++){
      for(iFi=0; iFi<nbinFi; iFi++){
       for(iR=0; iR<nbinR; iR++){
         if(
              BoxDFiR[iD][iFi][iR] > MINIMUMCOUNTS
           ) {
             auxDFiRIndex[icount][0]=iD;
             auxDFiRIndex[icount][1]=iFi;
             auxDFiRIndex[icount][2]=iR;
             icount++;
             if(icount == MAXElementsOverThresholdinHough){
                *STATUS=-1;
cout<<"Temporary printout from findmaximaDFiR  : too many cells (>= "<<MAXElementsOverThresholdinHough<<")  above MINIMUMCOUNTS (= "<<
     MINIMUMCOUNTS<<")"<<endl;
                return ;
             }
         }

       }
      }
     }



     if(istampa>=3 && IVOLTE<20) {
       cout<<"da findmaximaDFiR : numero di celle superiori al MINIMUM CUT = "<<icount<<" e loro elenco :"<<endl;
       for(i = 0; i<icount;i++){
          cout<<"da findmaximaDFiR : iD = "<<auxDFiRIndex[i][0]<<";  iFi = "<<auxDFiRIndex[i][1]<<"; iR = "<<auxDFiRIndex[i][2]<<
                ";  contenuto = "<<BoxDFiR[auxDFiRIndex[i][0]][auxDFiRIndex[i][1]][auxDFiRIndex[i][2]]<<
        "  e corispondenti a D = "<<auxDFiRIndex[i][0]*stepD+Dmin<<", Fi = "<<auxDFiRIndex[i][1]*stepFi+Fimin
         << ", R = "<< auxDFiRIndex[i][2]*stepR+Rmin<<endl;
       }
     }



    if ( icount == 0) {
       * NumberofMaximaDFiR = 0;
       *STATUS=1;
       return;
    } else if (icount == 1 ) {
       ntotClusters=1;
       nElementsinCluster[0]=1;
       for(i=0; i<3; i++){
         MaximaIndexesDFiR[0][i] =auxDFiRIndex[0][i];
       }
       * NumberofMaximaDFiR = 1;
       *STATUS=1;
       return;
    }

//   case with more that 1 elements over threshold ---------------------------------------------------------------


    ntotClusters=0;

    for(i=0; i<3; i++){
       Cluster[0][i] = auxDFiRIndex[0][i];
    }


    for(i=1; i<icount; i++){
     for(j=0; j<3; j++){
       Remai[i-1][j] = auxDFiRIndex[i][j];
     }
    }
    nRemai = icount-1;
    NinCluster=1;

    while(1){
      i=0;
      while(i<NinCluster && nRemai >0) {
        clustering3(
           (UShort_t *) (&Cluster[i][0]),  //   inputs to function clustering3
           nRemai, Remai,               //   inputs to function clustering3
           nClusterElementsFound, ClusterElementsFound,  //   ouputs from function clustering3
           nRemainingElements, RemainingElements       //   ouputs from function clustering3
                   );
        for(j=0; j<nClusterElementsFound; j++){
           Cluster[NinCluster+j][0] = ClusterElementsFound[j][0];
           Cluster[NinCluster+j][1] = ClusterElementsFound[j][1];
           Cluster[NinCluster+j][2] = ClusterElementsFound[j][2];
        }
        NinCluster += nClusterElementsFound;
        nRemai=nRemainingElements;
        for(j=0; j<nRemainingElements; j++){
           Remai[j][0] = RemainingElements[j][0];
           Remai[j][1] = RemainingElements[j][1];
           Remai[j][2] = RemainingElements[j][2];
        }
        i++;
      }   //  end of  while(i<NinCluster && nRemai >0)

      nElementsinCluster[ntotClusters]= NinCluster;
      for( j=0; j<NinCluster; j++) {
       for(i=0; i<3; i++){
          found[ntotClusters][j][i] = Cluster[j][i];
       }
      }
      ntotClusters ++;

      if(nRemai>1){
        NinCluster=1;
        for(i=0; i<3; i++){
          Cluster[0][i] = Remai[0][i];
        }

        nRemai--;
        for(j=0;j<nRemai;j++){
          for(i=0; i<3; i++){
            Remai[j][i]=Remai[j+1][i];
          }
        }


      } else if (nRemai==1) {
        nElementsinCluster[ntotClusters]= 1;
        for(i=0; i<3; i++){
            found[ntotClusters][0][i] = Remai[0][i];
        }
        ntotClusters ++;
        break;
      } else {  // this is the case when nRemai == 0
        break;
      }  //  endo of  if(nRemai>1)

    }   //   end   of   while(1)



//  now find the indeces for the maxima

    *NumberofMaximaDFiR = ntotClusters;


    for(i=0; i<ntotClusters; i++){
       for(j=0, max=-1;j<nElementsinCluster[i];j++){
          if(max < BoxDFiR[found[i][j][0]][found[i][j][1]][found[i][j][2]]) {
            max=BoxDFiR[found[i][j][0]][found[i][j][1]][found[i][j][2]];
            MaximaIndexesDFiR[i][0]=found[i][j][0];
            MaximaIndexesDFiR[i][1]=found[i][j][1];
            MaximaIndexesDFiR[i][2]=found[i][j][2];
          }
       }
    }


    *STATUS=1;

}


//----------end of function PndSttTrackFinderReal::findmaximaDFiR



  void PndSttTrackFinderReal::findmaximaKFI0(
                    UShort_t BoxKFI0[nbinKAPPA][nbinFI0],
                    Int_t MINIMUMCOUNTS,
                    Int_t *NumberofMaximaKFI0,
                    Int_t  MaximaIndexesKFI0[][2],
                    Int_t * STATUS)
{


     Int_t      i, j, iK, iFI0, icount,
                ntotClusters,
                NinCluster,
                nClusterElementsFound,
                nRemai,
                nRemainingElements,
                max,
                nElementsinCluster[MAXElementsOverThresholdinHough];

     UShort_t   found[MAXElementsOverThresholdinHough][MAXElementsOverThresholdinHough][2],
                auxKFI0Index[MAXElementsOverThresholdinHough][2],
                Remai[MAXElementsOverThresholdinHough][2],
                RemainingElements[MAXElementsOverThresholdinHough][2],
                Cluster[MAXElementsOverThresholdinHough][2],
                ClusterElementsFound[MAXElementsOverThresholdinHough][2];


     icount=0;
     for(iK=0; iK<nbinKAPPA; iK++){
      for(iFI0=0; iFI0<nbinFI0; iFI0++){
// cout<<"MINIMUMCOUNTS = "<<MINIMUMCOUNTS<<";  Box = "<<BoxKFI0[iK][iFI0]<< endl;
         if(
              BoxKFI0[iK][iFI0] > MINIMUMCOUNTS
           ) {
             auxKFI0Index[icount][0]=iK;
             auxKFI0Index[icount][1]=iFI0;
             icount++;
             if(icount == MAXElementsOverThresholdinHough){
                *STATUS=-1;
                return ;
             }
         }

      }
     }



     if(istampa>=3 && IVOLTE<20) {
       cout<<"da findmaximaKFI0 : numero di celle maggiori del MINIMUMCUT = "<<icount<<" e loro elenco :"<<endl;
       for(i = 0; i<icount;i++){
          cout<<"da findmaximaKFI0 : iK = "<<auxKFI0Index[i][0]<<";  iFI0 = "<<auxKFI0Index[i][1]<<
                ";  contenuto = "<<BoxKFI0[auxKFI0Index[i][0]][auxKFI0Index[i][1]]<<endl;
       }
     }




    if ( icount == 0) {
       *NumberofMaximaKFI0 = 0;
       *STATUS=1;
       return;
    } else if (icount == 1 ) {
       ntotClusters=1;
       nElementsinCluster[0]=1;
       for(i=0; i<2; i++){
         MaximaIndexesKFI0[0][i] =auxKFI0Index[0][i];
       }
       *STATUS=1;
       return;
    }

//   case with more that 1 elements over threshold ---------------------------------------------------------------


    ntotClusters=0;

    for(i=0; i<2; i++){
       Cluster[0][i] = auxKFI0Index[0][i];
    }


    for(i=1; i<icount; i++){
     for(j=0; j<2; j++){
       Remai[i-1][j] = auxKFI0Index[i][j];
     }
    }
    nRemai = icount-1;
    NinCluster=1;

    while(1){
      i=0;
      while(i<NinCluster && nRemai >0) {
        clustering2(
           (UShort_t *) (&Cluster[i][0]),  //   inputs to function clustering2
           nRemai, Remai,               //   inputs to function clustering2
           nClusterElementsFound, ClusterElementsFound,  //   ouputs from function clustering2
           nRemainingElements, RemainingElements       //   ouputs from function clustering2
                   );
        for(j=0; j<nClusterElementsFound; j++){
           Cluster[NinCluster+j][0] = ClusterElementsFound[j][0];
           Cluster[NinCluster+j][1] = ClusterElementsFound[j][1];
        }
        NinCluster += nClusterElementsFound;
        nRemai=nRemainingElements;
        for(j=0; j<nRemainingElements; j++){
           Remai[j][0] = RemainingElements[j][0];
           Remai[j][1] = RemainingElements[j][1];
        }
        i++;
      }   //  end of  while(i<NinCluster && nRemai >0)

      nElementsinCluster[ntotClusters]= NinCluster;
      for( j=0; j<NinCluster; j++) {
       for(i=0; i<2; i++){
          found[ntotClusters][j][i] = Cluster[j][i];
       }
      }
      ntotClusters ++;

      if(nRemai>1){
        NinCluster=1;
        for(i=0; i<2; i++){
          Cluster[0][i] = Remai[0][i];
        }

        nRemai--;
        for(j=0;j<nRemai;j++){
          for(i=0; i<2; i++){
            Remai[j][i]=Remai[j+1][i];
          }
        }


      } else if (nRemai==1) {
        nElementsinCluster[ntotClusters]= 1;
        for(i=0; i<2; i++){
            found[ntotClusters][0][i] = Remai[0][i];
        }
        ntotClusters ++;
        break;
      } else {  // this is the case when nRemai == 0
        break;
      }  //  endo of  if(nRemai>1)

    }   //   end   of   while(1)



//  now find the indeces for the maxima

if( istampa >= 3 && IVOLTE<20) cout<<"da findmaximaKFI0, ntotClusters = "<<ntotClusters<<endl;
    *NumberofMaximaKFI0 = ntotClusters;


    for(i=0; i<ntotClusters; i++){

if( istampa >= 3 && IVOLTE<20) cout<<"da findmaximaKFI0, cluster n. "<<i<<" formato da "<<nElementsinCluster[i]<<"  elementi\n";
       for(j=0, max=-1;j<nElementsinCluster[i];j++){
          if(max < BoxKFI0[found[i][j][0]][found[i][j][1]]) {
            max=BoxKFI0[found[i][j][0]][found[i][j][1]];
            MaximaIndexesKFI0[i][0]=found[i][j][0];
            MaximaIndexesKFI0[i][1]=found[i][j][1];
          }
       }
    }


    *STATUS=1;

}


//----------end of function PndSttTrackFinderReal::findmaximaKFI0



  bool  PndSttTrackFinderReal::iscontiguous(
                int ncomponents, UShort_t * vec1, UShort_t *vec2)
{

    for(int i=0; i<ncomponents;i++){
      if( vec1[i]-vec2[i] >3 || vec1[i]-vec2[i]<-3) return false;
    }

    return true;

}



//----------end of function PndSttTrackFinderReal::iscontiguous

void PndSttTrackFinderReal::clustering2(
          UShort_t vec1[2],                                       // input
          int nListElements, UShort_t List[][2],                 // input
          int & nClusterElementsFound, UShort_t ClusterElementsFound[][2],  // output
          int & nRemainingElements, UShort_t  RemainingElements[][2]     // output
                )
{
   int i;
   UShort_t  vec2[2];

   nClusterElementsFound=0;
   nRemainingElements=0;
   for(i=0; i<nListElements; i++){
      vec2[0]=List[i][0];
      vec2[1]=List[i][1];
      if( iscontiguous(2, vec1, vec2) ){
         ClusterElementsFound[nClusterElementsFound][0] = vec2[0];
         ClusterElementsFound[nClusterElementsFound][1] = vec2[1];
         nClusterElementsFound++;
      } else {
         RemainingElements[nRemainingElements][0] = vec2[0];
         RemainingElements[nRemainingElements][1] = vec2[1];
         nRemainingElements++;
      }
   }

    return;
}



//----------end of function PndSttTrackFinderReal::clustering2

void PndSttTrackFinderReal::clustering3 (
          UShort_t vec1[3],                                       // input
          int nListElements, UShort_t List[][3],                 // input
          int & nClusterElementsFound, UShort_t ClusterElementsFound[][3],  // output
          int & nRemainingElements, UShort_t  RemainingElements[][3]     // output
                )
{
   int i;
   UShort_t  vec2[3];

   nClusterElementsFound=0;
   nRemainingElements=0;
   for(i=0; i<nListElements; i++){
      vec2[0]=List[i][0];
      vec2[1]=List[i][1];
      vec2[2]=List[i][2];
      if( iscontiguous(3, vec1, vec2) ){
         ClusterElementsFound[nClusterElementsFound][0] = vec2[0];
         ClusterElementsFound[nClusterElementsFound][1] = vec2[1];
         ClusterElementsFound[nClusterElementsFound][2] = vec2[2];
         nClusterElementsFound++;
      } else {
         RemainingElements[nRemainingElements][0] = vec2[0];
         RemainingElements[nRemainingElements][1] = vec2[1];
         RemainingElements[nRemainingElements][2] = vec2[2];
         nRemainingElements++;
      }
   }

    return;
}



//----------end of function PndSttTrackFinderReal::clustering3



void PndSttTrackFinderReal::WriteHistograms(){

//     TFile* file = FairRootManager::Instance()->GetOutFile();
          TFile* file = FairRootManager::Instance()->GetOutFile();
 	  file->cd();
 	  file->mkdir("PndSttTrackFinderReal");
 	  file->cd("PndSttTrackFinderReal");

//          hx->Write();
// 	  delete hx;

}

//----------end of function PndSttTrackFinderReal::WriteHistograms




//----------start of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneral

  void PndSttTrackFinderReal::WriteMacroParallelHitsGeneral(
                   Int_t Nhits, Double_t info[][7], Int_t Nincl, Int_t Minclinations[], Double_t inclination[][3],
                   UShort_t nTracksFoundSoFar,
                   bool *TypeConf,
                   Double_t *ALFA, Double_t *BETA, Double_t *GAMMA
                                                     )
{

    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax, xl, xu, yl, yu,
           Ox[nmaxHits], Oy[nmaxHits], Radius[nmaxHits], gamma,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,ff,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,x1,x2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, rrr, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];

      char nome[300], nome2[300];





//---------- parallel straws Macro now
      sprintf(nome,"MacroGeneralParallelHitsEvent%d", IVOLTE);
      sprintf(nome2,"%s.C",nome);
      FILE * MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            if (info[i][0]-info[i][3] < xmin)   xmin = info[i][0]-info[i][3];
            if (info[i][0]+info[i][3] > xmax)   xmax = info[i][0]+info[i][3];
            if (info[i][1]-info[i][3] < ymin)   ymin = info[i][1]-info[i][3];
            if (info[i][1]+info[i][3] > ymax)   ymax = info[i][1]+info[i][3];
          }
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);


       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,info[i][0],info[i][1],info[i][3],info[i][3],i,i);
          }
       }




//-------------------------------   plotting all the tracks found

    for(i=0; i<nTracksFoundSoFar; i++){

     if( TypeConf[i] ){
       aaa = -0.5*ALFA[i];
       bbb = -0.5*BETA[i];
//  Questa riga perche' so che la crf passa per origine
       rrr = sqrt( aaa*aaa+bbb*bbb);
//       rrr = sqrt( aaa*aaa+bbb*bbb-GAMMA[i]);
          fprintf(MACRO,
"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);

     } else {
       if(fabs(BETA[i]) < 1.e-10){
//         fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,- GAMMA[i]/ALFA[i],ymin,- GAMMA[i]/ALFA[i],ymax);
         fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,0.,ymin,0.,ymax);
         fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
         fprintf(MACRO,"ris%d->Draw();\n",i);
       } else {
 //        yl = -xmin*ALFA[i]/BETA[i] - GAMMA[i]/BETA[i];
//         yu = -xmax*ALFA[i]/BETA[i] - GAMMA[i]/BETA[i];
         yl = -xmin*ALFA[i]/BETA[i];
         yu = -xmax*ALFA[i]/BETA[i];
         fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
         fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
         fprintf(MACRO,"ris%d->Draw();\n",i);
       }
     }




if(istampa>= 3 && IVOLTE<20) {
  cout<<"stampa da WriteMacroParallelHitsGeneral , for trackfoundsofar n. "<<i<<",  typconf "<<
   TypeConf[i]<<",  nel normale piano XY;  alfa "<<ALFA[i]<<",  beta "<<BETA[i]<<", gamma "<<GAMMA[i]
       <<"  a cui corrisponde  Cx = "<<-0.5*ALFA[i]<<",  Cy = "<<-0.5*BETA[i]<<" ed  R = "
//       << sqrt( aaa*aaa+bbb*bbb-GAMMA[i]) <<endl;
       << sqrt( aaa*aaa+bbb*bbb) <<endl;
}




    }

// -----------









      fprintf(MACRO,"}\n");
      fclose(MACRO);
       
//------------------------------------------------------------------------------------------------------------


//---------- parallel straws Macro now con anche le tracce MC

      sprintf(nome,"MacroGeneralParallelHitswithMCEvent%d", IVOLTE);
      sprintf(nome2,"%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            if (info[i][0]-info[i][3] < xmin)   xmin = info[i][0]-info[i][3];
            if (info[i][0]+info[i][3] > xmax)   xmax = info[i][0]+info[i][3];
            if (info[i][1]-info[i][3] < ymin)   ymin = info[i][1]-info[i][3];
            if (info[i][1]+info[i][3] > ymax)   ymax = info[i][1]+info[i][3];
          }
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);


       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,info[i][0],info[i][1],info[i][3],info[i][3],i,i);
          }
       }



       for( i=0; i< nMCTracks ; i++) {
            fprintf(MACRO,"TEllipse* MC%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nMC%d->SetFillStyle(0);\nMC%d->SetLineColor(3);\nMC%d->Draw();\n",
                     i,CxMC[i],CyMC[i],R_MC[i],R_MC[i],i,i,i);
// cout<<" info MC buone : MCtrack n. "<<i<<",  Cx, Cy, R  "<<CxMC[i]<<",  "<<CyMC[i]<<",  "<<R_MC[i]<<endl;
       }


//-------------------------------   plotting all the tracks found

    for(i=0; i<nTracksFoundSoFar; i++){

     if( TypeConf[i] ){
       aaa = -0.5*ALFA[i];
       bbb = -0.5*BETA[i];
       rrr = sqrt( aaa*aaa+bbb*bbb-GAMMA[i]);
       fprintf(MACRO,"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);
     } else {
       if(fabs(BETA[i]) < 1.e-10){
         fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,- GAMMA[i]/ALFA[i],ymin,- GAMMA[i]/ALFA[i],ymax);
         fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
         fprintf(MACRO,"ris%d->Draw();\n",i);
       } else {
         yl = -xmin*ALFA[i]/BETA[i] - GAMMA[i]/BETA[i];
         yu = -xmax*ALFA[i]/BETA[i] - GAMMA[i]/BETA[i];
         fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
         fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
         fprintf(MACRO,"ris%d->Draw();\n",i);
       }
     }


    }

// -----------

      fprintf(MACRO,"}\n");
      fclose(MACRO);
       
//------------------------------------------------------------------------------------------------------------







//   ora riplotto tutto nello spazio conforme usando la trasformazione u= x/(x**2+y**2) e   v = y/(x**2+y**2)
//
//   aggiungo anche la grigliatura dello spazio conforme usata per la box del pattern recognition

      sprintf(nome,"MacroGeneralParallelHitsConformeEvent%d", IVOLTE);
      sprintf(nome2,"%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
//   centro sfera in sistema conforme
            gamma = info[i][0]*info[i][0] + info[i][1]*info[i][1] - info[i][3]*info[i][3];
            Ox[i] = info[i][0] / gamma;
            Oy[i] = info[i][1] / gamma;
            Radius[i] = info[i][3]/gamma;
            if (Ox[i]-Radius[i] < xmin)   xmin = Ox[i]-Radius[i];
            if (Ox[i]+Radius[i] > xmax)   xmax = Ox[i]+Radius[i];
            if (Oy[i]-Radius[i] < ymin)   ymin = Oy[i]-Radius[i];
            if (Oy[i]+Radius[i] > ymax)   ymax = Oy[i]+Radius[i];
          }
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);

// ora la grigliatura  con i cerchi

       fprintf(MACRO,"TEllipse* Griglia%d = new TEllipse(0.,0.,%f,%f,0.,360.);\nGriglia%d->SetLineColor(4);\nGriglia%d->Draw();\n",
                     nRdivConformalEffective,1./RStrawDetectorMin,1./RStrawDetectorMin,nRdivConformalEffective,nRdivConformalEffective);

       for( i=nRdivConformalEffective-1; i>=0 ; i--) {
            fprintf(MACRO,"TEllipse* Griglia%d = new TEllipse(0.,0.,%f,%f,0.,360.);\nGriglia%d->SetLineColor(4);\nGriglia%d->Draw();\n",
                     i,radiaConf[i],radiaConf[i],i,i);
       }
//---------------------
// ora la grigliatura  con i segmenti

       for(i=0;  i<nFidivConformal; i++) {
            ff = i*2.*PI/nFidivConformal;
            x1=cos(ff)/RStrawDetectorMax;
            y1=sin(ff)/RStrawDetectorMax;
            x2=cos(ff)/RStrawDetectorMin;
            y2=sin(ff)/RStrawDetectorMin;
            fprintf(MACRO,"TLine* Seg%d = new TLine(%f,%f,%f,%f);\nSeg%d->SetLineColor(4);\nSeg%d->Draw();\n",
                     i,x1,y1,x2,y2,i,i);
       }
//---------------------

       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,Ox[i],Oy[i],Radius[i],Radius[i],i,i);
          }
       }




//------------------   plotting all the tracks found

    for(i=0; i<nTracksFoundSoFar; i++){


// cout<<" da writeparallelhitsgeneral, traccia found n. "<<i<<", typeconf "<<TypeConf[i]
//  <<",  alfa "<<ALFA[i]<<",  beta  "<<BETA[i]<<",  gamma "<<GAMMA[i]<<endl;

//  assumo che tutte le traiettorie siano rette nello spazio conforme, perche' le tracce vengono dal vertice primario

     if( TypeConf[i] ){

//      if( fabs(GAMMA[i]) > 1.e-10) {
//       aaa = -0.5*ALFA[i]/GAMMA[i];
//       bbb = -0.5*BETA[i]/GAMMA[i];
//       rrr = sqrt( 0.25*ALFA[i]*ALFA[i]+0.25*BETA[i]*BETA[i]-GAMMA[i])/fabs(GAMMA[i]);
//       if( fabs(rrr/GAMMA[i]) < 30.) {
//         fprintf(MACRO,"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
//                     i,aaa,bbb,rrr,rrr,i,i,i);
//       }  else {
//          yl = -xmin*ALFA[i]/BETA[i] - 1./BETA[i];
//          yu = -xmax*ALFA[i]/BETA[i] - 1./BETA[i];
//          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
//          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
//          fprintf(MACRO,"ris%d->Draw();\n",i);
//       }
//      }  else {

        if(fabs(BETA[i]) < 1.e-10){
         if(fabs(ALFA[i])<1.e-10) {
          continue;
         } else {
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,-1./ALFA[i],ymin,- 1./ALFA[i],ymax);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         }
        } else {
          yl = -xmin*ALFA[i]/BETA[i] - 1./BETA[i];
          yu = -xmax*ALFA[i]/BETA[i] - 1./BETA[i];
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
        }

//      }

     } else {   // in this case TypConf = 0 -->  straight line in XY


      if( fabs(GAMMA[i]) > 1.e-10) {
       aaa = -0.5*ALFA[i]/GAMMA[i];
       bbb = -0.5*BETA[i]/GAMMA[i];
       rrr = sqrt( aaa*aaa+bbb*bbb);
       fprintf(MACRO,"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);
      }  else {
         if(fabs(BETA[i])>1.e-10) {
          yl = -xmin*ALFA[i]/BETA[i] ;
          yu = -xmax*ALFA[i]/BETA[i] ;
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         } else {
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,0.,ymin,0.,ymax);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         }
      }

     }
    }

// ------------------------------

     fprintf(MACRO,"}\n");
     fclose(MACRO);
       







    return ;

}


//----------end of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneral



















//----------start of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneralConformalwithMC

  void PndSttTrackFinderReal::WriteMacroParallelHitsGeneralConformalwithMC(
                   Int_t Nhits, Double_t info[][7], Int_t Nincl, Int_t Minclinations[], Double_t inclination[][3],
                   UShort_t nTracksFoundSoFar,
                   bool *TypeConf,
                   Double_t *ALFA, Double_t *BETA, Double_t *GAMMA
                                                     )
{

    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax, xl, xu, yl, yu, rrr,
           Ox[nmaxHits], Oy[nmaxHits], Radius[nmaxHits], gamma,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,ff,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,x1,x2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           zl[200],zu[200];






//---------- parallel straws Macro now
      char nome[300], nome2[300];
      FILE * MACRO;

       
//   ora riplotto tutto nello spazio conforme usando la trasformazione u= x/(x**2+y**2) e   v = y/(x**2+y**2)
//
//   aggiungo anche la grigliatura dello spazio conforme usata per la box del pattern recognition

      sprintf(nome,"MacroGeneralParallelHitsConformewithMCEvent%d", IVOLTE);
      sprintf(nome2,"%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
//   centro sfera in sistema conforme
            gamma = info[i][0]*info[i][0] + info[i][1]*info[i][1] - info[i][3]*info[i][3];
            Ox[i] = info[i][0] / gamma;
            Oy[i] = info[i][1] / gamma;
            Radius[i] = info[i][3]/gamma;
            if (Ox[i]-Radius[i] < xmin)   xmin = Ox[i]-Radius[i];
            if (Ox[i]+Radius[i] > xmax)   xmax = Ox[i]+Radius[i];
            if (Oy[i]-Radius[i] < ymin)   ymin = Oy[i]-Radius[i];
            if (Oy[i]+Radius[i] > ymax)   ymax = Oy[i]+Radius[i];
          }
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);

// ora la grigliatura  con i cerchi

       fprintf(MACRO,"TEllipse* Griglia%d = new TEllipse(0.,0.,%f,%f,0.,360.);\nGriglia%d->SetLineColor(4);\nGriglia%d->Draw();\n",
                     nRdivConformalEffective,1./RStrawDetectorMin,1./RStrawDetectorMin,nRdivConformalEffective,nRdivConformalEffective);

       for( i=nRdivConformalEffective-1; i>=0 ; i--) {
            fprintf(MACRO,"TEllipse* Griglia%d = new TEllipse(0.,0.,%f,%f,0.,360.);\nGriglia%d->SetLineColor(4);\nGriglia%d->Draw();\n",
                     i,radiaConf[i],radiaConf[i],i,i);
       }
//---------------------
// ora la grigliatura  con i segmenti

       for(i=0;  i<nFidivConformal; i++) {
            ff = i*2.*PI/nFidivConformal;
            x1=cos(ff)/RStrawDetectorMax;
            y1=sin(ff)/RStrawDetectorMax;
            x2=cos(ff)/RStrawDetectorMin;
            y2=sin(ff)/RStrawDetectorMin;
            fprintf(MACRO,"TLine* Seg%d = new TLine(%f,%f,%f,%f);\nSeg%d->SetLineColor(4);\nSeg%d->Draw();\n",
                     i,x1,y1,x2,y2,i,i);
       }
//---------------------

       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetLineWidth(2);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,Ox[i],Oy[i],Radius[i],Radius[i],i,i,i);
          }
       }




//------------------   plotting all the tracks found

    for(i=0; i<nTracksFoundSoFar; i++){

     if( TypeConf[i] ){

      if( fabs(GAMMA[i]) > 1.e-10) {
       aaa = -0.5*ALFA[i]/GAMMA[i];
       bbb = -0.5*BETA[i]/GAMMA[i];
       rrr = sqrt( aaa*aaa+bbb*bbb-1./GAMMA[i]);
       if( fabs(rrr/GAMMA[i]) < 30.) {
           fprintf(MACRO,
"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);
       }  else{


          yl = -xmin*ALFA[i]/BETA[i] - 1./BETA[i];
          yu = -xmax*ALFA[i]/BETA[i] - 1./BETA[i];
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);



       }
      }  else {

        if(fabs(BETA[i]) < 1.e-10){
         if(fabs(ALFA[i])<1.e-10) {
          continue;
         } else {
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,-1./ALFA[i],ymin,- 1./ALFA[i],ymax);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         }
        } else {
          yl = -xmin*ALFA[i]/BETA[i] - 1./BETA[i];
          yu = -xmax*ALFA[i]/BETA[i] - 1./BETA[i];
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
        }

      }

     } else {   // in this case TypConf = 0 -->  straight line in XY


      if( fabs(GAMMA[i]) > 1.e-10) {
       aaa = -0.5*ALFA[i]/GAMMA[i];
       bbb = -0.5*BETA[i]/GAMMA[i];
       rrr = sqrt( aaa*aaa+bbb*bbb);
       fprintf(MACRO,"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);
      }  else {
         if(fabs(BETA[i])>1.e-10) {
          yl = -xmin*ALFA[i]/BETA[i] ;
          yu = -xmax*ALFA[i]/BETA[i] ;
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         } else {
          fprintf(MACRO,"TLine* ris%d = new TLine(%f,%f,%f,%f);\n",i,0.,ymin,0.,ymax);
          fprintf(MACRO,"ris%d->SetLineColor(2);\n",i);
          fprintf(MACRO,"ris%d->Draw();\n",i);
         }
      }

     }
    }

// ------------------------------

//   plotting all the tracks MC generated


    for(i=0; i<nMCTracks; i++){
//cout<<"super2, info MC DOVREBBERO essere buone : MCtrack n. "<<i<<",  Cx, Cy, R  "<<CxMC[i]<<",  "<<CyMC[i]<<",  "<<R_MC[i]<<endl;

    gamma = -R_MC[i]*R_MC[i] + (CxMC[i]*CxMC[i]+CyMC[i]*CyMC[i]);



//Double_t DDD = sqrt(CxMC[i]*CxMC[i]+CyMC[i]*CyMC[i])-R_MC[i];
//cout<<"  D = "<<DDD<<endl;
//cout<<"  gamma  "<<gamma<<"   ed il suo R/|gamma| "<<fabs(R_MC[i]/gamma)<<endl;

    if(fabs(gamma)< 0.001) {

//     if( R_MC[i] < RStrawDetectorMin)  continue;
     if(CyMC[i] != 0.) {
       yl = xmin*(-CxMC[i]/CyMC[i]) + 0.5/CyMC[i];
       yu = xmax*(-CxMC[i]/CyMC[i]) + 0.5/CyMC[i];
       xl = xmin;
       xu = xmax;
     } else {
       yl = ymin;
       yu = ymax;
       xu=xl = 0.5/CxMC[i];
     }
       fprintf(MACRO,"TLine* MCris%d = new TLine(%f,%f,%f,%f);\n",i,xl,yl,xu,yu);
       fprintf(MACRO,"MCris%d->SetLineStyle(2);\n",i);
       fprintf(MACRO,"MCris%d->SetLineColor(3);\n",i);
       fprintf(MACRO,"MCris%d->SetLineWidth(1);\n",i);
       fprintf(MACRO,"MCris%d->Draw();\n",i);

    }  else {

       if(fabs(R_MC[i]/gamma) > 1.) {
         if(fabs(CyMC[i])>0.001 ) {
           yl = -xmin*CxMC[i]/CyMC[i]+0.5/CyMC[i];
           yu = -xmax*CxMC[i]/CyMC[i]+0.5/CyMC[i];
           fprintf(MACRO,"TLine* MCline%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
           fprintf(MACRO,"MCline%d->SetLineColor(3);\n",i);
           fprintf(MACRO,"MCline%d->Draw();\n",i);
         } else {
           fprintf(MACRO,"TLine* MCline%d = new TLine(%f,%f,%f,%f);\n",i,2.*CxMC[i],ymin,2.*CxMC[i],ymax);
           fprintf(MACRO,"MCline%d->SetLineColor(2);\n",i);
           fprintf(MACRO,"MCline%d->Draw();\n",i);
         }
        }  else {
           fprintf(MACRO, "TEllipse* MCcerchio%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nMCcerchio%d->SetLineColor(3);\n",
                     i,CxMC[i]/gamma,CyMC[i]/gamma,R_MC[i]/fabs(gamma),R_MC[i]/fabs(gamma),i);

           fprintf(MACRO,"MCcerchio%d->SetFillStyle(0);\nMCcerchio%d->SetLineStyle(2);\nMCcerchio%d->SetLineWidth(1);\nMCcerchio%d->Draw();\n",
                     i,i,i,i);
        }
    }


   }



     fprintf(MACRO,"}\n");
     fclose(MACRO);
       







    return ;

}


//----------end of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneralConformalwithMC















//----------start of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneralConformalwithMCspecial

  void PndSttTrackFinderReal::WriteMacroParallelHitsConformalwithMCspecial(
                   Int_t Nhits,
//                   UShort_t iExclude,
                   Double_t auxinfoparalConformal[][5],
                   UShort_t nTracksFoundSoFar,
                   Double_t * ALFA, 
                   Double_t * BETA, 
                   Double_t * GAMMA, 
                   Short_t Status, Double_t *trajectory_vertex
                                                     )
{

    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax, xl, xu, yl, yu, rrr, cx, cy,
           Ox[nmaxHits], Oy[nmaxHits], Radius[nmaxHits], alfa, beta, gamma,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,ff,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,x1,x2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           zl[200],zu[200];






//---------- parallel straws Macro now
      char nome[300], nome2[300];
      FILE * MACRO;

       
//   ora riplotto tutto nello spazio conforme usando la trasformazione u= x/(x**2+y**2) e   v = y/(x**2+y**2)
//

      sprintf(nome,"MacroParallelHitsConformewithMCspecialEvent%dTrack%d", IVOLTE,nTracksFoundSoFar);
      sprintf(nome2,"%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
//             if( i== iExclude)  continue;
//   centro sfera in sistema conforme
            Ox[i] = auxinfoparalConformal[i][0] ;
            Oy[i] = auxinfoparalConformal[i][1] ;
            Radius[i] = auxinfoparalConformal[i][2];
            if (Ox[i]-Radius[i] < xmin)   xmin = Ox[i]-Radius[i];
            if (Ox[i]+Radius[i] > xmax)   xmax = Ox[i]+Radius[i];
            if (Oy[i]-Radius[i] < ymin)   ymin = Oy[i]-Radius[i];
            if (Oy[i]+Radius[i] > ymax)   ymax = Oy[i]+Radius[i];
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);


       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
//         if( i== iExclude)  continue;
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetLineWidth(2);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,Ox[i],Oy[i],Radius[i],Radius[i],i,i,i);
       }




//------------------   plotting the track found

     i = nTracksFoundSoFar;
     if( Status != 99){

          rrr = sqrt( 0.25*ALFA[nTracksFoundSoFar]*ALFA[nTracksFoundSoFar] + 0.25*BETA[nTracksFoundSoFar]*BETA[nTracksFoundSoFar]
                    -GAMMA[nTracksFoundSoFar]);
          alfa = ALFA[nTracksFoundSoFar]+2.*trajectory_vertex[0];
          beta = BETA[nTracksFoundSoFar]+2.*trajectory_vertex[1];
          cx = -0.5*alfa;
          cy = -0.5*beta;
          gamma = cx*cx+cy*cy-rrr*rrr;

       if(fabs(gamma) > 1.e-8){
          fprintf(MACRO, "TEllipse* FoundTrack%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nFoundTrack%d->SetLineColor(2);\n",
                     i,cx/gamma,cy/gamma,rrr/fabs(gamma),rrr/fabs(gamma),i);
          fprintf(MACRO,"FoundTrack%d->SetFillStyle(0);\nFoundTrack%d->SetLineStyle(2);\nFoundTrack%d->SetLineWidth(1);\nFoundTrack%d->Draw();\n",
                     i,i,i,i);
       } else {
          if( fabs(beta) > 1.e-8){
            yl = -xmin*alfa/beta-1./beta ;
            yu = -xmax*alfa/beta-1./beta  ;
            fprintf(MACRO,"TLine* FoundTrack%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
            fprintf(MACRO,"FoundTrack%d->SetLineColor(2);\n",i);
            fprintf(MACRO,"FoundTrack%d->Draw();\n",i);
          } else {
            fprintf(MACRO,"TLine* FoundTrack%d = new TLine(%f,%f,%f,%f);\n",i,-1./alfa,ymin,-1./alfa,ymax);
            fprintf(MACRO,"FoundTrack%d->SetLineColor(2);\n",i);
            fprintf(MACRO,"FoundTrack%d->Draw();\n",i);
          }
       }


     } else {

          alfa = ALFA[nTracksFoundSoFar];
          beta = BETA[nTracksFoundSoFar];
          gamma = GAMMA[nTracksFoundSoFar]+ALFA[nTracksFoundSoFar]*trajectory_vertex[0]+BETA[nTracksFoundSoFar]*trajectory_vertex[1];

          if( fabs(beta) > 1.e-8){
            yl = -xmin*alfa/beta-1./beta ;
            yu = -xmax*alfa/beta-1./beta  ;
            fprintf(MACRO,"TLine* FoundTrack%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
            fprintf(MACRO,"FoundTrack%d->SetLineColor(2);\n",i);
            fprintf(MACRO,"FoundTrack%d->Draw();\n",i);
          } else {
            fprintf(MACRO,"TLine* FoundTrack%d = new TLine(%f,%f,%f,%f);\n",i,-1./alfa,ymin,-1./alfa,ymax);
            fprintf(MACRO,"FoundTrack%d->SetLineColor(2);\n",i);
            fprintf(MACRO,"FoundTrack%d->Draw();\n",i);
          }


     }



// ------------------------------

//   plotting all the tracks MC generated

//cout<<" TRASLAZIONE IN "<<trajectory_vertex[0]<<",  "<<trajectory_vertex[1]<<endl;

    for(i=0; i<nMCTracks; i++){
// cout<<"PRIMA; traccia MC n. "<<i<<"  che ha cx, cy, r = "<<CxMC[i]<<",  "<<CyMC[i]<<",  "<<R_MC[i]<<endl;
     cx = CxMC[i] - trajectory_vertex[0];
     cy = CyMC[i] - trajectory_vertex[1];
     gamma = -R_MC[i]*R_MC[i] + (cx*cx+cy*cy);

//cout<<" DOPO; traccia MC n. "<<i<<"  che ha cx, cy, gamma = "<<cx<<",  "<<cy<<",  "<<gamma<<endl;



    if(fabs(gamma)< 0.001) {

     if(cy != 0.) {
       yl = xmin*(-cx/cy) + 0.5/cy;
       yu = xmax*(-cx/cy) + 0.5/cy;
       xl = xmin;
       xu = xmax;
     } else{
       yl = ymin;
       yu = ymax;
       xu=xl = 0.5/cx;
     }
       fprintf(MACRO,"TLine* MCris%d = new TLine(%f,%f,%f,%f);\n",i,xl,yl,xu,yu);
       fprintf(MACRO,"MCris%d->SetLineStyle(2);\n",i);
       fprintf(MACRO,"MCris%d->SetLineColor(3);\n",i);
       fprintf(MACRO,"MCris%d->SetLineWidth(1);\n",i);
       fprintf(MACRO,"MCris%d->Draw();\n",i);

    }  else {


       if(fabs(R_MC[i]/gamma) > 1.) {
         if(fabs(CyMC[i])>0.001 ) {
           yl = -xmin*CxMC[i]/CyMC[i]+0.5/CyMC[i];
           yu = -xmax*CxMC[i]/CyMC[i]+0.5/CyMC[i];
           fprintf(MACRO,"TLine* MCline%d = new TLine(%f,%f,%f,%f);\n",i,xmin,yl,xmax,yu);
           fprintf(MACRO,"MCline%d->SetLineColor(3);\n",i);
           fprintf(MACRO,"MCline%d->Draw();\n",i);
         } else {
           fprintf(MACRO,"TLine* MCline%d = new TLine(%f,%f,%f,%f);\n",i,2.*CxMC[i],ymin,2.*CxMC[i],ymax);
           fprintf(MACRO,"MCline%d->SetLineColor(2);\n",i);
           fprintf(MACRO,"MCline%d->Draw();\n",i);
         }
        }  else {



           fprintf(MACRO,
     "TEllipse* MCcerchio%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nMCcerchio%d->SetLineColor(3);\n",
                     i,cx/gamma,cy/gamma,R_MC[i]/fabs(gamma),R_MC[i]/fabs(gamma),i);
           fprintf(MACRO,
 "MCcerchio%d->SetFillStyle(0);\nMCcerchio%d->SetLineStyle(2);\nMCcerchio%d->SetLineWidth(1);\nMCcerchio%d->Draw();\n",
                     i,i,i,i);

       }


    }


   }



     fprintf(MACRO,"}\n");
     fclose(MACRO);
       







    return ;

}


//----------end of function PndSttTrackFinderReal::WriteMacroParallelHitsGeneralConformalwithMCspecial
























//----------start of function PndSttTrackFinderReal::WriteMacroParallelAssociatedHits

  void PndSttTrackFinderReal::WriteMacroParallelAssociatedHits(
                   Double_t Ox,Double_t Oy,Double_t R,
                   UShort_t Nhits,
		   UShort_t ListHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
//		   UShort_t infoparal[nmaxHits],
                   Double_t info[][7], Int_t Nincl, Int_t Minclinations[],
		   Double_t inclination[][3],
                   UShort_t imaxima
                                                     )
{

    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];





//    Ox = (D+R)*cos(Fi);
//    Oy = (D+R)*sin(Fi);

//cout<<"da MacroTrackparalleletc. Ox, Oy "<<Ox<<",  "<<Oy<<endl;


//---------- parallel straws Macro now
      char nome[300], nome2[300];
      sprintf(nome,"MacroTrackN%dParallelHitsEvent%d",imaxima, IVOLTE);
      sprintf(nome2,"%s.C",nome);
      FILE * MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( ii=1; ii< Nhits; ii++) {
            i = infoparal[  ListHitsinTrack[imaxima][ii]  ] ;
            if (info[i][0]-info[i][3] < xmin)   xmin = info[i][0]-info[i][3];
            if (info[i][0]+info[i][3] > xmax)   xmax = info[i][0]+info[i][3];
            if (info[i][1]-info[i][3] < ymin)   ymin = info[i][1]-info[i][3];
            if (info[i][1]+info[i][3] > ymax)   ymax = info[i][1]+info[i][3];
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);

       fprintf(MACRO,"TEllipse* TC = new TEllipse(%f,%f,%f,%f,0.,360.);\n",Ox,Oy,R,R);
       fprintf(MACRO,"TC->SetLineColor(2);\nTC->SetFillStyle(0);\nTC->Draw();\n");

       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( ii=0; ii< Nhits; ii++) {
            i = infoparal[  ListHitsinTrack[imaxima][ii]  ] ;
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,info[i][0],info[i][1],info[i][3],info[i][3],i,i);
       }

      fprintf(MACRO,"}\n");
      fclose(MACRO);
       

    return ;

}


//----------end of function PndSttTrackFinderReal::WriteMacroParallelAssociatedHits



//----------start of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHits


  void PndSttTrackFinderReal::WriteMacroSkewAssociatedHits(
                   Double_t KAPPA,
                   Double_t FI0,
                   Double_t D,
                   Double_t Fi,
                   Double_t R,
                   Double_t info[][7],
                   Int_t Nincl,
                   Int_t Minclinations[],
                   Double_t inclination[][3],
                   Int_t imaxima, Int_t nMaxima, 
                   UShort_t nSkewHitsinTrack,
                   UShort_t ListSkewHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
                   UShort_t nSkewCommon,
                   UShort_t SkewCommonList[MAXTRACKSPEREVENT][nmaxHits]

                                                     )


 {


    Int_t i, j, i1, ii, iii, index, Kincl, nlow, nup, STATUS, imc, Nmin, Nmax;

    Double_t xmin , xmax, ymin, ymax, Ox, Oy,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];





//-------------------  skew straws hits Macro now

      char  nome2[300],nome[300];
      FILE *MACRO;
      sprintf(nome,  "MacroParTrack%dSkewTrack%dSkewHitsEvent%d",imaxima,nMaxima, IVOLTE);
      sprintf(nome2,  "%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);

//KAPPA = 1./166.67 ;  FI0 = 1.5*PI;

      Smin=zmin = 1.e10;
      Smax=zmax = -zmin;
      index=0;

       for( iii=0; iii< nSkewHitsinTrack; iii++) {
         i = infoskew[ ListSkewHitsinTrack[imaxima][iii] ];

         Kincl = (int) info[i][5] - 1;


         aaa = sqrt(inclination[Kincl][0]*inclination[Kincl][0]+inclination[Kincl][1]*inclination[Kincl][1]+
                  inclination[Kincl][2]*inclination[Kincl][2]);
         vx1 = inclination[Kincl][0]/aaa;
         vy1 = inclination[Kincl][1]/aaa;
         vz1 = inclination[Kincl][2]/aaa;
         C0x1 = info[i][0];
         C0y1 = info[i][1];
         C0z1 = info[i][2];
         Ox = (R+D)*cos(Fi);
         Oy = (R+D)*sin(Fi);

       calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,info[i][3],
                              vx1,vy1,vz1,
                              &STATUS,POINTS1);

       if(STATUS < 0 ) continue ;



       for( ii=0; ii<2; ii++){
        j=3*ii;
        distance = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                            );
        if( distance >= info[i][4] ) continue;


        Rx = POINTS1[j]-Ox ;   //  x component Radial vector of cylinder of trajectory
        Ry = POINTS1[1+j]-Oy ;   //  y direction Radial vector of cylinder of trajectory

        aaa = sqrt(Rx*Rx+Ry*Ry);
        SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
        SkewInclWithRespectToS /= R;
        bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
        //  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
        if( bbb > 1.e-10){
           Tiltdirection1[0] = vz1/bbb;
           Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
        } else {
           Tiltdirection1[0] = 1.;
           Tiltdirection1[1] = 0.;
        }

        LL = fabs(vx1*Rx + vy1*Ry);
        if( LL < 1.e-10) continue;
        Aellipsis1 = info[i][3]*aaa/LL;

        Bellipsis1 = info[i][3]/R;



// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

/*
        if(
          fabs(POINTS1[j+2]-ZCENTER_STRAIGHT) > SEMILENGTH_STRAIGHT- Aellipsis1 ||
          distance + bbb > info[i][4]        //  the ellipsis goes out of the boundaries of the skew straw
          ) {
cout<<"the ellipsis goes out of the boundaries of the skew straw, hit n. "<<i<<endl
     <<"dis. from center "<<distance+bbb<<",  length of the straw "<<info[i][4]<<endl;
           continue;
          }
*/
//--------------------------


        fi1 = atan2(POINTS1[j+1]-Oy, POINTS1[j]-Ox) ;  // atan2 returns radians in (-pi and +pi]
        if( fi1 < 0.) fi1 += 2.*PI;

        if( zmin > POINTS1[j+2] - Aellipsis1 ) zmin = POINTS1[j+2] - Aellipsis1;
        if( zmax < POINTS1[j+2] + Aellipsis1 ) zmax = POINTS1[j+2] + Aellipsis1;

        if( Smin > fi1 - Bellipsis1 ) Smin = fi1 - Bellipsis1;
        if( Smax < fi1 + Bellipsis1 ) Smax = fi1 + Bellipsis1;


        Double_t rotation1 = 180.*atan2(Tiltdirection1[1],Tiltdirection1[0])/PI;
        fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.,%f);\nE%d->SetFillStyle(0);\n",
                     index,POINTS1[j+2],fi1,Aellipsis1,Bellipsis1,rotation1,index);





// ------ se lo hit e' spurio marcalo in rosso
        for( i1=0; i1<nSkewCommon; i1++){
          if ( SkewCommonList[   imaxima   ][i1] == i ){

                goto fuori ;
          }

        }
        fprintf(MACRO,"E%d->SetLineColor(2);\n",index);
fuori: ;






        index++;

   }    //  end of    for( ii=0; ii<2; ii++)

  }   //   end of  for( i=1; i< Nhits; i++)


  if(index==0) goto nohits ;
  if( zmax < zmin ) goto nohits ;
  if( Smax < Smin ) goto nohits;
  aaa = Smax-Smin;
  Smin -= aaa*1.;
  Smax += aaa*1.;

  aaa = zmax-zmin;
  zmin -= aaa*0.05;
  zmax += aaa*0.05;

  if(Smax > 2.*PI) Smax = 2.*PI;
  if( Smin < 0.) Smin = 0.;

//  Smin=0.;
//  Smax=2.*PI;


  fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",zmin,Smin,zmax,Smax);
  for( ii=0; ii< index; ii++) {
       fprintf(MACRO,"E%d->Draw();\n",ii);
  }

   deltaz = zmax-zmin;
   deltaS = Smax-Smin;
   fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmax-0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,zmax-0.05*deltaz);
   fprintf(MACRO,"Assex->Draw();\n");
   fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,Smax-0.05*deltaS,Smin+0.05*deltaS,Smax-0.05*deltaS);
   fprintf(MACRO,"Assey->Draw();\n");




// --------------------------------

//  plot della traccia trovata dal finder

  if ( KAPPA >= 0.) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
     fmax = KAPPA*zmin + FI0;
     fmin = KAPPA*zmax + FI0;
  }
  if( fmax>=0.) {
    Nmax = (int) (0.5*fmax/ PI);
  }  else  {
    Nmax = ( (int) (0.5*fmax/ PI) ) -1;
  }
  if( fmin>=0.) {
    Nmin = (int) (0.5*fmin/ PI);
  } else {
    Nmin = ((int) (0.5*fmin/ PI) )-1;
  }
  for(i=Nmin; i<= Nmax;i++){
   offset = 2.*PI*i;
   z1 = (i*2.*PI-FI0)/KAPPA;
   z2 = ((i+1)*2.*PI-FI0)/KAPPA;
   fprintf(MACRO,"TLine* FOUND%d = new TLine(%f,%f,%f,%f);\nFOUND%d->SetLineColor(2);\nFOUND%d->Draw();\n",
                 i-Nmin,z1,0.,z2, 2.*PI,i-Nmin,i-Nmin);

  }   //  end of  for(i=Nmin; i<= Nmax;++)



nohits: ;

      fprintf(MACRO,"}\n");
      fclose(MACRO);



}









//----------end of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHits







//----------start of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithMC




  void PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithMC(
                   Double_t KAPPA,
                   Double_t FI0,
                   Double_t D,
                   Double_t Fi,
                   Double_t R,
                   Double_t info[][7],
                   Int_t Nincl,
                   Int_t Minclinations[],
                   Double_t inclination[][3],
                   Int_t imaxima, Int_t nMaxima, 
                   UShort_t nSkewHitsinTrack,
                   UShort_t ListSkewHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
                   UShort_t nSkewCommon,
                   UShort_t SkewCommonList[MAXTRACKSPEREVENT][nmaxHits],
                   UShort_t daTrackFoundaTrackMC,
                   UShort_t nMCSkewAlone,
                   UShort_t MCSkewAloneList[MAXMCTRACKS][nmaxHits]
                                                     )
 {



    Int_t i, j, i1, ii, iii, index, Kincl, nlow, nup, STATUS, imc, Nmin, Nmax;

    Double_t xmin , xmax, ymin, ymax, Ox, Oy,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];





//-------------------  skew straws hits Macro now

      char  nome2[300],nome[300];
      FILE *MACRO;
      sprintf(nome,  "MacroParTrack%dSkewTrack%dSkewHitswithMCEvent%d",imaxima,nMaxima, IVOLTE);
      sprintf(nome2,  "%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);

//KAPPA = 1./166.67 ;  FI0 = 1.5*PI;

      Smin=zmin = 1.e10;
      Smax=zmax = -zmin;
      index=0;

       for( iii=0; iii< nSkewHitsinTrack; iii++) {
         i = infoskew[ ListSkewHitsinTrack[imaxima][iii] ];

         Kincl = (int) info[i][5] - 1;


         aaa = sqrt(inclination[Kincl][0]*inclination[Kincl][0]+inclination[Kincl][1]*inclination[Kincl][1]+
                  inclination[Kincl][2]*inclination[Kincl][2]);
         vx1 = inclination[Kincl][0]/aaa;
         vy1 = inclination[Kincl][1]/aaa;
         vz1 = inclination[Kincl][2]/aaa;
         C0x1 = info[i][0];
         C0y1 = info[i][1];
         C0z1 = info[i][2];
         Ox = (R+D)*cos(Fi);
         Oy = (R+D)*sin(Fi);

       calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,info[i][3],
                              vx1,vy1,vz1,
                              &STATUS,POINTS1);

       if(STATUS < 0 ) continue ;



       for( ii=0; ii<2; ii++){
        j=3*ii;
        distance = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                            );
        if( distance >= info[i][4] ) continue;


        Rx = POINTS1[j]-Ox ;   //  x component Radial vector of cylinder of trajectory
        Ry = POINTS1[1+j]-Oy ;   //  y direction Radial vector of cylinder of trajectory

        aaa = sqrt(Rx*Rx+Ry*Ry);
        SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
        SkewInclWithRespectToS /= R;
        bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
        //  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
        if( bbb > 1.e-10){
           Tiltdirection1[0] = vz1/bbb;
           Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
        } else {
           Tiltdirection1[0] = 1.;
           Tiltdirection1[1] = 0.;
        }

        LL = fabs(vx1*Rx + vy1*Ry);
        if( LL < 1.e-10) continue;
        Aellipsis1 = info[i][3]*aaa/LL;

        Bellipsis1 = info[i][3]/R;



// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

/*
        if(
          fabs(POINTS1[j+2]-ZCENTER_STRAIGHT) > SEMILENGTH_STRAIGHT- Aellipsis1 ||
          distance + bbb > info[i][4]        //  the ellipsis goes out of the boundaries of the skew straw
          ) {
cout<<"the ellipsis goes out of the boundaries of the skew straw, hit n. "<<i<<endl
     <<"dis. from center "<<distance+bbb<<",  length of the straw "<<info[i][4]<<endl;
           continue;
          }
*/
//--------------------------


        fi1 = atan2(POINTS1[j+1]-Oy, POINTS1[j]-Ox) ;  // atan2 returns radians in (-pi and +pi]
        if( fi1 < 0.) fi1 += 2.*PI;

        if( zmin > POINTS1[j+2] - Aellipsis1 ) zmin = POINTS1[j+2] - Aellipsis1;
        if( zmax < POINTS1[j+2] + Aellipsis1 ) zmax = POINTS1[j+2] + Aellipsis1;

        if( Smin > fi1 - Bellipsis1 ) Smin = fi1 - Bellipsis1;
        if( Smax < fi1 + Bellipsis1 ) Smax = fi1 + Bellipsis1;


        Double_t rotation1 = 180.*atan2(Tiltdirection1[1],Tiltdirection1[0])/PI;
        fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.,%f);\nE%d->SetFillStyle(0);\n",
                     index,POINTS1[j+2],fi1,Aellipsis1,Bellipsis1,rotation1,index);





// ------ se lo hit e' spurio marcalo in rosso
        for( i1=0; i1<nSkewCommon; i1++){
          if ( SkewCommonList[   imaxima   ][i1] == i ){

                goto fuori ;
          }

        }
        fprintf(MACRO,"E%d->SetLineColor(2);\n",index);
fuori: ;






        index++;

   }    //  end of    for( ii=0; ii<2; ii++)

  }   //   end of  for( i=1; i< Nhits; i++)


  if(index==0) goto nohits ;
  if( zmax < zmin ) goto nohits ;
  if( Smax < Smin ) goto nohits;
  aaa = Smax-Smin;
  Smin -= aaa*1.;
  Smax += aaa*1.;

  aaa = zmax-zmin;
  zmin -= aaa*0.05;
  zmax += aaa*0.05;

  if(Smax > 2.*PI) Smax = 2.*PI;
  if( Smin < 0.) Smin = 0.;

//  Smin=0.;
//  Smax=2.*PI;


  fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",zmin,Smin,zmax,Smax);
  for( ii=0; ii< index; ii++) {
       fprintf(MACRO,"E%d->Draw();\n",ii);
  }

   deltaz = zmax-zmin;
   deltaS = Smax-Smin;
   fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmax-0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,zmax-0.05*deltaz);
   fprintf(MACRO,"Assex->Draw();\n");
   fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,Smax-0.05*deltaS,Smin+0.05*deltaS,Smax-0.05*deltaS);
   fprintf(MACRO,"Assey->Draw();\n");




// --------------------------------

//  plot della traccia trovata dal finder

  if ( KAPPA >= 0.) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
     fmax = KAPPA*zmin + FI0;
     fmin = KAPPA*zmax + FI0;
  }
  if( fmax>=0.) {
    Nmax = (int) (0.5*fmax/ PI);
  }  else  {
    Nmax = ( (int) (0.5*fmax/ PI) ) -1;
  }
  if( fmin>=0.) {
    Nmin = (int) (0.5*fmin/ PI);
  } else {
    Nmin = ((int) (0.5*fmin/ PI) )-1;
  }
  for(i=Nmin; i<= Nmax;i++){
   offset = 2.*PI*i;
   z1 = (i*2.*PI-FI0)/KAPPA;
   z2 = ((i+1)*2.*PI-FI0)/KAPPA;
   fprintf(MACRO,"TLine* FOUND%d = new TLine(%f,%f,%f,%f);\nFOUND%d->SetLineColor(2);\nFOUND%d->Draw();\n",
                 i-Nmin,z1,0.,z2, 2.*PI,i-Nmin,i-Nmin);

  }   //  end of  for(i=Nmin; i<= Nmax;++)


//---------------------------------------------  qui ci aggiungo le traccie MC


// for(imc=0; imc<nMCTracks ; imc++){
//            if(imc !=    daTrackFoundaTrackMC[ imaxima ]) continue;
     imc=    daTrackFoundaTrackMC ;
     KAPPA=MCtruthTrkInfo[12][imc];
     FI0 = MCtruthTrkInfo[13][imc];
  if ( KAPPA >= 0.) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
     fmax = KAPPA*zmin + FI0;
     fmin = KAPPA*zmax + FI0;
  }
  if( fmax>=0.) {
    Nmax = (int) (0.5*fmax/ PI);
  }  else  {
    Nmax = ( (int) (0.5*fmax/ PI) ) -1;
  }
  if( fmin>=0.) {
    Nmin = (int) (0.5*fmin/ PI);
  } else {
    Nmin = ((int) (0.5*fmin/ PI) )-1;
  }

  for(i=Nmin; i<= Nmax;i++){
   offset = 2.*PI*i;
   z1 = (i*2.*PI-FI0)/KAPPA;
   z2 = ((i+1)*2.*PI-FI0)/KAPPA;
   fprintf(MACRO,"TLine* MC%d_%d = new TLine(%f,%f,%f,%f);\nMC%d_%d->SetLineColor(3);\nMC%d_%d->Draw();\n",
                 imc,i-Nmin,z1,0.,z2, 2.*PI,imc,i-Nmin,imc,i-Nmin);

  }   //  end of  for(i=Nmin; i<= Nmax;++)


//       }  // end of for(imc=0; imc<nMCTracks ; imc++)









nohits: ;

      fprintf(MACRO,"}\n");
      fclose(MACRO);





 }


//----------end of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithMC




//----------begin of function PndSttTrackFinderReal::PndSttfromXYtoConformal

 void PndSttTrackFinderReal::PndSttFromXYtoConformal(Double_t trajectory_vertex[3],
                            Double_t info[][7],
                            Int_t Nparal,Double_t infoparalConformal[][5],
                            Int_t *status )
{


//   do the transformation in the conformal space :  u= x/(x**2+y**2), v= y/(x**2+y**2) for each hit from parallel
//   straws;  also the equidrift radius changes.

//

    Double_t gamma, x, y, r;

    for(int i=0; i<Nparal; i++){
            x = info[infoparal[i]][0]-trajectory_vertex[0];
            y = info[infoparal[i]][1]-trajectory_vertex[1];
            r = info[infoparal[i]][3];
            gamma = x*x + y*y - r*r;
            if(fabs( gamma ) < 1.e-10) {
              *status = -1;
              continue;
            }
            infoparalConformal[i][0] = x / gamma;
            infoparalConformal[i][1] = y / gamma;
            infoparalConformal[i][2] = r/fabs(gamma);
            infoparalConformal[i][3] = infoparal[i] ;      //  n. of the Hit (in the original order)
            infoparalConformal[i][4] = StrawRadius/fabs(gamma);

    }


   *status=0;
   return;
}

//----------end of function PndSttTrackFinderReal::PndSttfromXYtoConformal









//----------start function PndSttTrackFinderReal::PndSttfromXYtoConformal2

 void PndSttTrackFinderReal::PndSttFromXYtoConformal2(
                                Double_t trajectory_vertex[3],
                                UShort_t nHitsinTrack ,
                                UShort_t iExclude ,
                                UShort_t *ListHits,
                                Double_t info[][7],
                                Double_t auxinfoparalConformal[][5],
                                Int_t * status
                                                     )
{


//   do the transformation in the conformal space :  u= x/(x**2+y**2), v= y/(x**2+y**2) for each hit from parallel
//   straws;  also the equidrift radius changes.

//

    Double_t gamma, x, y, r;

    for(int i=0; i<nHitsinTrack; i++){
            if( i == iExclude) continue;
            x = info[  infoparal[ListHits[i]]  ][0]-trajectory_vertex[0];
            y = info[  infoparal[ListHits[i]]  ][1]-trajectory_vertex[1];
            r = info[  infoparal[ListHits[i]]  ][3];
            gamma = x*x + y*y - r*r;
            if(fabs( gamma ) < 1.e-10) {
              *status = -1;
              continue;
            }
            auxinfoparalConformal[i][0] = x / gamma;
            auxinfoparalConformal[i][1] = y / gamma;
            auxinfoparalConformal[i][2] = r/fabs(gamma);
            auxinfoparalConformal[i][3] = infoparal[ListHits[i]] ;      //  n. of the Hit (in the original order)
            auxinfoparalConformal[i][4] = StrawRadius/fabs(gamma);


    }



   *status=0;
   return;
}

//----------end of function PndSttTrackFinderReal::PndSttfromXYtoConformal2



















//----------begin of function PndSttTrackFinderReal::PndSttBoxConformalFilling

 void  PndSttTrackFinderReal::PndSttBoxConformalFilling(
                                                        Double_t infoparalConformal[][5],Int_t Nparal,
                                                        UShort_t nBoxConformal[nRdivConformal][nFidivConformal],
                                                        UShort_t HitsinBoxConformal[nRdivConformal][nFidivConformal][nmaxHits],
                                                        UShort_t  RConformalIndex[nmaxHits],
                                                        UShort_t  FiConformalIndex[nmaxHits]   )
{

    Short_t iR, iFi, i, j;
    Double_t Fi;



      for(i = 0; i< nRdivConformalEffective ; i++){
        for(j = 0; j< nFidivConformal ; j++){
           nBoxConformal[i][j]= 0;
        }
      }

      for(i = 0; i< Nparal ; i++){

         Fi =  atan2(infoparalConformal[i][1],infoparalConformal[i][0]) ;
         if ( Fi < 0. ) Fi += 2.*PI;
         iFi =  (Short_t) (0.5*nFidivConformal*Fi/PI);
         if(iFi > nFidivConformal ) {
            iFi = nFidivConformal;
         } else if (iFi<0) {
            iFi = 0;
         }


         Double_t RRR = sqrt(infoparalConformal[i][0]*infoparalConformal[i][0]+infoparalConformal[i][1]*infoparalConformal[i][1]);
//   cout<<"from Fillng : hit parallel n. "<<i<<"  con raggio conforme "<<RRR<<endl;

         for(j=nRdivConformalEffective-1, iR=0; j>0; j--){
           if( RRR> radiaConf[j] ){
              iR = j;
              break;
           }
         }
         HitsinBoxConformal[iR][iFi][ nBoxConformal[iR][iFi] ]=(UShort_t) i;
         nBoxConformal[iR][iFi]++;
         RConformalIndex[ infoparal[i] ]  =  iR;
         FiConformalIndex[ infoparal[i] ]  =  iFi;
      }



    return;

}
//----------end of function PndSttTrackFinderReal::PndSttBoxConformalFilling



//----------begin of function PndSttTrackFinderReal::PndStt_Merge_Sort



void PndSttTrackFinderReal::PndStt_Merge_Sort(UShort_t n_ele, Double_t *array, UShort_t *ind)
{

  UShort_t nr, nl, middle, i,
           ind_left[n_ele], ind_right[n_ele];

  Double_t left[n_ele], right[n_ele], result[n_ele];

   if( n_ele <= 1)  return;

   middle = n_ele/2 ;
   for(i=0; i<middle; i++){
     left[i]=array[i];
     ind_left[i]= ind[i];
   }
   for(i=middle; i<n_ele; i++){
     right[i-middle]=array[i];
     ind_right[i-middle]= ind[i];
   }

   PndStt_Merge_Sort( middle,  left, ind_left);
   PndStt_Merge_Sort(n_ele-middle, right, ind_right);

   if( left[middle-1] > right[0]) {
     PndStt_Merge(middle, left,ind_left, n_ele-middle, right, ind_right, array, ind);
   }  else {
     //  do the appending
     for(i=0; i<middle; i++){
       array[i]=left[i];
       ind[i]=ind_left[i];
       
     }
     for(i=middle; i<n_ele; i++){
       array[i]=right[i-middle];
       ind[i]=ind_right[i-middle];
     }
   }


}


//----------end of function PndSttTrackFinderReal::PndStt_Merge_Sort


//----------begin of function PndSttTrackFinderReal::PndStt_Merge




void PndSttTrackFinderReal::PndStt_Merge(UShort_t nl, Double_t *left, UShort_t *ind_left, UShort_t nr,
                                         Double_t *right, UShort_t *ind_right,  Double_t *result, UShort_t *ind)
{
   UShort_t i =0, j, nl_curr=0, nr_curr=0;

   while( nl > 0 && nr >0){
     if( left[nl_curr] <= right[nr_curr]){
      result[i] =  left[nl_curr];
      ind[i] = ind_left[nl_curr];
      nl--;
      nl_curr++;
     } else {
      result[i] =  right [nr_curr];
      ind[i] =  ind_right [nr_curr];
      nr--;
      nr_curr++;
     }
    i++;
   }
//--------------------
   if( nl ==0) {
     for(j=0; j<nr; j++){
      result[i+j]= right[nr_curr+j];
      ind[i+j]= ind_right[nr_curr+j];
     }
   }   else {
     for(j=0; j<nl; j++){
      result[i+j]= left[nl_curr+j];
      ind[i+j]= ind_left[nl_curr+j];
     }
   }





}

//----------end of function PndSttTrackFinderReal::PndStt_Merge





//----------begin of function PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformal


  Short_t PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformal(
                                                  UShort_t NRCELLDISTANCE,
                                                  UShort_t NFiCELLDISTANCE,
                                                  UShort_t Nparal,
                                                  UShort_t ihit,
                                                  Double_t info[][7],
                                                  bool ExclusionList[nmaxHits],
                                                  UShort_t RConformalIndex[nmaxHits],
                                                  UShort_t FiConformalIndex[nmaxHits],
                                                  UShort_t nBoxConformal[nRdivConformal][nFidivConformal],
                                                  UShort_t HitsinBoxConformal[nRdivConformal][nFidivConformal][nmaxHits],
                                                  UShort_t *ListHitsinTrack
                                                                      )
{





     bool TemporaryExclusionList[nmaxHits];

     UShort_t i, j, iR, iFi, nRmin, nRmax, nRemainingHits, nRcell, nFicell, nHitsinTrack,
                 Remaining[nmaxHits],
                 auxIndex[nmaxHits];

     Short_t iFi2;

     Double_t auxRvalues[nmaxHits];

//   ihit        is the hit number in the PARALLEL number scheme




     for(i=0, nRemainingHits=0; i<Nparal; i++){
        if( i != ihit && ExclusionList[  infoparal[i]   ] ) {   //  exclusion of the parallel hit straws already used in other tracks
                                                           //  remember the index of ExclusionList is in the ORIGINAL scheme of hits
            TemporaryExclusionList[ infoparal[i]  ]= true;
            Remaining[nRemainingHits]= i;   //  index of the PARALLEL hit
            nRemainingHits++;
        } else {
            TemporaryExclusionList[ infoparal[i]  ]= false;
        }

     }


     if( nRemainingHits < MINIMUMHITSPERTRACK )    return 0;



//  cells of the seed hit

    nHitsinTrack=1;
    ListHitsinTrack[0]=  ihit ;

   i = 0;
   while( nRemainingHits > 0 &&  i < nHitsinTrack) {

    nRcell = RConformalIndex[   infoparal[  ListHitsinTrack[i] ]   ];
    nFicell = FiConformalIndex[  infoparal[  ListHitsinTrack[i]  ]  ];

//---------------

    if (nRcell - NRCELLDISTANCE < 0 ) {
      nRmin = 0;
    }  else {
      nRmin = nRcell - NRCELLDISTANCE;
    }
    if (nRcell + NRCELLDISTANCE >= nRdivConformalEffective ) {
      nRmax = nRdivConformalEffective-1;
    }  else {
      nRmax = nRcell + NRCELLDISTANCE;
    }


    for( iR= nRmin ; iR<= nRmax ; iR++){
      for( iFi2 = nFicell - NFiCELLDISTANCE ; iFi2<= nFicell + NFiCELLDISTANCE ; iFi2++){
          if ( iFi2 < 0 )  {
            iFi = nFidivConformal + iFi2;
          } else if ( iFi2 >= nFidivConformal) {
            iFi = iFi2  - nFidivConformal;
          }  else {
            iFi = iFi2;
          }
         for (j = 0; j< nBoxConformal[iR][iFi]; j++){
          if( ExclusionList[  infoparal[  HitsinBoxConformal[iR][iFi][j]  ]  ]
                                      &&
              TemporaryExclusionList[   infoparal[  HitsinBoxConformal[iR][iFi][j]  ]   ]) {
            ListHitsinTrack[nHitsinTrack]=HitsinBoxConformal[iR][iFi][j] ;   //  hit number in the PARALLEL straws scheme
//if(IVOLTE==4)   cout<<"nFi cell di hit accettato "<<iFi<<endl;

            nHitsinTrack++;
            TemporaryExclusionList[ infoparal[  HitsinBoxConformal[iR][iFi][j]  ]  ]= false;
            nRemainingHits--;
          }
         }
      }
    }
//----------------
    i++;


   }    //  end      while ( nRemainingHits > 0 && i < nHitsinTrack)



//   ordering the hits by INCREASING CONFORMAL RADIUS (decreasing space radius)
/*
    for (j = 0; j< nHitsinTrack; j++){
      auxIndex[j]=ListHitsinTrack[j];
      auxRvalues[j]=
                    info[ infoparal[ ListHitsinTrack[j] ]  ][0]*
                    info[ infoparal[ ListHitsinTrack[j] ]  ][0]+
                    info[ infoparal[ ListHitsinTrack[j] ]  ][1]*
                    info[ infoparal[ ListHitsinTrack[j] ]  ][1];
    }


    PndStt_Merge_Sort( nHitsinTrack, auxRvalues, auxIndex);
    for (j = 0; j< nHitsinTrack; j++){
      ListHitsinTrack[nHitsinTrack-1-j]=auxIndex[j];
    }
*/



    return nHitsinTrack;

}


//----------end of function PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformal


//----------begin of function PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformalSpecial


  Short_t PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformalSpecial(
                                                  UShort_t NRCELLDISTANCE,
                                                  UShort_t NFiCELLDISTANCE,                                                  
                                                  UShort_t Nparal,
                                                  UShort_t NparallelToSearch,
                                                  UShort_t iSeed,
                                                  UShort_t *ListHitsinTrackinWhichToSearch,
                                                  Double_t info[][7],
                                                  bool ExclusionList[nmaxHits],
                                                  UShort_t RConformalIndex[nmaxHits],
                                                  UShort_t FiConformalIndex[nmaxHits],
                                                  UShort_t nBoxConformal[nRdivConformal][nFidivConformal],
                                                  UShort_t HitsinBoxConformal[nRdivConformal][nFidivConformal][nmaxHits],
                                                  UShort_t  *OutputListHitsinTrack
                                                                      )
{





     bool TemporaryExclusionList[nmaxHits];

     UShort_t i, i2, j, iR, iFi, nRmin, nRmax, nRemainingHits, nRcell, nFicell, nHitsinTrack,
                 Remaining[nmaxHits],
                 auxIndex[nmaxHits];

     Short_t iFi2;

     Double_t auxRvalues[nmaxHits];

//   iSeed        is the hit number in the PARALLEL number scheme

//cout<<" Nparal "<<Nparal<<",  NparallelToSearch "<<NparallelToSearch<<
//", iSeed   "<<iSeed<< endl;
//--------    the following initialization is essential for the algorithm to work
     for(i=0; i<Nparal; i++){
       TemporaryExclusionList[ infoparal[i]  ]= false;
     }
//-------------

     for(i2=0, nRemainingHits=0; i2<NparallelToSearch; i2++){
        i=ListHitsinTrackinWhichToSearch[i2];
        if( i != iSeed && ExclusionList[  infoparal[i]   ] ) {   //  exclusion of the parallel hit straws already used in other tracks
                                                           //  remember the index of ExclusionList is in the ORIGINAL scheme of hits
            TemporaryExclusionList[ infoparal[i]  ]= true;
            Remaining[nRemainingHits]= i;   //  index of the PARALLEL hit
            nRemainingHits++;
        } 

     }


     if( nRemainingHits < MINIMUMHITSPERTRACK )    return 0;

//  cells of the seed hit

    nHitsinTrack=1;
    OutputListHitsinTrack[0]=  iSeed ;
//cout<<"From PatterninBoxConformal -------------------- hit seed n. (orig.) "<<OutputListHitsinTrack[0]<<endl;
   i = 0;
   while( nRemainingHits > 0 &&  i < nHitsinTrack) {

    nRcell = RConformalIndex[   infoparal[  OutputListHitsinTrack[i] ]   ];
    nFicell = FiConformalIndex[  infoparal[  OutputListHitsinTrack[i]  ]  ];
//cout<<"From PatterninBoxConformal HIT collezionatore ora ha nRcell e nFicell "<<nRcell<<",  "<< nFicell<<endl;

//---------------

    if (nRcell - NRCELLDISTANCE < 0 ) {
      nRmin = 0;
    }  else {
      nRmin = nRcell - NRCELLDISTANCE;
    }
    if (nRcell + NRCELLDISTANCE >= nRdivConformalEffective ) {
      nRmax = nRdivConformalEffective-1;
    }  else {
      nRmax = nRcell + NRCELLDISTANCE;
    }

//cout <<"    di conseguenza ora nRmin e  nRmax sono : "<<nRmin<<",  "<<nRmax<<endl;

    for( iR= nRmin ; iR<= nRmax ; iR++){
      for( iFi2 = nFicell - NFiCELLDISTANCE ; iFi2<= nFicell + NFiCELLDISTANCE ; iFi2++){
          if ( iFi2 < 0 )  {
            iFi = nFidivConformal + iFi2;
          } else if ( iFi2 >= nFidivConformal) {
            iFi = iFi2  - nFidivConformal;
          }  else {
            iFi = iFi2;
          }
         for (j = 0; j< nBoxConformal[iR][iFi]; j++){
          if( ExclusionList[  infoparal[  HitsinBoxConformal[iR][iFi][j]  ]  ]
                                      &&
              TemporaryExclusionList[   infoparal[  HitsinBoxConformal[iR][iFi][j]  ]   ]) {
            OutputListHitsinTrack[nHitsinTrack]=HitsinBoxConformal[iR][iFi][j] ;   //  hit number in the PARALLEL straws scheme
            nHitsinTrack++;
            TemporaryExclusionList[ infoparal[  HitsinBoxConformal[iR][iFi][j]  ]  ]= false;
            nRemainingHits--;
          }
         }
      }
    }
//----------------
    i++;

   }    //  end      while ( nRemainingHits > 0 && i < nHitsinTrack)






    return nHitsinTrack;

}


//----------end of function PndSttTrackFinderReal::PndSttFindTrackPatterninBoxConformalSpecial






//----------begin of function PndSttTrackFinderReal::PndSttFindTrackStrictCollection


  Short_t PndSttTrackFinderReal::PndSttFindTrackStrictCollection(
                                                  UShort_t NFiCELLDISTANCE,                                                  
                                                  UShort_t iSeed,   //  seed track (parallel notation) as fa as the Fi angle is concerned
                                                  UShort_t NParallelToSearch,    //  n. of hits to search in ListHitsinTrackinWhichToSearch
                                                  UShort_t *ListHitsinTrackinWhichToSearch,
                                                  bool ExclusionList[nmaxHits],
                                                  UShort_t FiConformalIndex[nmaxHits],
                                                  UShort_t  *OutputListHitsinTrack
                                                                      )
{






     UShort_t i,  j, iR, iFi,  iFiseed, nHitsinTrack;


     Double_t auxRvalues[nmaxHits];


if(istampa>=3 && IVOLTE<20) {
     cout<<"Da strictcollection, n. elementi delle search list "<<NParallelToSearch<<endl;
     for(i=0; i<NParallelToSearch; i++){
        cout<<"Da strictcollection,  hit n. (parallel notation ) "<<ListHitsinTrackinWhichToSearch[i]<<endl;
     }
}


//   iSeed        is the hit number in the PARALLEL number scheme

     iFiseed = FiConformalIndex[ infoparal[  iSeed ] ];
if(istampa>=3 && IVOLTE<20)cout<<"Da strictcollection, iFiseed "<<iFiseed<<endl;

     nHitsinTrack=0;
     for(i=0; i<NParallelToSearch; i++){
        if( ExclusionList[  infoparal[ ListHitsinTrackinWhichToSearch[i] ]   ] ) {   //  exclusion of the parallel hit straws already used in other tracks
                                                           //  remember the index of ExclusionList is in the ORIGINAL scheme of hits

          iFi = FiConformalIndex[ infoparal[  ListHitsinTrackinWhichToSearch[i] ] ];
          if( iFi == iFiseed ) {
            OutputListHitsinTrack[nHitsinTrack]=ListHitsinTrackinWhichToSearch[i];
            nHitsinTrack++;
          } else if ( iFi < iFiseed ) {
            if( iFiseed - iFi <= NFiCELLDISTANCE ) {
              OutputListHitsinTrack[nHitsinTrack]=ListHitsinTrackinWhichToSearch[i];
              nHitsinTrack++;
            }  else {
               if( iFi + nFidivConformal - iFiseed<= NFiCELLDISTANCE ) {
                 OutputListHitsinTrack[nHitsinTrack]=ListHitsinTrackinWhichToSearch[i];
                 nHitsinTrack++;
               }
            }
          }   else {   //  iFi > iFiseed
            if( -iFiseed + iFi <= NFiCELLDISTANCE ) {
              OutputListHitsinTrack[nHitsinTrack]=ListHitsinTrackinWhichToSearch[i];
              nHitsinTrack++;
            }  else {
               if( -iFi + nFidivConformal + iFiseed<= NFiCELLDISTANCE ) {
                 OutputListHitsinTrack[nHitsinTrack]=ListHitsinTrackinWhichToSearch[i];
                 nHitsinTrack++;
               }
            }

          }   //  end of   if( iFi == iFiseed )

        }    //  end of    if( ExclusionList[  infoparal[ ListHitsinTrackinWhichToSearch[i] ]   ] )

     }   //  end of        for(i=0; i<NparallelToSearch; i++)


if(istampa>=3 && IVOLTE<20) {
     cout<<"Da strictcollection, n. elementi aggiunti "<<nHitsinTrack<<endl;
     for(i=0; i<nHitsinTrack; i++){
       cout<<"Da strictcollection,  hit n. (parallel notaion ) "<<OutputListHitsinTrack[i]<<endl;
     }
}

    return nHitsinTrack;

}


//----------end of function PndSttTrackFinderReal::PndSttFindTrackStrictCollection








//----------begin of function PndSttTrackFinderReal::PndSttFitHelixCylinder

      Short_t PndSttTrackFinderReal::PndSttFitHelixCylinder( UShort_t nHitsinTrack,
                                                     Double_t auxinfoparalConformal[][5],
                                                     UShort_t  nTracksFoundSoFar,
                                                     Double_t rotationangle,
                                                     Double_t * trajectory_vertex,
                                                     UShort_t NMAX,
                                                     Double_t *emme,
                                                     Double_t *qu,
                                                     Double_t *ALFA,
                                                     Double_t *BETA,
                                                     Double_t *GAMMA,
                                                     bool *TypeConf
                                                            )
{

    //   definition of variables for the glpsol  solver
   //    ROWS (for read_rows  function)
   //
   UShort_t  NpointsInFit = nHitsinTrack-NMAX <0 ?  nHitsinTrack :  NMAX;
   int    nRows= NpointsInFit*9 +1;
   int typeRows[nRows];
   char * nameRows[nRows];
   char  auxnameRows[nRows][20];
//-------  end ROWS information
//--------begin COLUMNS information
      int  NStructVar=5+NpointsInFit*4;  //  number of  structural variables
      int  NStructRows = 8*NpointsInFit ;  //  maximum number of ROWS in which a structural variable can be found
      double final_values[NStructVar];
      int  NRowsInWhichStructVarArePresent[NStructVar];
      char *StructVarName[NStructVar];
      char auxStructVarName[NStructVar][20];
//      char *AuxNameRowsInWhichStructVarArePresent[NStructVar][NStructRows];
      char *NameRowsInWhichStructVarArePresent[NStructVar*NStructRows];
      char aux[NStructVar*NStructRows][20];
//      double Coefficients[NStructVar][NStructRows];
      double Coefficients[NStructVar*NStructRows];
//--------end COLUMNS information
//--------begin RHS information
      double ValueB[9*NpointsInFit];
//--------end RHS information
//--------begin RANGES information
      int nRanges = NpointsInFit;
      double ValueRanges[nRanges];
      char *NameRanges[nRanges];
      char auxNameRanges[nRanges][20];
//--------end RANGES information
//--------start BOUNDS information
      int nBounds=2*NpointsInFit+1;
      double BoundValue[nBounds];
      char *BoundStructVarName[nBounds];
      char auxBoundStructVarName[nBounds][20];
      char *TypeofBound[nBounds];
      char auxTypeofBound[nBounds][20];
//--------end BOUNDS information




     Double_t M = 1.,
              m_result,
              q_result,
              A,
              alfetta,
              angle,
              offsety,
              Delta[nmaxHits],
              Ox[nmaxHits],
              Oy[nmaxHits];

     UShort_t  i, ii;
     Short_t Status;

     char nome[300], stringa[300], stringa2[300];

//     FILE * MACRO ;

     float m1_result,m2_result, q1_result,q2_result, A1_result, A2_result;

// --

     if( nHitsinTrack < MINIMUMHITSPERTRACK) {
        return -1;
     }

//  use the trick of increasing the rotation angle by 10 degrees in order to obtain always a positive m
      rotationangle -= PI/18.;

      Double_t cose = cos(rotationangle), sine = sin(rotationangle);
      for(i=0;i<nHitsinTrack; i++){
//       if( i== iExclude)  continue;
       Ox[i] = auxinfoparalConformal[ i ][0] *cose +
               auxinfoparalConformal[ i ][1]*sine;
       Oy[i] = -auxinfoparalConformal[ i ][0] *sine +
               auxinfoparalConformal[ i ][1]*cose;

//cout<<"dal fitter, hit in lista sequenziale, n. "<<i<<",  Ox , Oy ruotati "<<Ox[i]<<",  "<<Oy[i]<<"  drift radius  "
//     <<auxinfoparalConformal[ i ][2]<<"   and  straw radisu  "<<auxinfoparalConformal[ i ][4]<<endl;



//  now traslate toward positive V values to obtain always positive q values
//       offsety = 10./RStrawDetectorMin;
//       Oy[i] += offsety;



//         Delta[i] = auxinfoparalConformal[ i ][4];
         
        if( auxinfoparalConformal[ i ][2] > 1.e-10) {
          Delta[i] = 3.*auxinfoparalConformal[ i ][2];   //   3 times the Drift Radius
        } else {
          Delta[i] = 3.*StrawRadius;
        }
      }

//      sprintf(nome,"GeneralParallelHitsConformeTraccia%dEvent%d.mcs",(nTracksFoundSoFar), IVOLTE);
//      MACRO = fopen(nome,"w");
//      fprintf(MACRO,"NAME    FIT\n");
//-----------------  write the ROWS  section

/*
      fprintf(MACRO,"ROWS\n");
      fprintf(MACRO," N OBJECT\n");
      for(i=0, ii=0 ; i< NpointsInFit ; i++) {
       ii++;
           fprintf(MACRO," L Ap%d\n L Bp%d\n L Cp%d\n L Dp%d\n",i,i,i,i);
           fprintf(MACRO," L Am%d\n L Bm%d\n L Cm%d\n L Dm%d\n G LAMBDA%d\n",i,i,i,i,i);
      }

*/

//--------
//      nameRows[0]="OBJECT";
      sprintf(&(auxnameRows[0][0]),"OBJECT",i);  nameRows[0]=&auxnameRows[0][0];
      typeRows[0]=GLP_FR;
      for(i=0 ; i< NpointsInFit ; i++) {
       ii=9*i;

       typeRows[1+ii]=GLP_UP;typeRows[2+ii]=GLP_UP;typeRows[3+ii]=GLP_UP;typeRows[4+ii]=GLP_UP;
       typeRows[5+ii]=GLP_UP;typeRows[6+ii]=GLP_UP;typeRows[7+ii]=GLP_UP;typeRows[8+ii]=GLP_UP;
       typeRows[9+ii]=GLP_LO;

       sprintf(&(auxnameRows[1+ii][0]),"Ap%d",i);  nameRows[1+ii]=&auxnameRows[1+ii][0];
       sprintf(&(auxnameRows[2+ii][0]),"Bp%d",i);  nameRows[2+ii]=&auxnameRows[2+ii][0];
       sprintf(&(auxnameRows[3+ii][0]),"Cp%d",i);  nameRows[3+ii]=&auxnameRows[3+ii][0];
       sprintf(&(auxnameRows[4+ii][0]),"Dp%d",i);  nameRows[4+ii]=&auxnameRows[4+ii][0];
       sprintf(&(auxnameRows[5+ii][0]),"Am%d",i);  nameRows[5+ii]=&auxnameRows[5+ii][0];
       sprintf(&(auxnameRows[6+ii][0]),"Bm%d",i);  nameRows[6+ii]=&auxnameRows[6+ii][0];
       sprintf(&(auxnameRows[7+ii][0]),"Cm%d",i);  nameRows[7+ii]=&auxnameRows[7+ii][0];
       sprintf(&(auxnameRows[8+ii][0]),"Dm%d",i);  nameRows[8+ii]=&auxnameRows[8+ii][0];
       sprintf(&(auxnameRows[9+ii][0]),"LAMBDA%d",i);  nameRows[9+ii]=&auxnameRows[9+ii][0];
      }




//-----------------  write the COLUMNS  section

//      fprintf(MACRO,"COLUMNS\n");

//  Column variable  m1


      for(i=0, ii=0 ; i< NpointsInFit ; i++) {
       ii++;
//          fprintf(MACRO,"  m1 Ap%d  %g  Am%d  %g\n  m1 Bp%d  %g   Bm%d  %g\n",
//                                  i,Ox[i],i,Ox[i],i,-Ox[i],i,-Ox[i]);
        Coefficients[i*4]=    Ox[i];
        Coefficients[i*4+1]=  Ox[i];
        Coefficients[i*4+2]= -Ox[i];
        Coefficients[i*4+3]= -Ox[i];
      }



//  Column variable  m2
      for(i=0; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  m2 Ap%d  %g  Am%d  %g\n  m2 Bp%d  %g   Bm%d  %g\n",
//                                  i,-Ox[i],i,-Ox[i],i,Ox[i],i,Ox[i]);
        Coefficients[NStructRows+i*4]=   -Ox[i];
        Coefficients[NStructRows+i*4+1]= -Ox[i];
        Coefficients[NStructRows+i*4+2]= Ox[i];
        Coefficients[NStructRows+i*4+3]= Ox[i];

      }

//  Column variable  q1
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  q1 Ap%d   1.  Am%d   1.\n  q1 Bp%d  -1.  Bm%d  -1.\n",
//                                  i,i,i,i);
        Coefficients[2*NStructRows+i*4]=    1.;
        Coefficients[2*NStructRows+i*4+1]=  1.;
        Coefficients[2*NStructRows+i*4+2]= -1.;
        Coefficients[2*NStructRows+i*4+3]= -1.;
      }

//  Column variable  q2
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  q2 Ap%d   -1.  Am%d   -1.\n  q2 Bp%d   1.   Bm%d   1.\n",
//                                  i,i,i,i);
        Coefficients[3*NStructRows+i*4]=   -1.;
        Coefficients[3*NStructRows+i*4+1]= -1.;
        Coefficients[3*NStructRows+i*4+2]=  1.;
        Coefficients[3*NStructRows+i*4+3]=  1.;
      }

//  Column variable  lambdap(i)
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  lamp%d  Ap%d  %g  Bp%d  %g\n  lamp%d  Cp%d  %g  Dp%d   %g\n  lamp%d  LAMBDA%d  1.\n",
//                                                i,i,-M,i,-M, i , i,-M, i, M, i,i);
        Coefficients[(4+i)*NStructRows+0]= -M;
        Coefficients[(4+i)*NStructRows+1]= -M;
        Coefficients[(4+i)*NStructRows+2]= -M;
        Coefficients[(4+i)*NStructRows+3]=  M;
        Coefficients[(4+i)*NStructRows+4]=  1.;
      }
//  Column variable  lambdam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  lamm%d  Am%d  %g  Bm%d  %g\n  lamm%d  Cm%d  %g  Dm%d %g\n  lamm%d  LAMBDA%d  1.\n",
//                                                i,i,-M,i,-M, i,i , -M, i, M, i,i);
        Coefficients[(4+i+NpointsInFit)*NStructRows+0]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+1]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+2]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+3]=  M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+4]=  1.;
      }
//  Column variable  sigmap(i)
      for(i=0; i< NpointsInFit ; i++) {

//          fprintf(MACRO,"  sigmap%d  OBJECT  %g  Ap%d  -1.\n  sigmap%d  Bp%d    -1. Cp%d  1.\n  sigmap%d  Dp%d -1.\n",
//                                                i,1./Delta[i],i,i,i,i,i,i);
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+4]= -1.;
      }
//  Column variable  sigmam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  sigmam%d  OBJECT %g  Am%d  -1.\n  sigmam%d  Bm%d   -1. Cm%d   1.\n  sigmam%d  Dm%d  -1.\n",
//                                                i,1./Delta[i],i,i,i,i,i,i);
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+4]= -1.;
      }

//  Column variable  DUMMY
/*
      for(i=0, ii=0 ; i< NpointsInFit ; i++) {
        fprintf(MACRO,"  DUMMY     Ap%d  1.      Am%d       1.\n  DUMMY   Bp%d   1.    Bm%d   1.\n  DUMMY    Cp%d   1.   Cm%d   1\n",
                                                i,i,i,i,i,i);
        fprintf(MACRO,"  DUMMY     Dp%d  1.      Dm%d       1.\n",
                                                i,i);
      }
*/

      for(i=0 ; i< NStructRows ; i++) {
        Coefficients[(4+4*NpointsInFit)*NStructRows+i]= 1.;
      }
//--------------------
      sprintf(&auxStructVarName[0][0],"m1",i);
      StructVarName[0] = &auxStructVarName[0][0];
//      StructVarName[0]="m1";
      NRowsInWhichStructVarArePresent[0]= 4*NpointsInFit;

      sprintf(&auxStructVarName[1][0],"m2",i);
      StructVarName[1] = &auxStructVarName[1][0];
//      StructVarName[1]="m2";
      NRowsInWhichStructVarArePresent[1]= 4*NpointsInFit;

      sprintf(&auxStructVarName[2][0],"q1",i);
      StructVarName[2] = &auxStructVarName[2][0];
//      StructVarName[2]="q1";
      NRowsInWhichStructVarArePresent[2]= 4*NpointsInFit;

      sprintf(&auxStructVarName[3][0],"q2",i);
      StructVarName[3] = &auxStructVarName[3][0];
//      StructVarName[3]="q2";
      NRowsInWhichStructVarArePresent[3]= 4*NpointsInFit;
      for(i=0; i< NpointsInFit ; i++) {
          sprintf(&auxStructVarName[3+i+1][0],"lamp%d",i);
          StructVarName[4+i] = &auxStructVarName[4+i][0];
          NRowsInWhichStructVarArePresent[4+i]= 5;

          sprintf(&auxStructVarName[4+NpointsInFit+i][0],"lamm%d",i);
          StructVarName[4+NpointsInFit+i] = &auxStructVarName[4+NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+2*NpointsInFit+i][0],"sigmap%d",i);
          StructVarName[4+2*NpointsInFit+i] = &auxStructVarName[4+2*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+2*NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+3*NpointsInFit+i][0],"sigmam%d",i);
          StructVarName[4+3*NpointsInFit+i] = &auxStructVarName[4+3*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+3*NpointsInFit+i]= 5;

      }


      sprintf(&auxStructVarName[4+4*NpointsInFit][0],"DUMMY",i);
      StructVarName[4+4*NpointsInFit] = &auxStructVarName[4+4*NpointsInFit][0];
//      StructVarName[4+4*NpointsInFit]="DUMMY";
      NRowsInWhichStructVarArePresent[4+4*NpointsInFit]= NStructRows;


//  for m1, m2, q1, q2
      for(i=0; i< 4; i++){
        for(ii=0; ii< NpointsInFit;ii++){
         sprintf(&aux[i*NStructRows+ii*4][0],"Ap%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4]=&aux[i*NStructRows+ii*4][0];
         sprintf(&aux[i*NStructRows+ii*4+1][0],"Am%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+1]=&aux[i*NStructRows+ii*4+1][0];
         sprintf(&aux[i*NStructRows+ii*4+2][0],"Bp%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+2]=&aux[i*NStructRows+ii*4+2][0];
         sprintf(&aux[i*NStructRows+ii*4+3][0],"Bm%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+3]=&aux[i*NStructRows+ii*4+3][0];
        }
      }

//  now for the    lamp*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4)*NStructRows+0][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+0]= &aux[(i+4)*NStructRows+0][0];
         sprintf(&aux[(i+4)*NStructRows+1][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+1]= &aux[(i+4)*NStructRows+1][0];
         sprintf(&aux[(i+4)*NStructRows+2][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+2]= &aux[(i+4)*NStructRows+2][0];
         sprintf(&aux[(i+4)*NStructRows+3][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+3]= &aux[(i+4)*NStructRows+3][0];
         sprintf(&aux[(i+4)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+4]= &aux[(i+4)*NStructRows+4][0];
      }

//  now for the    lamm*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+0][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+0]= &aux[(i+4+NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+1][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+1]= &aux[(i+4+NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+2][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+2]= &aux[(i+4+NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+3][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+3]= &aux[(i+4+NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+4]= &aux[(i+4+NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmap*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+0]= &aux[(i+4+2*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+1][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+1]= &aux[(i+4+2*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+2][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+2]= &aux[(i+4+2*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+3][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+3]= &aux[(i+4+2*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+4][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+4]= &aux[(i+4+2*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmam*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+0]= &aux[(i+4+3*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+1][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+1]= &aux[(i+4+3*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+2][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+2]= &aux[(i+4+3*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+3][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+3]= &aux[(i+4+3*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+4][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+4]= &aux[(i+4+3*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    DUMMY   variable
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows  +8*i][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+i*8  ]= &aux[(4+4*NpointsInFit)*NStructRows  +8*i][0];

         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+1+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+2+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+3+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+4+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+5+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+6+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+7+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0];
      }



//-----------------  write the RHS  section

//      fprintf(MACRO,"RHS\n");
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  BOUND  Ap%d  %g  Bp%d  %g\n  BOUND  Cp%d  %g  Dp%d  %g\n",
//              i, Oy[i]+auxinfoparalConformal[ i ][2]+2.*M,i,
//                -Oy[i]-auxinfoparalConformal[ i ][2]+2.*M,i,
//                 Delta[i]+2.*M,i,M-Delta[i]+2.*M);
          ValueB[i*9]  =  Oy[i]+auxinfoparalConformal[ i ][2]+2.*M;
          ValueB[i*9+1]= -Oy[i]-auxinfoparalConformal[ i ][2]+2.*M;
          ValueB[i*9+2]= Delta[i]+2.*M;
          ValueB[i*9+3]= M-Delta[i]+2.*M;


/*
          fprintf(MACRO,"  BOUND  Am%d  %g  Bm%d  %g\n  BOUND  Cm%d  %g  Dm%d %g\n",
              i, Oy[i]-auxinfoparalConformal[ i ][2]+2.*M,i,
                -Oy[i]+auxinfoparalConformal[ i ][2]+2.*M,i,
                 Delta[i]+2.*M,i,M-Delta[i]+2.*M);
          fprintf(MACRO,"  BOUND  LAMBDA%d   1.\n",i);
*/

          ValueB[i*9+4]=  Oy[i]-auxinfoparalConformal[ i ][2]+2.*M;
          ValueB[i*9+5]= -Oy[i]+auxinfoparalConformal[ i ][2]+2.*M;
          ValueB[i*9+6]= Delta[i]+2.*M;
          ValueB[i*9+7]= M-Delta[i]+2.*M;
          ValueB[i*9+8]= 1.;


      }


//-----------------  write the RANGES  section

//      fprintf(MACRO,"RANGES\n");
      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO,"  RANGE  LAMBDA%d  1.\n",i);
//---
        ValueRanges[i]=1.;
        sprintf(&auxNameRanges[i][0],"LAMBDA%d",i);
        NameRanges[i]=&auxNameRanges[i][0];
      }

//-----------------  write the BOUNDS  section

//      fprintf(MACRO,"BOUNDS\n");

      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO," BV  Bounds  lamp%d\n",  i);

          sprintf(&auxTypeofBound[i][0],"BV");   TypeofBound[i]= &auxTypeofBound[i][0];
//          TypeofBound[i]="BV";
          sprintf(&auxBoundStructVarName[i][0],"lamp%d",i);
          BoundStructVarName[i]=&auxBoundStructVarName[i][0];
          BoundValue[i]=0.;
      }

      for(i=0 ; i< NpointsInFit ; i++) {
//          fprintf(MACRO," BV  Bounds  lamm%d\n", i);
          sprintf(&auxTypeofBound[i+NpointsInFit][0],"BV");
          TypeofBound[i+NpointsInFit]= &auxTypeofBound[i+NpointsInFit][0];
//          TypeofBound[i+NpointsInFit]="BV";
          sprintf(&auxBoundStructVarName[i+NpointsInFit][0],"lamm%d",i);
          BoundStructVarName[i+NpointsInFit]=&auxBoundStructVarName[i+NpointsInFit][0];
          BoundValue[i]=0.;
      }

//          fprintf(MACRO," FX  Bounds  DUMMY  %g\n",2.*M);
          sprintf(&auxTypeofBound[2*NpointsInFit][0],"FX");
          TypeofBound[2*NpointsInFit]= &auxTypeofBound[2*NpointsInFit][0];
//          TypeofBound[2*NpointsInFit]="FX";

          sprintf(&auxTypeofBound[2*NpointsInFit][0],"FX");
          TypeofBound[2*NpointsInFit]= &auxTypeofBound[2*NpointsInFit][0];

          sprintf(&auxBoundStructVarName[2*NpointsInFit][0],"DUMMY");
          BoundStructVarName[2*NpointsInFit]=&auxBoundStructVarName[2*NpointsInFit][0];
//          BoundStructVarName[2*NpointsInFit]="DUMMY";
          BoundValue[2*NpointsInFit]=2.;
//-----

//      fprintf(MACRO,"ENDATA\n");
//      fclose(MACRO);

//-----------------------  funzioni chiamate direttamente
/*
cout<<"n.  punti nel fit "<<NpointsInFit<<endl;


cout<<"nRows "<<nRows<<endl;
for(int ic =0;ic<nRows; ic++){
   cout<<"n.  Row  "<<ic<<", nameRows "<<nameRows[ic]<<",  typeRows "<<typeRows[ic]<<endl;
}


cout<<"NstructRows, NStructVar "<<NStructRows<<", "<<NStructVar<<endl;
for(int ic =0;ic<NStructVar; ic++){
   cout<<"NRowsInWhichStructVarArePresent  "<<NRowsInWhichStructVarArePresent[ic]<<", nome var. strut. n."<<ic<<"  = "
     <<StructVarName[ic]<<endl;

  for(int jc=0; jc<NRowsInWhichStructVarArePresent[ic];jc++){
   cout<<"n. "<<jc<<"  NameRowsInWhichStructVarArePresent  "<<NameRowsInWhichStructVarArePresent[ic*NStructRows+jc]<<endl;
  }
}


cout<<"n Coefficient "<<NStructVar*NStructRows<<endl;
for(int ic =0;ic<NStructVar*NStructRows; ic++){
   cout<<"n. "<<ic<<",  Coefficient   "<<Coefficients[ic]<<endl;
}
cout<<"n valuesB "<<NpointsInFit*9<<endl;
for(int ic =0;ic<NpointsInFit*9; ic++){
   cout<<"n. "<<ic<<",  valuesB   "<<ValueB[ic]<<endl;
}
cout<<"n ranges "<<nRanges<<endl;
for(int ic =0;ic<nRanges; ic++){
   cout<<"n. "<<ic<<",  RANGES   "<<ValueRanges[ic]<<endl;
}
cout<<"n Bounds "<<nBounds<<endl;
for(int ic =0;ic<nBounds; ic++){
   cout<<"n. "<<ic<<",  Bounds   "<<BoundValue[ic]<<endl;
   cout<<"n. "<<ic<<",  Bound Type   "<<TypeofBound[ic]<<endl;
   cout<<"n. "<<ic<<",  Bound Name   "<<BoundStructVarName[ic]<<endl;
}

*/
      int status= glp_main(
            nRows,nameRows,typeRows, //  ROWS info
            NStructVar, NStructRows, NRowsInWhichStructVarArePresent,  //  COLUMNS info
      StructVarName, NameRowsInWhichStructVarArePresent,  //  COLUMNS info
      Coefficients,  //  COLUMNS info
      ValueB,  // RHS  info
      nRanges, ValueRanges, NameRanges, //  RANGES  info
      nBounds, BoundValue, BoundStructVarName, TypeofBound //  BOUNDS info
      ,final_values
       );
/*
printf("from main, final printout con routines chiamate direttamente -------------------------------\n");
printf("      number of structural variables %d\n",NStructVar);
int ica;
for(ica=0;ica<NStructVar;ica++){
    printf("name of structural variable %s and its final value %g\n",
           StructVarName[ica], final_values[ica]);
}
printf("from main, end of final printout  con routines chiamate direttamente -------------------------------\n");
*/
//-----------------------  fine funzioni chiamate direttamente




   if(istampa>=3 && IVOLTE<20){
     sprintf(stringa,
              "/home/boca/panda/glpk/glpk-4.39/examples/glpsol --min -o soluztrack%dEvent%dstep%d    GeneralParallelHitsConformeTraccia%dEvent%d.mcs",
                                nTracksFoundSoFar,IVOLTE,INTERO,nTracksFoundSoFar,IVOLTE);
   }  else {
     sprintf(stringa,
              "/home/boca/panda/glpk/glpk-4.39/examples/glpsol --min -o soluztrack%dEvent%dstep%d    GeneralParallelHitsConformeTraccia%dEvent%d.mcs >& /dev/null",
                                nTracksFoundSoFar, IVOLTE,INTERO,nTracksFoundSoFar,IVOLTE,INTERO);
   }

/*
     system(stringa);
     sprintf(stringa2,"grep -e ' m1  '  -e ' m2  '  -e  ' q1  ' -e ' q2   '  soluztrack%dEvent%dstep%d |  awk '{print $3}' > temp",
                             nTracksFoundSoFar,IVOLTE,INTERO);
     system(stringa2);


     FILE * RESULT = fopen("temp","r");
     fscanf(RESULT,"%f",&m1_result);
     fscanf(RESULT,"%f",&m2_result);
     fscanf(RESULT,"%f",&q1_result);
     fscanf(RESULT,"%f",&q2_result);
     fclose(RESULT);
*/

     m1_result = final_values[0];
     m2_result = final_values[1];
     q1_result = final_values[2];
     q2_result = final_values[3];

/*
     q_result = q1_result - q2_result;
     m_result = m1_result ;
     A = A1_result - A2_result;
     if( fabs( cose -sine*m_result) > 1.e-12) { 
       *emme = ( m_result*cose  + sine ) / (cose -sine*m_result);
       *qu = q_result/(cose -sine*m_result);
       Status=1;
     } else {
       *emme = m_result*cose  + sine ;
       *qu = q_result;
       Status=99;
     }
*/



//------------------------  transformation of the result in terms of ALFA, BETA, GAMMA


     *qu = q1_result - q2_result;
//     *qu = q1_result;
//     *emme = m1_result ;
     *emme = m1_result-m2_result ;
//if(istampa)   cout<<"Stampa dal fitter, prima della correzione displacement   *qu, *emme  "<<*qu<<",  "<<*emme<<endl;
//  cancel the effect of the last Y displacement
//     *qu -= offsety;
if(istampa>=3 && IVOLTE<20) {

  cout<<"Stampa dal fitter, risultato :   qu, emme non ri-ruotati  "<<*qu<<",  "<<*emme<<endl<<
        "                                 qu, emme  ri-ruotati  "<<*qu/(cose-*emme*sine)<<",  "<<(*emme*cose+sine)/(cose-*emme*sine)<<endl;
}

    GAMMA[nTracksFoundSoFar] = 0.;
    if( fabs( *qu ) > 1.e-10) {    //  trajectory is a circle in XY space
     ALFA[nTracksFoundSoFar] = *emme/(*qu);
     BETA[nTracksFoundSoFar] = -1./(*qu);
     TypeConf[nTracksFoundSoFar]=true;
//  now take into account the rotation and correct; the only affected quantities are ALFA and BETA
      alfetta = ALFA[nTracksFoundSoFar];
      ALFA[nTracksFoundSoFar] = ALFA[nTracksFoundSoFar]*cose - BETA[nTracksFoundSoFar]*sine;
      BETA[nTracksFoundSoFar] = alfetta*sine + BETA[nTracksFoundSoFar]*cose;
    }  else if(fabs(*emme)> 1.e-10)  {    //  trajectory is a straight line in XY space of equation y= m*x
       //  the rotation first
       angle = atan(*emme) + rotationangle;
       if( fabs(cos(angle)) > 1.e-10 ) {
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = -ALFA[nTracksFoundSoFar]/tan(angle);

       } else {  //  in this case the equation is y = 0.
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = 0.;
         TypeConf[nTracksFoundSoFar]=false;
       }
    }  else {   //  in this case also the equation in XY plane is  y = 0.
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = 0.;
         TypeConf[nTracksFoundSoFar]=false;
    }


// now take into account the displacement and correct
      GAMMA[nTracksFoundSoFar] += (trajectory_vertex[0]*trajectory_vertex[0]+ trajectory_vertex[1]*trajectory_vertex[1]
                                  -ALFA[nTracksFoundSoFar]*trajectory_vertex[0]-BETA[nTracksFoundSoFar]*trajectory_vertex[1]);
      ALFA[nTracksFoundSoFar] -=  2.*trajectory_vertex[0];
      BETA[nTracksFoundSoFar] -=  2.*trajectory_vertex[1];


//------------------------ end of transformation of the result in terms of ALFA, BETA, GAMMA










//--------   end of taking into account the traslation that was performed and undoing that


// taking into account the rotation that was performed and calculate emme and qu in the normal conformal plane

      if(fabs(cose-*emme*sine)> 1.e-10) {
        *qu=*qu/(cose-*emme*sine);
        *emme=(*emme*cose+sine)/(cose-*emme*sine);
        return 1;
      } else {    //  in this case the equation is   0 = x+*qu .
        if(fabs(sine+*emme*cose) < 1.e-10)  {
  cout<<" From PndSttFitHelixCylinder, situation impossible in principle! Returning -1"
                    <<endl;
           return -1;
        }

        *emme=1.;
        *qu = *qu/(sine+*emme*cose);
        return 99;    //  in this case the equation is   0 = x+*qu .
      }




}




//----------end of function PndSttTrackFinderReal::PndSttFitHelixCylinder









//----------begin of function PndSttTrackFinderReal::PndSttFitHelixCylinder2

      Short_t PndSttTrackFinderReal::PndSttFitHelixCylinder2( UShort_t nHitsinTrack,
//                                                     UShort_t iExclude,
                                                     Double_t auxinfoparalConformal[][5],
                                                     UShort_t  nTracksFoundSoFar,
                                                     Double_t rotationangle,
                                                     Double_t * trajectory_vertex,
                                                     UShort_t NMAX,
                                                     Double_t *ALFA,
                                                     Double_t *BETA,
                                                     Double_t *GAMMA,
                                                     bool *TypeConf
                                                            )
{

     Double_t M = 1.,
              emme, m_result,
              qu, q_result,
              A,
              alfetta,
              angle,
              offsety,
              aux,
              Delta[nmaxHits],
              Ox[nmaxHits],
              Oy[nmaxHits];

     UShort_t  i, ii;
     Short_t Status;

     char nome[300], stringa[300], stringa2[300];

     FILE * MACRO ;

     float m1_result,m2_result, q1_result,q2_result, A1_result, A2_result;

// --

     if( nHitsinTrack < MINIMUMHITSPERTRACK) {
        return -1;
     }

//  use the trick of increasing the rotation angle by 10 degrees in order to obtain always a positive m
      rotationangle -= PI/18.;

      Double_t cose = cos(rotationangle), sine = sin(rotationangle);
      for(i=0;i<nHitsinTrack; i++){
//       if( i== iExclude)  continue;
       Ox[i] = auxinfoparalConformal[ i ][0] *cose +
               auxinfoparalConformal[ i ][1]*sine;
       Oy[i] = -auxinfoparalConformal[ i ][0] *sine +
               auxinfoparalConformal[ i ][1]*cose;

//cout<<"dal fitter, hit in lista sequenziale, n. "<<i<<",  Ox , Oy ruotati "<<Ox[i]<<",  "<<Oy[i]<<"  drift radius  "
//     <<auxinfoparalConformal[ i ][2]<<"   and  straw radisu  "<<auxinfoparalConformal[ i ][4]<<endl;



//  now traslate toward positive V values to obtain always positive q values
//       offsety = 10./RStrawDetectorMin;
//       Oy[i] += offsety;



//         Delta[i] = auxinfoparalConformal[ i ][4];
         aux = 5.*(auxinfoparalConformal[ i ][4]/StrawRadius)*0.03;
         Delta[i] = 5.*auxinfoparalConformal[ i ][2];
         if( aux> Delta[i])  Delta[i] =aux;

      }

      sprintf(nome,"GeneralParallelHitsConformeTraccia%dEvent%d.mcs",(nTracksFoundSoFar), IVOLTE);
      MACRO = fopen(nome,"w");
      fprintf(MACRO,"NAME    FIT\n");
//-----------------  write the ROWS  section

      fprintf(MACRO,"ROWS\n");
      fprintf(MACRO," N OBJECT\n");
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
           fprintf(MACRO," L Ap%d\n L Bp%d\n L Cp%d\n L Dp%d\n",i,i,i,i);
           fprintf(MACRO," L Am%d\n L Bm%d\n L Cm%d\n L Dm%d\n E LAMBDA%d\n",i,i,i,i,i);
      }

//-----------------  write the COLUMNS  section

      fprintf(MACRO,"COLUMNS\n");






//  Column variable  A1
//      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
//       ii++;
//          fprintf(MACRO,"  A1 Ap%d  %g  Am%d  %g\n  A1 Bp%d  %g   Bm%d  %g\n",
//                                  i,Ox[i]*Ox[i],i,Ox[i]*Ox[i],i,-Ox[i]*Ox[i],i,-Ox[i]*Ox[i]);
//      }
//  Column variable  A2
//      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
//       ii++;
//          fprintf(MACRO,"  A2 Ap%d  %g  Am%d  %g\n  A2 Bp%d  %g   Bm%d  %g\n",
//                                  i,-Ox[i]*Ox[i],i,-Ox[i]*Ox[i],i,Ox[i]*Ox[i],i,Ox[i]*Ox[i]);
//      }











//  Column variable  m1
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  m1 Ap%d  %g  Am%d  %g\n  m1 Bp%d  %g   Bm%d  %g\n",
                                  i,Ox[i],i,Ox[i],i,-Ox[i],i,-Ox[i]);
      }

//  Column variable  m2
//      for(i=0; i< nHitsinTrack && i<NMAX ; i++) {
//          fprintf(MACRO,"  m2 Ap%d  %g  Am%d  %g\n  m2 Bp%d  %g   Bm%d  %g\n",
//                                  i,-Ox[i],i,-Ox[i],i,Ox[i],i,Ox[i]);
//      }

//  Column variable  q1
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  q1 Ap%d   1.  Am%d   1.\n  q1 Bp%d  -1.  Bm%d  -1.\n",
                                  i,i,i,i);
      }

//  Column variable  q2
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  q2 Ap%d   -1.  Am%d   -1.\n  q2 Bp%d   1.   Bm%d   1.\n",
                                  i,i,i,i);
      }

//  Column variable  lambdap(i)
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  lamp%d  Ap%d  %g  Bp%d  %g\n  lamp%d  Cp%d  %g  Dp%d   %g\n  lamp%d  LAMBDA%d  1.\n",
                                                i,i,-M,i,-M, i , i,-M, i, M, i,i);
      }
//  Column variable  lambdam(i)
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  lamm%d  Am%d  %g  Bm%d  %g\n  lamm%d  Cm%d  %g  Dm%d %g\n  lamm%d  LAMBDA%d  1.\n",
                                                i,i,-M,i,-M, i,i , -M, i, M, i,i);
      }
//  Column variable  sigmap(i)
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;

          fprintf(MACRO,"  sigmap%d  OBJECT  %g  Ap%d  -1.\n  sigmap%d  Bp%d    -1. Cp%d  1.\n  sigmap%d  Dp%d -1.\n",
                                                i,1./Delta[i],i,i,i,i,i,i);
      }
//  Column variable  sigmam(i)
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  sigmam%d  OBJECT %g  Am%d  -1.\n  sigmam%d  Bm%d   -1. Cm%d   1.\n  sigmam%d  Dm%d  -1.\n",
                                                i,1./Delta[i],i,i,i,i,i,i);
      }

//  Column variable  DUMMY
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
        fprintf(MACRO,"  DUMMY     Ap%d  1.      Am%d       1.\n  DUMMY   Bp%d   1.    Bm%d   1.\n  DUMMY    Cp%d   1.   Cm%d   1\n",
                                                i,i,i,i,i,i);
        fprintf(MACRO,"  DUMMY     Dp%d  1.      Dm%d       1.\n",
                                                i,i);
      }
//-----------------  write the RHS  section

      fprintf(MACRO,"RHS\n");
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  BOUND  Ap%d  %g  Bp%d  %g\n  BOUND  Cp%d  %g  Dp%d  %g\n",
              i, Oy[i]+auxinfoparalConformal[ i ][2]+2.*M,i,
                -Oy[i]-auxinfoparalConformal[ i ][2]+2.*M,i,
                 Delta[i]+2.*M,i,M-Delta[i]+2.*M);

          fprintf(MACRO,"  BOUND  Am%d  %g  Bm%d  %g\n  BOUND  Cm%d  %g  Dm%d %g\n",
              i, Oy[i]-auxinfoparalConformal[ i ][2]+2.*M,i,
                -Oy[i]+auxinfoparalConformal[ i ][2]+2.*M,i,
                 Delta[i]+2.*M,i,M-Delta[i]+2.*M);
          fprintf(MACRO,"  BOUND  LAMBDA%d   1.\n",i);
      }


//-----------------  write the RANGES  section

/*
      fprintf(MACRO,"RANGES\n");
      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO,"  RANGE  LAMBDA%d  1.\n",i);
      }
*/

//-----------------  write the BOUNDS  section

      fprintf(MACRO,"BOUNDS\n");
//      fprintf(MACRO," FR  Bounds  m\n FR  Bounds  q\n");

      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO," BV  Bounds  lamp%d\n",  i);
      }

      for(i=0, ii=0 ; i< nHitsinTrack && ii<NMAX ; i++) {
//       if( i== iExclude)  continue;
       ii++;
          fprintf(MACRO," BV  Bounds  lamm%d\n", i);
      }

          fprintf(MACRO," FX  Bounds  DUMMY  %g\n",2.*M);

//-----

      fprintf(MACRO,"ENDATA\n");
      fclose(MACRO);


   if(istampa>=3 && IVOLTE<20){
     sprintf(stringa,
              "/home/boca/panda/glpk/glpk-4.39/examples/glpsol --min -o soluztrack%dEvent%dstep%d    GeneralParallelHitsConformeTraccia%dEvent%d.mcs",
                                nTracksFoundSoFar,IVOLTE,INTERO,nTracksFoundSoFar,IVOLTE);
   }  else {
     sprintf(stringa,
              "/home/boca/panda/glpk/glpk-4.39/examples/glpsol --min -o soluztrack%dEvent%dstep%d    GeneralParallelHitsConformeTraccia%dEvent%d.mcs >& /dev/null",
                                nTracksFoundSoFar, IVOLTE,INTERO,nTracksFoundSoFar,IVOLTE,INTERO);
   }
     system(stringa);
//     sprintf(stringa2,"grep -e ' m1  '   -e  ' q1  ' -e ' q2   ' -e ' A1 ' -e ' A2 ' soluztrack%dEvent%dstep%d |  awk '{print $3}' > temp",
//                             (nTracksFoundSoFar),IVOLTE,INTERO);
     sprintf(stringa2,"grep -e ' m1  '   -e  ' q1  ' -e ' q2   '  soluztrack%dEvent%dstep%d |  awk '{print $3}' > temp",
                             nTracksFoundSoFar,IVOLTE,INTERO);
//     sprintf(stringa2,"grep -e ' m1  '   -e  ' q1  '   soluztrack%dEvent%dstep%d |  awk '{print $3}' > temp",
//                             nTracksFoundSoFar,IVOLTE,INTERO);
     system(stringa2);


     FILE * RESULT = fopen("temp","r");
//     fscanf(RESULT,"%f",&A1_result);
//     fscanf(RESULT,"%f",&A2_result);
     fscanf(RESULT,"%f",&m1_result);
//     fscanf(RESULT,"%f",&m2_result);
     fscanf(RESULT,"%f",&q1_result);
     fscanf(RESULT,"%f",&q2_result);
     fclose(RESULT);
//     system ("rm -f temp");
//     system ("rm -f soluz*    ");
//     system("rm -f GeneralParallelHitsConformeTraccia*");




/*
     q_result = q1_result - q2_result;
     m_result = m1_result ;
     A = A1_result - A2_result;
     if( fabs( cose -sine*m_result) > 1.e-12) { 
       emme = ( m_result*cose  + sine ) / (cose -sine*m_result);
       qu = q_result/(cose -sine*m_result);
       Status=1;
     } else {
       emme = m_result*cose  + sine ;
       qu = q_result;
       Status=99;
     }
*/



//------------------------  transformation of the result in terms of ALFA, BETA, GAMMA


     qu = q1_result - q2_result;
//     qu = q1_result;
     emme = m1_result ;
//if(istampa)   cout<<"Stampa dal fitter, prima della correzione displacement   qu, emme  "<<qu<<",  "<<emme<<endl;
//  cancel the effect of the last Y displacement
//     qu -= offsety;
if(istampa>=3 && IVOLTE<20) {

  cout<<"Stampa dal fitter, risultato :   qu, emme non ri-ruotati  "<<qu<<",  "<<emme<<endl<<
        "                                 qu, emme  ri-ruotati  "<<qu/(cose-emme*sine)<<",  "<<(emme*cose+sine)/(cose-emme*sine)<<endl;
}

    GAMMA[nTracksFoundSoFar] = 0.;
    if( fabs( qu ) > 1.e-10) {    //  trajectory is a circle in XY space
     ALFA[nTracksFoundSoFar] = emme/qu;
     BETA[nTracksFoundSoFar] = -1./qu;
     TypeConf[nTracksFoundSoFar]=true;
//  now take into account the rotation and correct; the only affected quantities are ALFA and BETA
      alfetta = ALFA[nTracksFoundSoFar];
      ALFA[nTracksFoundSoFar] = ALFA[nTracksFoundSoFar]*cose - BETA[nTracksFoundSoFar]*sine;
      BETA[nTracksFoundSoFar] = alfetta*sine + BETA[nTracksFoundSoFar]*cose;
    }  else if(fabs(emme)> 1.e-10)  {    //  trajectory is a straight line in XY space of equatio y= m*x
       //  the rotation first
       angle = atan(emme) + rotationangle;
       if( fabs(cos(angle)) > 1.e-10 ) {
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = -ALFA[nTracksFoundSoFar]/tan(angle);

       } else {  //  in this case the equation is y = 0.
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = 0.;
         TypeConf[nTracksFoundSoFar]=false;
       }
    }  else {   //  in this case also the equation in XY plane is  y = 0.
         ALFA[nTracksFoundSoFar] = 999999.;
         BETA[nTracksFoundSoFar] = 0.;
         TypeConf[nTracksFoundSoFar]=false;
    }


// now take into account the displacement and correct
      GAMMA[nTracksFoundSoFar] += (trajectory_vertex[0]*trajectory_vertex[0]+ trajectory_vertex[1]*trajectory_vertex[1]
                                  -ALFA[nTracksFoundSoFar]*trajectory_vertex[0]-BETA[nTracksFoundSoFar]*trajectory_vertex[1]);
      ALFA[nTracksFoundSoFar] -=  2.*trajectory_vertex[0];
      BETA[nTracksFoundSoFar] -=  2.*trajectory_vertex[1];


//------------------------ end of transformation of the result in terms of ALFA, BETA, GAMMA










// taking into account the traslation that was performed and undoing that
/*
      if( Status == 99) {      // in this case in the conformal space equation is m*X + q  = 0
         GAMMA[nTracksFoundSoFar] = trajectory_vertex[0]*trajectory_vertex[0]+trajectory_vertex[1]*trajectory_vertex[1]
                 -trajectory_vertex[0]*emme/qu;
           TypeConf[nTracksFoundSoFar]=true;
           ALFA[nTracksFoundSoFar]=  emme/qu - 2.*trajectory_vertex[0] ;
           BETA[nTracksFoundSoFar]= - 2.*trajectory_vertex[1];

      }  else if ( fabs(qu) > 1.e-10 ) {
         GAMMA[nTracksFoundSoFar]= trajectory_vertex[0]*trajectory_vertex[0]+trajectory_vertex[1]*trajectory_vertex[1]
                 -trajectory_vertex[0]*emme/qu + trajectory_vertex[1]/qu;
           TypeConf[nTracksFoundSoFar]=true;
           ALFA[nTracksFoundSoFar]= ( emme/qu - 2.*trajectory_vertex[0] );
           BETA[nTracksFoundSoFar]= (-1./qu - 2.*trajectory_vertex[1]);

      } else {     //   this is the case when q=0
         GAMMA[nTracksFoundSoFar] = -trajectory_vertex[0]*emme + trajectory_vertex[1];
           TypeConf[nTracksFoundSoFar]=false;
           ALFA[nTracksFoundSoFar]= emme;
           BETA[nTracksFoundSoFar]= -1.;
           GAMMA[nTracksFoundSoFar]= 0.;

      }

*/
//--------   end of taking into account the traslation that was performed and undoing that







      return 1;

}




//----------end of function PndSttTrackFinderReal::PndSttFitHelixCylinder2







//----------begin of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixBis
  UShort_t PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixBis(
                   Double_t m,
                   Double_t q,
                   Short_t Status,
                   UShort_t nHitsinTrack,
                   UShort_t *ListHitsinTrack,
                   Int_t NhitsParallel,
                   Double_t infoparalConformal[][5],
                   UShort_t *RConformalIndex,
                   UShort_t *FiConformalIndex,
                   UShort_t nBoxConformal[nRdivConformal][nFidivConformal],
                   UShort_t HitsinBoxConformal[nRdivConformal][nFidivConformal][nmaxHits],
                   UShort_t *auxListHitsinTrack
                                                     )
{
  bool passamin,passamax;

  Short_t i, i2, j, k, l,  l2, l3, itemp,
          iFi0,         FFimin,FFimax;
  UShort_t Nextra=8,
           nFi,
           Fi,
           nR,
           nAssociatedHits;
  Double_t maxFi,
           minFi,
           dist,
           xx,
           yy,
           aaa,
           angle,
           r;

  nAssociatedHits=0;

//   find the range in Fi spanned  by the candidate track

  FFimin = 10000;
  FFimax = 0;
  for(j=0; j<nHitsinTrack; j++){
    i = (UShort_t)  infoparalConformal[ ListHitsinTrack[j] ][3];
    if( FiConformalIndex[i] <  FFimin ) FFimin = FiConformalIndex[i];
    if( FiConformalIndex[i] >  FFimax ) FFimax = FiConformalIndex[i];
  }

if(istampa>=3 && IVOLTE<20) {
  cout<<"  evento n. "<<IVOLTE<<", Fimin prima  prima = "<<FFimin<<",  Fimax prima "<<FFimax<<endl;
}

  if( FFimax > 3.*nFidivConformal/4. && FFimin < nFidivConformal/4.) {
     FFimin = 10000;
     FFimax =  0;
     for(j=0; j<nHitsinTrack; j++){
       i = (UShort_t)  infoparalConformal[ ListHitsinTrack[j] ][3];
       Fi = FiConformalIndex[i];
       if( Fi < nFidivConformal/4. ) Fi = FiConformalIndex[i]+nFidivConformal;
       if( Fi <  FFimin ) FFimin = Fi;
       if( Fi >  FFimax ) FFimax = Fi;
     }
  }

if(istampa>=3 && IVOLTE<20) {
  cout<<"  evento n. "<<IVOLTE<<", Fimin prima = "<<FFimin<<",  Fimax prima "<<FFimax<<endl;
}

//  finding the boundaries in the Conformal plane. The basic assumption is that the range
// in Fi is much less that 180 degrees.
  
  FFimin -= (Short_t) nFidivConformal/Nextra;
  FFimax +=  (Short_t) nFidivConformal/Nextra;
  if( FFimax - FFimin > nFidivConformal/2 ) {
    cout<<"something fishy is going on in PndSttTrkAssociatedParallelHitsToHelixBis!"
      <<"Range in Fi (rad) is  "<<(FFimax - FFimin)*2.*PI/nFidivConformal<<endl;
    return 0;
  }

if(istampa>=3 && IVOLTE<20) {
  cout<<"  evento n. "<<IVOLTE<<", Fimin dopo = "<<FFimin<<",  Fimax dopo "<<FFimax<<endl;
}



//   use the equation of a line in polar coordinates
 
  if( Status ==99) {   //  case in which   0 = x + q




    if(fabs(q) > 1.e-10 ) {
      passamax=false;
      passamin=false;
      for(itemp=FFimin; itemp<=FFimax;itemp++){
        i=itemp;
        if( i< 0 ) {
          i += nFidivConformal;
        } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//         i -= nFidivConformal;
        }
        angle = (i+0.5)*2.*PI/nFidivConformal;
        aaa = cos(angle);
        if( fabs(cos(angle)) <1.e-10)  continue;
        r = -q/aaa;
        if(r< radiaConf[0] || r>= 1./RStrawDetectorMin)  continue;
        for(j=nRdivConformalEffective-1; j>=0;j--){
          if( r>= radiaConf[j] ){
           nR = j;
           break;
          }
        }


        for(l=-DELTAnR; l<DELTAnR+1;l++){
          l2 = nR+l;
          if(  l2<0 || l2 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l2][i];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][0];
                dist = fabs( xx +q );
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l2][i][k];
                    nAssociatedHits++; 
                }
              }
        }   //   end of for(l=0; l<3;l++)

        // ------- special cases
           if((nR == nRdivConformalEffective-1 && passamin && ! passamax) ||  (nR==0 && passamax && !passamin)  ) {   //  do the last two Fi columns
            if(nR == nRdivConformalEffective-1)  passamax=true;
            if(nR == 0)   passamin=true;

            for(l2=1;l2<3;l2++){
             i2 = i+l2;
             if(i2>=nFidivConformal) i2 -=  nFidivConformal;
            for(l=-2; l<3;l++){
             l3 = nR+l;
             if(  l3<0 || l3 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l3][i2];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][0];
                dist = fabs( xx +q );
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l3][i2][k];
                    nAssociatedHits++; 
                }
              }
            }   //   end of for(l=-2; l<3;l++)
            }   //   end of for(l2=0;l2<2;l2++)
            return  nAssociatedHits;
           } else if ((nR == nRdivConformalEffective-1 && ! passamin && !passamax) || (nR==0 && !passamax && !passamin)){
             if(nR == nRdivConformalEffective-1)  passamax=true;
             if(nR == 0)   passamin=true;

            for(l2=1;l2<3;l2++){
             i2 = i-l2;
             if(i2<nFidivConformal) i2 += nFidivConformal;
            for(l=-2; l<3;l++){
             l3 = nR+l;
             if(  l3<0 || l3 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l3][i2];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][0];
                dist = fabs( xx +q );
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l3][i2][k];
                    nAssociatedHits++; 
                }
              }
            }   //   end of for(l=-2; l<3;l++)
            }   //   end of for(l2=0;l2<2;l2++)
           }    //   end of if((nR == nRdivConformalEffective-1 && passamin) ||  (nR==0 && passamax)  )



      }   //  end of     for(itemp=FFimin; itemp<=FFimax;itemp++)


    } else {  //  q=0 --> x=0



      if( FFimax > nRdivConformal/4 && FFimin < nRdivConformal/4 ) {
        iFi0 =  (Short_t)  (nRdivConformal/4 );
      } else if ( FFimax > 3*nRdivConformal/4 && FFimin < 3*nRdivConformal/4 ){
        iFi0 =  (Short_t)  (3*nRdivConformal/4 );
      }  else {
                cout <<"From PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixBis  :"
                      <<"  inconsistency, 0 associated hits to this track candidate\n";
        return 0;
     }

      for(itemp=iFi0-5; itemp<=iFi0+5;itemp++){
        i=itemp;
        if( i< 0 ) {
          i += nFidivConformal;
        } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//         i -= nFidivConformal;
        }
        for(l=0; l<nRdivConformalEffective;l++){
              for( k=0;k<nBoxConformal[l][i];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l][i][k]  ][0];
                dist = fabs( xx  );

                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l][i][k];
                    nAssociatedHits++;
                }
              }  //  end of for( k=0;k<nBoxConformal[l][i];k++)
        }  //  end of for(l=0; l<nRdivConformalEffective;l++)
      }   //  end of for(itemp=iFi0-5; itemp<=iFi0+5;itemp++)




      }    //   end  of if(fabs(q) > 1.e-10 )


  }  else if( fabs(q)> 1.e-10) {   //   second part of    if( Status ==99),  in this case y = m*x +q

        passamax=false;
        passamin=false;
        for(itemp=FFimin; itemp<=FFimax;itemp++){
         i=itemp;

         if( i< 0 ) {
          i += nFidivConformal;
         } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
         }
         angle = (i+0.5)*2.*PI/nFidivConformal;
         aaa = sin(angle) - m*cos(angle);
         if( fabs(aaa) < 1.e-10) continue;
         r = q/aaa;
         if(r< radiaConf[0] || r>= 1./RStrawDetectorMin)  continue;
         for(j=nRdivConformalEffective-1; j>=0;j--){
          if( r>= radiaConf[j] ){
           nR = j;
           break;
          }
        }


        for(l=-2; l<3;l++){
          l2 = nR+l;
          if(  l2<0 || l2 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l2][i];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][0];
                yy=infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][1];
                dist = fabs( -yy+ m*xx +q )/sqrt(m*m+1.);

/*
if( IVOLTE==2 && ITRACCIA ==8) cout<<"Prima di associazione, hits n. (num. parallela)  : "<<HitsinBoxConformal[l2][i][k]<<
     ",  numerazione originale  "<<infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][3]<<
     ",  iR  "<<   RConformalIndex[(int)  infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][3] ]<<
     ",  iFi  "<<   FiConformalIndex[(int)  infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][3] ]<<
endl;
*/


                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l2][i][k];
                    nAssociatedHits++; 
//if( IVOLTE==2 && ITRACCIA ==8) cout<<"                      hits n. (num. parallela)  : "<<HitsinBoxConformal[l2][i][k]<<"   associato"<<endl;
                }
              }
        }   //   end of for(l=0; l<3;l++)


        // ------- special cases
           if((nR == nRdivConformalEffective-1 && passamin & !passamax) ||  (nR==0 && passamax && !passamin)  ) {   //  do the last two Fi columns
            if(nR == nRdivConformalEffective-1)  passamax=true;
            if(nR == 0)   passamin=true;

            for(l2=1;l2<3;l2++){
             i2 = i+l2;
             if(i2>=nFidivConformal) i2 -=  nFidivConformal;
            for(l=-2; l<3;l++){
             l3 = nR+l;
             if(  l3<0 || l3 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l3][i2];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][0];
                yy=infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][1];
                dist = fabs( -yy + m*xx +q )/sqrt(m*m+1.);
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l3][i2][k];
                    nAssociatedHits++; 
                }
              }
            }   //   end of for(l=-2; l<3;l++)
            }   //   end of for(l2=0;l2<2;l2++)
            return nAssociatedHits;
           } else if ((nR == nRdivConformalEffective-1 && ! passamin && !passamax) || (nR==0 && !passamax && !passamin)){
            if(nR == nRdivConformalEffective-1)  passamax=true;
            if(nR == 0)   passamin=true;
            for(l2=1;l2<3;l2++){
             i2 = i-l2;
             if(i2<0) i2 += nFidivConformal;

            for(l=-2; l<3;l++){
             l3 = nR+l;
             if(  l3<0 || l3 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l3][i2];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][0];
                yy=infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][1];
                dist = fabs( -yy+m*xx +q )/sqrt(m*m+1.);
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l3][i2][k];
                    nAssociatedHits++; 
                }
              }
            }   //   end of for(l=-2; l<3;l++)
            }   //   end of for(l2=0;l2<2;l2++)
           }    //   end of if((nR == nRdivConformalEffective-1 && passamin) ||  (nR==0 && passamax)  )




        }  // end of       for(itemp=FFimin; itemp<=FFimax;itemp++)



  } else {  //  case in which    y= m*x ,  m can be zero    ,  third part of if( Status ==99)

      iFi0 =  (Short_t)  (atan(m)*nRdivConformal/(2.*PI) );
      for(itemp=iFi0-5; itemp<=iFi0+5;itemp++){
         i=itemp;
         if( i< 0 ) {
          i += nFidivConformal;
         } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//          i -= nFidivConformal;
         }
        for(l=0; l<nRdivConformalEffective;l++){
              for( k=0;k<nBoxConformal[l][i];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l][i][k]  ][0];
                yy=infoparalConformal[  HitsinBoxConformal[l][i][k]  ][1];
                dist = fabs( m*xx-yy  )/sqrt( m*m+1.);
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[l][i][k]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l][i][k];
                    nAssociatedHits++;
                }
              }  //  end of for( k=0;k<nBoxConformal[l][i];k++)
        }
      }   //  end of for(itemp=FFimin; itemp<=FFimax;itemp++)





  }   //   end of if ( Status ==99)






 return nAssociatedHits;

}



//----------end of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixBis





















//----------begin of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixTris
  UShort_t PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixTris(
                   Double_t m,
                   Double_t q,
                   Short_t Status,
                   UShort_t nHitsinTrack,
                   UShort_t *ListHitsinTrack,
                   Int_t NhitsParallel,
                   Double_t infoparalConformal[][5],
                   UShort_t *RConformalIndex,
                   UShort_t *FiConformalIndex,
                   UShort_t nBoxConformal[nRdivConformal][nFidivConformal],
                   UShort_t HitsinBoxConformal[nRdivConformal][nFidivConformal][nmaxHits],
                   UShort_t *auxListHitsinTrack
                                                     )
{
  bool passamin,passamax,
       Unselected[nmaxHits];

  Short_t i, i2, j, k, l,  l2, l3, itemp, kstart, kend,
          iFi0,FFimin, FFimax;
  UShort_t Nextra=8,
           nFi,
           Fi,
           nR,
           nAssociatedHits;
  Double_t maxFi,
           minFi,
           dist,
           xx,
           yy,
           aaa,
           angle,
           r,
           erre1,
           erre2,
           Rin,
           Rout,
           Fi0,
           ddd,
           fi1,
           fi2;

  nAssociatedHits=0;
  for(i=0; i<NhitsParallel;i++){
   Unselected[i]= true;
  }

//   find the range in Fi spanned  by the candidate track

  FFimin = 10000;
  FFimax = 0;
  for(j=0; j<nHitsinTrack; j++){
    i = (UShort_t)  infoparalConformal[ ListHitsinTrack[j] ][3];
    if( FiConformalIndex[i] <  FFimin ) FFimin = FiConformalIndex[i];
    if( FiConformalIndex[i] >  FFimax ) FFimax = FiConformalIndex[i];
  }

if(istampa>=3 && IVOLTE<20) {
  cout<<"  evento n. "<<IVOLTE<<", Fimin prima  prima = "<<FFimin<<",  Fimax prima "<<FFimax<<endl;
}

  if( FFimax > 3.*nFidivConformal/4. && FFimin < nFidivConformal/4.) {
     FFimin = 10000;
     FFimax =  0;
     for(j=0; j<nHitsinTrack; j++){
       i = (UShort_t)  infoparalConformal[ ListHitsinTrack[j] ][3];
       Fi = FiConformalIndex[i];
       if( Fi < nFidivConformal/4. ) Fi = FiConformalIndex[i]+nFidivConformal;
       if( Fi <  FFimin ) FFimin = Fi;
       if( Fi >  FFimax ) FFimax = Fi;
     }
  }

if(istampa>=3 && IVOLTE<20) {
  cout<<"  evento n. "<<IVOLTE<<", Fimin prima = "<<FFimin<<",  Fimax prima "<<FFimax<<endl;
}

//  finding the boundaries in the Conformal plane. The basic assumption is that the range
// in Fi is much less that 180 degrees.
  
  FFimin -= (Short_t) nFidivConformal/Nextra;
  FFimax +=  (Short_t) nFidivConformal/Nextra;
  if( FFimax - FFimin > nFidivConformal/2 ) {
    cout<<"something fishy is going on in PndSttTrkAssociatedParallelHitsToHelixTris!"
      <<"Range in Fi (rad) is  "<<(FFimax - FFimin)*2.*PI/nFidivConformal<<endl;
    return 0;
  }

if(istampa>=3 && IVOLTE<20) {
  cout<<"  evento n. "<<IVOLTE<<", Fimin dopo = "<<FFimin<<",  Fimax dopo "<<FFimax<<endl;
}



//   use the equation of a line in polar coordinates
 
  if( Status ==99) {   //  case in which   0 = x + q




    if(fabs(q) > 1.e-10 ) {
      passamax=false;
      passamin=false;
      for(itemp=FFimin; itemp<=FFimax;itemp++){
        i=itemp;
        if( i< 0 ) {
          i += nFidivConformal;
        } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//         i -= nFidivConformal;
        }
        angle = (i+0.5)*2.*PI/nFidivConformal;
        aaa = cos(angle);
        if( fabs(cos(angle)) <1.e-10)  continue;
        r = -q/aaa;
        if(r< radiaConf[0] || r>= 1./RStrawDetectorMin)  continue;
        for(j=nRdivConformalEffective-1; j>=0;j--){
          if( r>= radiaConf[j] ){
           nR = j;
           break;
          }
        }


        for(l=-DELTAnR; l<DELTAnR+1;l++){
          l2 = nR+l;
          if(  l2<0 || l2 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l2][i];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][0];
                dist = fabs( xx +q );
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l2][i][k];
                    nAssociatedHits++; 
                }
              }
        }   //   end of for(l=0; l<3;l++)

        // ------- special cases
           if((nR == nRdivConformalEffective-1 && passamin && ! passamax) ||  (nR==0 && passamax && !passamin)  ) {   //  do the last two Fi columns
            if(nR == nRdivConformalEffective-1)  passamax=true;
            if(nR == 0)   passamin=true;

            for(l2=1;l2<3;l2++){
             i2 = i+l2;
             if(i2>=nFidivConformal) i2 -=  nFidivConformal;
            for(l=-2; l<3;l++){
             l3 = nR+l;
             if(  l3<0 || l3 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l3][i2];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][0];
                dist = fabs( xx +q );
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l3][i2][k];
                    nAssociatedHits++; 
                }
              }
            }   //   end of for(l=-2; l<3;l++)
            }   //   end of for(l2=0;l2<2;l2++)
            return  nAssociatedHits;
           } else if ((nR == nRdivConformalEffective-1 && ! passamin && !passamax) || (nR==0 && !passamax && !passamin)){
             if(nR == nRdivConformalEffective-1)  passamax=true;
             if(nR == 0)   passamin=true;

            for(l2=1;l2<3;l2++){
             i2 = i-l2;
             if(i2<nFidivConformal) i2 += nFidivConformal;
            for(l=-2; l<3;l++){
             l3 = nR+l;
             if(  l3<0 || l3 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l3][i2];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][0];
                dist = fabs( xx +q );
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l3][i2][k];
                    nAssociatedHits++; 
                }
              }
            }   //   end of for(l=-2; l<3;l++)
            }   //   end of for(l2=0;l2<2;l2++)
           }    //   end of if((nR == nRdivConformalEffective-1 && passamin) ||  (nR==0 && passamax)  )



      }   //  end of     for(itemp=Fimin; itemp<=FFimax;itemp++)


    } else {  //  q=0 --> x=0



      if( FFimax > nRdivConformal/4 && Fimin < nRdivConformal/4 ) {
        iFi0 =  (Short_t)  (nRdivConformal/4 );
      } else if ( FFimax > 3*nRdivConformal/4 && Fimin < 3*nRdivConformal/4 ){
        iFi0 =  (Short_t)  (3*nRdivConformal/4 );
      }  else {
                cout <<"From PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixTris  :"
                      <<"  inconsistency, 0 associated hits to this track candidate\n";
        return 0;
     }

      for(itemp=iFi0-5; itemp<=iFi0+5;itemp++){
        i=itemp;
        if( i< 0 ) {
          i += nFidivConformal;
        } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//         i -= nFidivConformal;
        }
        for(l=0; l<nRdivConformalEffective;l++){
              for( k=0;k<nBoxConformal[l][i];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l][i][k]  ][0];
                dist = fabs( xx  );

                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l][i][k];
                    nAssociatedHits++;
                }
              }  //  end of for( k=0;k<nBoxConformal[l][i];k++)
        }  //  end of for(l=0; l<nRdivConformalEffective;l++)
      }   //  end of for(itemp=iFi0-5; itemp<=iFi0+5;itemp++)




      }    //   end  of if(fabs(q) > 1.e-10 )


  }  else if( fabs(q)> 1.e-10) {   //   second part of    if( Status ==99),  in this case y = m*x +q


        Fi0 = atan2(q, -m*q);
        if(Fi0<0.)  { Fi0 += PI; if (Fi0 <0. ) Fi0 =0.; };

        ddd= fabs(q)/sqrt(1.+m*m);
// cout<<"  Fi0 "<<Fi0<<",  ddd  "<<ddd<<endl;

        for(itemp=FFimin; itemp<=FFimax;itemp++){
         i=itemp;
         if( i< 0 ) {
            i += nFidivConformal;
           } else if (i>=nFidivConformal){
            i -=  nFidivConformal*( i/nFidivConformal );
           }


              fi1 = i*2.*(PI/nFidivConformal);
              if( fabs(sin(fi1)-m*cos(fi1))>1.e-10) {
                 erre1 = q/(sin(fi1)-m*cos(fi1));
              }  else {
                 erre1 = 99999999999.;
              }

              fi2 = (i+1)*2.*(PI/nFidivConformal);
              if( fabs(sin(fi2)-m*cos(fi2))>1.e-10) {
                 erre2 = q/(sin(fi2)-m*cos(fi2));
              }  else {
                 erre2 = 99999999999.;
              }

// cout<<"  iFi = "<<i<<",  fi1 "<<fi1<<",  fi2 "<<fi2<<", erre1 "<<erre1<<",  erre2  "<<erre2<<endl;




         for(j=0; j<nRdivConformal; j++){
              Rin = radiaConf[j];
              if(j!=nRdivConformal-1) {
                 Rout =  radiaConf[j+1];
              }  else {
                 Rout = 1./RStrawDetectorMin;
              }

//  note that the following algorithm works also for negative erre1  and   erre2


              if(erre1<-1.e-10 ){
                if(erre2< 0. || erre2 > Rout ){
                     continue;
                } 
              } else if(fabs(erre1) < 1.e-10){
                if( Fi0 > fi2 || Fi0 < fi1)  continue;
              } else if ( erre1<Rin) {
                if( erre2< Rin )  continue;
              }   else if (erre1> Rout  &&  erre2 > Rout && !( fi1<=Fi0 && Fi0<=fi2 && ddd<=Rout )
                ) {
                   continue;
             }
// cout<<"accettato !   iFi = "<<i<<", iR  "<<j<<",fi1 "<<fi1<<",  fi2 "<<fi2<<", erre1 "<<erre1<<",  erre2  "<<erre2<<endl;
 
              for(l=itemp-2; l<=itemp+2; l++){
                if( l< 0 ) {
                  l2 = l+nFidivConformal;
                } else if (l>=nFidivConformal){
                  l2 = l- nFidivConformal*( l/nFidivConformal );
               } else {
                 l2 = l;
               }
                if( j-1<0) { 
                  kstart=0;
                }  else {
                  kstart = j-1;
                }
                if ( j+1 >=  nRdivConformal ) {
                  kend = nRdivConformal;
                } else {
                  kend = j+2;
                }

                for(k=kstart;k<kend;k++){
// cout<<"  iR = "<<k<<", iFi  "<<l2<<endl;

                 for( l3=0;l3<nBoxConformal[k][l2];l3++){
                   if( ! Unselected[HitsinBoxConformal[k][l2][l3] ] )  continue;
                   xx=infoparalConformal[  HitsinBoxConformal[k][l2][l3]  ][0];
                   yy=infoparalConformal[  HitsinBoxConformal[k][l2][l3]  ][1];
                   dist = fabs( -yy+ m*xx +q )/sqrt(m*m+1.);
// cout<<"  buona div???\n";
                   if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[k][l2][l3]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[k][l2][l3]  ][4]
                                                      ) )  {
//cout<<"  yes ,  buona div !!!!!\n";

                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[k][l2][l3];
                    Unselected[HitsinBoxConformal[k][l2][l3]]= false;
                    nAssociatedHits++;
                   }

                 }   //   end of  for( l3=0;l3<nBoxConformal[k][l2];l3++)

                }   //   end of  for(k=j-1;k<j+2;k++)
              }     //   end of  for(l=itemp-1; l<itemp+2; l++)


         }   //  end of for(j=0; j<nRdivConformal; j++)
        }   //   end of    for(itemp=FFimin; itemp<=FFimax;itemp++)





  } else {  //  case in which    y= m*x ,  m can be zero    ,  third part of if( Status ==99)

      iFi0 =  (Short_t)  (atan(m)*nRdivConformal/(2.*PI) );
      for(itemp=iFi0-5; itemp<=iFi0+5;itemp++){
         i=itemp;
         if( i< 0 ) {
          i += nFidivConformal;
         } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//          i -= nFidivConformal;
         }
        for(l=0; l<nRdivConformalEffective;l++){
              for( k=0;k<nBoxConformal[l][i];k++){
                xx=infoparalConformal[  HitsinBoxConformal[l][i][k]  ][0];
                yy=infoparalConformal[  HitsinBoxConformal[l][i][k]  ][1];
                dist = fabs( m*xx-yy  )/sqrt( m*m+1.);
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[l][i][k]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l][i][k];
                    nAssociatedHits++;
                }
              }  //  end of for( k=0;k<nBoxConformal[l][i];k++)
        }
      }   //  end of for(itemp=FFimin; itemp<=FFimax;itemp++)





  }   //   end of if ( Status ==99)






 return nAssociatedHits;

}



//----------end of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixTris









//----------begin of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixQuater
  UShort_t PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixQuater(
                   Double_t m,
                   Double_t q,
                   Short_t Status,
                   UShort_t nHitsinTrack,
                   UShort_t *ListHitsinTrack,
                   Int_t NhitsParallel,
                   Double_t Ox,
                   Double_t Oy,
                   Double_t R,
                   Double_t info[][7],
                   Double_t infoparalConformal[][5],
                   UShort_t *RConformalIndex,
                   UShort_t *FiConformalIndex,
                   UShort_t nBoxConformal[nRdivConformal][nFidivConformal],
                   UShort_t HitsinBoxConformal[nRdivConformal][nFidivConformal][nmaxHits],
                   UShort_t *auxListHitsinTrack
                                                     )
{
  bool passamin,passamax,
       Unselected[nmaxHits];

  Short_t i, i2, j, k, l,  l2, l3, itemp, kstart, kend,
          iFi0,FFimin, FFimax;
  UShort_t Nextra=8,
           nFi,
           Fi,
           nR,
           nAssociatedHits,
           nHit_original;
  Double_t maxFi,
           minFi,
           dist,
           xx,
           yy,
           aaa,
           angle,
           r,
           erre1,
           erre2,
           Rin,
           Rout,
           Fi0,
           ddd,
           fi1,
           fi2,
           dx,
           dy,
           distance,
           NTIMES=1.5;   //   number of Straw radia allowed in asociation

  nAssociatedHits=0;
  for(i=0; i<NhitsParallel;i++){
   Unselected[i]= true;
  }

//   find the range in Fi spanned  by the candidate track

  FFimin = 10000;
  FFimax = 0;
  for(j=0; j<nHitsinTrack; j++){
    i = (UShort_t)  infoparalConformal[ ListHitsinTrack[j] ][3];
    if( FiConformalIndex[i] <  FFimin ) FFimin = FiConformalIndex[i];
    if( FiConformalIndex[i] >  FFimax ) FFimax = FiConformalIndex[i];
  }

if(istampa>=3 && IVOLTE<20) {
  cout<<"  evento n. "<<IVOLTE<<", Fimin prima  prima = "<<FFimin<<",  Fimax prima "<<FFimax<<endl;
}

  if( FFimax > 3.*nFidivConformal/4. && FFimin < nFidivConformal/4.) {
     FFimin = 10000;
     FFimax =  0;
     for(j=0; j<nHitsinTrack; j++){
       i = (UShort_t)  infoparalConformal[ ListHitsinTrack[j] ][3];
       Fi = FiConformalIndex[i];
       if( Fi < nFidivConformal/4. ) Fi = FiConformalIndex[i]+nFidivConformal;
       if( Fi <  FFimin ) FFimin = Fi;
       if( Fi >  FFimax ) FFimax = Fi;
     }
  }

if(istampa>=3 && IVOLTE<20) {
  cout<<"  evento n. "<<IVOLTE<<", Fimin prima = "<<FFimin<<",  Fimax prima "<<FFimax<<endl;
}

//  finding the boundaries in the Conformal plane. The basic assumption is that the range
// in Fi is much less that 180 degrees.
  
  FFimin -= (Short_t) nFidivConformal/Nextra;
  FFimax +=  (Short_t) nFidivConformal/Nextra;
if( FFimax - FFimin > nFidivConformal/2 ) {
    cout<<"something fishy is going on in PndSttTrkAssociatedParallelHitsToHelixQuater!"
      <<"Range in Fi (rad) is  "<<(FFimax - FFimin)*2.*PI/nFidivConformal<<endl;
    return 0;
}

if(istampa>=3 && IVOLTE<20) {
  cout<<"  evento n. "<<IVOLTE<<", Fimin dopo = "<<FFimin<<",  Fimax dopo "<<FFimax<<endl;
}


//   use the equation of a line in polar coordinates
 
  if( Status ==99) {   //  case in which   0 = x + q



    if(fabs(q) > 1.e-10 ) {
      passamax=false;
      passamin=false;
      for(itemp=FFimin; itemp<=FFimax;itemp++){
        i=itemp;
        if( i< 0 ) {
          i += nFidivConformal;
        } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//         i -= nFidivConformal;
        }
        angle = (i+0.5)*2.*PI/nFidivConformal;
        aaa = cos(angle);
        if( fabs(cos(angle)) <1.e-10)  continue;
        r = -q/aaa;
        if(r< radiaConf[0] || r>= 1./RStrawDetectorMin)  continue;
        for(j=nRdivConformalEffective-1; j>=0;j--){
          if( r>= radiaConf[j] ){
           nR = j;
           break;
          }
        }


        for(l=-DELTAnR; l<DELTAnR+1;l++){
          l2 = nR+l;
          if(  l2<0 || l2 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l2][i];k++){
                nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][3];
// check if the hit position is near the circle of the Helix found by the fit
                dx = -Ox+info[ nHit_original ][0];
                dy = -Oy+info[ nHit_original ][1];
                distance = sqrt(dx*dx+dy*dy);
//cout<<"nuov, R "<<R<<",  distance  "<<distance<<endl;
                if ( fabs(R - distance ) > NTIMES*StrawRadius )  continue;

//-------------------
                xx=infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][0];
                dist = fabs( xx +q );
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l2][i][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l2][i][k];
                    nAssociatedHits++; 
                }
              }
        }   //   end of for(l=0; l<3;l++)

        // ------- special cases
           if((nR == nRdivConformalEffective-1 && passamin && ! passamax) ||  (nR==0 && passamax && !passamin)  ) {   //  do the last two Fi columns
            if(nR == nRdivConformalEffective-1)  passamax=true;
            if(nR == 0)   passamin=true;

            for(l2=1;l2<3;l2++){
             i2 = i+l2;
             if(i2>=nFidivConformal) i2 -=  nFidivConformal;
            for(l=-2; l<3;l++){
             l3 = nR+l;
             if(  l3<0 || l3 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l3][i2];k++){
                nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][3];
// check if the hit position is near the circle of the Helix found by the fit
                dx = -Ox+info[ nHit_original ][0];
                dy = -Oy+info[ nHit_original ][1];
                distance = sqrt(dx*dx+dy*dy);
                if ( fabs(R - distance ) > NTIMES*StrawRadius )  continue;

//-------------------
                xx=infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][0];
                dist = fabs( xx +q );
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l3][i2][k];
                    nAssociatedHits++; 
                }
              }
            }   //   end of for(l=-2; l<3;l++)
            }   //   end of for(l2=0;l2<2;l2++)
            return  nAssociatedHits;
           } else if ((nR == nRdivConformalEffective-1 && ! passamin && !passamax) || (nR==0 && !passamax && !passamin)){
             if(nR == nRdivConformalEffective-1)  passamax=true;
             if(nR == 0)   passamin=true;

            for(l2=1;l2<3;l2++){
             i2 = i-l2;
             if(i2<nFidivConformal) i2 += nFidivConformal;
            for(l=-2; l<3;l++){
             l3 = nR+l;
             if(  l3<0 || l3 >= nRdivConformalEffective )  continue;
              for( k=0;k<nBoxConformal[l3][i2];k++){
                nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][3];
// check if the hit position is near the circle of the Helix found by the fit
                dx = -Ox+info[ nHit_original ][0];
                dy = -Oy+info[ nHit_original ][1];
                distance = sqrt(dx*dx+dy*dy);
                if ( fabs(R - distance ) > NTIMES*StrawRadius )  continue;

//-------------------
                xx=infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][0];
                dist = fabs( xx +q );
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l3][i2][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l3][i2][k];
                    nAssociatedHits++; 
                }
              }
            }   //   end of for(l=-2; l<3;l++)
            }   //   end of for(l2=0;l2<2;l2++)
           }    //   end of if((nR == nRdivConformalEffective-1 && passamin) ||  (nR==0 && passamax)  )



      }   //  end of     for(itemp=Fimin; itemp<=FFimax;itemp++)


    } else {  //  q=0 --> x=0



      if( FFimax > nRdivConformal/4 && Fimin < nRdivConformal/4 ) {
        iFi0 =  (Short_t)  (nRdivConformal/4 );
      } else if ( FFimax > 3*nRdivConformal/4 && Fimin < 3*nRdivConformal/4 ){
        iFi0 =  (Short_t)  (3*nRdivConformal/4 );
      }  else {
                cout <<"From PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixQuater  :"
                      <<"  inconsistency, 0 associated hits to this track candidate\n";
        return 0;
     }

      for(itemp=iFi0-5; itemp<=iFi0+5;itemp++){
        i=itemp;
        if( i< 0 ) {
          i += nFidivConformal;
        } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//         i -= nFidivConformal;
        }
        for(l=0; l<nRdivConformalEffective;l++){
              for( k=0;k<nBoxConformal[l][i];k++){
                nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[l][i][k]  ][3];
// check if the hit position is near the circle of the Helix found by the fit
                dx = -Ox+info[ nHit_original ][0];
                dy = -Oy+info[ nHit_original ][1];
                distance = sqrt(dx*dx+dy*dy);
                if ( fabs(R - distance ) >NTIMES*StrawRadius )  continue;

//-------------------
                xx=infoparalConformal[  HitsinBoxConformal[l][i][k]  ][0];
                dist = fabs( xx  );

                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l][i][k];
                    nAssociatedHits++;
                }
              }  //  end of for( k=0;k<nBoxConformal[l][i];k++)
        }  //  end of for(l=0; l<nRdivConformalEffective;l++)
      }   //  end of for(itemp=iFi0-5; itemp<=iFi0+5;itemp++)




      }    //   end  of if(fabs(q) > 1.e-10 )


  }  else if( fabs(q)> 1.e-10) {   //   second part of    if( Status ==99),  in this case y = m*x +q


        Fi0 = atan2(q, -m*q);
        if(Fi0<0.)  { Fi0 += PI; if (Fi0 <0. ) Fi0 =0.; };

        ddd= fabs(q)/sqrt(1.+m*m);

        for(itemp=FFimin; itemp<=FFimax;itemp++){
         i=itemp;
         if( i< 0 ) {
            i += nFidivConformal;
         } else if (i>=nFidivConformal){
            i -=  nFidivConformal*( i/nFidivConformal );
         }


         fi1 = i*2.*(PI/nFidivConformal);
         if( fabs(sin(fi1)-m*cos(fi1))>1.e-10) {
                 erre1 = q/(sin(fi1)-m*cos(fi1));
         }  else {
                 erre1 = 99999999999.;
         }

         fi2 = (i+1)*2.*(PI/nFidivConformal);
         if( fabs(sin(fi2)-m*cos(fi2))>1.e-10) {
                 erre2 = q/(sin(fi2)-m*cos(fi2));
         }  else {
                 erre2 = 99999999999.;
         }




         for(j=0; j<nRdivConformal; j++){
              Rin = radiaConf[j];
              if(j!=nRdivConformal-1) {
                 Rout =  radiaConf[j+1];
              }  else {
                 Rout = 1./RStrawDetectorMin;
              }

//  note that the following algorithm works also for negative erre1  and   erre2


              if(erre1<-1.e-10 ){
                if(erre2< 0. || erre2 > Rout ){
                     continue;
                } 
              } else if(fabs(erre1) < 1.e-10){
                if( Fi0 > fi2 || Fi0 < fi1)  continue;
              } else if ( erre1<Rin) {
                if( erre2< Rin )  continue;
              }   else if (erre1> Rout  &&  erre2 > Rout && !( fi1<=Fi0 && Fi0<=fi2 && ddd<=Rout )
                ) {
                   continue;
             }

              for(l=itemp-2; l<=itemp+2; l++){
                if( l< 0 ) {
                  l2 = l+nFidivConformal;
                } else if (l>=nFidivConformal){
                  l2 = l- nFidivConformal*( l/nFidivConformal );
               } else {
                 l2 = l;
               }
                if( j-1<0) { 
                  kstart=0;
                }  else {
                  kstart = j-1;
                }
                if ( j+1 >=  nRdivConformal ) {
                  kend = nRdivConformal;
                } else {
                  kend = j+2;
                }

                for(k=kstart;k<kend;k++){

                 for( l3=0;l3<nBoxConformal[k][l2];l3++){
                  if( ! Unselected[HitsinBoxConformal[k][l2][l3] ] )  continue;
                   nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[k][l2][l3]  ][3];
// check if the hit position is near the circle of the Helix found by the fit
                   dx = -Ox+info[ nHit_original ][0];
                   dy = -Oy+info[ nHit_original ][1];
                   distance = sqrt(dx*dx+dy*dy);
                   if ( fabs(R - distance ) > NTIMES*StrawRadius )  continue;

//-------------------
                   xx=infoparalConformal[  HitsinBoxConformal[k][l2][l3]  ][0];
                   yy=infoparalConformal[  HitsinBoxConformal[k][l2][l3]  ][1];
                   dist = fabs( -yy+ m*xx +q )/sqrt(m*m+1.);
                   if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[k][l2][l3]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[k][l2][l3]  ][4]
                                                      ) )  {

                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[k][l2][l3];
                    Unselected[HitsinBoxConformal[k][l2][l3]]= false;
                    nAssociatedHits++;
                   }

                 }   //   end of  for( l3=0;l3<nBoxConformal[k][l2];l3++)
                }   //   end of  for(k=kstart;k<kend;k++)
              }     //   end of  for(l=itemp-1; l<itemp+2; l++)

         }   //  end of for(j=0; j<nRdivConformal; j++)

        }   //   end of    for(itemp=FFimin; itemp<=FFimax;itemp++)





  } else {  //  case in which    y= m*x ,  m can be zero    ,  third part of if( Status ==99)

      iFi0 =  (Short_t)  (atan(m)*nRdivConformal/(2.*PI) );
      for(itemp=iFi0-5; itemp<=iFi0+5;itemp++){
         i=itemp;
         if( i< 0 ) {
          i += nFidivConformal;
         } else if (i>=nFidivConformal){
          i -=  nFidivConformal*( i/nFidivConformal );
//          i -= nFidivConformal;
         }
        for(l=0; l<nRdivConformalEffective;l++){
              for( k=0;k<nBoxConformal[l][i];k++){
                nHit_original = (UShort_t) infoparalConformal[  HitsinBoxConformal[l][i][k]  ][3];
// check if the hit position is near the circle of the Helix found by the fit
                dx = -Ox+info[ nHit_original ][0];
                dy = -Oy+info[ nHit_original ][1];
                distance = sqrt(dx*dx+dy*dy);
                if ( fabs(R - distance ) > NTIMES*StrawRadius )  continue;

//-------------------
                xx=infoparalConformal[  HitsinBoxConformal[l][i][k]  ][0];
                yy=infoparalConformal[  HitsinBoxConformal[l][i][k]  ][1];
                dist = fabs( m*xx-yy  )/sqrt( m*m+1.);
//                if(dist < 3.*infoparalConformal[  HitsinBoxConformal[l][i][k]  ][2]){
                if(  PndSttAcceptHitsConformal(  dist,
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][2],
                                                 infoparalConformal[  HitsinBoxConformal[l][i][k]  ][4]
                                                      ) )  {
                    auxListHitsinTrack[nAssociatedHits]= HitsinBoxConformal[l][i][k];
                    nAssociatedHits++;
                }
              }  //  end of for( k=0;k<nBoxConformal[l][i];k++)
        }
      }   //  end of for(itemp=FFimin; itemp<=FFimax;itemp++)





  }   //   end of if ( Status ==99)


if(istampa>=3) {
  cout<<"from PndSttTrkAssociatedParallelHitsToHelixQuater, before exiting; nAssociatedHits = "
   <<nAssociatedHits<<endl;
}



 return nAssociatedHits;

}



//----------end of function PndSttTrackFinderReal::PndSttTrkAssociatedParallelHitsToHelixQuater


















//----------begin of function PndSttTrackFinderReal::PndSttAcceptHitsConformal

bool  PndSttTrackFinderReal::PndSttAcceptHitsConformal(  Double_t  distance,
                                                         Double_t  DriftConfR, //drift radius in conformal space
                                                         Double_t  StrawConfR  // straw radius in conformal space
                                                      )
{
//if( IVOLTE==2 && ITRACCIA ==8) cout <<" fabs(distance-DriftConfR)  "<<fabs(distance-DriftConfR)<<
//       ",   2.*StrawConfR  "<< 2.*StrawConfR<<endl;
     if(  fabs(distance-DriftConfR)  <   2.*StrawConfR )   return true;
     return false;


}




//----------end of function PndSttTrackFinderReal::PndSttAcceptHitsConformal

























//----------begin of function PndSttTrackFinderReal::AssociateSkewHitsToXYTrack

  UShort_t PndSttTrackFinderReal::AssociateSkewHitsToXYTrack(
                   bool *ExclusionListSkew,
                   Double_t Ox,
                   Double_t Oy,
                   Double_t R,
                   Double_t info[][7],
                   Double_t inclination[][3],
                   Double_t Fi_low_limit,
                   Double_t Fi_up_limit,
                   Double_t Fi_allowedforskew_low,
                   Double_t Fi_allowedforskew_up,
                   Short_t  Charge,
                   Double_t Fi_initial_helix_referenceframe,
                   Double_t Fi_final_helix_referenceframe,
                   UShort_t SkewList[nmaxHits][2], // output,  list of selected skew hits (in skew numbering)
                   Double_t *S,       //  output,  S coordinate of selected Skew hit
                   Double_t *Z,       //  output,  Z coordinate of selected Skew hit
                   Double_t *ZDrift,   //  output,  drift distance IN Z DIRECTION only, of selected Skew hit
                   Double_t *ZErrorafterTilt   //  output,  Radius taking into account the tilt, IN Z DIRECTION only, of selected Skew hit
                                                     )
 {



    Int_t i, j, i1, ii, iii, NAssociated, Kincl, nlow, nup, STATUS, Nmin, Nmax;

    Double_t xmin , xmax, ymin, ymax,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];


//   calculate the Fi range allowed to the skew hits, with Fi calculated in the TRACK CYLINDER REFERENCE FRAME.




//      Smin=zmin = 1.e10;
//      Smax=zmax = -zmin;
      NAssociated=0;

       for( iii=0; iii< NSkewhits; iii++) {
         i = infoskew[iii];
         if( !ExclusionListSkew[i]) continue;


         Kincl = (int) info[i][5] - 1;


         aaa = sqrt(inclination[Kincl][0]*inclination[Kincl][0]+inclination[Kincl][1]*inclination[Kincl][1]+
                  inclination[Kincl][2]*inclination[Kincl][2]);
         vx1 = inclination[Kincl][0]/aaa;
         vy1 = inclination[Kincl][1]/aaa;
         vz1 = inclination[Kincl][2]/aaa;
         C0x1 = info[i][0];
         C0y1 = info[i][1];
         C0z1 = info[i][2];

       calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,info[i][3],
                              vx1,vy1,vz1,
                              &STATUS,POINTS1);

       if(STATUS < 0 ) continue ;


       for( ii=0; ii<2; ii++){

        j=3*ii;
        distance = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                            );
        if( distance >= info[i][4] ) continue;


        Rx = POINTS1[j]-Ox ;   //  x component Radial vector of cylinder of trajectory
        Ry = POINTS1[1+j]-Oy ;   //  y direction Radial vector of cylinder of trajectory

        aaa = sqrt(Rx*Rx+Ry*Ry);
        SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
        SkewInclWithRespectToS /= R;
        bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
        //  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
        if( bbb > 1.e-10){
           Tiltdirection1[0] = vz1/bbb;
           Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
        } else {
           Tiltdirection1[0] = 1.;
           Tiltdirection1[1] = 0.;
        }

        LL = fabs(vx1*Rx + vy1*Ry);
        if( LL < 1.e-10) continue;
        Aellipsis1 = info[i][3]*aaa/LL;

        Bellipsis1 = info[i][3]/R;


// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

//        if(
//             fabs(POINTS1[j+2]-info[i][2]) > SEMILENGTH_STRAIGHT- Aellipsis1 ||
//             distance + bbb > info[i][4]        //  the ellipsis goes out of the boundaries of the skew straw
//          ) {
// if( istampa)  cout<<"the ellipsis goes out of the boundaries of the skew straw, hit n. "<<i<<endl
//     <<"dis. from center "<<distance+bbb<<",  length of the straw "<<info[i][4]<<endl;
//           continue;
//          }
//--------------------------


        S[NAssociated] = atan2(POINTS1[j+1]-Oy, POINTS1[j]-Ox) ;  // atan2 returns radians in (-pi and +pi]
        if( S[NAssociated] < 0.) S[NAssociated] += 2.*PI;

//  check if the S of this intersection is compatible with information coming from the parallel fit of this track
        Double_t Sprime = atan2(POINTS1[j+1], POINTS1[j]) ;
        if( Sprime < 0.) Sprime += 2.*PI;
        if(  Sprime < Fi_low_limit) {
           if(  Sprime+2.*PI > Fi_up_limit)  continue;
        }  else {
           if(  Sprime > Fi_up_limit)  continue;
        }





//  second check, to see if this hits are in the allowed Fi range in the Helix reference frame
/*
        if ( S[NAssociated] <  Fi_allowedforskew_low) {
              if (S[NAssociated] + 2.*PI >  Fi_allowedforskew_up)  continue;
        } else {
              if (S[NAssociated] >  Fi_allowedforskew_up)  continue;
        }
*/

//---------------------------   end check


        Z[NAssociated] = POINTS1[j+2];
        ZDrift[NAssociated] = Aellipsis1*Tiltdirection1[0];
        ZErrorafterTilt[NAssociated] = StrawDriftError*aaa*Tiltdirection1[0]/LL;
        SkewList[NAssociated][0] = iii;  // n. skew hit in skew hit numbering
        SkewList[NAssociated][1] = ii;  //  solution 0 or solution 1 were accepted


// check if this skew hit doesn't "push out"  the most external parallel hit
// (see Gianluigi's logbook on page 251)

        Double_t Zh1 = Z[NAssociated] - ZDrift[NAssociated];
        Double_t Zh2 = Z[NAssociated] + ZDrift[NAssociated];
        Double_t Sh1 = S[NAssociated] - Aellipsis1*Tiltdirection1[1];
        Double_t Sh2 = S[NAssociated] + Aellipsis1*Tiltdirection1[1];
        Double_t Zlast1 = (Fi_final_helix_referenceframe-Fi_initial_helix_referenceframe)*Zh1
                                  /(Sh1-Fi_initial_helix_referenceframe);
        Double_t Zlast2 = (Fi_final_helix_referenceframe-Fi_initial_helix_referenceframe)*Zh2
                                  /(Sh2-Fi_initial_helix_referenceframe);


if( istampa>=3 && IVOLTE<20){
     cout<<"   Zlast1 "<<Zlast1<<",  Zlast2 "<<Zlast2<<endl;
     cout<<"   centro straight straws "<<ZCENTER_STRAIGHT<<", lunghezza straight "<<SEMILENGTH_STRAIGHT
<<",  fabs(Zlast1 - ZCENTER_STRAIGHT) "<< fabs(Zlast1 - ZCENTER_STRAIGHT)<<",    fabs(Zlast2 - ZCENTER_STRAIGHT) "
 << fabs(Zlast2 - ZCENTER_STRAIGHT)    <<endl;
}



        if( fabs(Zlast1 - ZCENTER_STRAIGHT) > SEMILENGTH_STRAIGHT
                                  &&
            fabs(Zlast2 - ZCENTER_STRAIGHT) > SEMILENGTH_STRAIGHT
           )   continue;


        NAssociated++;

   }    //  end of    for( ii=0; ii<2; ii++)

  }   //   for( iii=0; iii< NSkewhits; iii++)



  return NAssociated;



 }

//----------end of function PndSttTrackFinderReal::AssociateSkewHitsToXYTrack











//----------begin of function PndSttTrackFinderReal::AssociateBetterAfterFitSkewHitsToXYTrack

  UShort_t PndSttTrackFinderReal::AssociateBetterAfterFitSkewHitsToXYTrack(
                   UShort_t TemporarynSkewHitsinTrack,  //  input
                   UShort_t SkewList[nmaxHits][2], // input,  list of selected skew hits (in skew numbering)
                   Double_t *S,       //  input,  S coordinate of selected Skew hit
                   Double_t *Z,       //  input,  Z coordinate of selected Skew hit
                   Double_t *ZDrift,  //  input,  drift distance IN Z DIRECTION only, of selected Skew hit
                   Double_t *ZErrorafterTilt,   //  input,  Radius taking into account the tilt, IN Z DIRECTION only, of selected Skew hit
                   Double_t KAPPA,    // input, KAPPA result of fit
                   Double_t FI0,    // input, FI0 result of fit
                   UShort_t *tempore,  //  output result, associated skew hits
                   Double_t *temporeS,  //  output, associated skew hit  S
                   Double_t *temporeZ,  //  output, associated skew hits Z
                   Double_t *temporeZDrift,  //  output, associated skew hit Z drift
                   Double_t *temporeZErrorafterTilt,  //  output, associated skew hits Z error after tilt
                   Int_t  *STATUS   // output
                                                     )
 {



    UShort_t NAssociated;
    Short_t  sign;
    Int_t i, j, i1, ii, iii,  Kincl, nlow, nup;

    Double_t bbb,
             tempZ[2],
             zmin, zmax, deltaz, zdist;

    Double_t allowed_distance = 4.*StrawRadius/sin(3.*PI/180.);


    if(fabs(KAPPA)<1.e-20) {
      *STATUS=-1;
      return 0;
    }


    NAssociated=0;

    if(KAPPA>0) {
     zmin = -FI0/KAPPA;
     zmax = (2.*PI-FI0)/KAPPA;
    }  else {
     zmax = -FI0/KAPPA;
     zmin = (2.*PI-FI0)/KAPPA;
    }
    deltaz = zmax-zmin;

if(istampa>=3 && IVOLTE<20) cout<<"  Zmax "<<zmax<<", Zmin  "<<zmin<<endl;



     for(i=0; i<TemporarynSkewHitsinTrack; i++){
       bbb=(S[i]-FI0)/KAPPA;
if(istampa>=3 && IVOLTE<20) cout<<"From AssociateBetterAfterFitSkewHitsToXYTrack ,  hit skew n. "<<SkewList[i][0]
                               <<", Zhit  "<<Z[i]<<",  S hit  "<<S[i]<<endl;
      for(sign=0;sign<=1; sign ++){
if(istampa>=3 && IVOLTE<20) cout<<"From AssociateBetterAfterFitSkewHitsToXYTrack :  segno "<<-1+sign*2<<endl;
       tempZ[sign]=Z[i]+(2*sign-1)*ZDrift[i];
       if( tempZ[sign] > zmax ){
         tempZ[sign]=fmod( tempZ[sign]-zmax, deltaz) - deltaz;
       } else if (tempZ[sign]<zmin){
         tempZ[sign]=fmod( tempZ[sign]-zmin, deltaz) + deltaz;
       }

       zdist = fabs( bbb - tempZ[sign]);
if(istampa>=3 && IVOLTE<20) cout<<"From AssociateBetterAfterFitSkewHitsToXYTrack ,  hit skew n. "<<SkewList[i][0]<<",  tempZ "<<tempZ[sign]
                           <<",   zdist  "<<zdist<<",  ZDrift[i] "<<ZDrift[i]
                             <<", ZErrorafterTilt  "<<ZErrorafterTilt[i]<<endl;
         if(  zdist < allowed_distance ){
//       if(  zdist < 4.*ZErrorafterTilt[i] ){
if(istampa>=3 && IVOLTE<20) cout<<"From AssociateBetterAfterFitSkewHitsToXYTrack ,  hit skew n. "<< SkewList[i][0]
      <<",  tempZ "<<tempZ[sign]<<",   zdist  "<<zdist<<",  preso!!"<<endl;
         tempore[NAssociated]=SkewList[ i ][0];
         temporeS[NAssociated]=S[i];
         temporeZ[NAssociated]=Z[i];
         temporeZDrift[NAssociated]=ZDrift[i];
         temporeZErrorafterTilt[NAssociated]=ZErrorafterTilt[i];
         NAssociated++;
         goto labella ;
       }
      }  //  end of for(sign=0;sign<=1; sign++)
      if( tempZ[0]< bbb && tempZ[1] > bbb ) {
         tempore[NAssociated]=SkewList[i][0];
         temporeS[NAssociated]=S[i];
         temporeZ[NAssociated]=Z[i];
         temporeZDrift[NAssociated]=ZDrift[i];
         temporeZErrorafterTilt[NAssociated]=ZErrorafterTilt[i];
         NAssociated++;
if(istampa==2 && IVOLTE<20) cout<<"From AssociateBetterAfterFitSkewHitsToXYTrack ,  hit skew n. "<<SkewList[i][0]
             <<",  tempZ[0] "<<tempZ[0]<<",  tempZ[1]  "
<<tempZ[1]<<", fit prediction (Z) "<<bbb<<",  preso alla terza volta!!"<<endl;
      }
      labella:  ;
     }   //  end of for(i=0; i<TemporarynSkewHitsinTrack; i++)


     *STATUS=0;

     return NAssociated;



 }

//----------end of function PndSttTrackFinderReal::AssociateBetterAfterFitSkewHitsToXYTrack











//----------begin of function PndSttTrackFinderReal::PndSttFitSZspace


     Short_t PndSttTrackFinderReal::PndSttFitSZspace(
                                                     UShort_t nHitsinTrack,
                                                     Double_t *S,
                                                     Double_t *Z,
                                                     Double_t *DriftRadius,
                                                     Double_t rotationangle,
                                                     UShort_t NMAX,
                                                     Double_t *emme,
                                                     Double_t *qu
                                                            )
{







    //   definition of variables for the glpsol  solver
   //    ROWS (for read_rows  function)
   //
   UShort_t  NpointsInFit = nHitsinTrack-NMAX <0 ?  nHitsinTrack :  NMAX;
   int    nRows= NpointsInFit*9 +1;
   int typeRows[nRows];
   char * nameRows[nRows];
   char  auxnameRows[nRows][20];
//-------  end ROWS information
//--------begin COLUMNS information
      int  NStructVar=5+NpointsInFit*4;  //  number of  structural variables
      int  NStructRows = 8*NpointsInFit ;  //  maximum number of ROWS in which a structural variable can be found
      double final_values[NStructVar];
      int  NRowsInWhichStructVarArePresent[NStructVar];
      char *StructVarName[NStructVar];
      char auxStructVarName[NStructVar][20];
      char *NameRowsInWhichStructVarArePresent[NStructVar*NStructRows];
      char aux[NStructVar*NStructRows][20];
//      double Coefficients[NStructVar][NStructRows];
      double Coefficients[NStructVar*NStructRows];
//--------end COLUMNS information
//--------begin RHS information
      double ValueB[9*NpointsInFit];
//--------end RHS information
//--------begin RANGES information
      int nRanges = NpointsInFit;
      double ValueRanges[nRanges];
      char *NameRanges[nRanges];
      char auxNameRanges[nRanges][20];
//--------end RANGES information
//--------start BOUNDS information
      int nBounds=2*NpointsInFit+1;
      double BoundValue[nBounds];
      char *BoundStructVarName[nBounds];
      char auxBoundStructVarName[nBounds][20];
      char *TypeofBound[nBounds];
      char auxTypeofBound[nBounds][20];
//--------end BOUNDS information


//----------------------------------------------------







     Double_t M = 50.,
              m_result,
              q_result,
              A,
              alfetta,
              angle,
              offsety,
              Ox[nmaxHits],
              Oy[nmaxHits],
              Delta[nmaxHits];

     UShort_t  i, ii;
     Short_t Status;

     char nome[300], stringa[300], stringa2[300];

//     FILE * MACRO ;

     float m1_result,m2_result, q1_result,q2_result, A1_result, A2_result;

// --

     if( nHitsinTrack < MINIMUMHITSPERTRACK) {
        return -1;
     }


//  use the trick of increasing the rotation angle by 10 degrees in order to obtain always a positive m
//      rotationangle -= PI/18.;

      Double_t cose = cos(rotationangle), sine = sin(rotationangle);
      for(i=0;i<nHitsinTrack; i++){
       Ox[i] = Z[ i ] *cose +
               S[ i ]*sine;
       Oy[i] = -Z[ i ] *sine +
               S[ i ]*cose;






         Delta[i] = 2.;

      }

//-----------------  write the ROWS  section



//--------
      sprintf(&(auxnameRows[0][0]),"OBJECT",i);
      nameRows[0]=&auxnameRows[0][0];
      typeRows[0]=GLP_FR;
      for(i=0 ; i< NpointsInFit ; i++) {
       ii=9*i;
       typeRows[1+ii]=GLP_UP;typeRows[2+ii]=GLP_UP;typeRows[3+ii]=GLP_UP;typeRows[4+ii]=GLP_UP;
       typeRows[5+ii]=GLP_UP;typeRows[6+ii]=GLP_UP;typeRows[7+ii]=GLP_UP;typeRows[8+ii]=GLP_UP;
       typeRows[9+ii]=GLP_LO;

       sprintf(&(auxnameRows[1+ii][0]),"Ap%d",i);  nameRows[1+ii]=&auxnameRows[1+ii][0];
       sprintf(&(auxnameRows[2+ii][0]),"Bp%d",i);  nameRows[2+ii]=&auxnameRows[2+ii][0];
       sprintf(&(auxnameRows[3+ii][0]),"Cp%d",i);  nameRows[3+ii]=&auxnameRows[3+ii][0];
       sprintf(&(auxnameRows[4+ii][0]),"Dp%d",i);  nameRows[4+ii]=&auxnameRows[4+ii][0];
       sprintf(&(auxnameRows[5+ii][0]),"Am%d",i);  nameRows[5+ii]=&auxnameRows[5+ii][0];
       sprintf(&(auxnameRows[6+ii][0]),"Bm%d",i);  nameRows[6+ii]=&auxnameRows[6+ii][0];
       sprintf(&(auxnameRows[7+ii][0]),"Cm%d",i);  nameRows[7+ii]=&auxnameRows[7+ii][0];
       sprintf(&(auxnameRows[8+ii][0]),"Dm%d",i);  nameRows[8+ii]=&auxnameRows[8+ii][0];
       sprintf(&(auxnameRows[9+ii][0]),"LAMBDA%d",i);  nameRows[9+ii]=&auxnameRows[9+ii][0];
      }





//-----------------  write the COLUMNS  section







//  Column variable  m1
      for(i=0, ii=0 ; i< NpointsInFit ; i++) {
       ii++;
        Coefficients[i*4]=    Ox[i];
        Coefficients[i*4+1]=  Ox[i];
        Coefficients[i*4+2]= -Ox[i];
        Coefficients[i*4+3]= -Ox[i];
      }

//  Column variable  m2
      for(i=0; i< NpointsInFit ; i++) {
        Coefficients[NStructRows+i*4]=   -Ox[i];
        Coefficients[NStructRows+i*4+1]= -Ox[i];
        Coefficients[NStructRows+i*4+2]= Ox[i];
        Coefficients[NStructRows+i*4+3]= Ox[i];

      }

//  Column variable  q1
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[2*NStructRows+i*4]=    1.;
        Coefficients[2*NStructRows+i*4+1]=  1.;
        Coefficients[2*NStructRows+i*4+2]= -1.;
        Coefficients[2*NStructRows+i*4+3]= -1.;
      }

//  Column variable  q2
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[3*NStructRows+i*4]=   -1.;
        Coefficients[3*NStructRows+i*4+1]= -1.;
        Coefficients[3*NStructRows+i*4+2]=  1.;
        Coefficients[3*NStructRows+i*4+3]=  1.;
      }

//  Column variable  lambdap(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i)*NStructRows+0]= -M;
        Coefficients[(4+i)*NStructRows+1]= -M;
        Coefficients[(4+i)*NStructRows+2]= -M;
        Coefficients[(4+i)*NStructRows+3]=  M;
        Coefficients[(4+i)*NStructRows+4]=  1.;
      }
//  Column variable  lambdam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i+NpointsInFit)*NStructRows+0]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+1]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+2]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+3]=  M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+4]=  1.;
      }
//  Column variable  sigmap(i)
      for(i=0; i< NpointsInFit ; i++) {

        Coefficients[(4+i+2*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+4]= -1.;
      }
//  Column variable  sigmam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+4]= -1.;
      }

//  Column variable  DUMMY
      for(i=0 ; i< NStructRows ; i++) {
        Coefficients[(4+4*NpointsInFit)*NStructRows+i]= 1.;
      }
//--------------------
      sprintf(&auxStructVarName[0][0],"m1");
      StructVarName[0] = &auxStructVarName[0][0];
      NRowsInWhichStructVarArePresent[0]= 4*NpointsInFit;

      sprintf(&auxStructVarName[1][0],"m2");
      StructVarName[1] = &auxStructVarName[1][0];
      NRowsInWhichStructVarArePresent[1]= 4*NpointsInFit;

      sprintf(&auxStructVarName[2][0],"q1");
      StructVarName[2] = &auxStructVarName[2][0];
      NRowsInWhichStructVarArePresent[2]= 4*NpointsInFit;

      sprintf(&auxStructVarName[3][0],"q2");
      StructVarName[3] = &auxStructVarName[3][0];
      NRowsInWhichStructVarArePresent[3]= 4*NpointsInFit;
      for(i=0; i< NpointsInFit ; i++) {
          sprintf(&auxStructVarName[4+i][0],"lamp%d",i);
          StructVarName[4+i] = &auxStructVarName[4+i][0];
          NRowsInWhichStructVarArePresent[4+i]= 5;

          sprintf(&auxStructVarName[4+NpointsInFit+i][0],"lamm%d",i);
          StructVarName[4+NpointsInFit+i] = &auxStructVarName[4+NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+2*NpointsInFit+i][0],"sigmap%d",i);
          StructVarName[4+2*NpointsInFit+i] = &auxStructVarName[4+2*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+2*NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+3*NpointsInFit+i][0],"sigmam%d",i);
          StructVarName[4+3*NpointsInFit+i] = &auxStructVarName[4+3*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+3*NpointsInFit+i]= 5;

      }
      sprintf(&auxStructVarName[4+4*NpointsInFit][0],"DUMMY");
      StructVarName[4+4*NpointsInFit] = &auxStructVarName[4+4*NpointsInFit][0];
      NRowsInWhichStructVarArePresent[4+4*NpointsInFit]= NStructRows;


//  for m1, m2, q1, q2
      for(i=0; i< 4; i++){
        for(ii=0; ii< NpointsInFit;ii++){
         sprintf(&aux[i*NStructRows+ii*4][0],"Ap%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4]=&aux[i*NStructRows+ii*4][0];
         sprintf(&aux[i*NStructRows+ii*4+1][0],"Am%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+1]=&aux[i*NStructRows+ii*4+1][0];
         sprintf(&aux[i*NStructRows+ii*4+2][0],"Bp%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+2]=&aux[i*NStructRows+ii*4+2][0];
         sprintf(&aux[i*NStructRows+ii*4+3][0],"Bm%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+3]=&aux[i*NStructRows+ii*4+3][0];
        }
      }

//  now for the    lamp*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4)*NStructRows+0][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+0]= &aux[(i+4)*NStructRows+0][0];
         sprintf(&aux[(i+4)*NStructRows+1][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+1]= &aux[(i+4)*NStructRows+1][0];
         sprintf(&aux[(i+4)*NStructRows+2][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+2]= &aux[(i+4)*NStructRows+2][0];
         sprintf(&aux[(i+4)*NStructRows+3][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+3]= &aux[(i+4)*NStructRows+3][0];
         sprintf(&aux[(i+4)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+4]= &aux[(i+4)*NStructRows+4][0];
      }

//  now for the    lamm*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+0][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+0]= &aux[(i+4+NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+1][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+1]= &aux[(i+4+NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+2][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+2]= &aux[(i+4+NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+3][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+3]= &aux[(i+4+NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+4]= &aux[(i+4+NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmap*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+0]= &aux[(i+4+2*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+1][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+1]= &aux[(i+4+2*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+2][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+2]= &aux[(i+4+2*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+3][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+3]= &aux[(i+4+2*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+4][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+4]= &aux[(i+4+2*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmam*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+0]= &aux[(i+4+3*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+1][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+1]= &aux[(i+4+3*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+2][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+2]= &aux[(i+4+3*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+3][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+3]= &aux[(i+4+3*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+4][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+4]= &aux[(i+4+3*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    DUMMY   variable
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows  +8*i][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+i*8  ]= &aux[(4+4*NpointsInFit)*NStructRows  +8*i][0];

         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+1+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+2+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+3+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+4+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+5+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+6+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+7+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0];
      }




//-----------------  write the RHS  section


      for(i=0 ; i< NpointsInFit ; i++) {
          ValueB[i*9]  =  Oy[i]+DriftRadius[ i ]+2.*M;
          ValueB[i*9+1]= -Oy[i]-DriftRadius[ i ]+2.*M;
          ValueB[i*9+2]= Delta[i]+2.*M;
          ValueB[i*9+3]= M-Delta[i]+2.*M;
          ValueB[i*9+4]=  Oy[i]-DriftRadius[ i ]+2.*M;
          ValueB[i*9+5]= -Oy[i]+DriftRadius[ i ]+2.*M;
          ValueB[i*9+6]= Delta[i]+2.*M;
          ValueB[i*9+7]= M-Delta[i]+2.*M;
          ValueB[i*9+8]= 1.;


      }




//-----------------  write the RANGES  section

      for(i=0 ; i< NpointsInFit ; i++) {
        ValueRanges[i]=1.;
        sprintf(&auxNameRanges[i][0],"LAMBDA%d",i);
        NameRanges[i]=&auxNameRanges[i][0];
      }


//-----------------  write the BOUNDS  section


      for(i=0 ; i< NpointsInFit ; i++) {
          sprintf(&auxTypeofBound[i][0],"BV");
          TypeofBound[i]=&auxTypeofBound[i][0];
          sprintf(&auxBoundStructVarName[i][0],"lamp%d",i);
          BoundStructVarName[i]=&auxBoundStructVarName[i][0];
          BoundValue[i]=0.;
      }

      for(i=0 ; i< NpointsInFit ; i++) {
          sprintf(&auxTypeofBound[i+NpointsInFit][0],"BV");
          TypeofBound[i+NpointsInFit]=&auxTypeofBound[i+NpointsInFit][0];
          sprintf(&auxBoundStructVarName[i+NpointsInFit][0],"lamm%d",i);
          BoundStructVarName[i+NpointsInFit]=&auxBoundStructVarName[i+NpointsInFit][0];
          BoundValue[i+NpointsInFit]=0.;
      }

          sprintf(&auxTypeofBound[2*NpointsInFit][0],"FX");
          TypeofBound[2*NpointsInFit]=&auxTypeofBound[2*NpointsInFit][0];


          sprintf(&auxBoundStructVarName[2*NpointsInFit][0],"DUMMY");
          BoundStructVarName[2*NpointsInFit]=&auxBoundStructVarName[2*NpointsInFit][0];
          BoundValue[2*NpointsInFit]=2.*M;




//-----






//----------------------  calling the minimizer


      int status= glp_main(
            nRows,nameRows,typeRows, //  ROWS info
            NStructVar, NStructRows, NRowsInWhichStructVarArePresent,  //  COLUMNS info
      StructVarName, NameRowsInWhichStructVarArePresent,  //  COLUMNS info
      Coefficients,  //  COLUMNS info
      ValueB,  // RHS  info
      nRanges, ValueRanges, NameRanges, //  RANGES  info
      nBounds, BoundValue, BoundStructVarName, TypeofBound //  BOUNDS info
      ,final_values
       );



//------------------------------------------

     m1_result=final_values[0];
     m2_result=final_values[1];
     q1_result=final_values[2];
     q2_result=final_values[3];


//------------------------  transformation of the result in terms of ALFA, BETA, GAMMA


     *qu = q1_result - q2_result;
     *emme = m1_result-m2_result ;



// taking into account the rotation that was performed and calculate emme and qu in the normal conformal plane

      if(fabs(cose-*emme*sine)> 1.e-10) {
        *qu=*qu/(cose-*emme*sine);
        *emme=(*emme*cose+sine)/(cose-*emme*sine);
        return 1;
      } else {    //  in this case the equation is   0 = x+*qu .
        if(fabs(sine+*emme*cose) < 1.e-10)  {
  cout<<" From PndSttFitSZspace, situation impossible in principle! Returning -1"
                    <<endl;
           return -1;
        }

        *emme=1.;
        *qu = *qu/(sine+*emme*cose);
        return 99;    //  in this case the equation is   0 = x+*qu .
      }





}













//----------end of function PndSttTrackFinderReal::PndSttFitSZspace












//----------begin of function PndSttTrackFinderReal::PndSttFitSZspacebis


     Short_t PndSttTrackFinderReal::PndSttFitSZspacebis(
                                                     UShort_t nSkewHitsinTrack,
                                                     Double_t *S,
                                                     Double_t *Z,
                                                     Double_t *DriftRadius,
                                                     Double_t FInot,
                                                     UShort_t NMAX,
                                                     Double_t *emme
                                                            )
{







    //   definition of variables for the glpsol  solver
   //    ROWS (for read_rows  function)
   //
   UShort_t  NpointsInFit = nSkewHitsinTrack-NMAX <0 ?  nSkewHitsinTrack :  NMAX;
   int    nRows= NpointsInFit*9 +1;
   int typeRows[nRows];
   char * nameRows[nRows];
   char  auxnameRows[nRows][20];
//-------  end ROWS information
//--------begin COLUMNS information
      int  NStructVar=5+NpointsInFit*4;  //  number of  structural variables
      int  NStructRows = 8*NpointsInFit ;  //  maximum number of ROWS in which a structural variable can be found
      double final_values[NStructVar];
      int  NRowsInWhichStructVarArePresent[NStructVar];
      char *StructVarName[NStructVar];
      char auxStructVarName[NStructVar][20];
      char *NameRowsInWhichStructVarArePresent[NStructVar*NStructRows];
      char aux[NStructVar*NStructRows][20];
//      double Coefficients[NStructVar][NStructRows];
      double Coefficients[NStructVar*NStructRows];
//--------end COLUMNS information
//--------begin RHS information
      double ValueB[9*NpointsInFit];
//--------end RHS information
//--------begin RANGES information
      int nRanges = NpointsInFit;
      double ValueRanges[nRanges];
      char *NameRanges[nRanges];
      char auxNameRanges[nRanges][20];
//--------end RANGES information
//--------start BOUNDS information
      int nBounds=2*NpointsInFit+3;
//      int nBounds=2*NpointsInFit+1;
      double BoundValue[nBounds];
      char *BoundStructVarName[nBounds];
      char auxBoundStructVarName[nBounds][20];
      char *TypeofBound[nBounds];
      char auxTypeofBound[nBounds][20];
//--------end BOUNDS information


//----------------------------------------------------







     Double_t M = 50.,
              m_result,
              q_result,
              A,
              alfetta,
              angle,
              offsety,
              Ox[nmaxHits],
              Oy[nmaxHits],
              Delta[nmaxHits];

     UShort_t  i, ii;
     Short_t Status;

     char nome[300], stringa[300], stringa2[300];

//     FILE * MACRO ;

     float m1_result,m2_result, q1_result,q2_result, A1_result, A2_result;

// --



//  use the trick of increasing the rotation angle by 10 degrees in order to obtain always a positive m
//      rotationangle -= PI/18.;

      for(i=0;i<nSkewHitsinTrack; i++){


       Ox[i] = S[ i ] - FInot;
       Oy[i] = -Z[ i ];

         Delta[i] = 3.*StrawRadius;   //  StrawRadius now is 0.5 cm

      }

//-----------------  write the ROWS  section

//--------
      sprintf(&auxnameRows[0][0],"OBJECT");
      nameRows[0]=&auxnameRows[0][0];
      typeRows[0]=GLP_FR;
      for(i=0 ; i< NpointsInFit ; i++) {
       ii=9*i;
       typeRows[1+ii]=GLP_UP;typeRows[2+ii]=GLP_UP;typeRows[3+ii]=GLP_UP;typeRows[4+ii]=GLP_UP;
       typeRows[5+ii]=GLP_UP;typeRows[6+ii]=GLP_UP;typeRows[7+ii]=GLP_UP;typeRows[8+ii]=GLP_UP;
       typeRows[9+ii]=GLP_LO;

       sprintf(&(auxnameRows[1+ii][0]),"Ap%d",i);  nameRows[1+ii]=&auxnameRows[1+ii][0];
       sprintf(&(auxnameRows[2+ii][0]),"Bp%d",i);  nameRows[2+ii]=&auxnameRows[2+ii][0];
       sprintf(&(auxnameRows[3+ii][0]),"Cp%d",i);  nameRows[3+ii]=&auxnameRows[3+ii][0];
       sprintf(&(auxnameRows[4+ii][0]),"Dp%d",i);  nameRows[4+ii]=&auxnameRows[4+ii][0];
       sprintf(&(auxnameRows[5+ii][0]),"Am%d",i);  nameRows[5+ii]=&auxnameRows[5+ii][0];
       sprintf(&(auxnameRows[6+ii][0]),"Bm%d",i);  nameRows[6+ii]=&auxnameRows[6+ii][0];
       sprintf(&(auxnameRows[7+ii][0]),"Cm%d",i);  nameRows[7+ii]=&auxnameRows[7+ii][0];
       sprintf(&(auxnameRows[8+ii][0]),"Dm%d",i);  nameRows[8+ii]=&auxnameRows[8+ii][0];
       sprintf(&(auxnameRows[9+ii][0]),"LAMBDA%d",i);  nameRows[9+ii]=&auxnameRows[9+ii][0];
      }





//-----------------  write the COLUMNS  section


//  Column variable  m1
      for(i=0, ii=0 ; i< NpointsInFit ; i++) {
       ii++;
        Coefficients[i*4]=    Ox[i];
        Coefficients[i*4+1]=  Ox[i];
        Coefficients[i*4+2]= -Ox[i];
        Coefficients[i*4+3]= -Ox[i];
      }

//  Column variable  m2
      for(i=0; i< NpointsInFit ; i++) {
        Coefficients[NStructRows+i*4]=   -Ox[i];
        Coefficients[NStructRows+i*4+1]= -Ox[i];
        Coefficients[NStructRows+i*4+2]= Ox[i];
        Coefficients[NStructRows+i*4+3]= Ox[i];

      }

//  Column variable  q1
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[2*NStructRows+i*4]=    1.;
        Coefficients[2*NStructRows+i*4+1]=  1.;
        Coefficients[2*NStructRows+i*4+2]= -1.;
        Coefficients[2*NStructRows+i*4+3]= -1.;
      }

//  Column variable  q2
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[3*NStructRows+i*4]=   -1.;
        Coefficients[3*NStructRows+i*4+1]= -1.;
        Coefficients[3*NStructRows+i*4+2]=  1.;
        Coefficients[3*NStructRows+i*4+3]=  1.;
      }

//  Column variable  lambdap(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i)*NStructRows+0]= -M;
        Coefficients[(4+i)*NStructRows+1]= -M;
        Coefficients[(4+i)*NStructRows+2]= -M;
        Coefficients[(4+i)*NStructRows+3]=  M;
        Coefficients[(4+i)*NStructRows+4]=  1.;
      }
//  Column variable  lambdam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i+NpointsInFit)*NStructRows+0]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+1]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+2]= -M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+3]=  M;
        Coefficients[(4+i+NpointsInFit)*NStructRows+4]=  1.;
      }
//  Column variable  sigmap(i)
      for(i=0; i< NpointsInFit ; i++) {

        Coefficients[(4+i+2*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+2*NpointsInFit)*NStructRows+4]= -1.;
      }
//  Column variable  sigmam(i)
      for(i=0 ; i< NpointsInFit ; i++) {
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+0]=  1./Delta[i];
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+1]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+2]= -1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+3]=  1.;
        Coefficients[(4+i+3*NpointsInFit)*NStructRows+4]= -1.;
      }

//  Column variable  DUMMY
      for(i=0 ; i< NStructRows ; i++) {
        Coefficients[(4+4*NpointsInFit)*NStructRows+i]= 1.;
      }
//--------------------
      sprintf(&auxStructVarName[0][0],"m1");
      StructVarName[0] = &auxStructVarName[0][0];
      NRowsInWhichStructVarArePresent[0]= 4*NpointsInFit;

      sprintf(&auxStructVarName[1][0],"m2");
      StructVarName[1] = &auxStructVarName[1][0];
      NRowsInWhichStructVarArePresent[1]= 4*NpointsInFit;

      sprintf(&auxStructVarName[2][0],"q1");
      StructVarName[2] = &auxStructVarName[2][0];
      NRowsInWhichStructVarArePresent[2]= 4*NpointsInFit;

      sprintf(&auxStructVarName[3][0],"q2");
      StructVarName[3] = &auxStructVarName[3][0];
      NRowsInWhichStructVarArePresent[3]= 4*NpointsInFit;
      for(i=0; i< NpointsInFit ; i++) {
          sprintf(&auxStructVarName[3+i+1][0],"lamp%d",i);
          StructVarName[4+i] = &auxStructVarName[4+i][0];
          NRowsInWhichStructVarArePresent[4+i]= 5;

          sprintf(&auxStructVarName[4+NpointsInFit+i][0],"lamm%d",i);
          StructVarName[4+NpointsInFit+i] = &auxStructVarName[4+NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+2*NpointsInFit+i][0],"sigmap%d",i);
          StructVarName[4+2*NpointsInFit+i] = &auxStructVarName[4+2*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+2*NpointsInFit+i]= 5;

          sprintf(&auxStructVarName[4+3*NpointsInFit+i][0],"sigmam%d",i);
          StructVarName[4+3*NpointsInFit+i] = &auxStructVarName[4+3*NpointsInFit+i][0];
          NRowsInWhichStructVarArePresent[4+3*NpointsInFit+i]= 5;

      }
      sprintf(&auxStructVarName[4+4*NpointsInFit][0],"DUMMY");
      StructVarName[4+4*NpointsInFit] = &auxStructVarName[4+4*NpointsInFit][0];
      NRowsInWhichStructVarArePresent[4+4*NpointsInFit]= NStructRows;


//  for m1, m2, q1, q2
      for(i=0; i< 4; i++){
        for(ii=0; ii< NpointsInFit;ii++){
         sprintf(&aux[i*NStructRows+ii*4][0],"Ap%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4]=&aux[i*NStructRows+ii*4][0];
         sprintf(&aux[i*NStructRows+ii*4+1][0],"Am%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+1]=&aux[i*NStructRows+ii*4+1][0];
         sprintf(&aux[i*NStructRows+ii*4+2][0],"Bp%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+2]=&aux[i*NStructRows+ii*4+2][0];
         sprintf(&aux[i*NStructRows+ii*4+3][0],"Bm%d",ii);
         NameRowsInWhichStructVarArePresent[i*NStructRows+ii*4+3]=&aux[i*NStructRows+ii*4+3][0];
        }
      }

//  now for the    lamp*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4)*NStructRows+0][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+0]= &aux[(i+4)*NStructRows+0][0];
         sprintf(&aux[(i+4)*NStructRows+1][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+1]= &aux[(i+4)*NStructRows+1][0];
         sprintf(&aux[(i+4)*NStructRows+2][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+2]= &aux[(i+4)*NStructRows+2][0];
         sprintf(&aux[(i+4)*NStructRows+3][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+3]= &aux[(i+4)*NStructRows+3][0];
         sprintf(&aux[(i+4)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4)*NStructRows+4]= &aux[(i+4)*NStructRows+4][0];
      }

//  now for the    lamm*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+0][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+0]= &aux[(i+4+NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+1][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+1]= &aux[(i+4+NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+2][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+2]= &aux[(i+4+NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+3][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+3]= &aux[(i+4+NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+NpointsInFit)*NStructRows+4][0],"LAMBDA%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+NpointsInFit)*NStructRows+4]= &aux[(i+4+NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmap*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+0]= &aux[(i+4+2*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+1][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+1]= &aux[(i+4+2*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+2][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+2]= &aux[(i+4+2*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+3][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+3]= &aux[(i+4+2*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+2*NpointsInFit)*NStructRows+4][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+2*NpointsInFit)*NStructRows+4]= &aux[(i+4+2*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    sigmam*   variables
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+0][0],"OBJECT",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+0]= &aux[(i+4+3*NpointsInFit)*NStructRows+0][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+1][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+1]= &aux[(i+4+3*NpointsInFit)*NStructRows+1][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+2][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+2]= &aux[(i+4+3*NpointsInFit)*NStructRows+2][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+3][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+3]= &aux[(i+4+3*NpointsInFit)*NStructRows+3][0];
         sprintf(&aux[(i+4+3*NpointsInFit)*NStructRows+4][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(i+4+3*NpointsInFit)*NStructRows+4]= &aux[(i+4+3*NpointsInFit)*NStructRows+4][0];
      }

//  now for the    DUMMY   variable
      for(i=0; i< NpointsInFit;i++){
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows  +8*i][0],"Ap%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+i*8  ]= &aux[(4+4*NpointsInFit)*NStructRows  +8*i][0];

         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0],"Am%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+1+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+1+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0],"Bp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+2+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+2+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0],"Bm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+3+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+3+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0],"Cp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+4+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+4+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0],"Cm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+5+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+5+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0],"Dp%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+6+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+6+8*i][0];
         sprintf(&aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0],"Dm%d",i);
         NameRowsInWhichStructVarArePresent[(4+4*NpointsInFit)*NStructRows+7+8*i]= &aux[(4+4*NpointsInFit)*NStructRows+7+8*i][0];
      }

//-----------------  write the RHS  section

      for(i=0 ; i< NpointsInFit ; i++) {
          ValueB[i*9]  =  Oy[i]+DriftRadius[ i ]+2.*M;
          ValueB[i*9+1]= -Oy[i]-DriftRadius[ i ]+2.*M;
          ValueB[i*9+2]= Delta[i]+2.*M;
          ValueB[i*9+3]= M-Delta[i]+2.*M;
          ValueB[i*9+4]=  Oy[i]-DriftRadius[ i ]+2.*M;
          ValueB[i*9+5]= -Oy[i]+DriftRadius[ i ]+2.*M;
          ValueB[i*9+6]= Delta[i]+2.*M;
          ValueB[i*9+7]= M-Delta[i]+2.*M;
          ValueB[i*9+8]= 1.;


      }


//-----------------  write the RANGES  section

      for(i=0 ; i< NpointsInFit ; i++) {
        ValueRanges[i]=1.;
        sprintf(&auxNameRanges[i][0],"LAMBDA%d",i);
        NameRanges[i]=&auxNameRanges[i][0];
      }

//-----------------  write the BOUNDS  section


      for(i=0 ; i< NpointsInFit ; i++) {
          sprintf(&auxTypeofBound[i][0],"BV");
          TypeofBound[i]=&auxTypeofBound[i][0];
          sprintf(&auxBoundStructVarName[i][0],"lamp%d",i);
          BoundStructVarName[i]=&auxBoundStructVarName[i][0];
          BoundValue[i]=0.;
      }

      for(i=0 ; i< NpointsInFit ; i++) {
          sprintf(&auxTypeofBound[i+NpointsInFit][0],"BV");
          TypeofBound[i+NpointsInFit]=&auxTypeofBound[i+NpointsInFit][0];
          sprintf(&auxBoundStructVarName[i+NpointsInFit][0],"lamm%d",i);
          BoundStructVarName[i+NpointsInFit]=&auxBoundStructVarName[i+NpointsInFit][0];
          BoundValue[i+NpointsInFit]=0.;
      }

          sprintf(&auxTypeofBound[2*NpointsInFit][0],"FX");
          TypeofBound[2*NpointsInFit]=&auxTypeofBound[2*NpointsInFit][0];
          sprintf(&auxBoundStructVarName[2*NpointsInFit][0],"DUMMY");
          BoundStructVarName[2*NpointsInFit]=&auxBoundStructVarName[2*NpointsInFit][0];
          BoundValue[2*NpointsInFit]=2.*M;



//   fixing q1
          sprintf(&auxTypeofBound[2*NpointsInFit+1][0],"FX");
          TypeofBound[2*NpointsInFit+1]=&auxTypeofBound[2*NpointsInFit+1][0];
          sprintf(&auxBoundStructVarName[2*NpointsInFit+1][0],"q1");
          BoundStructVarName[2*NpointsInFit+1]=&auxBoundStructVarName[2*NpointsInFit+1][0];
          BoundValue[2*NpointsInFit+1]= 0.;
//   fixing q2
          sprintf(&auxTypeofBound[2*NpointsInFit+2][0],"FX");
          TypeofBound[2*NpointsInFit+2]=&auxTypeofBound[2*NpointsInFit+2][0];
          sprintf(&auxBoundStructVarName[2*NpointsInFit+2][0],"q2");
          BoundStructVarName[2*NpointsInFit+2]=&auxBoundStructVarName[2*NpointsInFit+2][0];
          BoundValue[2*NpointsInFit+2]= 0.;

//-----






//----------------------  calling the minimizer


      int status= glp_main(
            nRows,nameRows,typeRows, //  ROWS info
            NStructVar, NStructRows, NRowsInWhichStructVarArePresent,  //  COLUMNS info
      StructVarName, NameRowsInWhichStructVarArePresent,  //  COLUMNS info
      Coefficients,  //  COLUMNS info
      ValueB,  // RHS  info
      nRanges, ValueRanges, NameRanges, //  RANGES  info
      nBounds, BoundValue, BoundStructVarName, TypeofBound //  BOUNDS info
      ,final_values
       );



//------------------------------------------

     m1_result=final_values[0];
     m2_result=final_values[1];
//     q1_result=final_values[2];
//     q2_result=final_values[3];

//------------------------  transformation of the result in terms of ALFA, BETA, GAMMA





// taking into account the rotation + traslation that was performed and calculate emme and qu

     *emme = m1_result-m2_result ;
//     *qu = FInot;

      if(fabs( (*emme)  )> 1.e-10) {
        *emme=-1./(*emme);
        return 1;
      } else {    //  in this case the equation is   0 = x+*qu .

        return -99;
      }





}



//----------end of function PndSttTrackFinderReal::PndSttFitSZspacebis






































//----------begin of function PndSttTrackFinderReal::PndSttFitwithKalman

/*
      void   PndSttTrackFinderReal::PndSttFitwithKalman(
                                                     Double_t oX,
                                                     Double_t oY,
                                                     Double_t Pxini,
                                                     Double_t Pyini,
                                                     Double_t Pzini,
                                                     Double_t Ptras,
                                                     Double_t info[][7],
                                                     UShort_t nParallelHits,
                                                     UShort_t *ListParallelHits,
                                                     UShort_t nSkewHits,
                                                     UShort_t *ListSkewHits,
                                                     Double_t *S,
                                                     UShort_t *Infoparal,
                                                     UShort_t *Infoskew
                                                       )
{


      UShort_t i,j,flag,
               nTotal = nParallelHits+nSkewHits,
               BigList[nTotal];
      Double_t old,
               auxFivalues[nmaxHits],
               auxFiSkewvalues[nmaxHits],
               auxRvalues[nmaxHits],
               BigListFi[nTotal];



//  here there is the ordering of the hits

//   ordering of the parallel hits first

    for (j = 0; j< nParallelHits; j++){
      auxRvalues[j]=
                    info[ infoparal[ ListParallelHits[j] ]  ][0]*
                    info[ infoparal[ ListParallelHits[j] ]  ][0]+
                    info[ infoparal[ ListParallelHits[j] ]  ][1]*
                    info[ infoparal[ ListParallelHits[j] ]  ][1];
    }

    PndStt_Merge_Sort( nParallelHits, auxRvalues, ListParallelHits);

    for (j = 0; j< nParallelHits; j++){              
      auxFivalues[j] = atan2( info[ infoparal[ ListParallelHits[j] ]  ][1]-oY,
                              info[ infoparal[ ListParallelHits[j] ]  ][0]-oX);
      if( auxFivalues[j] < 0. ) auxFivalues[j] += 2.*PI;
    }

//  fixing possible discontinuity between fi<2*PI and fi>0.
   for (old=auxFivalues[0],flag=0, j = 1; j< nParallelHits; j++){
      if( fabs(old - auxFivalues[j]) > PI ) {
        flag=1;
        break;
      } else {
        old=auxFivalues[j];
      }
   }
   if( flag==1) {
      for (j = 0; j< nParallelHits; j++){
        if( auxFivalues[j] < PI) auxFivalues[j] += 2.*PI;
      }
   }
//     now ordering of the skew hits

   if( flag==1) {
      for (j = 0; j< nSkewHits; j++){
       if( S[j] < PI) {
            auxFiSkewvalues[j] = S[j] + 2.*PI;
       } else {
            auxFiSkewvalues[j] = S[j];
       }
      }
   } else {
      for (j = 0; j< nSkewHits; j++){
       auxFiSkewvalues[j] = S[j];
      }
   }
 
    PndStt_Merge_Sort( nSkewHits, auxFiSkewvalues, ListSkewHits);
//    merge the parallel and skew hits
     for(j = 0;j< nParallelHits; j++){
       BigListFi[j]=auxFivalues[j];
       BigList [j] = Infoparal[  ListParallelHits[i]  ] ;        
     }
      for(j=0; j<nSkewHits; j++){
       BigListFi[j]=auxFiSkewvalues[j+nParallelHits];
       BigList [i+nParallelHits] = Infoskew[  ListSkewHits[i]  ] ;
      }

    PndStt_Merge_Sort(nTotal, BigListFi, BigList);

//  now decide if track ran clockwise or anticlockwise


    if( auxFivalues[0] > auxFivalues[nParallelHits]) {
      for(j=0; j<nTotal; j++){
       auxFivalues[j]=BigListFi[nTotal-1-j];
      }
      for(j=0; j<nTotal; j++){
       BigListFi[j]=auxFivalues[j];
      }
    }



//---------   end ordering




      PndSttTrack*      track = NULL;

      // STARTING VERTEX ERRORS
//      TVector3 StartPos    = *recovtx;
      TVector3 StartPos    = TVector3(0.,0.,0.);
      Double_t pterr, plerr;
      Double_t errxp, erryp, errzp;
      errxp = 10 * 0.02;                      // 200 micron * 10
      erryp = errxp;
      errzp = 10 * 0.15;                      // 1.5 mm     * 10
      TVector3 StartPosErr = TVector3(errxp, erryp, errzp);
      TVector3 StartMom    = TVector3(Pxini,Pyini,Pzini);
//      TVector3 mcStartMom = mctrack->GetMomentum();
      Double_t momerr;                        // = 4% of mc mom 
//      momerr = 0.04 *  mcStartMom.Mag();
      momerr = 0.04 *  Ptras;
      pterr = momerr;
      plerr = momerr;
      TVector3 StartMomErr = TVector3(pterr, pterr, plerr); 

//      Int_t pdg = mctrack->GetPdgCode();
      Int_t pdg = 13;

      TDatabasePDG *fdbPDG= TDatabasePDG::Instance();
      TParticlePDG *fParticle= fdbPDG->GetParticle(pdg);
      Double_t  fCharge= fParticle->Charge()/3.;
      
      TVector3 u(0.,1.,0.);
      TVector3 v(0.,0.,1.);
      GFDetPlane pl(StartPos,u,v);

      GFAbsTrackRep* rep = 0;
      GeaneTrackRep *grep = new GeaneTrackRep(fPro,pl,StartMom,StartPosErr,StartMomErr,fCharge,pdg);
      grep->setPropDir(1); // propagate in flight direction!
      rep=grep;

      GFTrack* trk = new GFTrack(rep);
      GFTrackCand *cand = new GFTrackCand();
      int detId;
      for(int iPoint = 0; iPoint < nTotal; iPoint++)
 	{

          PndSttHit * currenthit = (PndSttHit*) GetHitFromCollections(BigList[iPoint]);
	  if(!currenthit) continue;
	  

  
	  detId = currenthit->GetDetectorID() ;

	  cand->addHit(detId, BigList[iPoint]);

      	}   //  end of       for(int iPoint = 0; iPoint < nTotal; iPoint++)



       trk->setCandidate(*cand); // here the candidate is copied! 

//----  now the Kalman
	trk->addHitVector(_theRecoHitFactory->createMany(trk->getCand()));
	GFKalman k;
        k.setLazy(1);
	k.setNumIterations(1);
	k.processTrack(trk);
//------ estrazione delle info dal Kalman secondo Lia
    TVector3 dum = trk->getCardinalRep()->getMom();
//------------
 
    delete grep;
    delete trk;
    delete cand;

 return; 

}


*/


//----------end of function PndSttTrackFinderReal::PndSttFitwithKalman








//----------begin of function PndSttTrackFinderReal::PndSttOrderingParallel

      void   PndSttTrackFinderReal::PndSttOrderingParallel(
                                                     Double_t oX,
                                                     Double_t oY,
                                                     Double_t info[][7],
                                                     UShort_t nParallelHits,
                                                     UShort_t *ListParallelHits,
                                                     UShort_t *Infoparal,
                                                     Short_t  * Charge,
                                                     Double_t *Fi_initial_helix_referenceframe,
                                                     Double_t *Fi_final_helix_referenceframe
                                                       )
{


      UShort_t i,j,flag;
      Double_t old,
               auxFivalues[nmaxHits],
               auxRvalues[nmaxHits];



//  here there is the ordering of the hits

//   ordering of the parallel hits

    for (j = 0; j< nParallelHits; j++){
      auxRvalues[j]=
                    info[ infoparal[ ListParallelHits[j] ]  ][0]*
                    info[ infoparal[ ListParallelHits[j] ]  ][0]+
                    info[ infoparal[ ListParallelHits[j] ]  ][1]*
                    info[ infoparal[ ListParallelHits[j] ]  ][1];
    }

    PndStt_Merge_Sort( nParallelHits, auxRvalues, ListParallelHits);

    for (j = 0; j< nParallelHits; j++){              
      auxFivalues[j] = atan2( info[ infoparal[ ListParallelHits[j] ]  ][1]-oY,
                              info[ infoparal[ ListParallelHits[j] ]  ][0]-oX);
      if( auxFivalues[j] < 0. ) auxFivalues[j] += 2.*PI;
    }

//  fixing possible discontinuity between fi<2*PI and fi>0.
   for (old=auxFivalues[0],flag=0, j = 1; j< nParallelHits; j++){
      if( fabs(old - auxFivalues[j]) > PI ) {
        flag=1;
        break;
      } else {
        old=auxFivalues[j];
      }
   }
   if( flag==1) {
      for (j = 0; j< nParallelHits; j++){
        if( auxFivalues[j] < PI) auxFivalues[j] += 2.*PI;
      }
   }

//   finding the charge of the track

    if( auxFivalues[0] > auxFivalues[nParallelHits-1]) {
      *Charge =  1;
    }  else {
     *Charge =  -1;
    }



//  FI initial value (at 0,0  vertex) in the Helix reference frame

      *Fi_initial_helix_referenceframe = atan2(oY,oX) + PI;  //  this is in order to be coherent
                                                             //  with the calculatation of Fi, which is atan2(oY,oX). 
                                                             //  atan2  is defined in [-PI,PI)
      if ( *Fi_initial_helix_referenceframe <0.) *Fi_initial_helix_referenceframe += 2.*PI;

//  FI of the last parallel hit in the Helix reference frame

      *Fi_final_helix_referenceframe = auxFivalues[nParallelHits-1];

 return; 

}
//----------end of function PndSttTrackFinderReal::PndSttOrderingParallel











//----------begin of function PndSttTrackFinderReal::PndSttOrdering

      void   PndSttTrackFinderReal::PndSttOrdering(
                                                     Double_t oX,
                                                     Double_t oY,
                                                     Double_t info[][7],
                                                     UShort_t nParallelHits,
                                                     UShort_t *ListParallelHits,
                                                     UShort_t nSkewHits,
                                                     UShort_t *ListSkewHits,
                                                     Double_t *S,
                                                     UShort_t *Infoparal,
                                                     UShort_t *Infoskew,
                                                     UShort_t *nTotal,
                                                     UShort_t *BigList,
                                                     Short_t  * Charge
                                                       )
{

      *nTotal = nParallelHits+nSkewHits;

      UShort_t i,j,flag,
               aux[*nTotal];
      Double_t old,
               auxFivalues[nmaxHits],
               auxFiSkewvalues[nmaxHits],
               auxRvalues[nmaxHits],
               BigListFi[*nTotal];



//  here there is the ordering of the hits

//   ordering of the parallel hits first

    for (j = 0; j< nParallelHits; j++){
      auxRvalues[j]=
                    info[ infoparal[ ListParallelHits[j] ]  ][0]*
                    info[ infoparal[ ListParallelHits[j] ]  ][0]+
                    info[ infoparal[ ListParallelHits[j] ]  ][1]*
                    info[ infoparal[ ListParallelHits[j] ]  ][1];
    }

    PndStt_Merge_Sort( nParallelHits, auxRvalues, ListParallelHits);

    for (j = 0; j< nParallelHits; j++){              
      auxFivalues[j] = atan2( info[ infoparal[ ListParallelHits[j] ]  ][1]-oY,
                              info[ infoparal[ ListParallelHits[j] ]  ][0]-oX);
      if( auxFivalues[j] < 0. ) auxFivalues[j] += 2.*PI;
    }

//  fixing possible discontinuity between fi<2*PI and fi>0.
   for (old=auxFivalues[0],flag=0, j = 1; j< nParallelHits; j++){
      if( fabs(old - auxFivalues[j]) > PI ) {
        flag=1;
        break;
      } else {
        old=auxFivalues[j];
      }
   }
   if( flag==1) {
      for (j = 0; j< nParallelHits; j++){
        if( auxFivalues[j] < PI) auxFivalues[j] += 2.*PI;
      }
   }

//   finding the charge of the track

    if( auxFivalues[0] > auxFivalues[nParallelHits-1]) {
      *Charge =  1;
    }  else {
     *Charge =  -1;
    }




//     now ordering of the skew hits

   if( flag==1) {
      for (j = 0; j< nSkewHits; j++){
       if( S[j] < PI) {
            auxFiSkewvalues[j] = S[j] + 2.*PI;
       } else {
            auxFiSkewvalues[j] = S[j];
       }
      }
   } else {
      for (j = 0; j< nSkewHits; j++){
       auxFiSkewvalues[j] = S[j];
      }
   }
 
    PndStt_Merge_Sort( nSkewHits, auxFiSkewvalues, ListSkewHits);

//    merge the parallel and skew hits
     for(j = 0;j< nParallelHits; j++){
       BigListFi[j]=auxFivalues[j];
       BigList[j] = Infoparal[  ListParallelHits[j]  ] ;        
// cout<<"from Ordering, Parallel; j= "<<j<<", n. Hit // in original numbering = "<<BigList[j]<<endl;
     }
      for(j=0; j<nSkewHits; j++){
       BigListFi[j+nParallelHits]=auxFiSkewvalues[j];
       BigList [j+nParallelHits] = Infoskew[  ListSkewHits[j]  ] ;
// cout<<"from Ordering, Skew; j= "<<j<<", n. Hit skew in original numbering = "<<BigList[j+nParallelHits]<<endl;
      }

    PndStt_Merge_Sort(*nTotal, BigListFi, BigList);






// for POSITIVE charged tracks, the ordering based on the Fi angle must be reversed because hits at smaller
// distance from center have geatest Fi

     if(*Charge ==1) {
      for(j=0; j<*nTotal; j++){
       auxFivalues[j]=BigListFi[(*nTotal)-1-j];
       aux[j]=BigList[(*nTotal)-1-j];
      }
      for(j=0; j<*nTotal; j++){
       BigListFi[j]=auxFivalues[j];
       BigList[j]=aux[j];
      }
     }


/*
    cout<<"Printout di prova, dopo ordinamento globale, carica traccia = "<<*Charge<<endl;
    for(j=0; j<*nTotal; j++){
cout<<"    j= "<<j<<", n. Hit in original numbering = "<<BigList[j]<<" e suo FI "<<BigListFi[j]<<endl;
    }
*/

//--------------






//---------   end ordering



 return; 

}
//----------end of function PndSttTrackFinderReal::PndSttOrdering







//----------start  function PndSttTrackFinderReal::PndSttFindingParallelTrackAngularRange

      void   PndSttTrackFinderReal::PndSttFindingParallelTrackAngularRange(
                                                     Double_t oX,
                                                     Double_t oY,
                                                     Double_t R,
                                                     Short_t  Charge,
                                                     Double_t *Fi_low_limit,
                                                     Double_t *Fi_up_limit                                                      )
{
// -------------- calculate the maximum fi and minimum fi spanned by this track, vedere logbook pag.243.

//  working in the hypothesis that the starting point of the track is near (0,0) so that
//  R_vertex < RStrawDetectorMin


         Double_t  teta1, teta2, tetavertex, tmp1;


         tmp1 = sqrt(oX*oX+oY*oY);

         if(R + tmp1 - RStrawDetectorMax >= 0. ){     //     this is the most common case

            if( Charge < 0.){
               teta1=asin(0.5*RStrawDetectorMin/R);
               teta2=asin(0.5*RStrawDetectorMax/R);
               tetavertex=atan2( -oX, oY);
               teta1 +=tetavertex;
               teta2 +=tetavertex;
            } else {
               teta2=asin(0.5*RStrawDetectorMin/R);
               teta1=asin(0.5*RStrawDetectorMax/R);
               tetavertex=atan2( oX, -oY);
               teta1 = tetavertex - teta1;
               teta2 = tetavertex - teta2;
            }




         } else if ( R + tmp1 > RStrawDetectorMin  ){


            if( Charge < 0.){
               teta1=asin(0.5*RStrawDetectorMin/R);
               teta2= PI - teta1;
               tetavertex=atan2( -oX, oY);
               teta1 +=tetavertex;
               teta2 +=tetavertex;
            } else {
               teta2=asin(0.5*RStrawDetectorMin/R);
               teta1= PI - teta2;
               tetavertex=atan2( oX, -oY);
               teta1 = tetavertex - teta1;
               teta2 = tetavertex - teta2;
            }


         } else {            //  case when the trajectory is too small
               teta1=-99999.;
            
         }   //  end of          if(R + tmp1 - RStrawDetectorMax >= 0. )



         if(teta1>-99998) {

//  add safety margin
           teta1 -= 2.*StrawRadius/RStrawDetectorMin;
           teta2 += 2.*StrawRadius/RStrawDetectorMin;
           if(teta1<0.) {
             teta1 += 2.*PI;
             teta2 += 2.*PI;
           }
//-------

           if(teta1 > 2.*PI) {
             teta1=fmod(teta1,2.*PI);
             teta2=fmod(teta2,2.*PI);
           }
           *Fi_low_limit=teta1;
           *Fi_up_limit=teta2;

         }  //  end of  if(teta1>-99998)


//------------  end calculation the maximum fi and minimum fi spanned by this track



      return;
}


//---------- end of  function PndSttTrackFinderReal::PndSttFindingParallelTrackAngularRange




//----------start  function PndSttTrackFinderReal::PndSttFindingAllowedAngularRangeforSkew

      void   PndSttTrackFinderReal::PndSttFindingAllowedAngularRangeforSkew(
                                                     Double_t oX,
                                                     Double_t oY,
                                                     Double_t R,
                                                     Short_t  Charge,
                                                     Double_t *Fi_allowedforskew_low,
                                                     Double_t *Fi_allowedforskew_up
                                                       )
{

      UShort_t i,
               index,
               is;
      Double_t 
               alpha,
               beta,
               delta,
               fi_vertex,
               c1,
               c2,
               maximum,
               maximum2,
               minimum,
               minimum2,
               x1,
               x2,
               y,
               fi[12],
               a[] = { 0., -sqrt(3.), sqrt(3.) , 0. , -sqrt(3.), sqrt(3.) } ,
               b[] = { 1.,       2. ,      -2.,  -1.,   -2. ,    2.  },
               Erre[] = {RminStrawSkewArea, RmaxStrawSkewArea },  //  this is the distance from (0,0) of the side delimiting the Skew area
               exhagon_side_xlow[6][2] ,
               exhagon_side_xup[6][2]
                 ;


// cout<<"    Rmin = "<<RminStrawSkewArea<<", Rmx "<<RmaxStrawSkewArea<<endl;
// cout<<"    oX = "<<oX<<", oY "<<oY<<endl;


     alpha = -2.*oX ,  beta = -2.*oY;

     index=0;


//  do the assign in the dumb way in the hope of saving cpu cycles
     exhagon_side_xlow[0][0] = -Erre[0]/sqrt(3.);
     exhagon_side_xlow[1][0] =  Erre[0]/sqrt(3.);
     exhagon_side_xlow[2][0] =  Erre[0]/sqrt(3.);
     exhagon_side_xlow[3][0] =  -Erre[0]/sqrt(3.);
     exhagon_side_xlow[4][0] =  -2.*Erre[0]/sqrt(3.);
     exhagon_side_xlow[5][0] =  -2.*Erre[0]/sqrt(3.);
     exhagon_side_xup[0][0] = Erre[0]/sqrt(3.);
     exhagon_side_xup[1][0] = 2.*Erre[0]/sqrt(3.);
     exhagon_side_xup[2][0] = 2.*Erre[0]/sqrt(3.);
     exhagon_side_xup[3][0] = Erre[0]/sqrt(3.);
     exhagon_side_xup[4][0] = -Erre[0]/sqrt(3.);
     exhagon_side_xup[5][0] = -Erre[0]/sqrt(3.);


     exhagon_side_xlow[0][1] = -Erre[1]/sqrt(3.);
     exhagon_side_xlow[1][1] =  Erre[1]/sqrt(3.);
     exhagon_side_xlow[2][1] =  Erre[1]/sqrt(3.);
     exhagon_side_xlow[3][1] =  -Erre[1]/sqrt(3.);
     exhagon_side_xlow[4][1] =  -2.*Erre[1]/sqrt(3.);
     exhagon_side_xlow[5][1] =  -2.*Erre[1]/sqrt(3.);
     exhagon_side_xup[0][1] = Erre[1]/sqrt(3.);
     exhagon_side_xup[1][1] = 2.*Erre[1]/sqrt(3.);
     exhagon_side_xup[2][1] = 2.*Erre[1]/sqrt(3.);
     exhagon_side_xup[3][1] = Erre[1]/sqrt(3.);
     exhagon_side_xup[4][1] = -Erre[1]/sqrt(3.);
     exhagon_side_xup[5][1] = -Erre[1]/sqrt(3.);

//-----------------------

//   find intersection with the 6 sides of the smalle exhagon delimiting the skew straws zone
//   see on page 249-250 of Gianluigi's logbook.

     for(is=0; is<6; is++){
         c2 = 1.+a[is]*a[is];
         if( fabs(a[is]*oX-oY+ b[is]*Erre[0])/sqrt(c2) >= R) continue;   // skew hits not possible.
       for(i=0;i<2;i++){
         c1 = alpha+ 2.*a[is]*b[is]*Erre[i]+ a[is]*beta;
         delta = c1*c1 - 4.*c2*b[is]*Erre[i]*(b[is]*Erre[i]+beta);
         if(delta<0.) delta=0.;    //  delta<0 could never happen in principle, only caused by rounding
         x1 = 0.5*(-c1 - sqrt(delta))/c2;
         x2 = 0.5*(-c1 + sqrt(delta))/c2;
// cout<<"     is = "<<is<<", i= "<<i<<",  x1 "<<x1<<", x2 "<<x2<<",  RminStrawSkewArea "<<RminStrawSkewArea<<endl;
// cout<<"         low lim. = "<< exhagon_side_xlow[is][i] <<", up lim.= "<<exhagon_side_xup[is][i]<<endl;
         if( x1 >= exhagon_side_xlow[is][i] && x1 <= exhagon_side_xup[is][i] ) {
             y = a[is]*x1 + b[is]*Erre[i];
// cout<<"              x= "<<x1<<",      y = "<<y<<endl;
             fi[index]=atan2(y-oY,x1-oX);
             if( fi[index] <0. ) fi[index]+= 2.*PI ;
             index++;
         }
         if( x2 >= exhagon_side_xlow[is][i] && x2 <= exhagon_side_xup[is][i] ) {
             y = a[is]*x2 + b[is]*Erre[i];
// cout<<"             x= "<<x2<<",       y = "<<y<<endl;
             fi[index]=atan2(y-oY,x2-oX);
             if( fi[index] <0. ) fi[index]+= 2.*PI ;
             index++;
         }

      }  //  end of for(i=0;i<2;i++)


     }  //  end of for(is=0;i<6;is++)


// cout<<" RmaxStrawSkewArea= "<<RmaxStrawSkewArea<<", i outer/inner = "<<i<<", intersezioni compatibili sono "<<index<<" :"<<endl;
// for(int ica=0;ica<index;ica++){  cout<<"       fi (gradi) = "<<fi[ica]*180/PI<<endl; }


//  choose the low and upper limits taking into account the charge of this track

     if(index == 0) {
        cout<<
"from PndSttTrackFinderReal::PndSttFindingParallelTrackAngularRangeforSkew    :  radius of trajectory too small, no intersections\n";
        *Fi_allowedforskew_low= -9999;
        return;
     }
//  at this poin the intersection MUST be at least 2

     if(index == 1) {
        cout<<"from PndSttTrackFinderReal::PndSttFindingParallelTrackAngularRangeforSkew    this situation is mathematically impossible !\n";
        *Fi_allowedforskew_low= -9999;
        return;
     }

     fi_vertex = atan2(-oY, -oX);
     if(fi_vertex<0.) fi_vertex += 2.*PI; 
     if(fi_vertex<0.) fi_vertex += 0.;    //   this is a protection from possible rounding errors
// cout<<" fi_vertex(gradi) = "<<fi_vertex*180/PI<<endl;

     if(Charge < 0 ) {
       for(i=0, minimum=100000.;i<index;i++){
          if( fi[i] < fi_vertex ) fi[i] += 2.*PI;
          if( fi[i] < minimum ) minimum= fi[i] ;
       }
       for(i=0, minimum2=100000.;i<index;i++){
          if( fi[i] < minimum2 && fi[i]> minimum) minimum2 = fi[i] ;
       }
       *Fi_allowedforskew_low = minimum;
       *Fi_allowedforskew_up = minimum2;

     } else {

       for(i=0, maximum=-100000.;i<index;i++){
          if( fi[i] > fi_vertex ) fi[i] -= 2.*PI;
          if( fi[i] > maximum ) maximum= fi[i] ;
       }
       for(i=0, maximum2=-100000.;i<index;i++){
          if( fi[i] > maximum2 && fi[i] < maximum) maximum2 = fi[i] ;
       }
       *Fi_allowedforskew_low = maximum2;
       *Fi_allowedforskew_up = maximum;

     }   //   end of if(Charge < 0 )


// cout<<"Stampa di controllo Fimin(gradi) = "<<(*Fi_allowedforskew_low)*180./PI<<", Fmax = "<<(*Fi_allowedforskew_up)*180./PI<<endl;

      if( *Fi_allowedforskew_low > 2.*PI ) {
        *Fi_allowedforskew_low = fmod( (*Fi_allowedforskew_low),2.*PI);
        *Fi_allowedforskew_up = fmod( (*Fi_allowedforskew_up),2.*PI);
      }



      return;
}

//---------- end of  function PndSttTrackFinderReal::PndSttFindingAllowedAngularRangeforSkew










//----------start of function PndSttTrackFinderReal::WriteMacroParallelHitswithRfromMC

  void PndSttTrackFinderReal::WriteMacroParallelHitswithRfromMC(
                   Int_t Nhits, Double_t info[][7],
                   UShort_t nTracksFoundSoFar,
                   bool *TypeConf,
                   Double_t *Ox,
                   Double_t *Oy,
                   Short_t * daTrackFoundaTrackMC
                                                     )
{

    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS;

    Double_t xmin , xmax, ymin, ymax, xl, xu, yl, yu,
            gamma,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,ff,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,x1,x2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, rrr, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];

      char nome[300], nome2[300];







//---------- parallel straws Macro now con anche le tracce MC

      sprintf(nome,"MacrowithRfromMCParallelHitswithMCEvent%d", IVOLTE);
      sprintf(nome2,"%s.C",nome);
      FILE * MACRO = fopen(nome2,"w");
//      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);
      xmin=1.e20;
      xmax=-1.e20;
      ymin=1.e20;
      ymax=-1.e20;
       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            if (info[i][0]-info[i][3] < xmin)   xmin = info[i][0]-info[i][3];
            if (info[i][0]+info[i][3] > xmax)   xmax = info[i][0]+info[i][3];
            if (info[i][1]-info[i][3] < ymin)   ymin = info[i][1]-info[i][3];
            if (info[i][1]+info[i][3] > ymax)   ymax = info[i][1]+info[i][3];
          }
       }

       if( xmin > 0. ) xmin = 0.;
       if( xmax < 0.)  xmax = 0.;
       if( ymin > 0. ) ymin = 0.;
       if( ymax < 0.)  ymax = 0.;

       deltax = xmax-xmin;
       deltay = ymax - ymin;

       if( deltax > deltay) {
         ymin -=  0.5*(deltax-deltay);
         ymax = ymin+ deltax;
         delta = deltax;
       }  else  {
         xmin -=  0.5*(deltay-deltax);
         xmax = xmin+ deltay;
         delta= deltay;
       }

       xmax = xmax + delta*0.05;
       xmin = xmin - delta*0.05;

       ymax = ymax + delta*0.05;
       ymin = ymin - delta*0.05;


       fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",xmin,ymin,xmax,ymax);


       fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",xmin,0.,xmax,0.,xmin,xmax);
       fprintf(MACRO,"Assex->Draw();\n");
       fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n", 0.,ymin,0.,ymax,ymin,ymax);
       fprintf(MACRO,"Assey->Draw();\n");


       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1 ) {     // parallel straws
            fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nE%d->SetFillStyle(0);\nE%d->Draw();\n",
                     i,info[i][0],info[i][1],info[i][3],info[i][3],i,i);
          }
       }



       for( i=0; i< nMCTracks ; i++) {
            fprintf(MACRO,"TEllipse* MC%d = new TEllipse(%f,%f,%f,%f,0.,360.);\nMC%d->SetFillStyle(0);\nMC%d->SetLineColor(3);\nMC%d->Draw();\n",
                     i,CxMC[i],CyMC[i],R_MC[i],R_MC[i],i,i,i);
// cout<<" info MC buone : MCtrack n. "<<i<<",  Cx, Cy, R  "<<CxMC[i]<<",  "<<CyMC[i]<<",  "<<R_MC[i]<<endl;
       }


//-------------------------------   plotting all the tracks found, with R from corresponding MC track

    for(i=0; i<nTracksFoundSoFar; i++){

       if( daTrackFoundaTrackMC[i] == -1 )  continue;
       rrr = R_MC[  daTrackFoundaTrackMC[i]  ];
       double angolo = atan2(Oy[i],Ox[i]); 
       aaa = rrr*cos(angolo);
       bbb = rrr*sin(angolo);
       fprintf(MACRO,"TEllipse* ris%d=new TEllipse(%f,%f,%f,%f,0.,360.);\nris%d->SetFillStyle(0);\nris%d->SetLineColor(2);\nris%d->Draw();\n",
                     i,aaa,bbb,rrr,rrr,i,i,i);


    }

// -----------

      fprintf(MACRO,"}\n");
      fclose(MACRO);
       
//------------------------------------------------------------------------------------------------------------






    return ;

}


//----------end of function PndSttTrackFinderReal::WriteMacroParallelHitswithRfromMC








//----------start of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithRfromMC

  void PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithRfromMC(
                   Double_t KAPPA,Double_t FI0,Double_t D,Double_t Fi,Double_t R,
                   Int_t Nhits, Double_t info[][7],  Int_t Nincl, Int_t Minclinations[], Double_t inclination[][3],
                   Int_t imaxima, Int_t nMaxima 
                                                     )
 {



    Int_t i, j, i1, ii, index, Kincl, nlow, nup, STATUS, imc, Nmin, Nmax;

    Double_t xmin , xmax, ymin, ymax, Ox, Oy,
           dx, dy, diff, d1, d2,
           delta, deltax, deltay, deltaz, deltaS,
           factor,
           zmin, zmax, Smin, Smax, S1, S2,
           z1, z2, y1, y2,
           vx1, vy1, vz1, C0x1, C0y1, C0z1,
           aaa, bbb, ccc, angle, minor, major,
           distance, Rx, Ry, LL,
           Aellipsis1, Bellipsis1,fi1,
           fmin, fmax, offset, step,
           SkewInclWithRespectToS, zpos, zpos1, zpos2,
           Tiltdirection1[2],
           zl[200],zu[200],
           POINTS1[6];




//-------------------  skew straws hits Macro now

      char  nome2[300],nome[300];
      FILE *MACRO;
      sprintf(nome,  "MacroParTrack%dSkewTrack%dSkewHitswithRfromMCEvent%d",imaxima,nMaxima, IVOLTE);
      sprintf(nome2,  "%s.C",nome);
      MACRO = fopen(nome2,"w");
      fprintf(MACRO,"void %s()\n{\n",nome);

//KAPPA = 1./166.67 ;  FI0 = 1.5*PI;

      Smin=zmin = 1.e10;
      Smax=zmax = -zmin;
      index=0;

       for( i=0; i< Nhits; i++) {
         if( info[i][5] == 1. )   continue;     // exclude parallel straws

         Kincl = (int) info[i][5] - 1;


         aaa = sqrt(inclination[Kincl][0]*inclination[Kincl][0]+inclination[Kincl][1]*inclination[Kincl][1]+
                  inclination[Kincl][2]*inclination[Kincl][2]);
         vx1 = inclination[Kincl][0]/aaa;
         vy1 = inclination[Kincl][1]/aaa;
         vz1 = inclination[Kincl][2]/aaa;
         C0x1 = info[i][0];
         C0y1 = info[i][1];
         C0z1 = info[i][2];
         Ox = (R+D)*cos(Fi);
         Oy = (R+D)*sin(Fi);

       calculateintersections(Ox,Oy,R,C0x1,C0y1,C0z1,info[i][3],
                              vx1,vy1,vz1,
                              &STATUS,POINTS1);

       if(STATUS < 0 ) continue ;



       for( ii=0; ii<2; ii++){
        j=3*ii;
        distance = sqrt(
                  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) + 
                  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) + 
                  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1) 
                            );
        if( distance >= info[i][4] ) continue;


        Rx = POINTS1[j]-Ox ;   //  x component Radial vector of cylinder of trajectory
        Ry = POINTS1[1+j]-Oy ;   //  y direction Radial vector of cylinder of trajectory

        aaa = sqrt(Rx*Rx+Ry*Ry);
        SkewInclWithRespectToS = (-Ry*vx1 + Rx*vy1)/aaa ;
        SkewInclWithRespectToS /= R;
        bbb = sqrt( SkewInclWithRespectToS*SkewInclWithRespectToS + vz1*vz1);
        //  the tilt direction of this ellipse is (1,0)  when major axis along Z direction
        if( bbb > 1.e-10){
           Tiltdirection1[0] = vz1/bbb;
           Tiltdirection1[1] = SkewInclWithRespectToS/bbb;
        } else {
           Tiltdirection1[0] = 1.;
           Tiltdirection1[1] = 0.;
        }

        LL = fabs(vx1*Rx + vy1*Ry);
        if( LL < 1.e-10) continue;
        Aellipsis1 = info[i][3]*aaa/LL;

        Bellipsis1 = info[i][3]/R;



// checks that the projected ellipsis doesn't go out the boundaries of both the skew straw and the trajectory cylinder

        if(
          fabs(POINTS1[j+2]-ZCENTER_STRAIGHT) > SEMILENGTH_STRAIGHT- Aellipsis1 ||
          distance + bbb > info[i][4]        //  the ellipsis goes out of the boundaries of the skew straw
          ) {
cout<<"the ellipsis goes out of the boundaries of the skew straw, hit n. "<<i<<endl
     <<"dis. from center "<<distance+bbb<<",  length of the straw "<<info[i][4]<<endl;
           continue;
          }
//--------------------------


        fi1 = atan2(POINTS1[j+1]-Oy, POINTS1[j]-Ox) ;  // atan2 returns radians in (-pi and +pi]
        if( fi1 < 0.) fi1 += 2.*PI;

        if( zmin > POINTS1[j+2] - Aellipsis1 ) zmin = POINTS1[j+2] - Aellipsis1;
        if( zmax < POINTS1[j+2] + Aellipsis1 ) zmax = POINTS1[j+2] + Aellipsis1;

        if( Smin > fi1 - Bellipsis1 ) Smin = fi1 - Bellipsis1;
        if( Smax < fi1 + Bellipsis1 ) Smax = fi1 + Bellipsis1;


        Double_t rotation1 = 180.*atan2(Tiltdirection1[1],Tiltdirection1[0])/PI;
        fprintf(MACRO,"TEllipse* E%d = new TEllipse(%f,%f,%f,%f,0.,360.,%f);\nE%d->SetFillStyle(0);\n",
                     index,POINTS1[j+2],fi1,Aellipsis1,Bellipsis1,rotation1,index);

        index++;

   }    //  end of    for( ii=0; ii<2; ii++)

  }   //   end of  for( i=1; i< Nhits; i++)


  if(index==0) goto nohits ;
  if( zmax < zmin ) goto nohits ;
  if( Smax < Smin ) goto nohits;
  aaa = Smax-Smin;
  Smin -= aaa*1.;
  Smax += aaa*1.;

  aaa = zmax-zmin;
  zmin -= aaa*0.05;
  zmax += aaa*0.05;

  if(Smax > 2.*PI) Smax = 2.*PI;
  if( Smin < 0.) Smin = 0.;

//  Smin=0.;
//  Smax=2.*PI;


  fprintf(MACRO,"TCanvas* my= new TCanvas();\nmy->Range(%f,%f,%f,%f);\n",zmin,Smin,zmax,Smax);
  for( ii=0; ii< index; ii++) {
       fprintf(MACRO,"E%d->Draw();\n",ii);
  }

   deltaz = zmax-zmin;
   deltaS = Smax-Smin;
   fprintf(MACRO,"TGaxis *Assex = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmax-0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,zmax-0.05*deltaz);
   fprintf(MACRO,"Assex->Draw();\n");
   fprintf(MACRO,"TGaxis *Assey = new  TGaxis(%f,%f,%f,%f,%f,%f,510);\n",
        zmin+0.05*deltaz,Smin+0.05*deltaS,zmin+0.05*deltaz,Smax-0.05*deltaS,Smin+0.05*deltaS,Smax-0.05*deltaS);
   fprintf(MACRO,"Assey->Draw();\n");




// --------------------------------

//  plot della traccia trovata dal finder


  if ( KAPPA >= 0.) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
     fmax = KAPPA*zmin + FI0;
     fmin = KAPPA*zmax + FI0;
  }
  if( fmax>=0.) {
    Nmax = (int) (0.5*fmax/ PI);
  }  else  {
    Nmax = ( (int) (0.5*fmax/ PI) ) -1;
  }
  if( fmin>=0.) {
    Nmin = (int) (0.5*fmin/ PI);
  } else {
    Nmin = ((int) (0.5*fmin/ PI) )-1;
  }
  for(i=Nmin; i<= Nmax;i++){
   offset = 2.*PI*i;
   z1 = (i*2.*PI-FI0)/KAPPA;
   z2 = ((i+1)*2.*PI-FI0)/KAPPA;
   fprintf(MACRO,"TLine* FOUND%d = new TLine(%f,%f,%f,%f);\nFOUND%d->SetLineColor(2);\nFOUND%d->Draw();\n",
                 i-Nmin,z1,0.,z2, 2.*PI,i-Nmin,i-Nmin);

  }   //  end of  for(i=Nmin; i<= Nmax;++)


//---------------------------------------------  qui ci aggiungo le traccie MC


 for(imc=0; imc<nMCTracks ; imc++){

     KAPPA=MCtruthTrkInfo[12][imc];
     FI0 = MCtruthTrkInfo[13][imc];
  if ( KAPPA >= 0.) {
     fmin = KAPPA*zmin + FI0;
     fmax = KAPPA*zmax + FI0;
  }  else {
     fmax = KAPPA*zmin + FI0;
     fmin = KAPPA*zmax + FI0;
  }
  if( fmax>=0.) {
    Nmax = (int) (0.5*fmax/ PI);
  }  else  {
    Nmax = ( (int) (0.5*fmax/ PI) ) -1;
  }
  if( fmin>=0.) {
    Nmin = (int) (0.5*fmin/ PI);
  } else {
    Nmin = ((int) (0.5*fmin/ PI) )-1;
  }
  for(i=Nmin; i<= Nmax;i++){
   offset = 2.*PI*i;
   z1 = (i*2.*PI-FI0)/KAPPA;
   z2 = ((i+1)*2.*PI-FI0)/KAPPA;
   fprintf(MACRO,"TLine* MC%d_%d = new TLine(%f,%f,%f,%f);\nMC%d_%d->SetLineColor(3);\nMC%d_%d->Draw();\n",
                 imc,i-Nmin,z1,0.,z2, 2.*PI,imc,i-Nmin,imc,i-Nmin);

  }   //  end of  for(i=Nmin; i<= Nmax;++)


   }  // end of for(imc=0; imc<nMCTracks ; imc++)









nohits: ;

      fprintf(MACRO,"}\n");
      fclose(MACRO);





 }

//----------end of function PndSttTrackFinderReal::WriteMacroSkewAssociatedHitswithRfromMC


//----------begin of function PndSttTrackFinderReal::AssociateFoundTrackstoMC

    void PndSttTrackFinderReal::AssociateFoundTrackstoMC(
                  UShort_t nTracksFoundSoFar,
                  UShort_t *nHitsinTrack,
                  UShort_t  ListHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
                  UShort_t *nSkewHitsinTrack,
                  UShort_t  ListSkewHitsinTrack[MAXTRACKSPEREVENT][nmaxHits],
                  Short_t *daTrackFoundaTrackMC,
                  Short_t *daMCTrackaTrackFound 
                                                        )
{

   UShort_t  exphit,
             i,
             imc,
             jexp,
             mchit,
             BoxMC_Found[nMCTracks][nTracksFoundSoFar];
   bool inclusionMC[nMCTracks],
        inclusionExp[nTracksFoundSoFar];




   for(i=0; i<nTracksFoundSoFar;i++){
     daTrackFoundaTrackMC[i]=-1;
     inclusionExp[i]=true;
   }


   for(i=0; i<nMCTracks;i++){
     daMCTrackaTrackFound[i]=-1;
     inclusionMC[i]=true;
   }



   for(imc=0; imc<nMCTracks;imc++){

     for(jexp=0; jexp< nTracksFoundSoFar ;jexp++){

       BoxMC_Found[imc][jexp]=0;


// prima  gli hits paralleli ---------------------
        for(mchit=0; mchit<nHitsInMCTrack[imc]; mchit++){
           for(exphit=0; exphit<nHitsinTrack[jexp]; exphit++){
               if(infoparal[   ListHitsinTrack[jexp][exphit]  ] == FromMCTrackToHit[imc][mchit] ){
                  BoxMC_Found[imc][jexp]++;
                  goto  gotta ;
               }   //  end of   if(infoparal[ListHitsinTrack[jexp][exphit]] == FromMCTrackToHit[imc][mchit])
           }  //  end of  for(exphit=0; exphit<nHitsinTrack[jexp]; exphit++)
      gotta:   ;
        }   //  end of  for(mchit=0; mchit<nHitsInMCTrack[imc]; mchit++)


// poi  gli hits skew ---------------------

        for(mchit=0; mchit<nSkewHitsInMCTrack[imc]; mchit++){
           for(exphit=0; exphit<nSkewHitsinTrack[jexp]; exphit++){
               if(infoskew[   ListSkewHitsinTrack[jexp][exphit]  ] == FromMCTrackToSkewHit[imc][mchit] ){
                  BoxMC_Found[imc][jexp]++;
                  goto  gotta2 ;
               }   //  end of   if(infoskew[ListSkewHitsinTrack[jexp][exphit]] == FromMCTrackToSkewHit[imc][mchit])
           }  //  end of  for(exphit=0; exphit<nSkewHitsinTrack[jexp]; exphit++)
      gotta2:   ;
        }   //  end of  for(mchit=0; mchit<nSkewHitsInMCTrack[imc]; mchit++)



if( istampa>= 3 && IVOLTE<20) cout<<"  evento n. "<<IVOLTE<<", imc = "<<imc<<", jexp = "<<jexp<<", BoxMC_Found[imc][jexp] = "<<
    BoxMC_Found[imc][jexp]<<endl;

     } //  end of   for(jexp=0; jexp< nTracksFoundSoFar ;jexp++)
  }    //  end of     for(imc=0; imc<nMCTracks;imc++){



//   scelta degli accoppiamenti delle tracce MC con quelle trovate dal pattern recognition


    int Imc, Jexp, massimo;

    if( nMCTracks >= nTracksFoundSoFar){

      for( jexp=0; jexp< nTracksFoundSoFar ;jexp++){
          massimo=-1;
          for (imc=0; imc<nMCTracks;imc++){
             if( ! inclusionMC[imc] ) continue;
             if( BoxMC_Found[imc][jexp] > massimo ) {
               massimo = BoxMC_Found[imc][jexp];
               Imc = imc;
             }
          }    //  end for (imc=0; imc<nMCTracks;imc++)

          if( massimo >0) {
            daTrackFoundaTrackMC[jexp]=Imc;
            daMCTrackaTrackFound[Imc]=jexp;
            inclusionMC[Imc]=false;
          }

      }    //end for( jexp=0; jexp< nTracksFoundSoFar ;jexp++)


    }  else {
      

      for( imc=0; imc<nMCTracks;imc++){
          massimo=-1;
          for (jexp=0; jexp< nTracksFoundSoFar ;jexp++){
             if( ! inclusionExp[jexp] ) continue;
             if( BoxMC_Found[imc][jexp] > massimo ) {
               massimo = BoxMC_Found[imc][jexp];
               Jexp = jexp;
             }
          }    //  end for (jexp=0; jexp< nTracksFoundSoFar ;jexp++)
          if( massimo >0) {
            daTrackFoundaTrackMC[Jexp]=imc;
            daMCTrackaTrackFound[imc]=Jexp;
            inclusionExp[Jexp]=false;
          }

      }    //end for( jexp=0; jexp< nTracksFoundSoFar ;jexp++)


    }  // end if( nMCTracks >= nTracksFoundSoFar)

    return;
}




//----------end of function PndSttTrackFinderReal::AssociateFoundTrackstoMC



//---------- begin of function PndSttTrackFinderReal::PndSttInfoXYZParal




    void PndSttTrackFinderReal::PndSttInfoXYZParal (
                             Double_t info[][7],
                             UShort_t infopar,
                             Double_t Ox,
                             Double_t Oy,
                             Double_t R,
                             Double_t KAPPA,
                             Double_t FI0,
                             Short_t Charge,
                             Double_t *Posiz
                            )
{

   Double_t fi, norm, vers[2];

   vers[0] = Ox - info[infopar][0];
   vers[1] = Oy - info[infopar][1];
   norm = sqrt( vers[0]*vers[0] + vers[1]*vers[1] );

   if(norm < 1.e-20) {
     Posiz[0] = -999999999.;
     return;
   }
   
   Posiz[0] = info[infopar][0] + info[infopar][3]*vers[0]/norm;
   Posiz[1] = info[infopar][1] + info[infopar][3]*vers[1]/norm;

   if( fabs(KAPPA)<1.e-20 ){
     Posiz[0] = -888888888.;
     return;
   }


   fi = atan2(-vers[1],-vers[0]);
   if(fi<0.)  fi += 2.*PI;

   if ( Charge > 0){
    if(fi > FI0 )  FI0 += 2.*PI;
    Posiz[2] = (FI0-fi)/KAPPA;
   } else {
    if(fi < FI0 )  fi += 2.*PI;
    Posiz[2] = (fi-FI0)/KAPPA;
   }

   return;
}

//----------end of function PndSttTrackFinderReal::PndSttInfoXYZParal









//---------- begin of function PndSttTrackFinderReal::PndSttInfoXYZSkew




    void PndSttTrackFinderReal::PndSttInfoXYZSkew (
//                             Double_t info[][7],
//                             UShort_t infosk,
                             Double_t Z,       //  Z coordinate of selected Skew hit
                             Double_t ZDrift,   // drift distance IN Z DIRECTION only, of selected Skew hit
                             Double_t S,
                             Double_t Ox,
                             Double_t Oy,
                             Double_t R,
                             Double_t KAPPA,
                             Double_t FI0,
                             Short_t Charge,
                             Double_t *Posiz      //  output
                            )
{

//if(istampa >=3 && IVOLTE<20){
if(istampa>=3){
cout<<"  stampa da PndSttInfoXYZSkew  "<<", Z hit = "<<Z<<", Zdrift = "<<ZDrift<<", S = "<<S<<endl;
}


   Double_t Zline;

   if(fabs(KAPPA)< 1.e-20) {
     Posiz[0] = -999999999.;
     return;
   }

   Posiz[0] = Ox + R * cos(S);
   Posiz[1] = Oy + R * sin(S);

   if( Charge > 0 ) {
     if( S > FI0 )  {
        cout<<"from PndSttInfoXYZSkew : inconsistency, FI0 is not the maximum for this track "<<endl;
cout<<"  stampa da PndSttInfoXYZSkew,  "<<", Z hit = "<<Z<<", Zrift = "<<ZDrift<<", S = "<<S<<",  FI0 = "<<FI0<<endl;
        Posiz[0] = -777777777.;
        return;
      }
   }  else  {
     if( S < FI0 )  {
        cout<<"from PndSttInfoXYZSkew : inconsistency, FI0 is not the minimum for this track "<<endl;
cout<<"  stampa da PndSttInfoXYZSkew,  "<<", Z hit = "<<Z<<", Zrift = "<<ZDrift<<", S = "<<S<<",  FI0 = "<<FI0<<endl;
        Posiz[0] = -777777777.;
        return;
      }
   }

     Zline = (S-FI0)/KAPPA;


   if(  fabs( Zline - ZDrift - Z ) < fabs( Zline + ZDrift - Z ) ){
       Posiz[2] = ZDrift + Z;
   } else {
       Posiz[2] = Z - ZDrift;
   }



   return;
}

//----------end of function PndSttTrackFinderReal::PndSttInfoXYZSkew

//----------start of function PndSttTrackFinderReal::FixDiscontinuitiesFiangleinSZplane

  void PndSttTrackFinderReal::FixDiscontinuitiesFiangleinSZplane(
                          UShort_t TemporarynSkewHitsinTrack,
                          Double_t *S,
                          Double_t *Fi_initial_helix_referenceframe,
                          Short_t Charge
                                                                )
{

     UShort_t i;
     Double_t max, min;

     for(i=0, min = 9999., max = -9999.; i<TemporarynSkewHitsinTrack; i++){
        if( S[i] > max ) max = S[i];
        if( S[i] < min ) min = S[i];
     }


     if( max-min> PI) {
       for(i=0, min = 9999., max = -9999.; i<TemporarynSkewHitsinTrack; i++){
        if( S[i] < PI ) S[i] += 2.*PI;
        if( S[i] > max ) max = S[i];
        if( S[i] < min ) min = S[i];
       }
        
     }


     if( Charge >0 ){
       if( *Fi_initial_helix_referenceframe < max ) *Fi_initial_helix_referenceframe  += 2.*PI;
     } else {
       if( *Fi_initial_helix_referenceframe > min ) *Fi_initial_helix_referenceframe  -= 2.*PI;
     }

     return;

}
//----------end of function PndSttTrackFinderReal::FixDiscontinuitiesFiangleinSZplane


ClassImp(PndSttTrackFinderReal)