---

geneticdist.h

Go to the documentation of this file.

//****************************************************
//  April, 1993, University of Illinois
// Copyright (C) 1993, 1994 Tianlin Wang
/* Copyright (C) 1994-2003 Matvec Development Team. 

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Library General Public License for more details.
    
  You should have received a copy of the GNU Library General Public
  License along with this library; if not, write to the Free
  Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  MA 02111-1307, USA 
*/

#ifndef GeneticDist_H
#define GeneticDist_H

#include <iostream>
#include <string>
#include "util.h"
#include "doublematrix.h"
#include "safe_vectors.h"

namespace matvec {
extern int DISCRETE_TRAIT;  // was called  DISCRETE_TRAIT;
extern doubleMatrix PENETRANCE_MATRIX;

/////////////////////////// LocusStruct class ///////////////////////

class ChromStruct;
class GeneticDist;

/*!
   \class LocusStruct GeneticDist.h
   \brief a structure for a locus

   \sa Locus
*/
class LocusStruct {

   protected:
      unsigned   numallele;
      void       copyfrom(const LocusStruct& A);

   public:
      char       qtl_ml;
      Vector<double>     allele_freq;
      doubleMatrix     genotypic_val_mat;
//BRS
      double     distance; // distance from origin to this locus in Morgans
//BRS
//RLF
      std::string   nameOfcol1, nameOfcol2;              // for marker data
//RLF
// newHG
      unsigned nextMarker;
      unsigned nHaplotypes ;
      Vector<unsigned> listOfAllele;            // setup in population::ListAlleleFounders
      Vector<unsigned> al1Haplo, al2Haplo;      // setup in population::SetPossibleHaplotypes : related to the next marker on the right
// newHG
      LocusStruct(void) {numallele = 0;}
      LocusStruct(const unsigned na) {numallele = 0; resize(na);}
//      ~LocusStruct(void) {numallele =0;}

      const LocusStruct& operator=(const LocusStruct& A)
           {numallele=0; copyfrom(A); return *this;}

      void     resize(const unsigned na);
      void     nallele(const unsigned na) {numallele = na;}
      unsigned nallele(void) const {return numallele;}
      // LRT for the RSampler
      SafeSTLVector<int> peelOrder;
          bool cutLoops;
};

/////////////////////////// ChromStruct class ///////////////////////
/*!
   \class ChromStruct  GeneticDist.h
   \brief chromosome structure

   \sa Chromosome
*/
class ChromStruct {
   protected:
      unsigned numloci;
      void     copyfrom(const ChromStruct& A);

   public:
      SafeSTLVector<LocusStruct> locus;
      doubleMatrix       recomb_rate_mat;

      ChromStruct(void) {numloci=0;}
      ChromStruct(const unsigned nl) {numloci=0; resize(nl);}
      ~ChromStruct(void) {release();}

      const ChromStruct& operator=(const ChromStruct& A)
           {numloci=0; copyfrom(A); return *this;}

      void      resize(const unsigned nl);
      unsigned  nloci(void) const {return numloci;}

      void      release(void);
      // LRT for the RSampler
      SafeSTLVector<int> peelOrder;
};

class MaternalPaternalRQTLAlleles {
 public:
  unsigned maternal;
  unsigned paternal;
};
/*! \class MaternalPaternalRQTLAlleles geneticdist.h inc/geneticdist.h
 * \brief This is the building block class for dealing with RQTL.
 *
 * MaternalPaternalRQTLAlleles class defines the maternal and paternal 
 * alleles of a RQTL genotype.
 */ 

/////////////////////////// GeneticDist class ///////////////////////

/*!
   \class GeneticDist  GeneticDist.h
   \brief  a base for Genetic distributions

   \sa StatDist
*/

class GeneticDist  {
   protected:
      char         distname[25];
      unsigned     numchrom, numtrait;     // default numtrait = 1

   public:      
                  
          ChromStruct  *chromosome;
      unsigned numMarkerLoci; //LRT 
      GeneticDist(void);
      GeneticDist(const unsigned nc,...);
      GeneticDist(GeneticDist& G ){copyfrom(G);}
      virtual ~GeneticDist(void) {release();}

      const GeneticDist& operator=(const GeneticDist& A) {numchrom=0;
                  chromosome=0; copyfrom(A); return *this;}


      virtual void     resize(const unsigned nc) {nchrom(nc); }
      virtual unsigned ntrait(void) const {return numtrait;}
      virtual doubleMatrix*  var_matrix(void) { return 0;}

      const char* name(void) const {return distname;}
      ChromStruct  *chrom(void) {return chromosome;}
      double  recomb_rate(const unsigned c,const unsigned li,const unsigned lj);
      unsigned     nchrom(void) const {return numchrom;}
      unsigned     nloci_chrom(const unsigned c) const;
      unsigned     nallele(const unsigned c,const unsigned l) const
                           {return chromosome[c].locus[l].nallele();}

      //int     display(void)const{cout<<"  "<<distname<<"\n"; return 1;}
      int     display(void);

      void    copyfrom(const GeneticDist& A);
      void    nchrom(const unsigned nc);
      void    nloci(const unsigned nl0,...);
      void    release(void);
      void    locus(const unsigned c,const unsigned l,const char qm[],
                     const unsigned na, ...);
//RLF
     void putColmNames(const unsigned c,const unsigned l,
                                char nm1[],char nm2[]);
//RLF
      void    recomb_rate(const unsigned c,const unsigned li,const unsigned lj,
                           const double r);
      void    genotypic_val(const unsigned c,const unsigned l,const double* v);
      void    genotypic_val(const unsigned c,const unsigned l,
                             const double v0,...);
      double  sample(void) const {return 0.0;}
      const double** genotypic_val(const unsigned c,const unsigned l) const;
//BRS
      void multi_loci(int num_loci);
      void    put_distance(const unsigned c,const unsigned l, double distance);
      double  get_distance(const unsigned c,const unsigned l);
      void    locus(const unsigned c,const unsigned l,const char qm[], const unsigned na, Vector<double> allele_freq);
//BRS
      SafeSTLVector<MaternalPaternalRQTLAlleles> rqtlVector; 
};

inline const double** GeneticDist::genotypic_val(const unsigned c,
                                                 const unsigned l) const
{
   return (const double**)chromosome[c].locus[l].genotypic_val_mat.begin();
}

inline GeneticDist::GeneticDist(void)
{
   numchrom = 0; chromosome = 0; numtrait = 1;
   strcpy(distname,"GeneticDist");
//   cout << "GeneticDist::GeneticDist(void): numtrait = " << numtrait << endl;
}

inline unsigned  GeneticDist::nloci_chrom(const unsigned c) const
{
   if (c > 0) {
      return chromosome[c-1].nloci();
   }
   else {
      std::cerr << "GeneticDist::nloci(c): arg value out of range";
      exit(1);
   }
}


///////////////////  UnknownDist  class /////////////////////////////
/*!
   \class UnknownDist
   \brief a dummy genetic distribution
*/
class UnknownDist: public GeneticDist {
   protected:
      unsigned dim;
      Vector<double> mu_vec;
      doubleMatrix var_mat;

   public:
      UnknownDist(void) {strcpy(distname,"UnknownDist"); dim=0;}
      UnknownDist(const UnknownDist& u):GeneticDist() {copyfrom(u);}
      UnknownDist(const Vector<double> mu, const doubleMatrix sigma);
      UnknownDist(const double mu, const double sigma);
      ~UnknownDist(void) {;}

      void     copyfrom(const UnknownDist& A);
      void     resize(const unsigned n);
      unsigned ntrait(void) const {return dim;}

      Vector<double>*  mean_vector(void) {return &mu_vec;}
      doubleMatrix*  var_matrix(void) {return &var_mat;}
};
}
#endif

---